@absolutejs/voice 0.0.22-beta.78 → 0.0.22-beta.79

package/dist/index.d.ts

@@ -83,9 +83,11 @@ export type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredV
 export { createTwilioMediaStreamBridge, createTwilioVoiceRoutes, createTwilioVoiceResponse, decodeTwilioMulawBase64, encodeTwilioMulawBase64, transcodePCMToTwilioOutboundPayload, transcodeTwilioInboundPayloadToPCM16 } from './telephony/twilio';
 export { evaluateVoiceTelephonyContract } from './telephony/contract';
 export { createTelnyxVoiceResponse, createTelnyxVoiceRoutes, verifyVoiceTelnyxWebhookSignature } from './telephony/telnyx';
+export { createPlivoVoiceResponse, createPlivoVoiceRoutes, signVoicePlivoWebhook, verifyVoicePlivoWebhookSignature } from './telephony/plivo';
 export type { TwilioInboundMessage, TwilioMediaStreamBridge, TwilioMediaStreamBridgeOptions, TwilioMediaStreamSocket, TwilioOutboundClearMessage, TwilioOutboundMarkMessage, TwilioOutboundMediaMessage, TwilioOutboundMessage, TwilioVoiceRouteParameters, TwilioVoiceResponseOptions, TwilioVoiceSmokeCheck, TwilioVoiceSmokeOptions, TwilioVoiceSmokeReport, TwilioVoiceSetupOptions, TwilioVoiceSetupStatus, TwilioVoiceRoutesOptions } from './telephony/twilio';
 export type { VoiceTelephonyContractIssue, VoiceTelephonyContractOptions, VoiceTelephonyContractReport, VoiceTelephonyContractRequirement, VoiceTelephonyProvider, VoiceTelephonySetupStatus, VoiceTelephonySmokeCheck, VoiceTelephonySmokeReport } from './telephony/contract';
 export type { TelnyxVoiceResponseOptions, TelnyxVoiceRoutesOptions, TelnyxVoiceSetupOptions, TelnyxVoiceSetupStatus, TelnyxVoiceSmokeCheck, TelnyxVoiceSmokeOptions, TelnyxVoiceSmokeReport } from './telephony/telnyx';
+export type { PlivoVoiceResponseOptions, PlivoVoiceRoutesOptions, PlivoVoiceSetupOptions, PlivoVoiceSetupStatus, PlivoVoiceSmokeCheck, PlivoVoiceSmokeOptions, PlivoVoiceSmokeReport } from './telephony/plivo';
 export { shapeTelephonyAssistantText } from './telephony/response';
 export type { TelephonyResponseShapeMode, TelephonyResponseShapeOptions } from './telephony/response';
 export * from './types';

package/dist/index.js

@@ -16270,6 +16270,335 @@ var createTelnyxVoiceRoutes = (options = {}) => {
     return report;
   });
 };
