@vuevox/sdk 0.7.0 → 0.9.0

package/README.md

@@ -31,9 +31,12 @@ hello:read
 spaces:read
 agents:read
 calls:read
+calls:write
 leads:read
 leads:write
 lead_custom_fields:manage
+webhooks:read
+webhooks:write
 ```
 
 The token request can only request scopes that were granted to that API client.
@@ -104,6 +107,9 @@ vuevox.agents.list();
 vuevox.agents.paginate();
 vuevox.calls.list();
 vuevox.calls.get("call-id");
+vuevox.calls.upload({ idempotencyKey: "crm-call-123", spaceId: "space-id", agent: { externalId: "agent-1", name: "Morgan" }, lead: { externalId: "lead-1", firstName: "Ada", lastName: "Lovelace" }, audio: { file: audioBlob, filename: "call.mp3" } });
+vuevox.calls.queueAnalysis("call-id");
+vuevox.calls.waitForAnalysis("call-id");
 vuevox.calls.paginate();
 vuevox.leads.list();
 vuevox.leads.get("lead-id");
@@ -113,6 +119,12 @@ vuevox.leads.paginate();
 vuevox.leadCustomFields.list();
 vuevox.leadCustomFields.create({ key: "crm_stage", label: "CRM Stage", type: "select", options: ["new", "qualified"] });
 vuevox.leadCustomFields.update("crm_stage", { label: "CRM Stage" });
+vuevox.webhooks.endpoints.list();
+vuevox.webhooks.endpoints.create({ url: "https://example.com/vuevox/webhooks", events: ["analysis.completed", "analysis.failed"] });
+vuevox.webhooks.endpoints.update("endpoint-id", { isActive: false });
+vuevox.webhooks.endpoints.rotateSecret("endpoint-id");
+vuevox.webhooks.endpoints.test("endpoint-id");
+vuevox.webhooks.endpoints.delete("endpoint-id");
 vuevox.raw.GET("/v1/hello", { headers: { Authorization: `Bearer ${await vuevox.getAccessToken()}` } });
 ```
 
