@absolutejs/voice 0.0.22-beta.54 → 0.0.22-beta.540

package/dist/core/phoneAgentProductionSmoke.d.ts

@@ -0,0 +1,115 @@
+import { Elysia } from "elysia";
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from "./trace";
+import type { VoiceTelephonyContractReport, VoiceTelephonyProvider } from "../telephony/contract";
+export type VoicePhoneAgentProductionSmokeRequirement = "assistant-response" | "carrier-contract" | "fresh-trace" | "lifecycle-outcome" | "media-started" | "no-session-error" | "transcript";
+export type VoicePhoneAgentProductionSmokeIssue = {
+    message: string;
+    requirement: VoicePhoneAgentProductionSmokeRequirement;
+    severity: "error" | "warning";
+};
+export type VoicePhoneAgentProductionSmokeReport<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = {
+    contract?: VoiceTelephonyContractReport<TProvider>;
+    contractId: string;
+    generatedAt: number;
+    issues: VoicePhoneAgentProductionSmokeIssue[];
+    maxAgeMs?: number;
+    observed: {
+        assistantResponses: number;
+        carrierContract?: boolean;
+        lifecycleOutcomes: string[];
+        latestEventAt?: number;
+        mediaStarts: number;
+        sessionErrors: number;
+        transcripts: number;
+    };
+    pass: boolean;
+    provider?: TProvider;
+    required: VoicePhoneAgentProductionSmokeRequirement[];
+    scenarioId?: string;
+    sessionId?: string;
+    traceId?: string;
+};
+export type VoicePhoneAgentProductionSmokeOptions<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = {
+    contract?: VoiceTelephonyContractReport<TProvider>;
+    contractId?: string;
+    events?: readonly StoredVoiceTraceEvent[];
+    maxAgeMs?: number;
+    now?: number;
+    provider?: TProvider;
+    required?: readonly VoicePhoneAgentProductionSmokeRequirement[];
+    scenarioId?: string;
+    sessionId?: string;
+    store?: VoiceTraceEventStore;
+    traceId?: string;
+};
+export type VoicePhoneAgentProductionSmokeHandlerOptions<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = Omit<VoicePhoneAgentProductionSmokeOptions<TProvider>, "events" | "scenarioId" | "sessionId" | "traceId"> & {
+    getContract?: (input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceTelephonyContractReport<TProvider> | undefined> | VoiceTelephonyContractReport<TProvider> | undefined;
+    scenarioId?: string;
+    sessionId?: string;
+    traceId?: string;
+};
+export type VoicePhoneAgentProductionSmokeHTMLHandlerOptions<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = VoicePhoneAgentProductionSmokeHandlerOptions<TProvider> & {
+    headers?: HeadersInit;
+    render?: (report: VoicePhoneAgentProductionSmokeReport<TProvider>) => Promise<string> | string;
+    title?: string;
+};
+export type VoicePhoneAgentProductionSmokeRoutesOptions<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = VoicePhoneAgentProductionSmokeHTMLHandlerOptions<TProvider> & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const runVoicePhoneAgentProductionSmokeContract: <TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider>(options: VoicePhoneAgentProductionSmokeOptions<TProvider>) => Promise<VoicePhoneAgentProductionSmokeReport<TProvider>>;
+export declare const createVoicePhoneAgentProductionSmokeHTMLHandler: <TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider>(options: VoicePhoneAgentProductionSmokeHTMLHandlerOptions<TProvider>) => ({ query, request, }: {
+    query: Record<string, unknown>;
+    request: Request;
+}) => Promise<Response>;
+export declare const createVoicePhoneAgentProductionSmokeJSONHandler: <TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider>(options: VoicePhoneAgentProductionSmokeHandlerOptions<TProvider>) => ({ query, request, }: {
+    query: Record<string, unknown>;
+    request: Request;
+}) => Promise<VoicePhoneAgentProductionSmokeReport<TProvider>>;
+export declare const createVoicePhoneAgentProductionSmokeRoutes: <TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider>(options: VoicePhoneAgentProductionSmokeRoutesOptions<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: VoicePhoneAgentProductionSmokeReport<TProvider>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const renderVoicePhoneAgentProductionSmokeHTML: <TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider>(report: VoicePhoneAgentProductionSmokeReport<TProvider>, options?: {
+    title?: string;
+}) => string;

package/dist/core/phoneProvisioning.d.ts

@@ -0,0 +1,29 @@
+export type VoicePhoneNumber = {
+    phoneNumber: string;
+    provider: "telnyx" | "twilio" | (string & {});
+    providerNumberId: string;
+    raw: unknown;
+};
+export type TwilioProvisionInput = {
+    accountSid: string;
+    areaCode?: string;
+    authToken: string;
+    contains?: string;
+    countryCode?: string;
+    fetch?: typeof fetch;
+    friendlyName?: string;
+    smsUrl?: string;
+    statusCallbackUrl?: string;
+    voiceUrl: string;
+};
+export declare const provisionTwilioPhoneNumber: (input: TwilioProvisionInput) => Promise<VoicePhoneNumber>;
+export type TelnyxProvisionInput = {
+    apiKey: string;
+    areaCode?: string;
+    connectionId?: string;
+    countryCode?: string;
+    fetch?: typeof fetch;
+    messagingProfileId?: string;
+    voiceWebhookUrl: string;
+};
+export declare const provisionTelnyxPhoneNumber: (input: TelnyxProvisionInput) => Promise<VoicePhoneNumber>;

package/dist/core/platformCoverage.d.ts

@@ -0,0 +1,91 @@
+import { Elysia } from "elysia";
+export type VoicePlatformCoverageStatus = "fail" | "missing" | "pass" | "stale";
+export type VoicePlatformCoverageEvidence = {
+    method?: string;
+    name: string;
+    ok?: boolean;
+    path?: string;
+    status?: number;
+    url?: string;
+};
+export type VoicePlatformCoverageSurface = {
+    evidence: VoicePlatformCoverageEvidence[];
+    failed?: number;
+    gap?: string;
+    missing?: number;
+    missingEvidence?: string[];
+    replacement: string;
+    status: "fail" | "pass" | string;
+    surface: string;
+};
+export type VoicePlatformCoverageSummary = {
+    generatedAt?: string;
+    ok: boolean;
+    outputDir?: string;
+    runId?: string;
+    source?: string;
+    status: VoicePlatformCoverageStatus;
+    total: number;
+    coverage: VoicePlatformCoverageSurface[];
+};
+export type VoicePlatformCoverageSummaryInput = {
+    coverage?: VoicePlatformCoverageSurface[];
+    generatedAt?: string;
+    ok?: boolean;
+    outputDir?: string;
+    runId?: string;
+    source?: string;
+};
+export type VoicePlatformCoverageRoutesOptions = {
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+    source: (() => Promise<VoicePlatformCoverageSummary | VoicePlatformCoverageSummaryInput> | VoicePlatformCoverageSummary | VoicePlatformCoverageSummaryInput) | VoicePlatformCoverageSummary | VoicePlatformCoverageSummaryInput;
+};
+export type VoicePlatformCoverageAssertionInput = {
+    maxFailedSurfaces?: number;
+    minSurfaces?: number;
+    requiredEvidence?: string[];
+    requiredSurfaces?: string[];
+    requirePass?: boolean;
+};
+export type VoicePlatformCoverageAssertionReport = {
+    failed: number;
+    issues: string[];
+    missing: number;
+    ok: boolean;
+    status: VoicePlatformCoverageStatus;
+    surfaces: string[];
+    total: number;
+};
+export declare const assertVoicePlatformCoverage: (summary: VoicePlatformCoverageSummary, input?: VoicePlatformCoverageAssertionInput) => VoicePlatformCoverageAssertionReport;
+export declare const buildVoicePlatformCoverageSummary: (input: VoicePlatformCoverageSummaryInput) => VoicePlatformCoverageSummary;
+export declare const evaluateVoicePlatformCoverage: (summary: VoicePlatformCoverageSummary, input?: VoicePlatformCoverageAssertionInput) => VoicePlatformCoverageAssertionReport;
+export declare const createVoicePlatformCoverageRoutes: (options: VoicePlatformCoverageRoutesOptions) => 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/{plugin.d.ts → core/plugin.d.ts}

@@ -1,5 +1,5 @@
-import { Elysia } from 'elysia';
-import type { VoicePluginConfig, VoiceSessionRecord } from './types';
+import { Elysia } from "elysia";
+import type { VoicePluginConfig, VoiceSessionRecord } from "./types";
 export declare const voice: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(config: VoicePluginConfig<TContext, TSession, TResult>) => Elysia<"", {
     decorator: {};
     store: {};

package/dist/core/postCallAnalysis.d.ts

@@ -0,0 +1,98 @@
+import { Elysia } from "elysia";
+import type { StoredVoiceIntegrationEvent, StoredVoiceOpsTask, VoiceIntegrationEventStore, VoiceOpsTaskKind, VoiceOpsTaskStore } from "./ops";
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from "../testing/review";
+export type VoicePostCallAnalysisStatus = "fail" | "pass" | "warn";
+export type VoicePostCallAnalysisFieldRequirement = {
+    label?: string;
+    path: string;
+    required?: boolean;
+};
+export type VoicePostCallAnalysisFieldResult = {
+    label: string;
+    ok: boolean;
+    path: string;
+    required: boolean;
+    value?: unknown;
+};
+export type VoicePostCallAnalysisIssueCode = "voice.post_call_analysis.integration_failed" | "voice.post_call_analysis.integration_missing" | "voice.post_call_analysis.required_field_missing" | "voice.post_call_analysis.required_task_missing" | "voice.post_call_analysis.review_failed" | "voice.post_call_analysis.review_missing";
+export type VoicePostCallAnalysisIssue = {
+    code: VoicePostCallAnalysisIssueCode;
+    detail?: string;
+    label: string;
+    severity: Exclude<VoicePostCallAnalysisStatus, "pass">;
+};
+export type VoicePostCallAnalysisReport = {
+    checkedAt: number;
+    fields: VoicePostCallAnalysisFieldResult[];
+    integrationEvents: StoredVoiceIntegrationEvent[];
+    issues: VoicePostCallAnalysisIssue[];
+    operationRecordHref?: string;
+    review?: StoredVoiceCallReviewArtifact;
+    reviewId?: string;
+    sessionId?: string;
+    status: VoicePostCallAnalysisStatus;
+    summary: {
+        deliveredIntegrationEvents: number;
+        failedIntegrationEvents: number;
+        fields: number;
+        missingRequiredFields: number;
+        missingRequiredTasks: number;
+        requiredFields: number;
+        requiredTaskKinds: number;
+        tasks: number;
+    };
+    tasks: StoredVoiceOpsTask[];
+};
+export type VoicePostCallAnalysisOptions = {
+    at?: number;
+    extractedFields?: Record<string, unknown>;
+    fields?: VoicePostCallAnalysisFieldRequirement[];
+    integrationEvents?: StoredVoiceIntegrationEvent[] | VoiceIntegrationEventStore;
+    operationRecordBasePath?: string;
+    requireDeliveredIntegrationEvent?: boolean;
+    requiredTaskKinds?: VoiceOpsTaskKind[];
+    review?: StoredVoiceCallReviewArtifact;
+    reviewId?: string;
+    reviews?: StoredVoiceCallReviewArtifact[] | VoiceCallReviewStore;
+    sessionId?: string;
+    tasks?: StoredVoiceOpsTask[] | VoiceOpsTaskStore;
+};
+export type VoicePostCallAnalysisRoutesOptions = VoicePostCallAnalysisOptions & {
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+    source?: ((input: {
+        reviewId?: string;
+        sessionId?: string;
+    }) => Promise<VoicePostCallAnalysisOptions | VoicePostCallAnalysisReport> | VoicePostCallAnalysisOptions | VoicePostCallAnalysisReport) | VoicePostCallAnalysisOptions | VoicePostCallAnalysisReport;
+};
+export declare const buildVoicePostCallAnalysisReport: (options?: VoicePostCallAnalysisOptions) => Promise<VoicePostCallAnalysisReport>;
+export declare const renderVoicePostCallAnalysisMarkdown: (report: VoicePostCallAnalysisReport) => string;
+export declare const createVoicePostCallAnalysisRoutes: (options?: VoicePostCallAnalysisRoutesOptions) => 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/core/postCallSurvey.d.ts

@@ -0,0 +1,41 @@
+export type VoicePostCallSurveyQuestion = {
+    id: string;
+    prompt: string;
+    type: "rating" | "boolean" | "comment";
+    min?: number;
+    max?: number;
+    required?: boolean;
+};
+export type VoicePostCallSurveyAnswer = {
+    questionId: string;
+    value: number | boolean | string | null;
+};
+export type VoicePostCallSurveyResponse = {
+    sessionId: string;
+    startedAt: number;
+    completedAt: number | null;
+    answers: VoicePostCallSurveyAnswer[];
+    npsBucket: "promoter" | "passive" | "detractor" | null;
+};
+export type CreateVoicePostCallSurveyOptions = {
+    sessionId: string;
+    questions?: VoicePostCallSurveyQuestion[];
+    now?: () => number;
+};
+export declare const DEFAULT_VOICE_POST_CALL_SURVEY_QUESTIONS: VoicePostCallSurveyQuestion[];
+export declare const createVoicePostCallSurvey: (options: CreateVoicePostCallSurveyOptions) => {
+    complete: () => VoicePostCallSurveyResponse;
+    next: () => VoicePostCallSurveyQuestion | null;
+    questions: VoicePostCallSurveyQuestion[];
+    record: (questionId: string, value: number | boolean | string | null) => VoicePostCallSurveyAnswer;
+    skip: () => VoicePostCallSurveyQuestion | null;
+    getResponse: () => VoicePostCallSurveyResponse;
+};
+export type VoicePostCallSurvey = ReturnType<typeof createVoicePostCallSurvey>;
+export declare const summarizeVoicePostCallSurveys: (responses: VoicePostCallSurveyResponse[]) => {
+    completion: number;
+    detractors: number;
+    nps: number | null;
+    promoters: number;
+    sampleSize: number;
+};

package/dist/{postgresStore.d.ts → core/postgresStore.d.ts}

@@ -1,7 +1,11 @@
-import { type StoredVoiceTraceEvent, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore, type VoiceTraceEventStore } from './trace';
-import type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredVoiceOpsTask, VoiceExternalObjectMapStore, VoiceIntegrationEventStore, VoiceOpsTaskStore } from './ops';
-import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
-import type { VoiceSessionRecord, VoiceSessionStore } from './types';
+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 VoicePostgresClient = {
     unsafe: <TRow extends Record<string, unknown> = Record<string, unknown>>(query: string, parameters?: unknown[]) => Promise<TRow[]>;
 };
@@ -12,7 +16,10 @@ export type VoicePostgresStoreOptions = {
     tableName?: string;
     tablePrefix?: string;
 };
-export type VoicePostgresRuntimeStorage<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 VoicePostgresRuntimeStorage<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>;
@@ -21,11 +28,15 @@ export type VoicePostgresRuntimeStorage<TSession extends VoiceSessionRecord = Vo
     traceDeliveries: VoiceTraceSinkDeliveryStore<TTraceDelivery>;
     traces: VoiceTraceEventStore<TTrace>;
 };
-export declare const createVoicePostgresSessionStore: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoicePostgresStoreOptions) => VoiceSessionStore<TSession>;
+export declare const createVoicePostgresAuditEventStore: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>(options: VoicePostgresStoreOptions) => VoiceAuditEventStore<TEvent>;
+export declare const createVoicePostgresAuditSinkDeliveryStore: <TDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord>(options: VoicePostgresStoreOptions) => VoiceAuditSinkDeliveryStore<TDelivery>;
+export declare const createVoicePostgresCampaignStore: (options: VoicePostgresStoreOptions) => VoiceCampaignStore;
+export declare const createVoicePostgresExternalObjectMapStore: <TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap>(options: VoicePostgresStoreOptions) => VoiceExternalObjectMapStore<TMapping>;
+export declare const createVoicePostgresIntegrationEventStore: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoicePostgresStoreOptions) => VoiceIntegrationEventStore<TEvent>;
 export declare const createVoicePostgresReviewStore: <TArtifact extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact>(options: VoicePostgresStoreOptions) => VoiceCallReviewStore<TArtifact>;
