@absolutejs/voice 0.0.22-beta.24 → 0.0.22-beta.240

package/dist/opsActionAuditRoutes.d.ts

@@ -0,0 +1,99 @@
+import { Elysia } from 'elysia';
+import { type StoredVoiceAuditEvent, type VoiceAuditEventStore } from './audit';
+import { type VoiceTraceEventStore } from './trace';
+export type VoiceOpsActionAuditRecord = {
+    actionId: string;
+    body?: unknown;
+    error?: string;
+    ok: boolean;
+    ranAt: number;
+    status: number;
+};
+export type VoiceOpsActionAuditRoutesOptions = {
+    audit?: VoiceAuditEventStore;
+    historyHtmlPath?: false | string;
+    historyPath?: false | string;
+    name?: string;
+    path?: string;
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceOpsActionHistoryEntry = {
+    actionId: string;
+    at: number;
+    error?: string;
+    eventId: string;
+    ok: boolean;
+    status?: number;
+    traceId?: string;
+};
+export type VoiceOpsActionHistoryReport = {
+    checkedAt: number;
+    entries: VoiceOpsActionHistoryEntry[];
+    failed: number;
+    passed: number;
+    total: number;
+};
+export declare const recordVoiceOpsActionAudit: (record: VoiceOpsActionAuditRecord, options: Pick<VoiceOpsActionAuditRoutesOptions, "audit" | "trace">) => Promise<{
+    audit: StoredVoiceAuditEvent<Record<string, unknown>> | (Omit<import("./audit").VoiceAuditEvent<Record<string, unknown>>, "at" | "id"> & {
+        at: number;
+        id: string;
+    }) | undefined;
+    ok: boolean;
+    trace: (import("./trace").VoiceTraceEvent<Record<string, unknown>> & {
+        id: string;
+    }) | undefined;
+}>;
+export declare const createVoiceOpsActionAuditRoutes: (options: VoiceOpsActionAuditRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: {
+                    audit: StoredVoiceAuditEvent<Record<string, unknown>> | (Omit<import("./audit").VoiceAuditEvent<Record<string, unknown>>, "at" | "id"> & {
+                        at: number;
+                        id: string;
+                    }) | undefined;
+                    ok: boolean;
+                    trace: (import("./trace").VoiceTraceEvent<Record<string, unknown>> & {
+                        id: string;
+                    }) | undefined;
+                } | {
+                    error: string;
+                    ok: boolean;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const buildVoiceOpsActionHistoryReport: (options: Pick<VoiceOpsActionAuditRoutesOptions, "audit">) => Promise<VoiceOpsActionHistoryReport>;
+export declare const renderVoiceOpsActionHistoryHTML: (report: VoiceOpsActionHistoryReport) => string;

package/dist/opsConsoleRoutes.d.ts

@@ -0,0 +1,80 @@
+import { Elysia } from 'elysia';
+import { type VoiceDeliverySinkReport, type VoiceDeliverySinkRoutesOptions } from './deliverySinkRoutes';
+import { type VoiceQualityReport } from './qualityRoutes';
+import { type VoiceRoutingEvent } from './resilienceRoutes';
+import { type VoiceSessionListItem } from './sessionReplay';
+import { summarizeVoiceTrace, type VoiceTraceEventStore } from './trace';
+export type VoiceOpsConsoleLink = {
+    description?: string;
+    href: string;
+    label: string;
+    statusHref?: string;
+};
+export type VoiceOpsConsoleReport = {
+    checkedAt: number;
+    eventCount: number;
+    handoffs: {
+        failed: number;
+        total: number;
+    };
+    links: VoiceOpsConsoleLink[];
+    deliverySinks?: VoiceDeliverySinkReport;
+    providers: {
+        degraded: number;
+        healthy: number;
+        total: number;
+    };
+    quality: VoiceQualityReport;
+    recentRoutingEvents: VoiceRoutingEvent[];
+    recentSessions: VoiceSessionListItem[];
+    sessions: {
+        failed: number;
+        healthy: number;
+        total: number;
+    };
+    trace: ReturnType<typeof summarizeVoiceTrace>;
+};
+export type VoiceOpsConsoleRoutesOptions = {
+    headers?: HeadersInit;
+    deliverySinks?: false | VoiceDeliverySinkRoutesOptions;
+    links?: VoiceOpsConsoleLink[];
+    llmProviders?: readonly string[];
+    name?: string;
+    path?: string;
+    store: VoiceTraceEventStore;
+    sttProviders?: readonly string[];
+    title?: string;
+    ttsProviders?: readonly string[];
+};
+export declare const buildVoiceOpsConsoleReport: (options: VoiceOpsConsoleRoutesOptions) => Promise<VoiceOpsConsoleReport>;
+export declare const renderVoiceOpsConsoleHTML: (report: VoiceOpsConsoleReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceOpsConsoleRoutes: (options: VoiceOpsConsoleRoutesOptions) => 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/opsRecovery.d.ts

@@ -0,0 +1,137 @@
+import { Elysia } from 'elysia';
+import { type VoiceAuditSinkDeliveryQueueSummary, type VoiceAuditSinkDeliveryStore } from './auditSinks';
+import { type VoiceLatencySLOGateOptions, type VoiceLatencySLOGateReport } from './latencySlo';
+import { type VoiceHandoffDeliveryQueueSummary, type VoiceTraceSinkDeliveryQueueSummary } from './queue';
+import { type VoiceProviderHealthSummary } from './providerHealth';
+import type { VoiceProductionReadinessCheck } from './productionReadiness';
+import type { VoiceHandoffDeliveryStore } from './types';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore, VoiceTraceSinkDeliveryStore } from './trace';
+export type VoiceOpsRecoveryStatus = 'fail' | 'pass' | 'warn';
+export type VoiceOpsRecoveryIssueCode = 'voice.ops_recovery.audit_delivery_failed' | 'voice.ops_recovery.audit_delivery_pending' | 'voice.ops_recovery.handoff_failed' | 'voice.ops_recovery.handoff_pending' | 'voice.ops_recovery.latency_slo_failed' | 'voice.ops_recovery.latency_slo_warn' | 'voice.ops_recovery.provider_unresolved_failure' | 'voice.ops_recovery.trace_delivery_failed' | 'voice.ops_recovery.trace_delivery_pending';
+export type VoiceOpsRecoveryIssue = {
+    code: VoiceOpsRecoveryIssueCode;
+    detail?: string;
+    href?: string;
+    label: string;
+    severity: Exclude<VoiceOpsRecoveryStatus, 'pass'>;
+    value?: number | string;
+};
+export type VoiceOpsRecoveryProviderSummary<TProvider extends string = string> = {
+    healthy: number;
+    providers: VoiceProviderHealthSummary<TProvider>[];
+    recoveredFallbacks: number;
+    unresolvedFailures: number;
+};
+export type VoiceOpsRecoveryInterventionSummary = {
+    events: Array<{
+        action?: string;
+        at: number;
+        operatorId?: string;
+        sessionId: string;
+        traceId?: string;
+    }>;
+    total: number;
+};
+export type VoiceOpsRecoveryFailedSession = {
+    at: number;
+    error?: string;
+    operationsRecordHref?: string;
+    provider?: string;
+    sessionId: string;
+    traceId?: string;
+};
+export type VoiceOpsRecoveryReport<TProvider extends string = string> = {
+    auditDeliveries?: VoiceAuditSinkDeliveryQueueSummary;
+    checkedAt: number;
+    failedSessions: VoiceOpsRecoveryFailedSession[];
+    handoffDeliveries?: VoiceHandoffDeliveryQueueSummary;
+    interventions: VoiceOpsRecoveryInterventionSummary;
+    issues: VoiceOpsRecoveryIssue[];
+    latency?: VoiceLatencySLOGateReport;
+    providers: VoiceOpsRecoveryProviderSummary<TProvider>;
+    status: VoiceOpsRecoveryStatus;
+    traceDeliveries?: VoiceTraceSinkDeliveryQueueSummary;
+};
+export type VoiceOpsRecoveryLinks = {
+    auditDeliveries?: string;
+    handoffs?: string;
+    operationsRecords?: string | ((sessionId: string) => string);
+    providers?: string;
+    sessions?: string | ((sessionId: string) => string);
+    traceDeliveries?: string;
+    traces?: string | ((sessionId: string) => string);
+};
+export type VoiceOpsRecoveryReportOptions<TProvider extends string = string> = {
+    auditDeliveryDeadLetters?: VoiceAuditSinkDeliveryStore;
+    auditDeliveries?: VoiceAuditSinkDeliveryStore;
+    events?: StoredVoiceTraceEvent[];
+    handoffDeliveryDeadLetters?: VoiceHandoffDeliveryStore;
+    handoffDeliveries?: VoiceHandoffDeliveryStore;
+    latency?: VoiceLatencySLOGateOptions | false;
+    limit?: number;
+    links?: VoiceOpsRecoveryLinks;
+    providers?: readonly TProvider[];
+    traceDeliveryDeadLetters?: VoiceTraceSinkDeliveryStore;
+    traceDeliveries?: VoiceTraceSinkDeliveryStore;
+    traces?: VoiceTraceEventStore;
+};
+export type VoiceOpsRecoveryRoutesOptions<TProvider extends string = string> = VoiceOpsRecoveryReportOptions<TProvider> & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceOpsRecoveryReport<TProvider>) => string | Promise<string>;
+    title?: string;
+};
+export declare const buildVoiceOpsRecoveryReport: <TProvider extends string = string>(options?: VoiceOpsRecoveryReportOptions<TProvider>) => Promise<VoiceOpsRecoveryReport<TProvider>>;
+export declare const buildVoiceOpsRecoveryReadinessCheck: (report: VoiceOpsRecoveryReport, options?: {
+    href?: string;
+    label?: string;
+}) => VoiceProductionReadinessCheck;
+export declare const renderVoiceOpsRecoveryMarkdown: (report: VoiceOpsRecoveryReport, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceOpsRecoveryHTML: (report: VoiceOpsRecoveryReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceOpsRecoveryRoutes: <TProvider extends string = string>(options?: VoiceOpsRecoveryRoutesOptions<TProvider>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceOpsRecoveryReport<TProvider>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/opsStatus.d.ts

@@ -0,0 +1,76 @@
+import { type VoiceEvalLink, type VoiceEvalRoutesOptions } from './evalRoutes';
+import { type VoiceDeliverySinkRoutesOptions } from './deliverySinkRoutes';
+import { type VoiceQualityRoutesOptions } from './qualityRoutes';
+import { type VoiceProviderFallbackRecoverySummary } from './sessionReplay';
+import { type VoiceTraceEventStore } from './trace';
+export type VoiceOpsStatus = 'pass' | 'fail';
+export type VoiceOpsStatusLink = VoiceEvalLink & {
+    description?: string;
+    statusHref?: string;
+};
+export type VoiceOpsStatusOptions<TProvider extends string = string> = {
+    deliverySinks?: false | VoiceDeliverySinkRoutesOptions;
+    evals?: false | Partial<VoiceEvalRoutesOptions>;
+    include?: {
+        deliverySinks?: boolean;
+        handoffs?: boolean;
+        providers?: boolean;
+        providerRecovery?: boolean;
+        quality?: boolean;
+        sessions?: boolean;
+        workflows?: boolean;
+    };
+    links?: VoiceOpsStatusLink[];
+    llmProviders?: readonly TProvider[];
+    preferFixtureWorkflows?: boolean;
+    quality?: false | Partial<VoiceQualityRoutesOptions>;
+    store: VoiceTraceEventStore;
+    sttProviders?: readonly string[];
+    ttsProviders?: readonly string[];
+};
+export type VoiceOpsStatusReport = {
+    checkedAt: number;
+    failed: number;
+    links: VoiceOpsStatusLink[];
+    passed: number;
+    status: VoiceOpsStatus;
+    surfaces: {
+        handoffs?: {
+            failed: number;
+            status: VoiceOpsStatus;
+            total: number;
+        };
+        deliverySinks?: {
+            auditTotal: number;
+            status: VoiceOpsStatus;
+            traceTotal: number;
+        };
+        providers?: {
+            degraded: number;
+            status: VoiceOpsStatus;
+            total: number;
+        };
+        providerRecovery?: VoiceProviderFallbackRecoverySummary;
+        quality?: {
+            status: VoiceOpsStatus;
+        };
+        sessions?: {
+            failed: number;
+            status: VoiceOpsStatus;
+            total: number;
+        };
+        workflows?: {
+            failed: number;
+            source: 'fixtures' | 'live';
+            status: VoiceOpsStatus;
+            total: number;
+        };
+    };
+    total: number;
+};
+export type VoiceOpsStatusRoutesOptions<TProvider extends string = string> = VoiceOpsStatusOptions<TProvider> & {
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+};
+export declare const summarizeVoiceOpsStatus: <TProvider extends string = string>(options: VoiceOpsStatusOptions<TProvider>) => Promise<VoiceOpsStatusReport>;

package/dist/opsStatusRoutes.d.ts

@@ -0,0 +1,33 @@
+import { Elysia } from 'elysia';
+import { type VoiceOpsStatusReport, type VoiceOpsStatusRoutesOptions } from './opsStatus';
+export declare const renderVoiceOpsStatusHTML: (report: VoiceOpsStatusReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceOpsStatusRoutes: (options: VoiceOpsStatusRoutesOptions) => 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/opsWebhook.d.ts

@@ -0,0 +1,126 @@
+import { Elysia } from 'elysia';
+import type { StoredVoiceIntegrationEvent, VoiceIntegrationEventType } from './ops';
+import type { VoiceIntegrationHTTPSinkOptions, VoiceIntegrationSink } from './opsSinks';
+type MaybePromise<T> = T | Promise<T>;
+export type VoiceOpsWebhookLinkResolver = string | ((input: {
+    event: StoredVoiceIntegrationEvent;
+}) => MaybePromise<string | undefined>);
+export type VoiceOpsWebhookEntity = {
+    disposition?: string;
+    outcome?: string;
+    priority?: string;
+    queue?: string;
+    reviewId?: string;
+    scenarioId?: string;
+    sessionId?: string;
+    status?: string;
+    target?: string;
+    taskId?: string;
+};
+export type VoiceOpsWebhookEnvelope = {
+    entity: VoiceOpsWebhookEntity;
+    event: {
+        createdAt: number;
+        id: string;
+        payload: Record<string, unknown>;
+        type: VoiceIntegrationEventType;
+    };
+    links?: {
+        event?: string;
+        replay?: string;
+        review?: string;
+        task?: string;
+    };
+    schemaVersion: 1;
+    source: 'absolutejs-voice';
+};
+export type VoiceOpsWebhookSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions<VoiceOpsWebhookEnvelope>, 'body'> & {
+    baseUrl?: string;
+    eventHref?: VoiceOpsWebhookLinkResolver;
+    replayHref?: VoiceOpsWebhookLinkResolver;
+    reviewHref?: VoiceOpsWebhookLinkResolver;
+    taskHref?: VoiceOpsWebhookLinkResolver;
+};
+export type VoiceOpsWebhookVerificationResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: 'invalid-signature' | 'missing-secret' | 'missing-signature' | 'missing-timestamp' | 'stale-timestamp' | 'unsupported-algorithm';
+};
+export type VoiceOpsWebhookReceiverRoutesOptions = {
+    onEnvelope?: (input: {
+        envelope: VoiceOpsWebhookEnvelope;
+        request: Request;
+    }) => MaybePromise<void>;
+    path?: string;
+    signingSecret?: string;
+    toleranceMs?: number;
+};
+export declare const createVoiceOpsWebhookEnvelope: (input: {
+    baseUrl?: string;
+    event: StoredVoiceIntegrationEvent;
+    eventHref?: VoiceOpsWebhookLinkResolver;
+    replayHref?: VoiceOpsWebhookLinkResolver;
+    reviewHref?: VoiceOpsWebhookLinkResolver;
+    taskHref?: VoiceOpsWebhookLinkResolver;
+}) => Promise<VoiceOpsWebhookEnvelope>;
+export declare const createVoiceOpsWebhookSink: (options: VoiceOpsWebhookSinkOptions) => VoiceIntegrationSink;
+export declare const verifyVoiceOpsWebhookSignature: (input: {
+    body: string;
+    now?: number;
+    secret?: string;
+    signature?: string | null;
+    timestamp?: string | null;
+    toleranceMs?: number;
+}) => Promise<VoiceOpsWebhookVerificationResult>;
+export declare const createVoiceOpsWebhookReceiverRoutes: (options?: VoiceOpsWebhookReceiverRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: {
+                    ok: boolean;
+                    reason: "invalid-signature" | "missing-secret" | "missing-signature" | "missing-timestamp" | "stale-timestamp" | "unsupported-algorithm";
+                    eventId?: undefined;
+                    type?: undefined;
+                } | {
+                    eventId: string;
+                    ok: boolean;
+                    type: VoiceIntegrationEventType;
+                    reason?: undefined;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/dist/outcomeContract.d.ts

@@ -0,0 +1,115 @@
+import { Elysia } from 'elysia';
+import type { StoredVoiceHandoffDelivery, VoiceCallDisposition, VoiceHandoffAction, VoiceHandoffDeliveryStore, VoiceSessionRecord, VoiceSessionStore } from './types';
+import type { StoredVoiceIntegrationEvent, StoredVoiceOpsTask, VoiceIntegrationEventType } from './ops';
+import type { StoredVoiceCallReviewArtifact } from './testing/review';
+export type VoiceOutcomeContractStatus = 'pass' | 'fail';
+export type VoiceOutcomeContractDefinition = {
+    description?: string;
+    expectedDisposition?: VoiceCallDisposition;
+    id: string;
+    label?: string;
+    minSessions?: number;
+    minTasks?: number;
+    requireHandoffActions?: VoiceHandoffAction[];
+    requireIntegrationEvents?: VoiceIntegrationEventType[];
+    requireReview?: boolean;
+    requireTask?: boolean;
+    scenarioId?: string;
+};
+export type VoiceOutcomeContractIssue = {
+    code: string;
+    message: string;
+};
+export type VoiceOutcomeContractReport = {
+    contractId: string;
+    description?: string;
+    issues: VoiceOutcomeContractIssue[];
+    label?: string;
+    matched: {
+        handoffs: number;
+        integrationEvents: number;
+        reviews: number;
+        sessions: number;
+        tasks: number;
+    };
+    operationsRecordHrefs: string[];
+    pass: boolean;
+    sessionIds: string[];
+};
+export type VoiceOutcomeContractSuiteReport = {
+    checkedAt: number;
+    contracts: VoiceOutcomeContractReport[];
+    failed: number;
+    passed: number;
+    status: VoiceOutcomeContractStatus;
+    total: number;
+};
+type ListStore<T> = {
+    list: () => Promise<T[]> | T[];
+};
+export type VoiceOutcomeContractOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    contracts: VoiceOutcomeContractDefinition[];
+    events?: StoredVoiceIntegrationEvent[] | ListStore<StoredVoiceIntegrationEvent>;
+    handoffs?: StoredVoiceHandoffDelivery[] | VoiceHandoffDeliveryStore;
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
+    reviews?: StoredVoiceCallReviewArtifact[] | ListStore<StoredVoiceCallReviewArtifact>;
+    sessions?: TSession[] | VoiceSessionStore<TSession>;
+    tasks?: StoredVoiceOpsTask[] | ListStore<StoredVoiceOpsTask>;
+};
+export type VoiceOutcomeContractHTMLHandlerOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = VoiceOutcomeContractOptions<TSession> & {
+    headers?: HeadersInit;
+    render?: (report: VoiceOutcomeContractSuiteReport) => string | Promise<string>;
+    title?: string;
+};
+export type VoiceOutcomeContractRoutesOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = VoiceOutcomeContractHTMLHandlerOptions<TSession> & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const runVoiceOutcomeContractSuite: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractOptions<TSession>) => Promise<VoiceOutcomeContractSuiteReport>;
+export declare const renderVoiceOutcomeContractHTML: (report: VoiceOutcomeContractSuiteReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceOutcomeContractJSONHandler: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractOptions<TSession>) => () => Promise<VoiceOutcomeContractSuiteReport>;
+export declare const createVoiceOutcomeContractHTMLHandler: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractHTMLHandlerOptions<TSession>) => () => Promise<Response>;
+export declare const createVoiceOutcomeContractRoutes: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractRoutesOptions<TSession>) => 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: VoiceOutcomeContractSuiteReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};