@@ -160,7 +172,7 @@ for await (const call of vuevox.calls.paginate({ limit: 50 })) {
 }
 ```
 
-Pagination helpers are available for `spaces`, `agents`, `calls`, and `leads`.
+Pagination helpers are available for `spaces`, `agents`, `calls`, `leads`, and `webhooks.endpoints`.
 
 ## Methods
 
@@ -312,6 +324,106 @@ console.log(response.data.data.transcript);
 
 Returns: `Promise<VueVoxApiResponse<CallDetailResponse>>`.
 
+### `vuevox.calls.upload(input)`
+
+Uploads an audio recording, upserts the agent and lead by `externalId`, creates the call in an existing platform-managed space, and optionally queues analysis.
+
+Required scope: `calls:write`.
+
+The API requires an idempotency key for uploads. Reusing the same `idempotencyKey` with the same request returns the original response; reusing it with different metadata or audio returns an `idempotency_key_conflict` error.
+
+Spaces are managed in VueVox. Use `vuevox.spaces.list()` to obtain the `spaceId`.
+
+The maximum audio upload size is configured by a VueVox superadmin and defaults to 20 MB. Your server/proxy upload limits must also allow that size.
+
+Options: `UploadCallInput`
+
+| Option | Type | Description |
+| --- | --- | --- |
+| `idempotencyKey` | `string` | Required unique key for safe retries. |
+| `spaceId` | `string` | Required existing VueVox space ID. |
+| `externalId` | `string \| null` | Optional call ID from your system. |
+| `queueAnalysis` | `boolean` | Optional. Defaults to `true`; set `false` to upload now and queue later. |
+| `agent.externalId` | `string` | Required agent ID from your system. |
+| `agent.name` | `string` | Required when creating a new agent. |
+| `agent.email` | `string \| null` | Optional agent email. |
+| `agent.phone` | `string \| null` | Optional agent phone. |
+| `lead.externalId` | `string` | Required lead/prospect ID from your system. |
+| `lead.firstName` | `string` | Required when creating a new lead. |
+| `lead.lastName` | `string` | Required when creating a new lead. |
+| `lead.email` | `string \| null` | Optional lead email. |
+| `lead.phone` | `string \| null` | Optional lead phone. |
+| `lead.customFields` | `Record<string, unknown>` | Optional organization-defined lead custom fields. |
+| `audio.file` | `Blob` | Required audio file blob. In Node, use `new Blob([buffer], { type: "audio/mpeg" })`. |
+| `audio.filename` | `string` | Optional filename sent in multipart upload. |
+
+```ts
+import { readFile } from "node:fs/promises";
+
+const buffer = await readFile("./call.mp3");
+
+const response = await vuevox.calls.upload({
+  idempotencyKey: "crm-call-789",
+  externalId: "crm-call-789",
+  spaceId: "space-id",
+  queueAnalysis: true,
+  agent: {
+    externalId: "agent-123",
+    name: "Morgan Agent",
+  },
+  lead: {
+    externalId: "prospect-456",
+    firstName: "Ada",
+    lastName: "Lovelace",
+    email: "ada@example.com",
+    customFields: {
+      crm_stage: "qualified",
+    },
+  },
+  audio: {
+    file: new Blob([buffer], { type: "audio/mpeg" }),
+    filename: "call.mp3",
+  },
+});
+
+console.log(response.data.data.id, response.data.data.analysisStatus, response.requestId);
+```
+
+Returns: `Promise<VueVoxApiResponse<CallResponse>>`.
+
+### `vuevox.calls.queueAnalysis(callId)`
+
+Queues analysis for a call that was uploaded with `queueAnalysis: false`.
+
+Required scope: `calls:write`.
+
+```ts
+const response = await vuevox.calls.queueAnalysis("call-id");
+console.log(response.data.data.analysisStatus, response.data.data.queueStatus);
+```
+
+Returns: `Promise<VueVoxApiResponse<CallResponse>>`.
+
+### `vuevox.calls.waitForAnalysis(callId, options?)`
+
+Polls `vuevox.calls.get(callId)` until the call analysis status is `completed` or `failed`.
+
+Required scope: `calls:read`.
+
+Options: `WaitForAnalysisOptions`
+
+| Option | Type | Description |
+| --- | --- | --- |
+| `intervalMs` | `number` | Poll interval. Defaults to `2000`. |
+| `timeoutMs` | `number` | Timeout before throwing `analysis_timeout`. Defaults to `120000`. |
+
+```ts
+const response = await vuevox.calls.waitForAnalysis("call-id", { timeoutMs: 180000 });
+console.log(response.data.data.analysis);
+```
+
+Returns: `Promise<VueVoxApiResponse<CallDetailResponse>>`.
+
 ### `vuevox.calls.paginate(options?)`
 
 Iterates organization calls across all pages.
@@ -497,6 +609,126 @@ await vuevox.leadCustomFields.update("crm_stage", {
 
 Returns: `Promise<VueVoxApiResponse<LeadCustomFieldResponse>>`.
 
+### `vuevox.webhooks.endpoints.list(options?)`
+
+Lists webhook endpoints for the authenticated API client.
+
+Required scope: `webhooks:read`.
+
+Options: `ListWebhookEndpointsOptions`
+
+```ts
+const response = await vuevox.webhooks.endpoints.list({ limit: 50 });
+console.log(response.data.data);
+```
+
+Returns: `Promise<VueVoxApiResponse<WebhookEndpointsListResponse>>`.
+
+### `vuevox.webhooks.endpoints.create(input)`
+
+Creates a webhook endpoint. The signing secret is returned only once in this response.
+
+Required scope: `webhooks:write`.
+
+Input: `WebhookEndpointCreateRequest`
+
+```ts
+const response = await vuevox.webhooks.endpoints.create({
+  url: "https://example.com/vuevox/webhooks",
+  events: ["analysis.completed", "analysis.failed"],
+});
+
+console.log(response.data.data.id, response.data.data.secret);
+```
+
+Returns: `Promise<VueVoxApiResponse<WebhookEndpointSecretResponse>>`.
+
+### `vuevox.webhooks.endpoints.update(endpointId, input)`
+
+Updates a webhook endpoint URL, event subscriptions, or active state.
+
+Required scope: `webhooks:write`.
+
+Input: `WebhookEndpointUpdateRequest`
+
+```ts
+const response = await vuevox.webhooks.endpoints.update("endpoint-id", {
+  events: ["analysis.completed"],
+  isActive: true,
+});
+```
+
+Returns: `Promise<VueVoxApiResponse<WebhookEndpointResponse>>`.
+
+### `vuevox.webhooks.endpoints.delete(endpointId)`
+
+Deletes a webhook endpoint.
+
+Required scope: `webhooks:write`.
+
+```ts
+await vuevox.webhooks.endpoints.delete("endpoint-id");
+```
+
+Returns: `Promise<VueVoxApiResponse<null>>`.
+
+### `vuevox.webhooks.endpoints.rotateSecret(endpointId)`
+
+Rotates the endpoint signing secret. The new secret is returned only once.
+
+Required scope: `webhooks:write`.
+
+```ts
+const response = await vuevox.webhooks.endpoints.rotateSecret("endpoint-id");
+console.log(response.data.data.secret);
+```
+
+Returns: `Promise<VueVoxApiResponse<WebhookEndpointSecretResponse>>`.
+
+### `vuevox.webhooks.endpoints.test(endpointId)`
+
+Queues a `webhook.test` delivery to validate endpoint reachability and signature verification.
+
+Required scope: `webhooks:write`.
+
+```ts
+const response = await vuevox.webhooks.endpoints.test("endpoint-id");
+console.log(response.data.data.eventType, response.data.data.status);
+```
+
+Returns: `Promise<VueVoxApiResponse<WebhookTestResponse>>`.
+
+### `vuevox.webhooks.endpoints.paginate(options?)`
+
+Iterates webhook endpoints across all pages.
+
+Required scope: `webhooks:read`.
+
+```ts
+for await (const endpoint of vuevox.webhooks.endpoints.paginate({ limit: 50 })) {
+  console.log(endpoint.id, endpoint.events);
+}
+```
+
+Returns: `AsyncGenerator<WebhookEndpoint>`.
+
+### `verifyVueVoxWebhookSignature(input)`
+
+Verifies a webhook HMAC signature. Pass the raw request body string exactly as received.
+
+```ts
+import { verifyVueVoxWebhookSignature } from "@vuevox/sdk";
+
+const valid = await verifyVueVoxWebhookSignature({
+  body: rawBody,
+  secret: process.env.VUEVOX_WEBHOOK_SECRET!,
+  signature: request.headers.get("VueVox-Signature") ?? "",
+  timestamp: request.headers.get("VueVox-Timestamp") ?? "",
+});
+```
+
+Returns: `Promise<boolean>`.
+
 ## Lower-Level Calls
 
 For advanced integrations, `raw` exposes a typed lower-level OpenAPI client. You must attach authorization yourself.
@@ -551,6 +783,14 @@ insufficient_scope
 rate_limited
 invalid_request
 call_not_found
+call_external_id_conflict
+analysis_already_queued
+analysis_timeout
+ai_config_missing
+evaluation_grid_missing
+audio_not_found
+idempotency_key_conflict
+idempotency_key_in_progress
 lead_not_found
 custom_field_not_found
 custom_field_conflict
@@ -608,8 +848,10 @@ import type {
   Agent,
   AgentsListResponse,
   CallDetailResponse,
+  CallResponse,
   CallsListResponse,
   CallSummary,
+  CallUploadMetadata,
   CustomFieldFilters,
   CustomFieldFilterValue,
   HelloResponse,
@@ -628,13 +870,25 @@ import type {
   ListLeadCustomFieldsOptions,
   ListLeadsOptions,
   ListSpacesOptions,
+  ListWebhookEndpointsOptions,
   Space,
   SpacesListResponse,
+  UploadCallInput,
+  VerifyWebhookSignatureInput,
   VueVoxApiResponse,
   VueVoxClientOptions,
   VueVoxErrorResponse,
   VueVoxResponseEvent,
   VueVoxResponseMetadata,
+  WaitForAnalysisOptions,
+  WebhookEndpoint,
+  WebhookEndpointCreateRequest,
+  WebhookEndpointResponse,
+  WebhookEndpointSecretResponse,
+  WebhookEndpointUpdateRequest,
+  WebhookEndpointsListResponse,
+  WebhookEventPayload,
+  WebhookTestResponse,
 } from "@vuevox/sdk";
 ```
 

