@absolutejs/voice 0.0.22-beta.3 → 0.0.22-beta.300

package/dist/sessionReplay.d.ts

@@ -0,0 +1,187 @@
+import { Elysia } from 'elysia';
+import { type StoredVoiceTraceEvent, type VoiceTraceEvaluationOptions, type VoiceTraceEventStore, type VoiceTraceRedactionConfig, type VoiceTraceSummary, type VoiceTraceEvaluation } from './trace';
+export type VoiceSessionReplayTurn = {
+    assistantReplies: string[];
+    committedText?: string;
+    errors: Array<Record<string, unknown>>;
+    id: string;
+    modelCalls: Array<Record<string, unknown>>;
+    tools: Array<Record<string, unknown>>;
+    transcripts: Array<{
+        isFinal: boolean;
+        text?: string;
+    }>;
+};
+export type VoiceSessionReplay = {
+    evaluation: VoiceTraceEvaluation;
+    events: StoredVoiceTraceEvent[];
+    html: string;
+    markdown: string;
+    sessionId: string;
+    summary: VoiceTraceSummary;
+    timeline: Array<{
+        at: number;
+        offsetMs?: number;
+        payload: Record<string, unknown>;
+        turnId?: string;
+        type: StoredVoiceTraceEvent['type'];
+    }>;
+    turns: VoiceSessionReplayTurn[];
+};
+export type VoiceSessionListStatus = 'failed' | 'healthy';
+export type VoiceSessionListItem = {
+    endedAt?: number;
+    errorCount: number;
+    eventCount: number;
+    latestOutcome?: string;
+    operationsRecordHref?: string;
+    providerErrors: Record<string, number>;
+    providers: string[];
+    replayHref: string;
+    sessionId: string;
+    startedAt?: number;
+    status: VoiceSessionListStatus;
+    transcriptCount: number;
+    turnCount: number;
+};
+export type VoiceProviderFallbackRecoverySummary = {
+    recovered: number;
+    recoveredSessions: number;
+    recoveredTurns: number;
+    status: 'fail' | 'pass';
+    total: number;
+    unresolvedErrors: number;
+    unresolvedSessions: number;
+};
+export type VoiceSessionListOptions = {
+    events?: StoredVoiceTraceEvent[];
+    limit?: number;
+    operationsRecordHref?: false | string | ((session: Omit<VoiceSessionListItem, 'operationsRecordHref' | 'replayHref'>) => string);
+    provider?: string;
+    q?: string;
+    replayHref?: false | string | ((session: Omit<VoiceSessionListItem, 'replayHref'>) => string);
+    status?: VoiceSessionListStatus | 'all';
+    store?: VoiceTraceEventStore;
+};
+export type VoiceSessionListHTMLHandlerOptions = VoiceSessionListOptions & {
+    headers?: HeadersInit;
+    render?: (sessions: VoiceSessionListItem[]) => string | Promise<string>;
+};
+export type VoiceSessionListRoutesOptions = VoiceSessionListHTMLHandlerOptions & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export type VoiceSessionReplayOptions = {
+    evaluation?: VoiceTraceEvaluationOptions;
+    events?: StoredVoiceTraceEvent[];
+    redact?: VoiceTraceRedactionConfig;
+    sessionId: string;
+    store?: VoiceTraceEventStore;
+    title?: string;
+};
+export type VoiceSessionReplayHTMLHandlerOptions = Omit<VoiceSessionReplayOptions, 'sessionId'> & {
+    headers?: HeadersInit;
+    render?: (replay: VoiceSessionReplay) => string | Promise<string>;
+};
+export type VoiceSessionReplayRoutesOptions = VoiceSessionReplayHTMLHandlerOptions & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const summarizeVoiceProviderFallbackRecovery: (events: StoredVoiceTraceEvent[]) => VoiceProviderFallbackRecoverySummary;
+export declare const summarizeVoiceSessionReplay: (options: VoiceSessionReplayOptions) => Promise<VoiceSessionReplay>;
+export declare const summarizeVoiceSessions: (options?: VoiceSessionListOptions) => Promise<VoiceSessionListItem[]>;
+export declare const renderVoiceSessionsHTML: (sessions: VoiceSessionListItem[]) => string;
+export declare const createVoiceSessionsJSONHandler: (options?: VoiceSessionListOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<VoiceSessionListItem[]>;
+export declare const createVoiceSessionsHTMLHandler: (options?: VoiceSessionListHTMLHandlerOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<Response>;
+export declare const createVoiceSessionListRoutes: (options?: VoiceSessionListRoutesOptions) => 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: VoiceSessionListItem[];
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const createVoiceSessionReplayJSONHandler: (options: Omit<VoiceSessionReplayOptions, "sessionId">) => ({ params }: {
+    params: Record<string, string | undefined>;
+}) => Promise<VoiceSessionReplay>;
+export declare const createVoiceSessionReplayHTMLHandler: (options: VoiceSessionReplayHTMLHandlerOptions) => ({ params }: {
+    params: Record<string, string | undefined>;
+}) => Promise<Response>;
+export declare const createVoiceSessionReplayRoutes: (options: VoiceSessionReplayRoutesOptions) => 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: VoiceSessionReplay;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/simulationSuite.d.ts

@@ -0,0 +1,143 @@
+import { Elysia } from 'elysia';
+import { type VoiceEvalReport, type VoiceEvalRoutesOptions, type VoiceScenarioEvalDefinition, type VoiceScenarioEvalReport, type VoiceScenarioFixture, type VoiceScenarioFixtureEvalReport, type VoiceScenarioFixtureStore } from './evalRoutes';
+import { type VoiceOutcomeContractDefinition, type VoiceOutcomeContractOptions, type VoiceOutcomeContractSuiteReport } from './outcomeContract';
+import { type VoiceToolContractDefinition, type VoiceToolContractSuiteReport } from './toolContract';
+import type { VoiceQualityThresholds } from './qualityRoutes';
+import type { VoiceTraceEventStore } from './trace';
+import type { VoiceSessionRecord } from './types';
+export type VoiceSimulationSuiteStatus = 'pass' | 'fail';
+export type VoiceSimulationSuiteReport = {
+    actions: VoiceSimulationSuiteAction[];
+    checkedAt: number;
+    failed: number;
+    fixtures?: VoiceScenarioFixtureEvalReport;
+    outcomes?: VoiceOutcomeContractSuiteReport;
+    passed: number;
+    scenarios?: VoiceScenarioEvalReport;
+    sessions?: VoiceEvalReport;
+    status: VoiceSimulationSuiteStatus;
+    summary: {
+        fixtures?: VoiceSimulationSuiteSectionSummary;
+        outcomes?: VoiceSimulationSuiteSectionSummary;
+        scenarios?: VoiceSimulationSuiteSectionSummary;
+        sessions?: VoiceSimulationSuiteSectionSummary;
+        tools?: VoiceSimulationSuiteSectionSummary;
+    };
+    tools?: VoiceToolContractSuiteReport;
+    total: number;
+};
+export type VoiceSimulationSuiteAction = {
+    description: string;
+    href?: string;
+    label: string;
+    section: 'fixtures' | 'outcomes' | 'scenarios' | 'sessions' | 'tools';
+    severity: 'error' | 'warning';
+};
+export type VoiceSimulationSuiteSectionSummary = {
+    failed: number;
+    passed: number;
+    status: VoiceSimulationSuiteStatus;
+    total: number;
+};
+export type VoiceSimulationSuiteSection = 'fixtures' | 'outcomes' | 'scenarios' | 'sessions' | 'tools';
+export type VoiceSimulationSuiteAssertionInput = {
+    maxActions?: number;
+    maxFailed?: number;
+    minPassed?: number;
+    minSections?: number;
+    requiredSections?: VoiceSimulationSuiteSection[];
+    sectionMinimums?: Partial<Record<VoiceSimulationSuiteSection, number>>;
+};
+export type VoiceSimulationSuiteAssertionReport = {
+    actions: number;
+    failed: number;
+    issues: string[];
+    ok: boolean;
+    passed: number;
+    sections: VoiceSimulationSuiteSection[];
+    sectionTotals: Partial<Record<VoiceSimulationSuiteSection, number>>;
+    status: VoiceSimulationSuiteStatus;
+    total: number;
+};
+export type VoiceSimulationSuiteOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    actionLinks?: {
+        fixtures?: string;
+        outcomes?: string;
+        scenarios?: string;
+        sessions?: string;
+        tools?: string;
+    };
+    fixtures?: VoiceScenarioFixture[];
+    fixtureStore?: VoiceScenarioFixtureStore;
+    include?: {
+        fixtures?: boolean;
+        outcomes?: boolean;
+        scenarios?: boolean;
+        sessions?: boolean;
+        tools?: boolean;
+    };
+    limit?: number;
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
+    outcomes?: Omit<VoiceOutcomeContractOptions<TSession>, 'contracts'> & {
+        contracts: VoiceOutcomeContractDefinition[];
+    };
+    scenarios?: VoiceScenarioEvalDefinition[];
+    store?: VoiceTraceEventStore;
+    thresholds?: VoiceQualityThresholds;
+    tools?: VoiceToolContractDefinition[];
+};
+export type VoiceSimulationSuiteRoutesOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = VoiceSimulationSuiteOptions<TSession> & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceSimulationSuiteReport) => string | Promise<string>;
+    title?: string;
+};
+export declare const runVoiceSimulationSuite: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceSimulationSuiteOptions<TSession>) => Promise<VoiceSimulationSuiteReport>;
+export declare const evaluateVoiceSimulationSuiteEvidence: (report: VoiceSimulationSuiteReport, input?: VoiceSimulationSuiteAssertionInput) => VoiceSimulationSuiteAssertionReport;
+export declare const assertVoiceSimulationSuiteEvidence: (report: VoiceSimulationSuiteReport, input?: VoiceSimulationSuiteAssertionInput) => VoiceSimulationSuiteAssertionReport;
+export declare const renderVoiceSimulationSuiteHTML: (report: VoiceSimulationSuiteReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceSimulationSuiteRoutes: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceSimulationSuiteRoutesOptions<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: VoiceSimulationSuiteReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export type VoiceSimulationSuiteEvalRoutesOptions = VoiceEvalRoutesOptions;

package/dist/sloCalibration.d.ts

@@ -0,0 +1,185 @@
+import { Elysia } from 'elysia';
+import type { VoiceProviderSloThresholdConfig } from './providerSlo';
+import type { VoiceProductionReadinessRoutesOptions } from './productionReadiness';
+import type { VoiceProofTrendReport } from './proofTrends';
+export type VoiceSloCalibrationStatus = 'fail' | 'pass' | 'warn';
+export type VoiceSloCalibrationMetricKey = 'interruption' | 'liveLatency' | 'monitorRun' | 'notifierDelivery' | 'provider' | 'reconnect' | 'turnLatency';
+export type VoiceSloCalibrationSample = {
+    generatedAt?: string;
+    interruptionP95Ms?: number;
+    liveP95Ms?: number;
+    monitorRunP95Ms?: number;
+    notifierDeliveryP95Ms?: number;
+    ok?: boolean;
+    providerP95Ms?: number;
+    reconnectP95Ms?: number;
+    runId?: string;
+    source?: string;
+    turnP95Ms?: number;
+};
+export type VoiceSloCalibrationThreshold = {
+    baselineP95Ms?: number;
+    failAfterMs?: number;
+    headroomMultiplier: number;
+    maxObservedMs?: number;
+    metric: VoiceSloCalibrationMetricKey;
+    minimumMs: number;
+    recommendedMs?: number;
+    samples: number;
+    status: VoiceSloCalibrationStatus;
+    warnAfterMs?: number;
+};
+export type VoiceSloCalibrationThresholds = {
+    interruption: VoiceSloCalibrationThreshold;
+    liveLatency: VoiceSloCalibrationThreshold;
+    monitorRun: VoiceSloCalibrationThreshold;
+    notifierDelivery: VoiceSloCalibrationThreshold;
+    provider: VoiceSloCalibrationThreshold;
+    reconnect: VoiceSloCalibrationThreshold;
+    turnLatency: VoiceSloCalibrationThreshold;
+};
+export type VoiceSloCalibrationReport = {
+    generatedAt: string;
+    issues: string[];
+    minPassingRuns: number;
+    ok: boolean;
+    passingRuns: number;
+    recommendedProviderSloThresholds: VoiceProviderSloThresholdConfig;
+    runs: number;
+    sources: string[];
+    status: VoiceSloCalibrationStatus;
+    thresholds: VoiceSloCalibrationThresholds;
+};
+export type VoiceSloThresholdProfile = {
+    bargeIn: {
+        thresholdMs?: number;
+    };
+    issues: string[];
+    liveLatency: {
+        failAfterMs?: number;
+        warnAfterMs?: number;
+    };
+    monitoring: {
+        monitorRunFailAfterMs?: number;
+        notifierDeliveryFailAfterMs?: number;
+    };
+    providerSlo: VoiceProviderSloThresholdConfig;
+    reconnect: {
+        failAfterMs?: number;
+    };
+    status: VoiceSloCalibrationStatus;
+};
+export type VoiceSloReadinessThresholdOptions = Pick<VoiceProductionReadinessRoutesOptions, 'liveLatencyFailAfterMs' | 'liveLatencyWarnAfterMs' | 'monitoringNotifierDeliveryFailAfterMs' | 'monitoringRunFailAfterMs' | 'reconnectResumeFailAfterMs'>;
+export type VoiceSloReadinessThresholdReport = {
+    bargeIn: VoiceSloThresholdProfile['bargeIn'];
+    generatedAt: string;
+    issues: string[];
+    liveLatencyMaxAgeMs?: number;
+    ok: boolean;
+    providerSlo: VoiceProviderSloThresholdConfig;
+    readinessOptions: VoiceSloReadinessThresholdOptions;
+    sources: string[];
+    status: VoiceSloCalibrationStatus;
+};
+export type VoiceSloCalibrationOptions = {
+    headroomMultiplier?: number;
+    liveLatencyMinimumMs?: number;
+    minPassingRuns?: number;
+    monitorRunMinimumMs?: number;
+    notifierDeliveryMinimumMs?: number;
+    providerMinimumMs?: number;
+    reconnectMinimumMs?: number;
+    interruptionMinimumMs?: number;
+    turnLatencyMinimumMs?: number;
+    warnRatio?: number;
+};
+export type VoiceSloCalibrationRoutesOptions = VoiceSloCalibrationOptions & {
+    headers?: HeadersInit;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    source: (() => Promise<Array<VoiceProofTrendReport | VoiceSloCalibrationSample>> | Array<VoiceProofTrendReport | VoiceSloCalibrationSample>) | Array<VoiceProofTrendReport | VoiceSloCalibrationSample>;
+    title?: string;
+};
+export type VoiceSloReadinessThresholdReportOptions = VoiceSloCalibrationOptions & {
+    liveLatencyMaxAgeMs?: number;
+};
+export type VoiceSloReadinessThresholdRoutesOptions = VoiceSloReadinessThresholdReportOptions & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    source: (() => Promise<VoiceSloCalibrationReport | VoiceSloThresholdProfile | Array<VoiceProofTrendReport | VoiceSloCalibrationSample>> | VoiceSloCalibrationReport | VoiceSloThresholdProfile | Array<VoiceProofTrendReport | VoiceSloCalibrationSample>) | VoiceSloCalibrationReport | VoiceSloThresholdProfile | Array<VoiceProofTrendReport | VoiceSloCalibrationSample>;
+    title?: string;
+};
+export declare const buildVoiceSloCalibrationReport: (input: Array<VoiceProofTrendReport | VoiceSloCalibrationSample>, options?: VoiceSloCalibrationOptions) => VoiceSloCalibrationReport;
+export declare const assertVoiceSloCalibration: (input: Array<VoiceProofTrendReport | VoiceSloCalibrationSample>, options?: VoiceSloCalibrationOptions) => VoiceSloCalibrationReport;
+export declare const createVoiceSloThresholdProfile: (input: VoiceSloCalibrationReport | Array<VoiceProofTrendReport | VoiceSloCalibrationSample>, options?: VoiceSloCalibrationOptions) => VoiceSloThresholdProfile;
+export declare const createVoiceSloReadinessThresholdOptions: (input: VoiceSloCalibrationReport | VoiceSloThresholdProfile | Array<VoiceProofTrendReport | VoiceSloCalibrationSample>, options?: VoiceSloCalibrationOptions) => VoiceSloReadinessThresholdOptions;
+export declare const buildVoiceSloReadinessThresholdReport: (input: VoiceSloCalibrationReport | VoiceSloThresholdProfile | Array<VoiceProofTrendReport | VoiceSloCalibrationSample>, options?: VoiceSloReadinessThresholdReportOptions) => VoiceSloReadinessThresholdReport;
+export declare const renderVoiceSloCalibrationMarkdown: (report: VoiceSloCalibrationReport, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceSloReadinessThresholdMarkdown: (report: VoiceSloReadinessThresholdReport, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceSloReadinessThresholdHTML: (report: VoiceSloReadinessThresholdReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceSloCalibrationRoutes: (options: VoiceSloCalibrationRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const createVoiceSloReadinessThresholdRoutes: (options: VoiceSloReadinessThresholdRoutesOptions) => 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/sqliteStore.d.ts

@@ -1,13 +1,20 @@
 import { type StoredVoiceTraceEvent, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore, type VoiceTraceEventStore } from './trace';
+import { type StoredVoiceAuditEvent, type VoiceAuditEventStore } from './audit';
+import type { VoiceAuditSinkDeliveryRecord, VoiceAuditSinkDeliveryStore } from './auditSinks';
 import type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredVoiceOpsTask, VoiceExternalObjectMapStore, VoiceIntegrationEventStore, VoiceOpsTaskStore } from './ops';
 import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
+import type { VoiceTelephonyWebhookIdempotencyStore } from './telephonyOutcome';
+import type { VoiceCampaignStore } from './campaign';
 import type { VoiceSessionRecord, VoiceSessionStore } from './types';
 export type VoiceSQLiteStoreOptions = {
     path: string;
     tableName?: string;
     tablePrefix?: string;
 };
-export type VoiceSQLiteRuntimeStorage<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> = {
+export type VoiceSQLiteRuntimeStorage<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> = {
+    audit: VoiceAuditEventStore<TAudit>;
+    auditDeliveries: VoiceAuditSinkDeliveryStore<TAuditDelivery>;
+    campaigns: VoiceCampaignStore;
     events: VoiceIntegrationEventStore<TEvent>;
     externalObjects: VoiceExternalObjectMapStore<TMapping>;
     reviews: VoiceCallReviewStore<TReview>;
@@ -23,4 +30,8 @@ export declare const createVoiceSQLiteIntegrationEventStore: <TEvent extends Sto
 export declare const createVoiceSQLiteExternalObjectMapStore: <TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap>(options: VoiceSQLiteStoreOptions) => VoiceExternalObjectMapStore<TMapping>;
 export declare const createVoiceSQLiteTraceEventStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(options: VoiceSQLiteStoreOptions) => VoiceTraceEventStore<TEvent>;
 export declare const createVoiceSQLiteTraceSinkDeliveryStore: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoiceSQLiteStoreOptions) => VoiceTraceSinkDeliveryStore<TDelivery>;
-export declare const createVoiceSQLiteRuntimeStorage: <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>(options: VoiceSQLiteStoreOptions) => VoiceSQLiteRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery>;
+export declare const createVoiceSQLiteAuditEventStore: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>(options: VoiceSQLiteStoreOptions) => VoiceAuditEventStore<TEvent>;
+export declare const createVoiceSQLiteAuditSinkDeliveryStore: <TDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord>(options: VoiceSQLiteStoreOptions) => VoiceAuditSinkDeliveryStore<TDelivery>;
+export declare const createVoiceSQLiteTelephonyWebhookIdempotencyStore: <TResult = unknown>(options: VoiceSQLiteStoreOptions) => VoiceTelephonyWebhookIdempotencyStore<TResult>;
+export declare const createVoiceSQLiteCampaignStore: (options: VoiceSQLiteStoreOptions) => VoiceCampaignStore;
+export declare const createVoiceSQLiteRuntimeStorage: <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>(options: VoiceSQLiteStoreOptions) => VoiceSQLiteRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery, TAudit, TAuditDelivery>;

package/dist/svelte/createVoiceAgentSquadStatus.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceAgentSquadStatusWidgetOptions } from '../client/agentSquadStatusWidget';
+export declare const createVoiceAgentSquadStatus: (path?: string, options?: VoiceAgentSquadStatusWidgetOptions) => {
+    close: () => void;
+    getHTML: () => string;
+    getSnapshot: () => import("../client").VoiceAgentSquadStatusSnapshot;
+    getViewModel: () => import("../client").VoiceAgentSquadStatusViewModel;
+    refresh: () => Promise<import("..").VoiceTraceTimelineReport | null>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceCampaignDialerProof.d.ts

@@ -0,0 +1,9 @@
+import type { VoiceCampaignDialerProofClientOptions } from '../client/campaignDialerProof';
+export declare const createVoiceCampaignDialerProof: (path?: string, options?: VoiceCampaignDialerProofClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => import("../client").VoiceCampaignDialerProofSnapshot;
+    getSnapshot: () => import("../client").VoiceCampaignDialerProofSnapshot;
+    refresh: () => Promise<import("..").VoiceCampaignDialerProofStatus | undefined>;
+    runProof: () => Promise<import("..").VoiceCampaignDialerProofReport>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceDeliveryRuntime.d.ts

@@ -0,0 +1,11 @@
+import { type VoiceDeliveryRuntimeWidgetOptions } from '../client/deliveryRuntimeWidget';
+export declare const createVoiceDeliveryRuntime: (path?: string, options?: VoiceDeliveryRuntimeWidgetOptions) => {
+    close: () => void;
+    getHTML: () => string;
+    getSnapshot: () => import("../client").VoiceDeliveryRuntimeSnapshot;
+    getViewModel: () => import("../client").VoiceDeliveryRuntimeViewModel;
+    requeueDeadLetters: () => Promise<import("../client").VoiceDeliveryRuntimeActionResult | undefined>;
+    refresh: () => Promise<import("..").VoiceDeliveryRuntimeReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+    tick: () => Promise<import("../client").VoiceDeliveryRuntimeActionResult | undefined>;
+};

package/dist/svelte/createVoiceLiveOps.d.ts

@@ -0,0 +1,13 @@
+import { type VoiceLiveOpsClientOptions } from '../client/liveOps';
+import { type VoiceLiveOpsWidgetOptions } from '../client/liveOpsWidget';
+export declare const createVoiceLiveOps: (options?: VoiceLiveOpsClientOptions | VoiceLiveOpsWidgetOptions) => {
+    close: () => void;
+    getHTML: () => string;
+    getSnapshot: () => import("../client").VoiceLiveOpsSnapshot;
+    mount: (element: Element) => {
+        close: () => void;
+        run: (input: import("..").VoiceLiveOpsActionInput) => Promise<import("..").VoiceLiveOpsActionResult | undefined>;
+    };
+    run: (input: import("..").VoiceLiveOpsActionInput) => Promise<import("..").VoiceLiveOpsActionResult | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceOpsActionCenter.d.ts

@@ -0,0 +1,10 @@
+import { type VoiceOpsActionCenterWidgetOptions } from '../client/opsActionCenterWidget';
+export declare const createVoiceOpsActionCenter: (options?: VoiceOpsActionCenterWidgetOptions) => {
+    close: () => void;
+    getHTML: () => string;
+    getSnapshot: () => import("../client").VoiceOpsActionCenterSnapshot;
+    getViewModel: () => import("../client").VoiceOpsActionCenterViewModel;
+    run: (actionId: string) => Promise<import("../client").VoiceOpsActionRunResult | undefined>;
+    setActions: (actions: import("../client").VoiceOpsActionDescriptor[]) => void;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceOpsStatus.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceOpsStatusWidgetOptions } from '../client/opsStatusWidget';
+export declare const createVoiceOpsStatus: (path?: string, options?: VoiceOpsStatusWidgetOptions) => {
+    close: () => void;
+    getHTML: () => string;
+    getSnapshot: () => import("../client").VoiceOpsStatusSnapshot;
+    getViewModel: () => import("../client").VoiceOpsStatusViewModel;
+    refresh: () => Promise<import("..").VoiceOpsStatusReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoicePlatformCoverage.d.ts

@@ -0,0 +1,7 @@
+import type { VoicePlatformCoverageClientOptions } from '../client/platformCoverage';
+export declare const createVoicePlatformCoverage: (path?: string, options?: VoicePlatformCoverageClientOptions) => {
+    close: () => void;
+    getSnapshot: () => import("../client/platformCoverage").VoicePlatformCoverageSnapshot;
+    refresh: () => Promise<import("..").VoicePlatformCoverageSummary | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceProofTrends.d.ts

@@ -0,0 +1,7 @@
+import type { VoiceProofTrendsClientOptions } from '../client/proofTrends';
+export declare const createVoiceProofTrends: (path?: string, options?: VoiceProofTrendsClientOptions) => {
+    close: () => void;
+    getSnapshot: () => import("../client/proofTrends").VoiceProofTrendsSnapshot;
+    refresh: () => Promise<import("..").VoiceProofTrendReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceProviderCapabilities.d.ts

@@ -0,0 +1,10 @@
+import { type VoiceProviderCapabilitiesWidgetOptions } from '../client/providerCapabilitiesWidget';
+export declare const createVoiceProviderCapabilities: <TProvider extends string = string>(path?: string, options?: VoiceProviderCapabilitiesWidgetOptions) => {
+    getHTML: () => string;
+    getViewModel: () => import("../client").VoiceProviderCapabilitiesViewModel<TProvider>;
+    close: () => void;
+    getServerSnapshot: () => import("../client").VoiceProviderCapabilitiesSnapshot<TProvider>;
+    getSnapshot: () => import("../client").VoiceProviderCapabilitiesSnapshot<TProvider>;
+    refresh: () => Promise<import("..").VoiceProviderCapabilityReport<TProvider> | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceProviderContracts.d.ts

@@ -0,0 +1,10 @@
+import { type VoiceProviderContractsWidgetOptions } from '../client/providerContractsWidget';
+export declare const createVoiceProviderContracts: <TProvider extends string = string>(path?: string, options?: VoiceProviderContractsWidgetOptions) => {
+    getHTML: () => string;
+    getViewModel: () => import("../client").VoiceProviderContractsViewModel<TProvider>;
+    close: () => void;
+    getServerSnapshot: () => import("../client").VoiceProviderContractsSnapshot<TProvider>;
+    getSnapshot: () => import("../client").VoiceProviderContractsSnapshot<TProvider>;
+    refresh: () => Promise<import("..").VoiceProviderContractMatrixReport<TProvider> | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};