+export declare const createVoicePostgresRuntimeStorage: <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: VoicePostgresStoreOptions) => VoicePostgresRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery, TAudit, TAuditDelivery>;
+export declare const createVoicePostgresSessionStore: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoicePostgresStoreOptions) => VoiceSessionStore<TSession>;
 export declare const createVoicePostgresTaskStore: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoicePostgresStoreOptions) => VoiceOpsTaskStore<TTask>;
-export declare const createVoicePostgresIntegrationEventStore: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoicePostgresStoreOptions) => VoiceIntegrationEventStore<TEvent>;
-export declare const createVoicePostgresExternalObjectMapStore: <TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap>(options: VoicePostgresStoreOptions) => VoiceExternalObjectMapStore<TMapping>;
+export declare const createVoicePostgresTelephonyWebhookIdempotencyStore: <TResult = unknown>(options: VoicePostgresStoreOptions) => VoiceTelephonyWebhookIdempotencyStore<TResult>;
 export declare const createVoicePostgresTraceEventStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(options: VoicePostgresStoreOptions) => VoiceTraceEventStore<TEvent>;
 export declare const createVoicePostgresTraceSinkDeliveryStore: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoicePostgresStoreOptions) => VoiceTraceSinkDeliveryStore<TDelivery>;