package/dist/client.d.ts

@@ -4,12 +4,22 @@ export type SpacesListResponse = components["schemas"]["SpacesListResponse"];
 export type AgentsListResponse = components["schemas"]["AgentsListResponse"];
 export type CallsListResponse = components["schemas"]["CallsListResponse"];
 export type CallDetailResponse = components["schemas"]["CallDetailResponse"];
+export type CallResponse = components["schemas"]["CallResponse"];
+export type CallUploadMetadata = components["schemas"]["CallUploadMetadata"];
 export type LeadsListResponse = components["schemas"]["LeadsListResponse"];
 export type LeadDetailResponse = components["schemas"]["LeadDetailResponse"];
 export type LeadCustomFieldsListResponse = components["schemas"]["LeadCustomFieldsListResponse"];
 export type LeadCustomFieldResponse = components["schemas"]["LeadCustomFieldResponse"];
 export type LeadCustomFieldCreateRequest = components["schemas"]["LeadCustomFieldCreateRequest"];
 export type LeadCustomFieldUpdateRequest = components["schemas"]["LeadCustomFieldUpdateRequest"];
+export type WebhookEndpoint = components["schemas"]["WebhookEndpoint"];
+export type WebhookEndpointCreateRequest = components["schemas"]["WebhookEndpointCreateRequest"];
+export type WebhookEndpointUpdateRequest = components["schemas"]["WebhookEndpointUpdateRequest"];
+export type WebhookEndpointResponse = components["schemas"]["WebhookEndpointResponse"];
+export type WebhookEndpointSecretResponse = components["schemas"]["WebhookEndpointSecretResponse"];
+export type WebhookEndpointsListResponse = components["schemas"]["WebhookEndpointsListResponse"];
+export type WebhookTestResponse = components["schemas"]["WebhookTestResponse"];
+export type WebhookEventPayload = components["schemas"]["WebhookEventPayload"];
 export type LeadUpsertRequest = components["schemas"]["LeadUpsertRequest"];
 export type LeadUpdateRequest = components["schemas"]["LeadUpdateRequest"];
 export type Space = components["schemas"]["Space"];
