@absolutejs/voice 0.0.22-beta.51 → 0.0.22-beta.510

package/dist/telephony/contract.d.ts

@@ -0,0 +1,61 @@
+export type VoiceTelephonyProvider = "generic" | "plivo" | "telnyx" | "twilio";
+export type VoiceTelephonySetupStatus<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = {
+    generatedAt: number;
+    missing: string[];
+    provider: TProvider;
+    ready: boolean;
+    signing: {
+        configured: boolean;
+        mode: "custom" | "none" | "provider-signature" | "twilio-signature";
+        verificationUrl?: string;
+    };
+    urls: {
+        stream: string;
+        twiml?: string;
+        webhook: string;
+    };
+    warnings: string[];
+};
+export type VoiceTelephonySmokeCheck = {
+    details?: Record<string, unknown>;
+    message?: string;
+    name: string;
+    status: "fail" | "pass" | "warn";
+};
+export type VoiceTelephonySmokeReport<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = {
+    checks: VoiceTelephonySmokeCheck[];
+    generatedAt: number;
+    pass: boolean;
+    provider: TProvider;
+    setup: VoiceTelephonySetupStatus<TProvider>;
+    twiml?: {
+        status: number;
+        streamUrl?: string;
+    };
+    webhook?: {
+        body?: unknown;
+        status: number;
+    };
+};
+export type VoiceTelephonyContractRequirement = "signed-webhook" | "smoke-pass" | "stream-url" | "webhook-url" | "wss-stream";
+export type VoiceTelephonyContractIssue = {
+    requirement: VoiceTelephonyContractRequirement;
+    severity: "error" | "warning";
+    message: string;
+};
+export type VoiceTelephonyContractReport<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = {
+    issues: VoiceTelephonyContractIssue[];
+    pass: boolean;
+    provider: TProvider;
+    requirements: VoiceTelephonyContractRequirement[];
+    setup: VoiceTelephonySetupStatus<TProvider>;
+    smoke?: VoiceTelephonySmokeReport<TProvider>;
+};
+export type VoiceTelephonyContractOptions = {
+    requirements?: VoiceTelephonyContractRequirement[];
+};
+export declare const evaluateVoiceTelephonyContract: <TProvider extends VoiceTelephonyProvider>(input: {
+    options?: VoiceTelephonyContractOptions;
+    setup: VoiceTelephonySetupStatus<TProvider>;
+    smoke?: VoiceTelephonySmokeReport<TProvider>;
+}) => VoiceTelephonyContractReport<TProvider>;

package/dist/telephony/matrix.d.ts

