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

package/dist/core/vapiAdapter.d.ts

@@ -0,0 +1,160 @@
+import type { VoiceAgent, VoiceAgentModel, VoiceAgentTool } from "./agent";
+import { type VoiceDTMFToolOptions } from "./agentTools";
+import { type VoiceAssistant, type VoiceAssistantOptions } from "./assistant";
+import { type VoiceRAGCollectionLike, type VoiceRAGToolOptions } from "./ragTool";
+import type { VoiceSessionRecord } from "./types";
+export type VapiAssistantMessage = {
+    content?: string;
+    role?: "assistant" | "system" | "user";
+};
+export type VapiAssistantConfigModel = {
+    emotionRecognitionEnabled?: boolean;
+    maxTokens?: number;
+    messages?: readonly VapiAssistantMessage[];
+    model?: string;
+    numFastTurns?: number;
+    provider?: string;
+    systemPrompt?: string;
+    temperature?: number;
+    toolIds?: readonly string[];
+    tools?: readonly VapiAssistantConfigTool[];
+};
+export type VapiAssistantConfigVoice = {
+    provider?: string;
+    speed?: number;
+    stability?: number;
+    style?: number;
+    voiceId?: string;
+};
+export type VapiAssistantConfigTranscriber = {
+    confidenceThreshold?: number;
+    language?: string;
+    model?: string;
+    provider?: string;
+};
+export type VapiAssistantConfigTransferDestination = {
+    description?: string;
+    message?: string;
+    metadata?: Record<string, unknown>;
+    number?: string;
+    sipUri?: string;
+    type?: string;
+};
+export type VapiAssistantConfigTool = {
+    async?: boolean;
+    description?: string;
+    destinations?: readonly VapiAssistantConfigTransferDestination[];
+    function?: {
+        description?: string;
+        name?: string;
+        parameters?: Record<string, unknown>;
+    };
+    headers?: Record<string, string>;
+    knowledgeBases?: readonly string[] | readonly Record<string, unknown>[];
+    method?: string;
+    name?: string;
+    server?: {
+        headers?: Record<string, string>;
+        url?: string;
+    };
+    type?: string;
+    url?: string;
+};
+export type VapiAssistantConfig = {
+    backgroundDenoisingEnabled?: boolean;
+    backgroundSound?: string;
+    compliancePlan?: {
+        hipaaEnabled?: boolean;
+        pciEnabled?: boolean;
+    };
+    endCallMessage?: string;
+    endCallPhrases?: readonly string[];
+    firstMessage?: string;
+    firstMessageMode?: string;
+    knowledgeBaseId?: string;
+    maxDurationSeconds?: number;
+    model?: VapiAssistantConfigModel;
+    monitorPlan?: Record<string, unknown>;
+    recordingEnabled?: boolean;
+    silenceTimeoutSeconds?: number;
+    startSpeakingPlan?: Record<string, unknown>;
+    stopSpeakingPlan?: Record<string, unknown>;
+    transcriber?: VapiAssistantConfigTranscriber;
+    variableValues?: Record<string, unknown>;
+    voice?: VapiAssistantConfigVoice;
+    voicemailDetection?: {
+        provider?: string;
+    };
+    voicemailMessage?: string;
+};
+export type VoiceFromVapiModelFactoryInput = {
+    model?: string;
+    provider?: string;
+    raw: VapiAssistantConfigModel;
+    temperature?: number;
+};
+export type VoiceFromVapiModelFactory<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = (input: VoiceFromVapiModelFactoryInput) => VoiceAgentModel<TContext, TSession, TResult>;
+export type VoiceFromVapiCustomToolInput = {
+    raw: VapiAssistantConfigTool;
+};
+export type VoiceFromVapiCustomToolFactory<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = (input: VoiceFromVapiCustomToolInput) => VoiceAgentTool<TContext, TSession, Record<string, unknown>, unknown, TResult> | undefined;
+export type VoiceFromVapiDTMFFactory<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord> = (input: {
+    raw: VapiAssistantConfigTool;
+}) => VoiceDTMFToolOptions<TContext, TSession>["send"] | undefined;
+export type VoiceFromVapiKnowledgeBase<TContext = unknown> = {
+    collection: VoiceRAGCollectionLike;
+    toolOptions?: VoiceRAGToolOptions<TContext>;
+};
+export type VoiceFromVapiUnsupportedReason = {
+    detail: string;
+    field: string;
+};
+export type VoiceFromVapiRouteHints = {
+    backgroundDenoisingEnabled?: boolean;
+    backgroundSound?: string;
+    endCallMessage?: string;
+    endCallPhrases?: readonly string[];
+    firstMessage?: string;
+    firstMessageMode?: string;
+    hipaaEnabled?: boolean;
+    maxDurationSeconds?: number;
+    pciEnabled?: boolean;
+    recordingEnabled?: boolean;
+    silenceTimeoutSeconds?: number;
+    stt?: {
+        confidenceThreshold?: number;
+        language?: string;
+        model?: string;
+        provider?: string;
+    };
+    tts?: {
+        provider?: string;
+        speed?: number;
+        stability?: number;
+        style?: number;
+        voiceId?: string;
+    };
+    voicemailMessage?: string;
+};
+export type VoiceFromVapiAssistantOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    assistantId?: string;
+    customToolFactory?: VoiceFromVapiCustomToolFactory<TContext, TSession, TResult>;
+    dtmfSendFactory?: VoiceFromVapiDTMFFactory<TContext, TSession>;
+    fetch?: typeof fetch;
+    knowledgeBase?: VoiceFromVapiKnowledgeBase<TContext>;
+    modelFactory: VoiceFromVapiModelFactory<TContext, TSession, TResult>;
+    systemFallback?: string;
+    variableResolver?: (path: string, input: {
+        context: TContext;
+        session: TSession;
+    }) => unknown;
+};
+export type VoiceFromVapiAssistantResult<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    assistant: VoiceAssistant<TContext, TSession, TResult>;
+    assistantOptions: VoiceAssistantOptions<TContext, TSession, TResult>;
+    modelAgent: VoiceAgent<TContext, TSession, TResult>;
+    routeHints: VoiceFromVapiRouteHints;
+    tools: ReadonlyArray<VoiceAgentTool<TContext, TSession, Record<string, unknown>, unknown, TResult>>;
+    unsupported: readonly VoiceFromVapiUnsupportedReason[];
+};
+export declare const fromVapiAssistantConfig: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(config: VapiAssistantConfig, options: VoiceFromVapiAssistantOptions<TContext, TSession, TResult>) => VoiceFromVapiAssistantResult<TContext, TSession, TResult>;

