@elevenlabs/elevenlabs-js 2.2.0 → 2.3.0

package/wrapper/ElevenLabsClient.d.ts

@@ -1,6 +1,6 @@
 import { ElevenLabsClient as FernClient } from "../Client";
-import * as ElevenLabs from "../api";
-import * as core from "../core";
+import type * as ElevenLabs from "../api";
+import type * as core from "../core";
 import { WebhooksClient } from "./webhooks";
 export declare namespace ElevenLabsClient {
     interface Options extends FernClient.Options {
@@ -17,6 +17,7 @@ export declare namespace ElevenLabsClient {
     }
 }
 export declare class ElevenLabsClient extends FernClient {
-    readonly webhooks: WebhooksClient;
+    private _customWebhooks;
     constructor(options?: ElevenLabsClient.Options);
+    get webhooks(): WebhooksClient;
 }

package/wrapper/ElevenLabsClient.js

@@ -48,7 +48,12 @@ class ElevenLabsClient extends Client_1.ElevenLabsClient {
         }
         options.apiKey = apiKey;
         super(options);
-        this.webhooks = new webhooks_1.WebhooksClient();
+    }
+    get webhooks() {
+        if (!this._customWebhooks) {
+            this._customWebhooks = new webhooks_1.WebhooksClient(this._options);
+        }
+        return this._customWebhooks;
     }
 }
 exports.ElevenLabsClient = ElevenLabsClient;

package/wrapper/webhooks.d.ts

@@ -1,7 +1,8 @@
+import { Webhooks } from '../api/resources/webhooks/client/Client';
 /**
- * A client to handle ElevenLabs webhook-related functionality
+ * Extended webhook client that includes both auto-generated API methods and custom functionality
  */
-export declare class WebhooksClient {
+export declare class WebhooksClient extends Webhooks {
     /**
      * Constructs a webhook event object from a payload and signature.
      * Verifies the webhook signature to ensure the event came from ElevenLabs.
@@ -12,5 +13,5 @@ export declare class WebhooksClient {
      * @returns The verified webhook event
      * @throws {ElevenLabsError} if the signature is invalid or missing
      */
-    constructEvent(rawBody: string, sigHeader: string, secret: string): any;
+    constructEvent(rawBody: string, sigHeader: string, secret: string): Promise<any>;
 }

package/wrapper/webhooks.js

@@ -1,15 +1,35 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
 };
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebhooksClient = void 0;
-const node_crypto_1 = __importDefault(require("node:crypto"));
+const crypto_1 = require("crypto");
 const errors_1 = require("../errors");
+const Client_1 = require("../api/resources/webhooks/client/Client");
+const crypto = (_a = globalThis.crypto) !== null && _a !== void 0 ? _a : crypto_1.webcrypto;
+// Async HMAC-SHA256 using Web Crypto API
+function hmacSHA256(key, message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const enc = new TextEncoder();
+        const keyData = enc.encode(key);
+        const msgData = enc.encode(message);
+        const cryptoKey = yield crypto.subtle.importKey('raw', keyData, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+        const sig = yield crypto.subtle.sign('HMAC', cryptoKey, msgData);
+        return 'v0=' + Array.from(new Uint8Array(sig)).map(b => b.toString(16).padStart(2, '0')).join('');
+    });
+}
 /**
- * A client to handle ElevenLabs webhook-related functionality
+ * Extended webhook client that includes both auto-generated API methods and custom functionality
  */
-class WebhooksClient {
+class WebhooksClient extends Client_1.Webhooks {
     /**
      * Constructs a webhook event object from a payload and signature.
      * Verifies the webhook signature to ensure the event came from ElevenLabs.
@@ -21,47 +41,49 @@ class WebhooksClient {
      * @throws {ElevenLabsError} if the signature is invalid or missing
      */
     constructEvent(rawBody, sigHeader, secret) {
-        var _a;
-        if (!sigHeader) {
-            throw new errors_1.ElevenLabsError({
-                message: 'Missing signature header',
-                statusCode: 400,
-            });
-        }
-        if (!secret) {
-            throw new errors_1.ElevenLabsError({
-                message: 'Webhook secret not configured',
-                statusCode: 400,
-            });
-        }
-        const headers = sigHeader.split(',');
-        const timestamp = (_a = headers.find((e) => e.startsWith('t='))) === null || _a === void 0 ? void 0 : _a.substring(2);
-        const signature = headers.find((e) => e.startsWith('v0='));
-        if (!timestamp || !signature) {
-            throw new errors_1.ElevenLabsError({
-                message: 'No signature hash found with expected scheme v0',
-                statusCode: 400,
-            });
-        }
-        // Validate timestamp
-        const reqTimestamp = Number(timestamp) * 1000;
-        const tolerance = Date.now() - 30 * 60 * 1000;
-        if (reqTimestamp < tolerance) {
-            throw new errors_1.ElevenLabsError({
-                message: 'Timestamp outside the tolerance zone',
-                statusCode: 400,
-            });
-        }
-        // Validate hash
-        const message = `${timestamp}.${rawBody}`;
-        const digest = `v0=${node_crypto_1.default.createHmac('sha256', secret).update(message).digest('hex')}`;
-        if (signature !== digest) {
-            throw new errors_1.ElevenLabsError({
-                message: 'Signature hash does not match the expected signature hash for payload',
-                statusCode: 400,
-            });
-        }
-        return JSON.parse(rawBody);
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!sigHeader) {
+                throw new errors_1.ElevenLabsError({
+                    message: 'Missing signature header',
+                    statusCode: 400,
+                });
+            }
+            if (!secret) {
+                throw new errors_1.ElevenLabsError({
+                    message: 'Webhook secret not configured',
+                    statusCode: 400,
+                });
+            }
+            const headers = sigHeader.split(',');
+            const timestamp = (_a = headers.find((e) => e.startsWith('t='))) === null || _a === void 0 ? void 0 : _a.substring(2);
+            const signature = headers.find((e) => e.startsWith('v0='));
+            if (!timestamp || !signature) {
+                throw new errors_1.ElevenLabsError({
+                    message: 'No signature hash found with expected scheme v0',
+                    statusCode: 400,
+                });
+            }
+            // Validate timestamp
+            const reqTimestamp = Number(timestamp) * 1000;
+            const tolerance = Date.now() - 30 * 60 * 1000;
+            if (reqTimestamp < tolerance) {
+                throw new errors_1.ElevenLabsError({
+                    message: 'Timestamp outside the tolerance zone',
+                    statusCode: 400,
+                });
+            }
+            // Validate hash
+            const message = `${timestamp}.${rawBody}`;
+            const digest = yield hmacSHA256(secret, message);
+            if (signature !== digest) {
+                throw new errors_1.ElevenLabsError({
+                    message: 'Signature hash does not match the expected signature hash for payload',
+                    statusCode: 400,
+                });
+            }
+            return JSON.parse(rawBody);
+        });
     }
 }
 exports.WebhooksClient = WebhooksClient;