@absolutejs/voice 0.0.22-beta.9 → 0.0.22-beta.90

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,254 @@
+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 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 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;
+        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 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/telnyx.d.ts

@@ -0,0 +1,247 @@
+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 TwilioMediaStreamBridgeOptions } from './twilio';
+export type TelnyxMediaPayload = {
+    chunk?: string;
+    payload: string;
+    timestamp?: string;
+    track?: 'inbound' | 'outbound' | 'inbound_track' | 'outbound_track';
+};
+export type TelnyxInboundMessage = {
+    event: 'connected';
+    version?: string;
+} | {
+    event: 'start';
+    sequence_number?: string;
+    start?: {
+        call_control_id?: string;
+        call_leg_id?: string;
+        call_session_id?: string;
+        custom_parameters?: Record<string, string>;
+        media_format?: {
+            channels?: number;
+            encoding?: string;
+            sample_rate?: number;
+        };
+        user_id?: string;
+    };
+    stream_id?: string;
+} | {
+    event: 'media';
+    media: TelnyxMediaPayload;
+    sequence_number?: string;
+    stream_id?: string;
+} | {
+    event: 'mark';
+    mark?: {
+        name?: string;
+    };
+    sequence_number?: string;
+    stream_id?: string;
+} | {
+    event: 'dtmf';
+    dtmf?: {
+        digit?: string;
+    };
+    sequence_number?: string;
+    stream_id?: string;
+} | {
+    event: 'error';
+    payload?: {
+        code?: number;
+        detail?: string;
+        title?: string;
+    };
+    stream_id?: string;
+} | {
+    event: 'stop';
+    sequence_number?: string;
+    stop?: {
+        call_control_id?: string;
+        user_id?: string;
+    };
+    stream_id?: string;
+};
+export type TelnyxOutboundMediaMessage = {
+    event: 'media';
+    media: {
+        payload: string;
+    };
+};
+export type TelnyxOutboundClearMessage = {
+    event: 'clear';
+};
+export type TelnyxOutboundMarkMessage = {
+    event: 'mark';
+    mark: {
+        name: string;
+    };
+};
+export type TelnyxOutboundMessage = TelnyxOutboundMediaMessage | TelnyxOutboundClearMessage | TelnyxOutboundMarkMessage;
+export type TelnyxMediaStreamSocket = {
+    close: (code?: number, reason?: string) => void | Promise<void>;
+    send: (data: string) => void | Promise<void>;
+};
+export type TelnyxMediaStreamBridgeOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<TwilioMediaStreamBridgeOptions<TContext, TSession, TResult>, 'onVoiceMessage'> & {
+    onVoiceMessage?: (input: {
+        callControlId?: string;
+        message: VoiceServerMessage<TResult>;
+        sessionId: string;
+        streamId?: string;
+    }) => Promise<void> | void;
+};
+export type TelnyxMediaStreamBridge = {
+    close: (reason?: string) => Promise<void>;
+    getSessionId: () => string | null;
+    getStreamId: () => string | null;
+    handleMessage: (raw: string | TelnyxInboundMessage) => Promise<void>;
+};
+export type TelnyxVoiceResponseOptions = {
+    bidirectionalCodec?: 'AMR-WB' | 'G722' | 'OPUS' | 'PCMA' | 'PCMU';
+    bidirectionalMode?: 'mp3' | 'rtp';
+    codec?: 'AMR-WB' | 'G722' | 'OPUS' | 'PCMA' | 'PCMU' | 'default';
+    streamName?: string;
+    streamUrl: string;
+    track?: 'both_tracks' | 'inbound_track' | 'outbound_track';
+};
+export type TelnyxVoiceSetupStatus = VoiceTelephonySetupStatus<'telnyx'> & {
+    urls: VoiceTelephonySetupStatus<'telnyx'>['urls'] & {
+        texml: string;
+    };
+};
+export type TelnyxVoiceSetupOptions = {
+    path?: false | string;
+    requiredEnv?: Record<string, string | undefined>;
+    title?: string;
+};
+export type TelnyxVoiceSmokeCheck = VoiceTelephonySmokeCheck;
+export type TelnyxVoiceSmokeReport = VoiceTelephonySmokeReport<'telnyx'> & {
+    contract: VoiceTelephonyContractReport<'telnyx'>;
+    setup: TelnyxVoiceSetupStatus;
+    texml?: {
+        status: number;
+        streamUrl?: string;
+    };
+};
+export type TelnyxVoiceSmokeOptions = {
+    callControlId?: string;
+    callLegId?: string;
+    eventType?: string;
+    path?: false | string;
+    sessionId?: string;
+    title?: string;
+};
+export type TelnyxVoiceRoutesOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    bridge?: TelnyxMediaStreamBridgeOptions<TContext, TSession, TResult>;
+    context?: TContext;
+    name?: string;
+    outcomePolicy?: VoiceTelephonyOutcomePolicy;
+    setup?: TelnyxVoiceSetupOptions;
+    smoke?: TelnyxVoiceSmokeOptions;
+    streamPath?: string;
+    texml?: {
+        path?: string;
+        response?: Omit<TelnyxVoiceResponseOptions, 'streamUrl'>;
+        streamUrl?: string | ((input: {
+            query: Record<string, unknown>;
+            request: Request;
+            streamPath: string;
+        }) => Promise<string> | string);
+    };
+    webhook?: Omit<VoiceTelephonyWebhookRoutesOptions<TContext, TSession, TResult>, 'context' | 'path' | 'policy' | 'provider'> & {
+        path?: string;
+        policy?: VoiceTelephonyOutcomePolicy;
+        publicKey?: string;
+        toleranceSeconds?: number;
+    };
+};
+export declare const createTelnyxVoiceResponse: (options: TelnyxVoiceResponseOptions) => string;
+export declare const createTelnyxMediaStreamBridge: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(socket: TelnyxMediaStreamSocket, options: TelnyxMediaStreamBridgeOptions<TContext, TSession, TResult>) => TelnyxMediaStreamBridge;
+export declare const verifyVoiceTelnyxWebhookSignature: (input: {
+    body: string;
+    headers: Headers;
+    publicKey?: string;
+    toleranceSeconds?: number;
+}) => Promise<VoiceTelephonyWebhookVerificationResult>;
+export declare const createTelnyxVoiceRoutes: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options?: TelnyxVoiceRoutesOptions<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: {};
+}>;