@vuevox/sdk 0.8.0 → 0.9.0

package/README.md

@@ -35,6 +35,8 @@ 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.
@@ -117,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()}` } });
 ```
 
@@ -164,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
 
@@ -601,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.
@@ -742,15 +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

@@ -12,6 +12,14 @@ export type LeadCustomFieldsListResponse = components["schemas"]["LeadCustomFiel
 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"];
@@ -65,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;
@@ -158,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

@@ -95,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, {
@@ -118,6 +136,24 @@ 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, {
@@ -190,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(" ");
@@ -293,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

@@ -148,6 +148,88 @@ export interface paths {
         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;
@@ -267,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 calls:write 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;
         };
@@ -277,7 +359,7 @@ export interface components {
             token_type: "Bearer";
             /** @example 3600 */
             expires_in: number;
-            /** @example hello:read spaces:read agents:read calls:read calls:write 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: {
@@ -511,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;
@@ -535,7 +690,10 @@ export interface components {
         };
     };
     responses: never;
-    parameters: never;
+    parameters: {
+        /** @description Webhook endpoint ID. */
+        WebhookEndpointId: string;
+    };
     requestBodies: never;
     headers: never;
     pathItems: never;
@@ -1055,6 +1213,320 @@ export interface operations {
             };
         };
     };
+    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, CallResponse, CallsListResponse, CallSummary, CallUploadMetadata, CustomFieldFilters, CustomFieldFilterValue, HelloResponse, Lead, LeadCustomField, LeadCustomFieldCreateRequest, LeadCustomFieldResponse, LeadCustomFieldUpdateRequest, LeadCustomFieldsListResponse, LeadDetailResponse, LeadUpdateRequest, LeadUpsertRequest, LeadsListResponse, ListAgentsOptions, ListCallsOptions, ListLeadCustomFieldsOptions, ListLeadsOptions, ListSpacesOptions, Space, SpacesListResponse, UploadCallInput, VueVoxApiResponse, VueVoxClientOptions, VueVoxResponseEvent, VueVoxResponseMetadata, WaitForAnalysisOptions, } 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.8.0",
+  "version": "0.9.0",
   "description": "TypeScript SDK for the VueVox Developer API.",
   "type": "module",
   "main": "./dist/index.js",