@absolutejs/voice 0.0.22-beta.7 → 0.0.22-beta.70

package/dist/telephonyOutcome.d.ts

@@ -0,0 +1,143 @@
+import { Elysia } from 'elysia';
+import type { VoiceCallDisposition, VoiceRouteResult, VoiceSessionHandle, VoiceSessionRecord } from './types';
+export type VoiceTelephonyOutcomeAction = 'complete' | 'escalate' | 'ignore' | 'no-answer' | 'transfer' | 'voicemail';
+export type VoiceTelephonyOutcomeProviderEvent = {
+    answeredBy?: string;
+    durationMs?: number;
+    from?: string;
+    metadata?: Record<string, unknown>;
+    provider?: string;
+    reason?: string;
+    sipCode?: number;
+    status?: string;
+    target?: string;
+    to?: string;
+};
+export type VoiceTelephonyOutcomeDecision = {
+    action: VoiceTelephonyOutcomeAction;
+    confidence: 'high' | 'low' | 'medium';
+    disposition?: VoiceCallDisposition;
+    metadata?: Record<string, unknown>;
+    reason?: string;
+    source: 'answered-by' | 'duration' | 'explicit-target' | 'policy' | 'sip' | 'status';
+    target?: string;
+};
+export type VoiceTelephonyOutcomeStatusDecision = VoiceTelephonyOutcomeAction | Omit<VoiceTelephonyOutcomeDecision, 'confidence' | 'source'> & {
+    confidence?: VoiceTelephonyOutcomeDecision['confidence'];
+    source?: VoiceTelephonyOutcomeDecision['source'];
+};
+export type VoiceTelephonyOutcomePolicy = {
+    completedStatuses?: string[];
+    escalationStatuses?: string[];
+    failedAsNoAnswer?: boolean;
+    failedStatuses?: string[];
+    includeProviderPayload?: boolean;
+    machineDetectionVoicemailValues?: string[];
+    metadata?: Record<string, unknown>;
+    minAnsweredDurationMs?: number;
+    noAnswerOnZeroDuration?: boolean;
+    noAnswerSipCodes?: number[];
+    noAnswerStatuses?: string[];
+    statusMap?: Record<string, VoiceTelephonyOutcomeStatusDecision>;
+    transferStatuses?: string[];
+    transferTarget?: string | ((event: VoiceTelephonyOutcomeProviderEvent) => string | undefined);
+    voicemailStatuses?: string[];
+};
+export type VoiceTelephonyOutcomeRouteResult<TResult = unknown> = VoiceRouteResult<TResult>;
+export type VoiceTelephonyWebhookProvider = 'generic' | 'plivo' | 'telnyx' | 'twilio';
+export type VoiceTelephonyWebhookParseInput = {
+    body: unknown;
+    headers: Headers;
+    provider: VoiceTelephonyWebhookProvider;
+    query: Record<string, unknown>;
+    request: Request;
+};
+export type VoiceTelephonyWebhookDecision<TResult = unknown> = {
+    applied: boolean;
+    decision: VoiceTelephonyOutcomeDecision;
+    event: VoiceTelephonyOutcomeProviderEvent;
+    routeResult: VoiceTelephonyOutcomeRouteResult<TResult>;
+    sessionId?: string;
+};
+export type VoiceTelephonyWebhookHandlerOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    apply?: boolean | ((input: VoiceTelephonyWebhookDecision<TResult>) => boolean);
+    context?: TContext;
+    getSessionHandle?: (input: {
+        context: TContext;
+        decision: VoiceTelephonyOutcomeDecision;
+        event: VoiceTelephonyOutcomeProviderEvent;
+        request: Request;
+        sessionId?: string;
+    }) => Promise<VoiceSessionHandle<TContext, TSession, TResult> | undefined> | VoiceSessionHandle<TContext, TSession, TResult> | undefined;
+    onDecision?: (input: VoiceTelephonyWebhookDecision<TResult> & {
+        context: TContext;
+        request: Request;
+    }) => Promise<void> | void;
+    parse?: (input: VoiceTelephonyWebhookParseInput) => Promise<VoiceTelephonyOutcomeProviderEvent> | VoiceTelephonyOutcomeProviderEvent;
+    policy?: VoiceTelephonyOutcomePolicy;
+    provider?: VoiceTelephonyWebhookProvider;
+    resolveSessionId?: (input: {
+        body: unknown;
+        event: VoiceTelephonyOutcomeProviderEvent;
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<string | undefined> | string | undefined;
+    result?: TResult | ((input: {
+        decision: VoiceTelephonyOutcomeDecision;
+        event: VoiceTelephonyOutcomeProviderEvent;
+        sessionId?: string;
+    }) => Promise<TResult | undefined> | TResult | undefined);
+};
+export type VoiceTelephonyWebhookRoutesOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoiceTelephonyWebhookHandlerOptions<TContext, TSession, TResult> & {
+    name?: string;
+    path?: string;
+};
+export declare const createVoiceTelephonyOutcomePolicy: (policy?: VoiceTelephonyOutcomePolicy) => Required<Pick<VoiceTelephonyOutcomePolicy, "completedStatuses" | "escalationStatuses" | "failedAsNoAnswer" | "failedStatuses" | "includeProviderPayload" | "machineDetectionVoicemailValues" | "noAnswerOnZeroDuration" | "noAnswerSipCodes" | "noAnswerStatuses" | "transferStatuses" | "voicemailStatuses">> & VoiceTelephonyOutcomePolicy;
+export declare const resolveVoiceTelephonyOutcome: (event: VoiceTelephonyOutcomeProviderEvent, policyInput?: VoiceTelephonyOutcomePolicy) => VoiceTelephonyOutcomeDecision;
+export declare const voiceTelephonyOutcomeToRouteResult: <TResult = unknown>(decision: VoiceTelephonyOutcomeDecision, result?: TResult) => VoiceTelephonyOutcomeRouteResult<TResult>;
+export declare const applyVoiceTelephonyOutcome: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(api: VoiceSessionHandle<TContext, TSession, TResult>, decision: VoiceTelephonyOutcomeDecision, result?: TResult) => Promise<void>;
+export declare const parseVoiceTelephonyWebhookEvent: (input: VoiceTelephonyWebhookParseInput) => VoiceTelephonyOutcomeProviderEvent;
+export declare const createVoiceTelephonyWebhookHandler: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options?: VoiceTelephonyWebhookHandlerOptions<TContext, TSession, TResult>) => (input: {
+    query?: Record<string, unknown>;
+    request: Request;
+}) => Promise<VoiceTelephonyWebhookDecision<TResult>>;
+export declare const createVoiceTelephonyWebhookRoutes: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options?: VoiceTelephonyWebhookRoutesOptions<TContext, TSession, TResult>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceTelephonyWebhookDecision<TResult>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/testing/index.d.ts

@@ -3,6 +3,8 @@ export * from './benchmark';
 export * from './corrected';
 export * from './duplex';
 export * from './fixtures';
+export * from './ioProviderSimulator';
+export * from './providerSimulator';
 export * from './resilience';
 export * from './review';
 export * from './sessionBenchmark';