@@ -40,6 +50,17 @@ export interface ListCallsOptions extends ListSpacesOptions {
     createdBefore?: string;
     leadCustomFields?: CustomFieldFilters;
 }
+export interface UploadCallInput extends CallUploadMetadata {
+    idempotencyKey: string;
+    audio: {
+        file: Blob;
+        filename?: string;
+    };
+}
+export interface WaitForAnalysisOptions {
+    intervalMs?: number;
+    timeoutMs?: number;
+}
 export interface ListAgentsOptions extends ListSpacesOptions {
     spaceId?: string;
 }
@@ -52,6 +73,16 @@ export interface ListLeadsOptions extends ListSpacesOptions {
 export interface ListLeadCustomFieldsOptions {
     includeArchived?: boolean;
 }
+export interface ListWebhookEndpointsOptions extends ListSpacesOptions {
+}
+export interface VerifyWebhookSignatureInput {
+    body: string;
+    secret: string;
+    signature: string;
+    timestamp: string;
+    toleranceSeconds?: number;
+    now?: number;
+}
 export interface VueVoxResponseMetadata {
     requestId?: string;
     status: number;
@@ -104,8 +135,12 @@ export declare function createVueVoxClient(options: VueVoxClientOptions): {
     calls: {
         list: (listOptions?: ListCallsOptions) => Promise<VueVoxApiResponse<CallsListResponse>>;
         get: (callId: string) => Promise<VueVoxApiResponse<CallDetailResponse>>;
+        upload: (input: UploadCallInput) => Promise<VueVoxApiResponse<CallResponse>>;
+        queueAnalysis: (callId: string) => Promise<VueVoxApiResponse<CallResponse>>;
+        waitForAnalysis: (callId: string, waitOptions?: WaitForAnalysisOptions) => Promise<VueVoxApiResponse<CallDetailResponse>>;
         paginate: (listOptions?: ListCallsOptions) => AsyncGenerator<{
             id: string;
+            externalId: string | null;
             space: components["schemas"]["ResourceSummary"];
             lead: components["schemas"]["LeadSummary"];
             agent: components["schemas"]["AgentSummary"];
@@ -141,5 +176,25 @@ export declare function createVueVoxClient(options: VueVoxClientOptions): {
         create: (input: LeadCustomFieldCreateRequest) => Promise<VueVoxApiResponse<LeadCustomFieldResponse>>;
         update: (key: string, input: LeadCustomFieldUpdateRequest) => Promise<VueVoxApiResponse<LeadCustomFieldResponse>>;
     };
+    webhooks: {
+        endpoints: {
+            list: (listOptions?: ListWebhookEndpointsOptions) => Promise<VueVoxApiResponse<WebhookEndpointsListResponse>>;
+            create: (input: WebhookEndpointCreateRequest) => Promise<VueVoxApiResponse<WebhookEndpointSecretResponse>>;
+            update: (endpointId: string, input: WebhookEndpointUpdateRequest) => Promise<VueVoxApiResponse<WebhookEndpointResponse>>;
+            delete: (endpointId: string) => Promise<VueVoxApiResponse<null>>;
+            rotateSecret: (endpointId: string) => Promise<VueVoxApiResponse<WebhookEndpointSecretResponse>>;
+            test: (endpointId: string) => Promise<VueVoxApiResponse<WebhookTestResponse>>;
+            paginate: (listOptions?: ListWebhookEndpointsOptions) => AsyncGenerator<{
+                id: string;
+                url: string;
+                events: components["schemas"]["WebhookEventType"][];
+                isActive: boolean;
+                lastDeliveredAt: string | null;
+                createdAt: string;
+                updatedAt: string;
+            }, any, any>;
+        };
+    };
     raw: import("openapi-fetch").Client<paths, `${string}/${string}`>;
 };
+export declare function verifyVueVoxWebhookSignature(input: VerifyWebhookSignatureInput): Promise<boolean>;

package/dist/client.js

@@ -46,6 +46,34 @@ export function createVueVoxClient(options) {
     async function getCall(callId) {
         return apiGet(`/v1/calls/${encodeURIComponent(callId)}`);
     }
+    async function uploadCall(input) {
+        const { audio, idempotencyKey, ...metadata } = input;
+        const formData = new FormData();
+        formData.set("metadata", JSON.stringify(metadata));
+        formData.set("audioFile", audio.file, audio.filename ?? "call-audio");
+        return apiMultipart("POST", "/v1/calls", formData, {
+            "Idempotency-Key": idempotencyKey,
+        });
+    }
+    async function queueCallAnalysis(callId) {
+        return apiJson("POST", `/v1/calls/${encodeURIComponent(callId)}/analysis-jobs`, {});
+    }
+    async function waitForCallAnalysis(callId, waitOptions = {}) {
+        const intervalMs = waitOptions.intervalMs ?? 2_000;
+        const timeoutMs = waitOptions.timeoutMs ?? 120_000;
+        const startedAt = Date.now();
+        for (;;) {
+            const response = await getCall(callId);
+            const status = response.data.data.analysisStatus;
+            if (status === "completed" || status === "failed") {
+                return response;
+            }
+            if (Date.now() - startedAt >= timeoutMs) {
+                throw new VueVoxApiError(408, "analysis_timeout", "Timed out waiting for call analysis.", undefined, response.requestId);
+            }
+            await sleep(intervalMs);
+        }
+    }
     async function listLeads(listOptions = {}) {
         return apiGet("/v1/leads", listOptions);
     }
@@ -67,6 +95,24 @@ export function createVueVoxClient(options) {
     async function updateLeadCustomField(key, input) {
         return apiJson("PATCH", `/v1/lead-custom-fields/${encodeURIComponent(key)}`, input);
     }
+    async function listWebhookEndpoints(listOptions = {}) {
+        return apiGet("/v1/webhooks/endpoints", listOptions);
+    }
+    async function createWebhookEndpoint(input) {
+        return apiJson("POST", "/v1/webhooks/endpoints", input);
+    }
+    async function updateWebhookEndpoint(endpointId, input) {
+        return apiJson("PATCH", `/v1/webhooks/endpoints/${encodeURIComponent(endpointId)}`, input);
+    }
+    async function deleteWebhookEndpoint(endpointId) {
+        return apiDelete(`/v1/webhooks/endpoints/${encodeURIComponent(endpointId)}`);
+    }
+    async function rotateWebhookEndpointSecret(endpointId) {
+        return apiJson("POST", `/v1/webhooks/endpoints/${encodeURIComponent(endpointId)}/rotate-secret`, {});
+    }
+    async function testWebhookEndpoint(endpointId) {
+        return apiJson("POST", `/v1/webhooks/endpoints/${encodeURIComponent(endpointId)}/test`, {});
+    }
     async function apiGet(path, query) {
         const accessToken = await getAccessToken();
         const result = await requestJson("GET", path, {
@@ -90,6 +136,36 @@ export function createVueVoxClient(options) {
         });
         return withMetadata(result.data, result.response, result.requestId);
     }
+    async function apiDelete(path) {
+        const accessToken = await getAccessToken();
+        const response = await fetchFn(buildUrl(baseUrl, path, undefined), {
+            method: "DELETE",
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+        });
+        const body = await parseJson(response);
+        const requestId = getRequestId(response, body);
+        const retryAfter = retryAfterSeconds(response);
+        notifyResponse(options, "DELETE", path, response, requestId, retryAfter);
+        if (response.ok) {
+            return withMetadata(null, response, requestId);
+        }
+        const error = isErrorResponse(body) ? body.error : null;
+        throw new VueVoxApiError(response.status, error?.code ?? "api_request_failed", error?.message ?? "VueVox API request failed.", isErrorResponse(body) ? body : undefined, requestId, retryAfter);
+    }
+    async function apiMultipart(method, path, body, headers) {
+        const accessToken = await getAccessToken();
+        const result = await requestJson(method, path, {
+            method,
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                ...headers,
+            },
+            body,
+        });
+        return withMetadata(result.data, result.response, result.requestId);
+    }
     async function requestJson(method, path, init) {
         for (let attempt = 0;; attempt++) {
             const response = await fetchFn(buildUrl(baseUrl, path, init.query), init);
@@ -133,6 +209,9 @@ export function createVueVoxClient(options) {
         calls: {
             list: listCalls,
             get: getCall,
+            upload: uploadCall,
+            queueAnalysis: queueCallAnalysis,
+            waitForAnalysis: waitForCallAnalysis,
             paginate: (listOptions = {}) => paginate(listCalls, listOptions),
         },
         leads: {
@@ -147,9 +226,34 @@ export function createVueVoxClient(options) {
             create: createLeadCustomField,
             update: updateLeadCustomField,
         },
+        webhooks: {
+            endpoints: {
+                list: listWebhookEndpoints,
+                create: createWebhookEndpoint,
+                update: updateWebhookEndpoint,
+                delete: deleteWebhookEndpoint,
+                rotateSecret: rotateWebhookEndpointSecret,
+                test: testWebhookEndpoint,
+                paginate: (listOptions = {}) => paginate(listWebhookEndpoints, listOptions),
+            },
+        },
         raw,
     };
 }
+export async function verifyVueVoxWebhookSignature(input) {
+    const toleranceSeconds = input.toleranceSeconds ?? 300;
+    const now = input.now ?? Date.now();
+    const timestampSeconds = Number(input.timestamp);
+    if (!Number.isFinite(timestampSeconds)) {
+        return false;
+    }
+    if (Math.abs(Math.floor(now / 1000) - timestampSeconds) > toleranceSeconds) {
+        return false;
+    }
+    const expected = await hmacSha256Hex(input.secret, `${input.timestamp}.${input.body}`);
+    const provided = input.signature.startsWith("v1=") ? input.signature.slice(3) : input.signature;
+    return constantTimeEqual(expected, provided);
+}
 function formatScope(scope) {
     if (Array.isArray(scope)) {
         return scope.join(" ");
@@ -250,3 +354,18 @@ function retryAfterSeconds(response) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+async function hmacSha256Hex(secret, value) {
+    const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const signature = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(value));
+    return [...new Uint8Array(signature)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function constantTimeEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    let result = 0;
+    for (let index = 0; index < left.length; index++) {
+        result |= left.charCodeAt(index) ^ right.charCodeAt(index);
+    }
+    return result === 0;
+}

package/dist/generated/schema.d.ts

@@ -97,7 +97,11 @@ export interface paths {
          */
         get: operations["listCalls"];
         put?: never;
-        post?: never;
+        /**
+         * Upload a call and optionally queue analysis
+         * @description Uploads a call recording, upserts the agent and lead by externalId, creates the call in an existing platform-managed space, and optionally queues analysis. Requires an Idempotency-Key header for safe retries. The audio size limit is configured by a VueVox superadmin and defaults to 20 MB.
+         */
+        post: operations["uploadCall"];
         delete?: never;
         options?: never;
         head?: never;
@@ -124,6 +128,108 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/calls/{callId}/analysis-jobs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Queue analysis for a call
+         * @description Queues analysis for a previously uploaded organization call. Use this when a call was uploaded with queueAnalysis set to false.
+         */
+        post: operations["queueCallAnalysis"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/webhooks/endpoints": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List webhook endpoints
+         * @description Returns webhook endpoints for the authenticated API client using cursor pagination.
+         */
+        get: operations["listWebhookEndpoints"];
+        put?: never;
+        /**
+         * Create a webhook endpoint
+         * @description Creates a webhook endpoint for the authenticated API client. The signing secret is returned only once.
+         */
+        post: operations["createWebhookEndpoint"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/webhooks/endpoints/{endpointId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /** Delete a webhook endpoint */
+        delete: operations["deleteWebhookEndpoint"];
+        options?: never;
+        head?: never;
+        /** Update a webhook endpoint */
+        patch: operations["updateWebhookEndpoint"];
+        trace?: never;
+    };
+    "/v1/webhooks/endpoints/{endpointId}/rotate-secret": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Rotate a webhook endpoint signing secret
+         * @description Replaces the endpoint signing secret. The new secret is returned only once.
+         */
+        post: operations["rotateWebhookEndpointSecret"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/webhooks/endpoints/{endpointId}/test": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Send a test webhook event
+         * @description Queues a webhook.test delivery to validate endpoint reachability and signature verification.
+         */
+        post: operations["testWebhookEndpoint"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/leads": {
         parameters: {
             query?: never;
@@ -243,7 +349,7 @@ export interface components {
             client_secret: string;
             /**
              * @description Space-separated scopes requested for the access token.
-             * @example hello:read spaces:read agents:read calls:read leads:read leads:write lead_custom_fields:manage
+             * @example hello:read spaces:read agents:read calls:read calls:write leads:read leads:write lead_custom_fields:manage webhooks:read webhooks:write
              */
             scope?: string;
         };
@@ -253,7 +359,7 @@ export interface components {
             token_type: "Bearer";
             /** @example 3600 */
             expires_in: number;
-            /** @example hello:read spaces:read agents:read calls:read leads:read leads:write lead_custom_fields:manage */
+            /** @example hello:read spaces:read agents:read calls:read calls:write leads:read leads:write lead_custom_fields:manage webhooks:read webhooks:write */
             scope: string;
         };
         HelloResponse: {
@@ -317,6 +423,8 @@ export interface components {
         CallSummary: {
             /** Format: uuid */
             id: string;
+            /** @description Optional ID from an external system. */
+            externalId: string | null;
             space: components["schemas"]["ResourceSummary"];
             lead: components["schemas"]["LeadSummary"];
             agent: components["schemas"]["AgentSummary"];
@@ -357,6 +465,44 @@ export interface components {
         CallDetailResponse: {
             data: components["schemas"]["CallDetail"];
         };
+        CallResponse: {
+            data: components["schemas"]["CallSummary"];
+        };
+        CallUploadMetadata: {
+            /** @description Optional call ID from your system. Must be unique within the organization when provided. */
+            externalId?: string | null;
+            /**
+             * Format: uuid
+             * @description Existing VueVox space ID. Spaces are managed in the VueVox platform.
+             */
+            spaceId: string;
+            /**
+             * @description When true or omitted, queues analysis immediately after upload. When false, queue later with queueCallAnalysis.
+             * @default true
+             */
+            queueAnalysis: boolean;
+            agent: components["schemas"]["CallUploadAgent"];
+            lead: components["schemas"]["CallUploadLead"];
+        };
+        CallUploadAgent: {
+            externalId: string;
+            /** @description Required when creating a new agent. */
+            name?: string;
+            /** Format: email */
+            email?: string | null;
+            phone?: string | null;
+        };
+        CallUploadLead: {
+            externalId: string;
+            /** @description Required when creating a new lead. */
+            firstName?: string;
+            /** @description Required when creating a new lead. */
+            lastName?: string;
+            /** Format: email */
+            email?: string | null;
+            phone?: string | null;
+            customFields?: components["schemas"]["CustomFields"];
+        };
         Lead: {
             /** Format: uuid */
             id: string;
@@ -447,6 +593,79 @@ export interface components {
             isFilterable?: boolean;
             archived?: boolean;
         };
+        /**
+         * @description Subscribable webhook event type.
+         * @enum {string}
+         */
+        WebhookEventType: "analysis.completed" | "analysis.failed";
+        WebhookEndpoint: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uri */
+            url: string;
+            events: components["schemas"]["WebhookEventType"][];
+            isActive: boolean;
+            /** Format: date-time */
+            lastDeliveredAt: string | null;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        WebhookEndpointWithSecret: components["schemas"]["WebhookEndpoint"] & {
+            /** @description Signing secret shown only when creating or rotating the endpoint. */
+            secret: string;
+        };
+        WebhookEndpointsListResponse: {
+            data: components["schemas"]["WebhookEndpoint"][];
+            pagination: components["schemas"]["CursorPagination"];
+        };
+        WebhookEndpointResponse: {
+            data: components["schemas"]["WebhookEndpoint"];
+        };
+        WebhookEndpointSecretResponse: {
+            data: components["schemas"]["WebhookEndpointWithSecret"];
+        };
+        WebhookEndpointCreateRequest: {
+            /**
+             * Format: uri
+             * @description Public HTTPS URL that will receive webhook POST requests.
+             */
+            url: string;
+            events: components["schemas"]["WebhookEventType"][];
+            /** @default true */
+            isActive: boolean;
+        };
+        WebhookEndpointUpdateRequest: {
+            /** Format: uri */
+            url?: string;
+            events?: components["schemas"]["WebhookEventType"][];
+            isActive?: boolean;
+        };
+        WebhookTestResponse: {
+            data: {
+                /**
+                 * Format: uuid
+                 * @description Delivery ID.
+                 */
+                id: string;
+                /** @enum {string} */
+                status: "pending" | "retrying" | "delivered" | "failed" | "skipped";
+                /** @enum {string} */
+                eventType: "webhook.test";
+            };
+        };
+        WebhookEventPayload: {
+            /** Format: uuid */
+            id: string;
+            /** @enum {string} */
+            type: "analysis.completed" | "analysis.failed" | "webhook.test";
+            /** Format: date-time */
+            createdAt: string;
+            data: {
+                [key: string]: unknown;
+            };
+        };
         CursorPagination: {
             /** @example 50 */
             limit: number;
@@ -471,7 +690,10 @@ export interface components {
         };
     };
     responses: never;
-    parameters: never;
+    parameters: {
+        /** @description Webhook endpoint ID. */
+        WebhookEndpointId: string;
+    };
     requestBodies: never;
     headers: never;
     pathItems: never;
@@ -789,6 +1011,77 @@ export interface operations {
             };
         };
     };
+    uploadCall: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Unique key for this upload attempt. Reusing the same key with the same request returns the original response; reusing it with a different request returns a conflict. */
+                "Idempotency-Key": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "multipart/form-data": {
+                    /** @description JSON string matching CallUploadMetadata. */
+                    metadata: string;
+                    /**
+                     * Format: binary
+                     * @description Audio file. Supported extensions include wav, mp3, aac, m4a, amr, mpeg, mpga, x-wav, ogg, oga, mp4, and mp4a.
+                     */
+                    audioFile: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Call uploaded. Analysis is queued when metadata.queueAnalysis is true. */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CallResponse"];
+                };
+            };
+            /** @description Bearer token is missing, invalid, or expired. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bearer token does not include the required scope. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Idempotency key conflict, external call ID conflict, or analysis already queued. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Multipart upload or metadata failed validation. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
     getCall: {
         parameters: {
             query?: never;
@@ -852,6 +1145,388 @@ export interface operations {
             };
         };
     };
+    queueCallAnalysis: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Call ID. */
+                callId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Analysis queued. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CallResponse"];
+                };
+            };
+            /** @description Bearer token is missing, invalid, or expired. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bearer token does not include the required scope. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Call was not found in the API client's organization. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Analysis is already queued or processing. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Organization AI settings, evaluation grid, or audio file is missing. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    listWebhookEndpoints: {
+        parameters: {
+            query?: {
+                /** @description Number of endpoints to return. Defaults to 50. Maximum is 100. */
+                limit?: number;
+                /** @description Opaque cursor from the previous response's pagination.nextCursor value. */
+                cursor?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Paginated webhook endpoints response. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebhookEndpointsListResponse"];
+                };
+            };
+            /** @description Bearer token is missing, invalid, or expired. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bearer token does not include the required scope. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Query parameters failed validation. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    createWebhookEndpoint: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebhookEndpointCreateRequest"];
+            };
+        };
+        responses: {
+            /** @description Webhook endpoint created. */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebhookEndpointSecretResponse"];
+                };
+            };
+            /** @description Bearer token is missing, invalid, or expired. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bearer token does not include the required scope. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Request body failed validation. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    deleteWebhookEndpoint: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Webhook endpoint ID. */
+                endpointId: components["parameters"]["WebhookEndpointId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Webhook endpoint deleted. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Bearer token is missing, invalid, or expired. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bearer token does not include the required scope. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Webhook endpoint was not found for this API client. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    updateWebhookEndpoint: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Webhook endpoint ID. */
+                endpointId: components["parameters"]["WebhookEndpointId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebhookEndpointUpdateRequest"];
+            };
+        };
+        responses: {
+            /** @description Webhook endpoint updated. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebhookEndpointResponse"];
+                };
+            };
+            /** @description Bearer token is missing, invalid, or expired. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bearer token does not include the required scope. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Webhook endpoint was not found for this API client. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Request body failed validation. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    rotateWebhookEndpointSecret: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Webhook endpoint ID. */
+                endpointId: components["parameters"]["WebhookEndpointId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Webhook endpoint secret rotated. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebhookEndpointSecretResponse"];
+                };
+            };
+            /** @description Bearer token is missing, invalid, or expired. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bearer token does not include the required scope. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Webhook endpoint was not found for this API client. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    testWebhookEndpoint: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Webhook endpoint ID. */
+                endpointId: components["parameters"]["WebhookEndpointId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Test delivery queued. */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebhookTestResponse"];
+                };
+            };
+            /** @description Bearer token is missing, invalid, or expired. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bearer token does not include the required scope. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Webhook endpoint was not found for this API client. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
     listLeads: {
         parameters: {
             query?: {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { createVueVoxClient } from "./client.js";
-export type { Agent, AgentsListResponse, CallDetailResponse, CallsListResponse, CallSummary, CustomFieldFilters, CustomFieldFilterValue, HelloResponse, Lead, LeadCustomField, LeadCustomFieldCreateRequest, LeadCustomFieldResponse, LeadCustomFieldUpdateRequest, LeadCustomFieldsListResponse, LeadDetailResponse, LeadUpdateRequest, LeadUpsertRequest, LeadsListResponse, ListAgentsOptions, ListCallsOptions, ListLeadCustomFieldsOptions, ListLeadsOptions, ListSpacesOptions, Space, SpacesListResponse, VueVoxApiResponse, VueVoxClientOptions, VueVoxResponseEvent, VueVoxResponseMetadata, } from "./client.js";
+export { createVueVoxClient, verifyVueVoxWebhookSignature } from "./client.js";
+export type { Agent, AgentsListResponse, CallDetailResponse, CallResponse, CallsListResponse, CallSummary, CallUploadMetadata, CustomFieldFilters, CustomFieldFilterValue, HelloResponse, Lead, LeadCustomField, LeadCustomFieldCreateRequest, LeadCustomFieldResponse, LeadCustomFieldUpdateRequest, LeadCustomFieldsListResponse, LeadDetailResponse, LeadUpdateRequest, LeadUpsertRequest, LeadsListResponse, ListAgentsOptions, ListCallsOptions, ListLeadCustomFieldsOptions, ListLeadsOptions, ListSpacesOptions, ListWebhookEndpointsOptions, Space, SpacesListResponse, UploadCallInput, VerifyWebhookSignatureInput, VueVoxApiResponse, VueVoxClientOptions, VueVoxResponseEvent, VueVoxResponseMetadata, WaitForAnalysisOptions, WebhookEndpoint, WebhookEndpointCreateRequest, WebhookEndpointResponse, WebhookEndpointSecretResponse, WebhookEndpointUpdateRequest, WebhookEndpointsListResponse, WebhookEventPayload, WebhookTestResponse, } from "./client.js";
 export { VueVoxApiError } from "./errors.js";
 export type { VueVoxErrorResponse } from "./errors.js";

package/dist/index.js

@@ -1,2 +1,2 @@
-export { createVueVoxClient } from "./client.js";
+export { createVueVoxClient, verifyVueVoxWebhookSignature } from "./client.js";
 export { VueVoxApiError } from "./errors.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vuevox/sdk",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "TypeScript SDK for the VueVox Developer API.",
   "type": "module",
   "main": "./dist/index.js",