package/dist/core/variableAnalytics.d.ts

@@ -0,0 +1,47 @@
+export type VoiceAnalyticsVariableValue = string | number | boolean | null;
+export type VoiceAnalyticsCall = {
+    sessionId: string;
+    variables: Record<string, VoiceAnalyticsVariableValue>;
+    durationSeconds?: number;
+    costUsd?: number;
+    outcome?: string;
+    success?: boolean;
+    at?: number;
+};
+export type VoiceVariableValueStats = {
+    value: string;
+    count: number;
+    share: number;
+    successRate: number | null;
+    avgDurationSeconds: number | null;
+    avgCostUsd: number | null;
+    outcomes: Record<string, number>;
+};
+export type VoiceVariableBreakdown = {
+    variable: string;
+    distinctValues: number;
+    missingCount: number;
+    values: VoiceVariableValueStats[];
+};
+export type VoiceVariableAnalyticsReport = {
+    totalCalls: number;
+    overall: {
+        successRate: number | null;
+        avgDurationSeconds: number | null;
+        avgCostUsd: number | null;
+    };
+    byVariable: Record<string, VoiceVariableBreakdown>;
+};
+export type BuildVoiceVariableAnalyticsInput = {
+    calls: ReadonlyArray<VoiceAnalyticsCall>;
+    /** Variable keys to break analytics down by. */
+    variables: ReadonlyArray<string>;
+    /**
+     * Treat these outcome strings as successes when a call has no explicit
+     * `success` flag. Case-insensitive.
+     */
+    successOutcomes?: ReadonlyArray<string>;
+    /** Cap the values returned per variable (highest count first). */
+    topValuesPerVariable?: number;
+};
+export declare const buildVoiceVariableAnalytics: (input: BuildVoiceVariableAnalyticsInput) => VoiceVariableAnalyticsReport;