-export declare const createVoicePostgresRuntimeStorage: <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: VoicePostgresStoreOptions) => VoicePostgresRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery>;

package/dist/{presets.d.ts → core/presets.d.ts}

@@ -1,9 +1,9 @@
-import type { VoiceCaptureOptions, VoiceConnectionOptions, VoiceResolvedAudioConditioningConfig, VoiceResolvedTurnDetectionConfig, VoiceRuntimePreset, VoiceSTTLifecycle } from './types';
+import type { VoiceCaptureOptions, VoiceConnectionOptions, VoiceResolvedAudioConditioningConfig, VoiceResolvedTurnDetectionConfig, VoiceRuntimePreset, VoiceSTTLifecycle } from "./types";
 export type VoiceResolvedRuntimePreset = {
     audioConditioning?: VoiceResolvedAudioConditioningConfig;
     capture: {
-        channelCount: NonNullable<VoiceCaptureOptions['channelCount']>;
-        sampleRateHz: NonNullable<VoiceCaptureOptions['sampleRateHz']>;
+        channelCount: NonNullable<VoiceCaptureOptions["channelCount"]>;
+        sampleRateHz: NonNullable<VoiceCaptureOptions["sampleRateHz"]>;
     };
     connection: VoiceConnectionOptions;
     name: VoiceRuntimePreset;