+// src/telephony/plivo.ts
+import { Buffer as Buffer5 } from "buffer";
+import { Elysia as Elysia20 } from "elysia";
+var escapeXml4 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var escapeHtml19 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&#39;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var joinUrlPath3 = (origin, path) => `${origin.replace(/\/$/, "")}${path.startsWith("/") ? path : `/${path}`}`;
+var resolveRequestOrigin3 = (request) => {
+  const url = new URL(request.url);
+  const forwardedHost = request.headers.get("x-forwarded-host");
+  const forwardedProto = request.headers.get("x-forwarded-proto");
+  const host = forwardedHost ?? request.headers.get("host") ?? url.host;
+  const protocol = forwardedProto ?? url.protocol.replace(":", "");
+  return `${protocol}://${host}`;
+};
+var boolAttr = (value) => typeof value === "boolean" ? String(value) : undefined;
+var extraHeadersAttr = (headers) => {
+  if (!headers || typeof headers === "string") {
+    return headers;
+  }
+  return Object.entries(headers).filter((entry) => entry[1] !== undefined).map(([key, value]) => `${key}=${String(value)}`).join(",");
+};
+var extractPlivoStreamUrl = (xml) => xml.match(/<Stream\b[^>]*>([^<]+)<\/Stream>/i)?.[1]?.trim();
+var createSmokeCheck3 = (name, status, message, details) => ({
+  details,
+  message,
+  name,
+  status
+});
+var resolvePlivoStreamUrl = async (options, input) => {
+  if (typeof options.answer?.streamUrl === "function") {
+    return options.answer.streamUrl(input);
+  }
+  if (typeof options.answer?.streamUrl === "string") {
+    return options.answer.streamUrl;
+  }
+  const origin = resolveRequestOrigin3(input.request);
+  const wsOrigin = origin.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
+  return `${wsOrigin}${input.streamPath}`;
+};
+var createPlivoVoiceResponse = (options) => {
+  const attributes = [
+    options.bidirectional !== undefined ? `bidirectional="${escapeXml4(String(options.bidirectional))}"` : undefined,
+    options.audioTrack ? `audioTrack="${escapeXml4(options.audioTrack)}"` : undefined,
+    options.streamTimeout ? `streamTimeout="${escapeXml4(String(options.streamTimeout))}"` : undefined,
+    options.contentType ? `contentType="${escapeXml4(options.contentType)}"` : undefined,
+    options.keepCallAlive !== undefined ? `keepCallAlive="${escapeXml4(String(options.keepCallAlive))}"` : undefined,
+    extraHeadersAttr(options.extraHeaders) ? `extraHeaders="${escapeXml4(extraHeadersAttr(options.extraHeaders))}"` : undefined,
+    options.statusCallbackUrl ? `statusCallbackUrl="${escapeXml4(options.statusCallbackUrl)}"` : undefined,
+    options.statusCallbackMethod ? `statusCallbackMethod="${escapeXml4(options.statusCallbackMethod)}"` : undefined,
+    boolAttr(options.noiseCancellation) ? `noiseCancellation="${escapeXml4(boolAttr(options.noiseCancellation))}"` : undefined,
+    options.noiseCancellationLevel ? `noiseCancellationLevel="${escapeXml4(String(options.noiseCancellationLevel))}"` : undefined
+  ].filter((value) => Boolean(value)).join(" ");
+  const openTag = attributes ? `<Stream ${attributes}>` : "<Stream>";
+  return `<?xml version="1.0" encoding="UTF-8"?><Response>${openTag}${escapeXml4(options.streamUrl)}</Stream></Response>`;
+};
+var toBase642 = (bytes) => Buffer5.from(new Uint8Array(bytes)).toString("base64");
+var timingSafeEqual3 = (left, right) => {
+  const encoder = new TextEncoder;
+  const leftBytes = encoder.encode(left);
+  const rightBytes = encoder.encode(right);
+  if (leftBytes.length !== rightBytes.length) {
+    return false;
+  }
+  let diff = 0;
+  for (let index = 0;index < leftBytes.length; index += 1) {
+    diff |= leftBytes[index] ^ rightBytes[index];
+  }
+  return diff === 0;
+};
+var signHmacSHA256Base64 = async (secret, payload) => {
+  const encoder = new TextEncoder;
+  const key = await crypto.subtle.importKey("raw", encoder.encode(secret), {
+    hash: "SHA-256",
+    name: "HMAC"
+  }, false, ["sign"]);
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(payload));
+  return toBase642(signature);
+};
+var sortedParamsForSignature2 = (body) => {
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return "";
+  }
+  return Object.entries(body).filter(([, value]) => value !== undefined && value !== null).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}${String(value)}`).join("");
+};
+var signVoicePlivoWebhook = async (input) => signHmacSHA256Base64(input.authToken, `${input.url}${sortedParamsForSignature2(input.body)}.${input.nonce}`);
+var headerList = (value) => value?.split(",").map((signature) => signature.trim()).filter(Boolean) ?? [];
+var verifyVoicePlivoWebhookSignature = async (input) => {
+  if (!input.authToken) {
+    return { ok: false, reason: "missing-secret" };
+  }
+  const nonce = input.headers.get("x-plivo-signature-v3-nonce");
+  const signatures = [
+    ...headerList(input.headers.get("x-plivo-signature-v3")),
+    ...headerList(input.headers.get("x-plivo-signature-ma-v3"))
+  ];
+  if (!nonce || signatures.length === 0) {
+    return { ok: false, reason: "missing-signature" };
+  }
+  const expected = await signVoicePlivoWebhook({
+    authToken: input.authToken,
+    body: input.body,
+    nonce,
+    url: input.url
+  });
+  return signatures.some((signature) => timingSafeEqual3(signature, expected)) ? { ok: true } : { ok: false, reason: "invalid-signature" };
+};
+var buildPlivoVoiceSetupStatus = async (options, input) => {
+  const origin = resolveRequestOrigin3(input.request);
+  const stream = await resolvePlivoStreamUrl(options, input);
+  const answer = joinUrlPath3(origin, input.answerPath);
+  const webhook = joinUrlPath3(origin, input.webhookPath);
+  const missing = Object.entries(options.setup?.requiredEnv ?? {}).filter((entry) => !entry[1]).map(([name]) => name);
+  const signingConfigured = Boolean(options.webhook?.authToken || options.webhook?.verify);
+  const warnings = [
+    ...stream.startsWith("wss://") ? [] : ["Plivo audio streams should use wss:// in production."],
+    ...signingConfigured ? [] : ["Webhook signature verification is not configured."]
+  ];
+  return {
+    generatedAt: Date.now(),
+    missing,
+    provider: "plivo",
+    ready: missing.length === 0 && signingConfigured && warnings.length === 0,
+    signing: {
+      configured: signingConfigured,
+      mode: options.webhook?.verify ? "custom" : options.webhook?.authToken ? "provider-signature" : "none",
+      verificationUrl: webhook
+    },
+    urls: {
+      answer,
+      stream,
+      twiml: answer,
+      webhook
+    },
+    warnings
+  };
+};
+var renderPlivoSetupHTML = (status, title) => `<main style="font-family: ui-sans-serif, system-ui; max-width: 860px; margin: 40px auto; padding: 0 20px;">
+<p style="letter-spacing: .12em; text-transform: uppercase; color: #52606d;">Plivo setup</p>
+<h1>${escapeHtml19(title)}</h1>
+<p><strong>Status:</strong> ${status.ready ? "Ready" : "Needs attention"}</p>
+<ul>
+<li><strong>Answer XML:</strong> <code>${escapeHtml19(status.urls.answer)}</code></li>
+<li><strong>Audio stream:</strong> <code>${escapeHtml19(status.urls.stream)}</code></li>
+<li><strong>Status webhook:</strong> <code>${escapeHtml19(status.urls.webhook)}</code></li>
+</ul>
+${status.missing.length ? `<h2>Missing env</h2><ul>${status.missing.map((name) => `<li><code>${escapeHtml19(name)}</code></li>`).join("")}</ul>` : ""}
+${status.warnings.length ? `<h2>Warnings</h2><ul>${status.warnings.map((warning) => `<li>${escapeHtml19(warning)}</li>`).join("")}</ul>` : ""}
+</main>`;
+var renderPlivoSmokeHTML = (report, title) => `<main style="font-family: ui-sans-serif, system-ui; max-width: 860px; margin: 40px auto; padding: 0 20px;">
+<p style="letter-spacing: .12em; text-transform: uppercase; color: #52606d;">Plivo smoke test</p>
+<h1>${escapeHtml19(title)}</h1>
+<p><strong>Status:</strong> ${report.pass ? "Pass" : "Fail"}</p>
+<ul>${report.checks.map((check) => `<li><strong>${escapeHtml19(check.name)}</strong>: ${escapeHtml19(check.status)}${check.message ? ` - ${escapeHtml19(check.message)}` : ""}</li>`).join("")}</ul>
+</main>`;
+var runPlivoSmokeTest = async (input) => {
+  const setup = await buildPlivoVoiceSetupStatus(input.options, input);
+  const checks = [];
+  const answerResponse = await input.app.handle(new Request(setup.urls.answer));
+  const answerXml = await answerResponse.text();
+  const streamUrl = extractPlivoStreamUrl(answerXml);
+  checks.push(createSmokeCheck3("answer-xml", answerResponse.ok && Boolean(streamUrl) ? "pass" : "fail", streamUrl ? "Answer XML includes a Stream URL." : "Answer XML is missing <Stream>...</Stream>.", {
+    status: answerResponse.status,
+    streamUrl
+  }));
+  checks.push(createSmokeCheck3("stream-url", streamUrl?.startsWith("wss://") ? "pass" : "fail", streamUrl?.startsWith("wss://") ? "Audio stream URL uses wss://." : "Audio stream URL should use wss:// for Plivo.", {
+    streamUrl
+  }));
+  const webhookBody = new URLSearchParams({
+    CallUUID: input.options.smoke?.callUuid ?? "plivo-smoke-call",
+    Duration: "0",
+    Event: input.options.smoke?.eventType ?? "Hangup",
+    From: "+15555550100",
+    HangupCause: "busy",
+    SessionId: input.options.smoke?.sessionId ?? "plivo-smoke-session",
+    SipResponseCode: String(input.options.smoke?.sipCode ?? 486),
+    To: "+15555550101",
+    status: input.options.smoke?.status ?? "busy"
+  });
+  const webhookResponse = await input.app.handle(new Request(setup.urls.webhook, {
+    body: webhookBody,
+    headers: {
+      "content-type": "application/x-www-form-urlencoded"
+    },
+    method: "POST"
+  }));
+  const webhookText = await webhookResponse.text();
+  const webhookPayload = (() => {
+    try {
+      return JSON.parse(webhookText);
+    } catch {
+      return webhookText;
+    }
+  })();
+  checks.push(createSmokeCheck3("webhook", webhookResponse.ok ? "pass" : "fail", webhookResponse.ok ? "Synthetic Plivo event was accepted." : "Synthetic Plivo event failed.", {
+    status: webhookResponse.status
+  }));
+  for (const warning of setup.warnings) {
+    checks.push(createSmokeCheck3("setup-warning", "warn", warning));
+  }
+  for (const name of setup.missing) {
+    checks.push(createSmokeCheck3("missing-env", "fail", `${name} is missing.`));
+  }
+  const baseReport = {
+    answer: {
+      status: answerResponse.status,
+      streamUrl
+    },
+    checks,
+    generatedAt: Date.now(),
+    pass: checks.every((check) => check.status !== "fail"),
+    provider: "plivo",
+    setup,
+    twiml: {
+      status: answerResponse.status,
+      streamUrl
+    },
+    webhook: {
+      body: webhookPayload,
+      status: webhookResponse.status
+    }
+  };
+  return {
+    ...baseReport,
+    contract: evaluateVoiceTelephonyContract({
+      setup,
+      smoke: baseReport
+    })
+  };
+};
+var createPlivoVoiceRoutes = (options = {}) => {
+  const streamPath = options.streamPath ?? "/api/voice/plivo/stream";
+  const answerPath = options.answer?.path ?? "/api/voice/plivo";
+  const webhookPath = options.webhook?.path ?? "/api/voice/plivo/webhook";
+  const setupPath = options.setup?.path === false ? false : options.setup?.path ?? "/api/voice/plivo/setup";
+  const smokePath = options.smoke?.path === false ? false : options.smoke?.path ?? "/api/voice/plivo/smoke";
+  const webhookPolicy = options.webhook?.policy ?? options.outcomePolicy ?? createVoiceTelephonyOutcomePolicy();
+  const verificationUrl = options.webhook?.verificationUrl;
+  const verify = options.webhook?.verify ?? (options.webhook?.authToken ? (input) => verifyVoicePlivoWebhookSignature({
+    authToken: options.webhook?.authToken,
+    body: input.body,
+    headers: input.request.headers,
+    url: typeof verificationUrl === "function" ? verificationUrl({
+      query: input.query,
+      request: input.request
+    }) : verificationUrl ?? input.request.url
+  }) : undefined);
+  const app = new Elysia20({
+    name: options.name ?? "absolutejs-voice-plivo"
+  }).get(answerPath, async ({ query, request }) => {
+    const streamUrl = await resolvePlivoStreamUrl(options, {
+      query,
+      request,
+      streamPath
+    });
+    return new Response(createPlivoVoiceResponse({
+      ...options.answer?.response,
+      streamUrl
+    }), {
+      headers: {
+        "content-type": "text/xml; charset=utf-8"
+      }
+    });
+  }).post(answerPath, async ({ query, request }) => {
+    const streamUrl = await resolvePlivoStreamUrl(options, {
+      query,
+      request,
+      streamPath
+    });
+    return new Response(createPlivoVoiceResponse({
+      ...options.answer?.response,
+      streamUrl
+    }), {
+      headers: {
+        "content-type": "text/xml; charset=utf-8"
+      }
+    });
+  }).use(createVoiceTelephonyWebhookRoutes({
+    ...options.webhook ?? {},
+    context: options.context,
+    path: webhookPath,
+    policy: webhookPolicy,
+    provider: "plivo",
+    requireVerification: Boolean(options.webhook?.authToken),
+    resolveSessionId: options.webhook?.resolveSessionId ?? (({ event }) => {
+      const metadata = event.metadata;
+      return typeof metadata?.SessionId === "string" ? metadata.SessionId : typeof metadata?.sessionId === "string" ? metadata.sessionId : typeof metadata?.CallUUID === "string" ? metadata.CallUUID : typeof metadata?.call_uuid === "string" ? metadata.call_uuid : undefined;
+    }),
+    verify
+  }));
+  const withSetup = setupPath ? app.get(setupPath, async ({ query, request }) => {
+    const status = await buildPlivoVoiceSetupStatus(options, {
+      answerPath,
+      query,
+      request,
+      streamPath,
+      webhookPath
+    });
+    if (query.format === "html") {
+      return new Response(renderPlivoSetupHTML(status, options.setup?.title ?? "AbsoluteJS Plivo Voice Setup"), {
+        headers: {
+          "content-type": "text/html; charset=utf-8"
+        }
+      });
+    }
+    return status;
+  }) : app;
+  if (!smokePath) {
+    return withSetup;
+  }
+  return withSetup.get(smokePath, async ({ query, request }) => {
+    const report = await runPlivoSmokeTest({
+      answerPath,
+      app,
+      options,
+      query,
+      request,
+      streamPath,
+      webhookPath
+    });
+    if (query.format === "html") {
+      return new Response(renderPlivoSmokeHTML(report, options.smoke?.title ?? "AbsoluteJS Plivo Voice Smoke Test"), {
+        headers: {
+          "content-type": "text/html; charset=utf-8"
+        }
+      });
+    }
+    return report;
+  });
+};
 // src/telephony/response.ts
 var normalizeWhitespace = (value) => value.replace(/\s+/g, " ").trim();
 var DEFAULT_MAX_WORDS = 12;
@@ -16329,6 +16658,7 @@ export {
   voice,
   verifyVoiceTwilioWebhookSignature,
   verifyVoiceTelnyxWebhookSignature,
+  verifyVoicePlivoWebhookSignature,
   verifyVoiceOpsWebhookSignature,
   validateVoiceWorkflowRouteResult,
   transcodeTwilioInboundPayloadToPCM16,
@@ -16352,6 +16682,7 @@ export {
   summarizeVoiceAppKitStatus,
   startVoiceOpsTask,
   signVoiceTwilioWebhook,
+  signVoicePlivoWebhook,
   shapeTelephonyAssistantText,
   selectVoiceTraceEventsForPrune,
   runVoiceToolContractSuite,
@@ -16577,6 +16908,8 @@ export {
   createStoredVoiceExternalObjectMap,
   createStoredVoiceCallReviewArtifact,
   createRiskyTurnCorrectionHandler,
+  createPlivoVoiceRoutes,
+  createPlivoVoiceResponse,
   createPhraseHintCorrectionHandler,
   createOpenAIVoiceAssistantModel,
   createMemoryVoiceTelephonyWebhookIdempotencyStore,

package/dist/telephony/plivo.d.ts

@@ -0,0 +1,154 @@
+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 { VoiceSessionRecord } from '../types';
+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);
+    };
+    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 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]: {
+        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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/voice",
-	"version": "0.0.22-beta.78",
+	"version": "0.0.22-beta.79",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",