package/dist/core/voiceConfiguration.d.ts

@@ -0,0 +1,8 @@
+import type { VoicePluginConfig, VoiceSessionRecord } from "./types";
+/**
+ * Type-safe identity helper for authoring a `voice()` plugin config as a
+ * standalone value. Lets you extract a large configuration object out of the
+ * server file with full type-checking and autocomplete, then pass it straight
+ * to `voice(config)`.
+ */
+export declare const createVoiceConfiguration: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(configuration: VoicePluginConfig<TContext, TSession, TResult>) => VoicePluginConfig<TContext, TSession, TResult>;

package/dist/core/voiceMonitoring.d.ts

@@ -0,0 +1,444 @@
+import { Elysia } from "elysia";
+export type VoiceMonitorStatus = "fail" | "pass" | "warn";
+export type VoiceMonitorSeverity = "critical" | "info" | "warn";
+export type VoiceMonitorIssueStatus = "acknowledged" | "muted" | "open" | "resolved";
+export type VoiceMonitorEvaluationInput<TEvidence = unknown> = {
+    evidence: TEvidence;
+    now: number;
+};
+export type VoiceMonitorEvaluation = {
+    detail?: string;
+    impactedSessions?: readonly string[];
+    operationsRecordHrefs?: readonly string[];
+    status: VoiceMonitorStatus;
+    threshold?: number | string;
+    value?: number | string;
+};
+export type VoiceMonitorDefinition<TEvidence = unknown> = {
+    description?: string;
+    id: string;
+    label: string;
+    severity?: VoiceMonitorSeverity;
+    windowMs?: number;
+    evaluate: (input: VoiceMonitorEvaluationInput<TEvidence>) => Promise<VoiceMonitorEvaluation> | VoiceMonitorEvaluation;
+};
+export type VoiceMonitorRun = VoiceMonitorEvaluation & {
+    checkedAt: number;
+    description?: string;
+    id: string;
+    label: string;
+    severity: VoiceMonitorSeverity;
+    windowMs?: number;
+};
+export type VoiceMonitorIssue = {
+    acknowledgedAt?: number;
+    acknowledgedBy?: string;
+    createdAt: number;
+    detail?: string;
+    id: string;
+    impactedSessions: string[];
+    label: string;
+    lastSeenAt: number;
+    monitorId: string;
+    mutedAt?: number;
+    mutedBy?: string;
+    operationsRecordHrefs: string[];
+    resolvedAt?: number;
+    resolvedBy?: string;
+    severity: VoiceMonitorSeverity;
+    status: VoiceMonitorIssueStatus;
+    threshold?: number | string;
+    value?: number | string;
+};
+export type VoiceMonitorIssueStore = {
+    list: () => Promise<VoiceMonitorIssue[]> | VoiceMonitorIssue[];
+    upsert: (issue: VoiceMonitorIssue) => Promise<VoiceMonitorIssue> | VoiceMonitorIssue;
+    update: (id: string, patch: Partial<VoiceMonitorIssue>) => Promise<VoiceMonitorIssue | undefined> | VoiceMonitorIssue | undefined;
+};
+export type VoiceMonitorNotifier = {
+    deliver: (input: VoiceMonitorNotifierDeliveryInput) => Promise<VoiceMonitorNotifierDeliveryResult> | VoiceMonitorNotifierDeliveryResult;
+    id: string;
+    label: string;
+};
+export type VoiceMonitorNotifierDeliveryInput = {
+    issue: VoiceMonitorIssue;
+    now: number;
+};
+export type VoiceMonitorNotifierDeliveryResult = {
+    detail?: string;
+    status: "failed" | "sent" | "skipped";
+};
+export type VoiceMonitorNotifierDeliveryReceipt = {
+    detail?: string;
+    id: string;
+    issueId: string;
+    notifierId: string;
+    notifierLabel: string;
+    sentAt: number;
+    status: "failed" | "sent" | "skipped";
+};
+export type VoiceMonitorNotifierDeliveryReceiptStore = {
+    list: () => Promise<VoiceMonitorNotifierDeliveryReceipt[]> | VoiceMonitorNotifierDeliveryReceipt[];
+    set: (id: string, receipt: VoiceMonitorNotifierDeliveryReceipt) => Promise<VoiceMonitorNotifierDeliveryReceipt> | VoiceMonitorNotifierDeliveryReceipt;
+};
+export type VoiceMonitorNotifierDeliveryReport = {
+    checkedAt: number;
+    elapsedMs: number;
+    receipts: VoiceMonitorNotifierDeliveryReceipt[];
+    status: VoiceMonitorStatus;
+    summary: {
+        failed: number;
+        notifiers: number;
+        sent: number;
+        skipped: number;
+        total: number;
+    };
+};
+export type VoiceMonitorRunReport = {
+    checkedAt: number;
+    elapsedMs: number;
+    issues: VoiceMonitorIssue[];
+    runs: VoiceMonitorRun[];
+    status: VoiceMonitorStatus;
+    summary: {
+        acknowledged: number;
+        criticalOpen: number;
+        failed: number;
+        muted: number;
+        open: number;
+        passed: number;
+        resolved: number;
+        total: number;
+        warned: number;
+    };
+};
+export type VoiceMonitorRunOptions<TEvidence = unknown> = {
+    evidence: TEvidence;
+    issueStore?: VoiceMonitorIssueStore;
+    monitors: readonly VoiceMonitorDefinition<TEvidence>[];
+    now?: number;
+};
+export type VoiceMonitorNotifierDeliveryOptions = {
+    issueStore: VoiceMonitorIssueStore;
+    notifiers: readonly VoiceMonitorNotifier[];
+    now?: number;
+    receiptStore?: VoiceMonitorNotifierDeliveryReceiptStore;
+    statuses?: readonly VoiceMonitorIssueStatus[];
+};
+export type VoiceMonitorWebhookNotifierOptions = {
+    fetch?: typeof fetch;
+    headers?: HeadersInit;
+    id: string;
+    label?: string;
+    mapIssue?: (issue: VoiceMonitorIssue) => unknown;
+    url: string;
+};
+export type VoiceMonitorRoutesOptions<TEvidence = unknown> = VoiceMonitorRunOptions<TEvidence> & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    issuePath?: string;
+    name?: string;
+    notifierPath?: false | string;
+    notifiers?: readonly VoiceMonitorNotifier[];
+    path?: string;
+    receiptStore?: VoiceMonitorNotifierDeliveryReceiptStore;
+    render?: (report: VoiceMonitorRunReport) => Promise<string> | string;
+    title?: string;
+};
+export type VoiceMonitorRunnerTickResult = {
+    completedAt: number;
+    monitoring: VoiceMonitorRunReport;
+    notifierDelivery?: VoiceMonitorNotifierDeliveryReport;
+    startedAt: number;
+};
+export type VoiceMonitorRunner = {
+    isRunning: () => boolean;
+    start: () => void;
+    stop: () => void;
+    tick: () => Promise<VoiceMonitorRunnerTickResult>;
+};
+export type VoiceMonitorRunnerOptions<TEvidence = unknown> = {
+    evidence?: TEvidence;
+    issueStore?: VoiceMonitorIssueStore;
+    loadEvidence?: () => Promise<TEvidence> | TEvidence;
+    monitors: readonly VoiceMonitorDefinition<TEvidence>[];
+    notifiers?: readonly VoiceMonitorNotifier[];
+    now?: () => number;
+    pollIntervalMs?: number;
+    receiptStore?: VoiceMonitorNotifierDeliveryReceiptStore;
+};
+export type VoiceMonitorRunnerRoutesOptions = {
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+    runner: VoiceMonitorRunner;
+};
+export declare const acknowledgeVoiceMonitorIssue: (store: VoiceMonitorIssueStore, id: string, input?: {
+    actorId?: string;
+    now?: number;
+}) => Promise<VoiceMonitorIssue | undefined>;
+export declare const buildVoiceMonitorRunReport: <TEvidence = unknown>(options: VoiceMonitorRunOptions<TEvidence>) => Promise<VoiceMonitorRunReport>;
+export declare const createVoiceMemoryMonitorIssueStore: (initial?: readonly VoiceMonitorIssue[]) => VoiceMonitorIssueStore;
+export declare const createVoiceMemoryMonitorNotifierDeliveryReceiptStore: (initial?: readonly VoiceMonitorNotifierDeliveryReceipt[]) => VoiceMonitorNotifierDeliveryReceiptStore;
+export declare const createVoiceMonitorRunner: <TEvidence = unknown>(options: VoiceMonitorRunnerOptions<TEvidence>) => VoiceMonitorRunner;
+export declare const createVoiceMonitorWebhookNotifier: (options: VoiceMonitorWebhookNotifierOptions) => VoiceMonitorNotifier;
+export declare const deliverVoiceMonitorIssueNotifications: (options: VoiceMonitorNotifierDeliveryOptions) => Promise<VoiceMonitorNotifierDeliveryReport>;
+export declare const muteVoiceMonitorIssue: (store: VoiceMonitorIssueStore, id: string, input?: {
+    actorId?: string;
+    now?: number;
+}) => Promise<VoiceMonitorIssue | undefined>;
+export declare const renderVoiceMonitorHTML: (report: VoiceMonitorRunReport, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceMonitorMarkdown: (report: VoiceMonitorRunReport) => string;
+export declare const resolveVoiceMonitorIssue: (store: VoiceMonitorIssueStore, id: string, input?: {
+    actorId?: string;
+    now?: number;
+}) => Promise<VoiceMonitorIssue | undefined>;
+export declare const createVoiceMonitorRoutes: <TEvidence = unknown>(options: VoiceMonitorRoutesOptions<TEvidence>) => 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: VoiceMonitorRunReport;
+            };
+        };
+    };
+} & {
+    [x: `${string}.md`]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceMonitorIssue[];
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        notifications: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: VoiceMonitorNotifierDeliveryReceipt[];
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":id": {
+            acknowledge: {
+                post: {
+                    body: unknown;
+                    params: {
+                        id: string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response | VoiceMonitorIssue;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":id": {
+            resolve: {
+                post: {
+                    body: unknown;
+                    params: {
+                        id: string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response | VoiceMonitorIssue;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":id": {
+            mute: {
+                post: {
+                    body: unknown;
+                    params: {
+                        id: string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response | VoiceMonitorIssue;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const createVoiceMonitorRunnerRoutes: (options: VoiceMonitorRunnerRoutesOptions) => 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: {
+                    isRunning: boolean;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        tick: {
+            post: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: VoiceMonitorRunnerTickResult;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        start: {
+            post: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        isRunning: boolean;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        stop: {
+            post: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        isRunning: boolean;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/core/webhookFanout.d.ts

@@ -0,0 +1,48 @@
+export type VoiceWebhookSinkDeliveryResult = {
+    attempt: number;
+    durationMs: number;
+    error?: string;
+    ok: boolean;
+    sinkId: string;
+    status?: number;
+};
+export type VoiceWebhookSink = {
+    /** Apply only when this filter returns true. Default: accept all. */
+    acceptEvent?: (event: {
+        payload?: unknown;
+        type?: string;
+    }) => boolean;
+    /** Backoff between retries in ms. Default 1_000. */
+    backoffMs?: number;
+    /** Extra headers. */
+    headers?: Record<string, string>;
+    /** Stable id used for retry queues + dead-letter tracking. */
+    id: string;
+    /** Max retry attempts. Default 3. */
+    maxRetries?: number;
+    /** HMAC signing secret. When present, signature headers are emitted. */
+    signingSecret?: string;
+    /** Per-request fetch timeout in ms. Default 10_000. */
+    timeoutMs?: number;
+    /** Target URL. */
+    url: string;
+};
+export type VoiceWebhookFanoutOptions = {
+    /** Custom fetch — used for testing. */
+    fetch?: typeof fetch;
+    /** Sinks to deliver to. */
+    sinks: ReadonlyArray<VoiceWebhookSink>;
+};
+export type VoiceWebhookFanoutEvent = {
+    payload: unknown;
+    type?: string;
+};
+export type VoiceWebhookFanoutReport = {
+    deliveries: VoiceWebhookSinkDeliveryResult[];
+    failed: number;
+    succeeded: number;
+};
+export type VoiceWebhookFanout = {
+    deliver: (event: VoiceWebhookFanoutEvent) => Promise<VoiceWebhookFanoutReport>;
+};
+export declare const createVoiceWebhookFanout: (options: VoiceWebhookFanoutOptions) => VoiceWebhookFanout;