@@ -0,0 +1,97 @@
+import { Elysia } from "elysia";
+import { type VoiceTelephonyContractOptions, type VoiceTelephonyContractReport, type VoiceTelephonyProvider, type VoiceTelephonySetupStatus, type VoiceTelephonySmokeReport } from "./contract";
+export type VoiceTelephonyCarrierMatrixStatus = "fail" | "pass" | "warn";
+export type VoiceTelephonyCarrierMatrixInput<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = {
+    contract?: VoiceTelephonyContractReport<TProvider>;
+    name?: string;
+    setup: VoiceTelephonySetupStatus<TProvider>;
+    smoke?: VoiceTelephonySmokeReport<TProvider>;
+};
+export type VoiceTelephonyCarrierMatrixEntry<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = {
+    contract: VoiceTelephonyContractReport<TProvider>;
+    issues: VoiceTelephonyContractReport<TProvider>["issues"];
+    name: string;
+    provider: TProvider;
+    ready: boolean;
+    setup: VoiceTelephonySetupStatus<TProvider>;
+    smoke?: VoiceTelephonySmokeReport<TProvider>;
+    status: VoiceTelephonyCarrierMatrixStatus;
+    summary: {
+        errors: number;
+        failures: number;
+        missing: number;
+        warnings: number;
+    };
+};
+export type VoiceTelephonyCarrierMatrix = {
+    entries: VoiceTelephonyCarrierMatrixEntry[];
+    generatedAt: number;
+    pass: boolean;
+    summary: {
+        contractsPassing: number;
+        failing: number;
+        providers: number;
+        ready: number;
+        smokePassing: number;
+        warnings: number;
+    };
+};
+export type VoiceTelephonyCarrierMatrixOptions = {
+    contract?: VoiceTelephonyContractOptions;
+    generatedAt?: number;
+    providers: VoiceTelephonyCarrierMatrixInput[];
+};
+export type VoiceTelephonyCarrierMatrixRoutesOptions = {
+    load: (input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceTelephonyCarrierMatrixInput[]> | VoiceTelephonyCarrierMatrixInput[];
+    name?: string;
+    path?: string;
+    title?: string;
+    contract?: VoiceTelephonyContractOptions;
+};
+export declare const createVoiceTelephonyCarrierMatrix: (options: VoiceTelephonyCarrierMatrixOptions) => VoiceTelephonyCarrierMatrix;
+export declare const renderVoiceTelephonyCarrierMatrixHTML: (matrix: VoiceTelephonyCarrierMatrix, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceTelephonyCarrierMatrixRoutes: (options: VoiceTelephonyCarrierMatrixRoutesOptions) => 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: Response | VoiceTelephonyCarrierMatrix;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/telephony/plivo.d.ts

@@ -0,0 +1,303 @@
+import { Database } from "bun:sqlite";
+import type { RedisClient } from "bun";
+import { Elysia } from "elysia";
+import { type VoiceTelephonyContractReport, type VoiceTelephonySetupStatus, type VoiceTelephonySmokeCheck, type VoiceTelephonySmokeReport } from "./contract";
+import { type VoiceTelephonyOutcomePolicy, type VoiceTelephonyWebhookRoutesOptions, type VoiceTelephonyWebhookVerificationResult } from "../telephonyOutcome";
+import type { VoiceServerMessage, VoiceSessionRecord } from "../types";
+import type { VoicePostgresClient } from "../postgresStore";
+import { type TwilioMediaStreamBridgeOptions } from "./twilio";
+export type PlivoInboundMessage = {
+    event: "start";
+    sequenceNumber?: number;
+    start?: {
+        callId?: string;
+        callUuid?: string;
+        extra_headers?: string;
+        mediaFormat?: {
+            channels?: number;
+            encoding?: string;
+            sampleRate?: number;
+        };
+        streamId?: string;
+    };
+    streamId?: string;
+} | {
+    event: "media";
+    media: {
+        payload: string;
+        timestamp?: string;
+        track?: "inbound" | "outbound";
+    };
+    sequenceNumber?: number;
+    streamId?: string;
+} | {
+    event: "dtmf";
+    dtmf?: {
+        digit?: string;
+        timestamp?: string;
+        track?: string;
+    };
+    sequenceNumber?: number;
+    streamId?: string;
+} | {
+    event: "playedStream";
+    name?: string;
+    sequenceNumber?: number;
+    streamId?: string;
+} | {
+    event: "clearedAudio";
+    sequenceNumber?: number;
+    streamId?: string;
+} | {
+    event: "stop";
+    sequenceNumber?: number;
+    stop?: {
+        callId?: string;
+        callUuid?: string;
+    };
+    streamId?: string;
+};
+export type PlivoOutboundPlayAudioMessage = {
+    event: "playAudio";
+    media: {
+        contentType: "audio/x-mulaw";
+        payload: string;
+        sampleRate: 8000;
+    };
+};
+export type PlivoOutboundClearAudioMessage = {
+    event: "clearAudio";
+    streamId?: string;
+};
+export type PlivoOutboundCheckpointMessage = {
+    event: "checkpoint";
+    name: string;
+    streamId?: string;
+};
+export type PlivoOutboundMessage = PlivoOutboundPlayAudioMessage | PlivoOutboundClearAudioMessage | PlivoOutboundCheckpointMessage;
+export type PlivoMediaStreamSocket = {
+    close: (code?: number, reason?: string) => void | Promise<void>;
+    send: (data: string) => void | Promise<void>;
+};
+export type PlivoMediaStreamBridgeOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<TwilioMediaStreamBridgeOptions<TContext, TSession, TResult>, "onVoiceMessage"> & {
+    onVoiceMessage?: (input: {
+        callId?: string;
+        message: VoiceServerMessage<TResult>;
+        sessionId: string;
+        streamId?: string;
+    }) => Promise<void> | void;
+};
+export type PlivoMediaStreamBridge = {
+    close: (reason?: string) => Promise<void>;
+    getSessionId: () => string | null;
+    getStreamId: () => string | null;
+    handleMessage: (raw: string | PlivoInboundMessage) => Promise<void>;
+};
+export type PlivoVoiceResponseOptions = {
+    audioTrack?: "both" | "inbound" | "outbound";
+    bidirectional?: boolean;
+    contentType?: "audio/x-l16;rate=8000" | "audio/x-l16;rate=16000" | "audio/x-mulaw;rate=8000";
+    extraHeaders?: Record<string, string | number | boolean | undefined> | string;
+    keepCallAlive?: boolean;
+    noiseCancellation?: boolean;
+    noiseCancellationLevel?: number;
+    statusCallbackMethod?: "GET" | "POST";
+    statusCallbackUrl?: string;
+    streamTimeout?: number;
+    streamUrl: string;
+};
+export type PlivoVoiceSetupStatus = VoiceTelephonySetupStatus<"plivo"> & {
+    urls: VoiceTelephonySetupStatus<"plivo">["urls"] & {
+        answer: string;
+    };
+};
+export type PlivoVoiceSetupOptions = {
+    path?: false | string;
+    requiredEnv?: Record<string, string | undefined>;
+    title?: string;
+};
+export type PlivoVoiceSmokeCheck = VoiceTelephonySmokeCheck;
+export type PlivoVoiceSmokeReport = VoiceTelephonySmokeReport<"plivo"> & {
+    answer?: {
+        status: number;
+        streamUrl?: string;
+    };
+    contract: VoiceTelephonyContractReport<"plivo">;
+    setup: PlivoVoiceSetupStatus;
+};
+export type PlivoVoiceSmokeOptions = {
+    callUuid?: string;
+    eventType?: string;
+    path?: false | string;
+    sessionId?: string;
+    sipCode?: number;
+    status?: string;
+    title?: string;
+};
+export type VoicePlivoWebhookNonceStore = {
+    claim?: (nonce: string) => Promise<boolean> | boolean;
+    has: (nonce: string) => Promise<boolean> | boolean;
+    set: (nonce: string) => Promise<void> | void;
+};
+export type VoicePlivoWebhookNonceStoreOptions = {
+    ttlSeconds?: number;
+};
+export type VoiceSQLitePlivoWebhookNonceStoreOptions = VoicePlivoWebhookNonceStoreOptions & {
+    database?: Database;
+    path?: string;
+    tableName?: string;
+    tablePrefix?: string;
+};
+export type VoicePostgresPlivoWebhookNonceStoreOptions = VoicePlivoWebhookNonceStoreOptions & {
+    connectionString?: string;
+    schemaName?: string;
+    sql?: VoicePostgresClient;
+    tableName?: string;
+    tablePrefix?: string;
+};
+export type VoiceRedisPlivoWebhookNonceClient = Pick<RedisClient, "exists" | "set">;
+export type VoiceRedisPlivoWebhookNonceStoreOptions = VoicePlivoWebhookNonceStoreOptions & {
+    client?: VoiceRedisPlivoWebhookNonceClient;
+    keyPrefix?: string;
+    url?: string;
+};
+export type VoicePlivoWebhookVerifierOptions = {
+    authToken?: string;
+    nonceStore?: VoicePlivoWebhookNonceStore;
+    verificationUrl?: string | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => string);
+};
+export type PlivoVoiceRoutesOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    answer?: {
+        path?: string;
+        response?: Omit<PlivoVoiceResponseOptions, "streamUrl">;
+        streamUrl?: string | ((input: {
+            query: Record<string, unknown>;
+            request: Request;
+            streamPath: string;
+        }) => Promise<string> | string);
+    };
+    bridge?: PlivoMediaStreamBridgeOptions<TContext, TSession, TResult>;
+    context?: TContext;
+    name?: string;
+    outcomePolicy?: VoiceTelephonyOutcomePolicy;
+    setup?: PlivoVoiceSetupOptions;
+    smoke?: PlivoVoiceSmokeOptions;
+    streamPath?: string;
+    webhook?: Omit<VoiceTelephonyWebhookRoutesOptions<TContext, TSession, TResult>, "context" | "path" | "policy" | "provider"> & {
+        authToken?: string;
+        nonceStore?: VoicePlivoWebhookNonceStore;
+        path?: string;
+        policy?: VoiceTelephonyOutcomePolicy;
+        verificationUrl?: string | ((input: {
+            query: Record<string, unknown>;
+            request: Request;
+        }) => string);
+    };
+};
+export declare const createPlivoVoiceResponse: (options: PlivoVoiceResponseOptions) => string;
+export declare const createPlivoMediaStreamBridge: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(socket: PlivoMediaStreamSocket, options: PlivoMediaStreamBridgeOptions<TContext, TSession, TResult>) => PlivoMediaStreamBridge;
+export declare const signVoicePlivoWebhook: (input: {
+    authToken: string;
+    body?: unknown;
+    nonce: string;
+    url: string;
+}) => Promise<string>;
+export declare const verifyVoicePlivoWebhookSignature: (input: {
+    authToken?: string;
+    body?: unknown;
+    headers: Headers;
+    url: string;
+}) => Promise<VoiceTelephonyWebhookVerificationResult>;
+export declare const createMemoryVoicePlivoWebhookNonceStore: () => VoicePlivoWebhookNonceStore;
+export declare const createVoiceSQLitePlivoWebhookNonceStore: (options: VoiceSQLitePlivoWebhookNonceStoreOptions) => VoicePlivoWebhookNonceStore;
+export declare const createVoicePostgresPlivoWebhookNonceStore: (options?: VoicePostgresPlivoWebhookNonceStoreOptions) => VoicePlivoWebhookNonceStore;
+export declare const createVoiceRedisPlivoWebhookNonceStore: (options?: VoiceRedisPlivoWebhookNonceStoreOptions) => VoicePlivoWebhookNonceStore;
+export declare const createVoicePlivoWebhookVerifier: (options: VoicePlivoWebhookVerifierOptions) => (input: {
+    body: unknown;
+    headers: Headers;
+    query: Record<string, unknown>;
+    request: Request;
+}) => Promise<VoiceTelephonyWebhookVerificationResult>;
+export declare const createPlivoVoiceRoutes: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options?: PlivoVoiceRoutesOptions<TContext, TSession, TResult>) => 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: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        subscribe: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {};
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response | import("..").VoiceTelephonyWebhookDecision<TResult>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/telephony/response.d.ts

@@ -1,4 +1,4 @@
-export type TelephonyResponseShapeMode = 'full' | 'lead-clause';
+export type TelephonyResponseShapeMode = "full" | "lead-clause";
 export type TelephonyResponseShapeOptions = {
     mode?: TelephonyResponseShapeMode;
     maxChars?: number;

package/dist/telephony/security.d.ts

@@ -0,0 +1,182 @@
+import { type VoiceTelephonyWebhookIdempotencyStore, type VoiceTelephonyWebhookProvider, type VoiceTelephonyWebhookVerificationResult } from "../telephonyOutcome";
+import { Elysia } from "elysia";
+import { type VoicePostgresClient } from "../postgresStore";
+import { type VoiceRedisTelephonyWebhookIdempotencyClient } from "../queue";
+import { type VoicePlivoWebhookNonceStore, type VoiceRedisPlivoWebhookNonceClient } from "./plivo";
+import { type VoiceRedisTelnyxWebhookEventClient, type VoiceTelnyxWebhookEventStore } from "./telnyx";
+export type VoiceTelephonyWebhookSecurityStorePreset = {
+    kind?: "memory";
+} | {
+    kind: "sqlite";
+    path: string;
+    tablePrefix?: string;
+} | {
+    connectionString?: string;
+    kind: "postgres";
+    schemaName?: string;
+    sql?: VoicePostgresClient;
+    tablePrefix?: string;
+} | {
+    idempotencyClient?: VoiceRedisTelephonyWebhookIdempotencyClient;
+    keyPrefix?: string;
+    kind: "redis";
+    plivoClient?: VoiceRedisPlivoWebhookNonceClient;
+    telnyxClient?: VoiceRedisTelnyxWebhookEventClient;
+    url?: string;
+};
+export type VoiceTelephonyWebhookSecurityOptions<TResult = unknown> = {
+    plivo?: {
+        authToken?: string;
+        nonceStore?: VoicePlivoWebhookNonceStore;
+        verificationUrl?: string | ((input: {
+            query: Record<string, unknown>;
+            request: Request;
+        }) => string);
+    };
+    store?: VoiceTelephonyWebhookSecurityStorePreset;
+    telnyx?: {
+        eventStore?: VoiceTelnyxWebhookEventStore;
+        publicKey?: string;
+        toleranceSeconds?: number;
+    };
+    ttlSeconds?: number;
+    twilio?: {
+        authToken?: string;
+        idempotencyStore?: VoiceTelephonyWebhookIdempotencyStore<TResult>;
+        verificationUrl?: string | ((input: {
+            query: Record<string, unknown>;
+            request: Request;
+        }) => string);
+    };
+};
+export type VoiceTelephonyWebhookSecurityPreset<TResult = unknown> = {
+    plivo: {
+        authToken?: string;
+        nonceStore: VoicePlivoWebhookNonceStore;
+        verify: (input: {
+            body: unknown;
+            headers: Headers;
+            query: Record<string, unknown>;
+            request: Request;
+        }) => Promise<VoiceTelephonyWebhookVerificationResult>;
+    };
+    telnyx: {
+        eventStore: VoiceTelnyxWebhookEventStore;
+        publicKey?: string;
+        toleranceSeconds?: number;
+        verify: (input: {
+            headers: Headers;
+            rawBody: string;
+        }) => Promise<VoiceTelephonyWebhookVerificationResult>;
+    };
+    twilio: {
+        idempotency: {
+            enabled: true;
+            store: VoiceTelephonyWebhookIdempotencyStore<TResult>;
+        };
+        requireVerification: true;
+        signingSecret?: string;
+        verificationUrl?: string | ((input: {
+            query: Record<string, unknown>;
+            request: Request;
+        }) => string);
+        verify: (input: {
+            body: unknown;
+            headers: Headers;
+            query: Record<string, unknown>;
+            request: Request;
+        }) => Promise<VoiceTelephonyWebhookVerificationResult>;
+    };
+    verify: {
+        plivo: VoiceTelephonyWebhookSecurityPreset<TResult>["plivo"]["verify"];
+        telnyx: VoiceTelephonyWebhookSecurityPreset<TResult>["telnyx"]["verify"];
+        twilio: VoiceTelephonyWebhookSecurityPreset<TResult>["twilio"]["verify"];
+    };
+};
+export type VoiceTelephonyWebhookSecurityProviderStatus = {
+    checks: {
+        idempotency?: boolean;
+        persistentStore: boolean;
+        replayProtection: boolean;
+        verification: boolean;
+    };
+    enabled: boolean;
+    issues: string[];
+    provider: VoiceTelephonyWebhookProvider;
+    status: "fail" | "pass" | "warn";
+    store: VoiceTelephonyWebhookSecurityStorePreset["kind"] | "memory";
+};
+export type VoiceTelephonyWebhookSecurityReport = {
+    generatedAt: number;
+    ok: boolean;
+    providers: VoiceTelephonyWebhookSecurityProviderStatus[];
+    status: "fail" | "pass" | "warn";
+    summary: {
+        enabled: number;
+        failed: number;
+        passed: number;
+        warned: number;
+    };
+};
+export type VoiceTelephonyWebhookSecurityAssertionInput = {
+    maxFailedProviders?: number;
+    minEnabledProviders?: number;
+    requirePersistentStores?: boolean;
+    requiredProviders?: VoiceTelephonyWebhookProvider[];
+};
+export type VoiceTelephonyWebhookSecurityAssertionReport = {
+    failedProviders: VoiceTelephonyWebhookProvider[];
+    issues: string[];
+    ok: boolean;
+    passingProviders: VoiceTelephonyWebhookProvider[];
+    status: VoiceTelephonyWebhookSecurityReport["status"];
+};
+export type VoiceTelephonyWebhookSecurityRoutesOptions<TResult = unknown> = {
+    name?: string;
+    options: VoiceTelephonyWebhookSecurityOptions<TResult>;
+    path?: string;
+};
+export declare const buildVoiceTelephonyWebhookSecurityReport: <TResult = unknown>(options?: VoiceTelephonyWebhookSecurityOptions<TResult>) => VoiceTelephonyWebhookSecurityReport;
+export declare const evaluateVoiceTelephonyWebhookSecurityEvidence: (report: VoiceTelephonyWebhookSecurityReport, input?: VoiceTelephonyWebhookSecurityAssertionInput) => VoiceTelephonyWebhookSecurityAssertionReport;
+export declare const assertVoiceTelephonyWebhookSecurityEvidence: (report: VoiceTelephonyWebhookSecurityReport, input?: VoiceTelephonyWebhookSecurityAssertionInput) => VoiceTelephonyWebhookSecurityAssertionReport;
+export declare const createVoiceTelephonyWebhookSecurityRoutes: <TResult = unknown>(options: VoiceTelephonyWebhookSecurityRoutesOptions<TResult>) => 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: VoiceTelephonyWebhookSecurityReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const createVoiceTelephonyWebhookSecurityPreset: <TResult = unknown>(options?: VoiceTelephonyWebhookSecurityOptions<TResult>) => VoiceTelephonyWebhookSecurityPreset<TResult>;