whatsapp-cloud 0.0.4 → 0.0.6

package/cloud-api-docs/webhooks/overview.md

@@ -0,0 +1,154 @@
+Nav-Logo
+Build with us
+Docs
+Blog
+Resources
+Developer centers
+Meine Apps
+Dokumente
+Übersicht
+Webhooks
+Webhooks
+Aktualisiert: 07.11.2025
+In diesem Dokument werden Webhooks beschrieben und wie sie auf der WhatsApp Business-Plattform verwendet werden.
+Webhooks sind HTTP-Anfragen mit JSON-Payloads, die von Meta-Servern an einen von dir bestimmten Server gesendet werden. Die WhatsApp Business-Plattform verwendet Webhooks, um dich über eingehende Nachrichten, den Status ausgehender Nachrichten und andere wichtige Informationen zu informieren, wie z. B. Änderungen an deinem Kontostatus, Upgrades der Nachrichtenfunktion und Änderungen an der Qualitätsbewertungen deiner Vorlagen.
+Hier siehst du einen Webhook, der eine Nachricht beschreibt, die von einem*einer WhatsApp-Benutzer*in an ein Unternehmen gesendet wurde:
+{
+"object": "whatsapp_business_account",
+"entry": [
+{
+"id": "102290129340398",
+"changes": [
+{
+"value": {
+"messaging_product": "whatsapp",
+"metadata": {
+"display_phone_number": "15550783881",
+"phone_number_id": "106540352242922"
+},
+"contacts": [
+{
+"profile": {
+"name": "Sheena Nelson"
+},
+"wa_id": "16505551234"
+}
+],
+"messages": [
+{
+"from": "16505551234",
+"id": "wamid.HBgLMTY1MDM4Nzk0MzkVAgASGBQzQTRBNjU5OUFFRTAzODEwMTQ0RgA=",
+"timestamp": "1749416383",
+"type": "text"
+"text": {
+"body": "Does it come in another color?"
+}
+}
+]
+},
+"field": "messages"
+}
+]
+}
+]
+}
+
+Einen Webhook-Endpunkt erstellen
+Um Webhooks zu empfangen, musst du einen Webhook-Endpunkt erstellen und konfigurieren. Im Dokument Webhook-Endpunkt erstellen erfährst du, wie du deinen eigenen Endpunkt erstellst.
+Wenn du noch nicht bereit bist, deinen eigenen Endpunkt zu erstellen, kannst du einen Test-Webhook-Endpunkt erstellen, der Webhook-Payloads an die Konsole exportiert. Beachte jedoch, dass du deinen eigenen Endpunkt erstellen musst, bevor du deine App in einer Produktionsumgebung verwenden kannst.
+Berechtigungen
+Du benötigst die folgenden Berechtigungen, um Webhooks zu erhalten:
+whatsapp_business_messaging – für messages-Webhooks
+whatsapp_business_management – für alle anderen Webhooks
+Wenn du ein*e direkte*r Entwickler*in bist, gewähre deiner App über deine*n Systemnutzer*in diese Berechtigungen, wenn du dein Systemtoken generierst.
+Wenn du als Lösungsanbieter*in diese Berechtigungen benötigst, um deinen Unternehmenskunden entsprechende Services zur Verfügung zu stellen, musst du vor der App-Review die Genehmigung für erweiterten Zugriff auf die Berechtigungen erhalten. Erst dann können deine Unternehmenskunden deiner App während des Onboardings diese Berechtigungen erteilen.
+Felder
+Sobald du deinen Webhook-Endpunkt erstellt und konfiguriert hast, kannst du die folgenden Webhook-Felder abonnieren.
+Name des Feldes Beschreibung
+account_alerts
+Der account_alerts-Webhook benachrichtigt dich über Änderungen des Messaging-Limits, des Unternehmensprofils und des Status als offizielles Unternehmenskonto einer Unternehmenstelefonnummer.
+account_review_update
+Der account_review_update-Webhook benachrichtigt dich, wenn ein WhatsApp-Unternehmenskonto hinsichtlich der Einhaltung unserer Richtlinien überprüft wurde.
+account_update
+Der account_update-Webhook benachrichtigt dich über Änderungen an der partnergeführten Unternehmensverifizierung eines WhatsApp-Unternehmenskontos, seiner Berechtigung für den Tarif für internationale Authentifizierung oder seinem Hauptgeschäftsstandort, wenn das Konto mit einem*einer Lösungsanbieter*in geteilt wird, bei Richtlinien- oder Nutzungsbedingungsverstößen oder wenn es gelöscht wird.
+automatic_events
+Der automatic_events-Webhook benachrichtigt dich, wenn wir ein Kauf- oder Lead-Event in einem Chat-Thread zwischen dir und einem*einer WhatsApp-Nutzer*in erkennen, der*die dir über deine Click-to-WhatsApp Ad eine Nachricht gesendet hat. Dazu musst du Berichte für automatische Events aktiviert haben.
+business_capability_update
+Der business_capability_update-Webhook informiert dich über Änderungen der Funktionen für WhatsApp-Unternehmenskonto oder Business-Portfolio (Messaging-Limits, Telefonnummer-Limits usw.).
+history
+Der history-Webhook wird verwendet, um den Chatverlauf in der WhatsApp Business-App eines Unternehmenskunden zu synchronisieren, der von einem*einer Lösungsanbieter*in freigeschaltet wurde.
+message_template_components_update
+Der message_template_components_update-Webhook benachrichtigt dich über Änderungen an den Komponenten einer Vorlage.
+message_template_quality_update
+Der message_template_quality_update-Webhook benachrichtigt dich über Änderungen an der Qualitätsbewertung einer Vorlage.
+message_template_status_update
+Der message_template_status_update-Webhook benachrichtigt dich über Änderungen am Status einer vorhandenen Vorlage.
+messages
+Der messages-Webhook beschreibt Nachrichten, die von einem*einer WhatsApp-Nutzer*in an ein Unternehmen gesendet werden, und den Status von Nachrichten, die von einem Unternehmen an eine*n WhatsApp-Nutzer*in gesendet werden.
+partner_solutions
+Der partner_solutions-Webhook beschreibt Änderungen am Status einer Multi-Partner-Lösung.
+payment_configuration_update
+Der payment_configuration_update-Webhook informiert dich über Änderungen an Zahlungskonfigurationen für die Payments API für Indien und die Payments API für Brasilien.
+phone_number_name_update
+Der phone_number_name_update-Webhook informiert dich über die Verifizierung des Display-Namens der Unternehmenstelefonnummer.
+phone_number_quality_update
+Der phone_number_quality_update-Webhook benachrichtigt dich über Änderungen an der Durchsatzrate einer Unternehmenstelefonnummer.
+security
+Der security-Webhook benachrichtigt dich über Änderungen an den Sicherheitseinstellungen einer Unternehmenstelefonnummer.
+smb_app_state_sync
+Der smb_app_state_sync-Webhook wird zum Synchronisieren von Kontakten von Nutzer*innen der WhatsApp Business-App verwendet, die über eine*n Lösungsanbieter*in freigeschaltet wurden.
+smb_message_echoes
+Der smb_message_echoes-Webhook benachrichtigt dich über Nachrichten, die über die WhatsApp Business-App oder ein begleitendes („verknüpftes“) Gerät von einem Unternehmenskunden gesendet wurden, der über eine*n Lösungsanbieter*in für die Cloud API freigeschaltet wurde.
+template_category_update
+Der template_category_update-Webhook benachrichtigt dich über Änderungen an der Kategorie einer Vorlage.
+user_preferences
+Der user_preferences-Webhook benachrichtigt dich über Änderungen an den Marketing-Nachrichten-Einstellungen eines*einer WhatsApp-Nutzer*in.
+Webhooks überschreiben
+Du kannst einen alternativen Webhook-Endpunkt für messages-Webhooks für dein WhatsApp-Unternehmenskonto (WABA) oder deine Unternehmenstelefonnummer verwenden. Dieser kann für Testzwecke nützlich sein oder wenn du als Lösungsanbieter eindeutige Webhook-Endpunkte für alle deine registrierten Kund\*innen verwenden möchtest.
+In unserem Dokument zu Webhook-Überschreibungen erfährst du, wie du Webhooks überschreiben kannst.
+Payload-Größe
+Payload-Webhooks können bis zu 3 MB groß sein.
+Fehler bei der Webhook-Auslieferung
+Wenn wir eine Webhook-Anfrage an deinen Endpunkt senden und dein Server mit einem anderen HTTP-Statuscode als 200 antwortet oder wenn wir den Webhook aus einem anderen Grund nicht zustellen können, versuchen wir es so lange mit abnehmender Häufigkeit, bis die Anfrage erfolgreich ist, und zwar bis zu 7 Tage lang.
+Beachte, dass Wiederholungsversuche an alle Apps gesendet werden, die Webhooks (und ihre entsprechenden Felder) für das WhatsApp Business-Konto abonniert haben. Dies kann zu doppelten Webhook-Benachrichtigungen führen.
+IP-Adressen
+Du kannst die IP-Adressen unserer Webhook-Server abrufen, indem du in deinem Terminal den folgenden Befehl ausführst:
+whois -h whois.radb.net — '-i origin AS32934' | grep '^route' | awk '{print $2}' | sort
+Wir ändern diese IP-Adressen in regelmäßigen Abständen. Wenn du also unsere Server auf der Positivliste hast, solltest du diese Liste gelegentlich neu erstellen und deine Positivliste entsprechend aktualisieren.
+Problembehandlung
+Wenn du keine Webhooks erhältst:
+Vergewissere dich, dass dein Endpunkt Anfragen akzeptiert.
+Sende eine Test-Payload an deinen Endpunkt über das Panel App-Dashboard > WhatsApp > Konfigurationen.
+Stelle sicher, dass der Live-Modus für deine App aktiviert ist. Wenn deine App im Entwicklungsmodus ist, werden einige Webhooks nicht gesendet.
+Mehr dazu
+Siehe unseren Blogeintrag Implementierung von Webhooks mit Node.js für WhatsApp Business.
+War diese Seite hilfreich?
+„Daumen hoch“-Symbol
+„Daumen runter“-Symbol
+Meta
+FacebookInstagramXLinkedInYouTube
+Build with Meta
+AI
+Meta Horizon
+Social technologies
+Wearables
+News
+Meta for Developers
+Blog
+Success stories
+Support
+Developer Support
+Bug tool
+Platform status
+Developer community forum
+Report an incident
+About us
+About
+Careers
+Terms and policies
+Responsible platform initiatives
+Platform terms
+Developer policies
+Privacy policy
+Cookies
+English (US)

package/docs/DEVELOPMENT.md

@@ -0,0 +1,154 @@
+# Development Guide
+
+## Local Development with npm/pnpm link
+
+To test the SDK in your own project without publishing to npm:
+
+### Step 1: Link the package (in whatsapp-cloud directory)
+
+```bash
+cd /Users/lukas/Developer/whatsapp-cloud
+pnpm build  # Build the package first
+pnpm link --global  # Creates a global symlink
+```
+
+Or with npm:
+
+```bash
+npm link
+```
+
+### Step 2: Link in your project
+
+```bash
+cd /path/to/your/project
+pnpm link whatsapp-cloud
+```
+
+Or with npm:
+
+```bash
+npm link whatsapp-cloud
+```
+
+**What this does:** Creates a symlink in your project's `node_modules` pointing to your local package. You don't need to:
+
+- Add it to `package.json` (link handles it)
+- Run `pnpm install` (link is enough)
+- Publish to npm
+
+### Step 3: Use it in your project
+
+```typescript
+import { WhatsAppClient, type IncomingTextMessage } from "whatsapp-cloud";
+
+const client = new WhatsAppClient({
+  accessToken: "...",
+});
+```
+
+### Important Notes
+
+- **Rebuild after changes**: After making changes to whatsapp-cloud, run `pnpm build` in the whatsapp-cloud directory
+- **Hot reload**: Some bundlers (like Next.js) may need a restart to pick up changes
+- **Unlink**: When done, unlink with `pnpm unlink whatsapp-cloud` in your project
+
+## Production / CI/CD
+
+For production builds and CI/CD, you have a few options:
+
+### Option 1: Publish to npm (Recommended)
+
+Once ready, publish the package:
+
+```bash
+cd /Users/lukas/Developer/whatsapp-cloud
+pnpm publish
+```
+
+Then in your project's `package.json`:
+
+```json
+{
+  "dependencies": {
+    "whatsapp-cloud": "^0.0.5"
+  }
+}
+```
+
+### Option 2: Git dependency (For private repos)
+
+If your repo is private, use git dependency:
+
+```json
+{
+  "dependencies": {
+    "whatsapp-cloud": "git+https://github.com/your-username/whatsapp-cloud.git"
+  }
+}
+```
+
+### Option 3: Local file path (For monorepos)
+
+If both projects are in the same repo/monorepo:
+
+```json
+{
+  "dependencies": {
+    "whatsapp-cloud": "file:../whatsapp-cloud"
+  }
+}
+```
+
+### Option 4: Conditional linking (Dev vs Prod)
+
+Use environment detection:
+
+```json
+{
+  "dependencies": {
+    "whatsapp-cloud": process.env.NODE_ENV === "development"
+      ? "link:../whatsapp-cloud"
+      : "^0.0.5"
+  }
+}
+```
+
+**Note:** For CI/CD, you'll need Option 1 (npm publish) or Option 2 (git dependency). `pnpm link` only works locally.
+
+## Type Exports
+
+All types are properly exported and can be imported in React/Next.js projects:
+
+```typescript
+// Import client
+import { WhatsAppClient } from "whatsapp-cloud";
+
+// Import types
+import type {
+  IncomingTextMessage,
+  IncomingMessage,
+  WebhookPayload,
+  MessageContext,
+  CreateTemplateRequest,
+  // ... all other types
+} from "whatsapp-cloud";
+
+// Import schemas (for validation)
+import {
+  incomingTextMessageSchema,
+  webhookPayloadSchema,
+  // ... all other schemas
+} from "whatsapp-cloud";
+```
+
+## Verifying Exports
+
+To verify all types are exported correctly:
+
+```bash
+# In your project
+pnpm exec tsc --noEmit --skipLibCheck
+```
+
+This will check that all imported types are available.

package/docs/webhooks.md

@@ -0,0 +1,76 @@
+# Webhooks
+
+Handle incoming WhatsApp messages and status updates via webhooks.
+
+## Quick Start
+
+```typescript
+import { WhatsAppClient } from "@whatsapp-cloud/sdk";
+
+const client = new WhatsAppClient({
+  accessToken: process.env.WHATSAPP_ACCESS_TOKEN!,
+});
+
+// In your webhook endpoint
+app.post("/webhook", async (req, res) => {
+  // handle() returns IMMEDIATELY - handlers run in background
+  client.webhooks.handle(req.body, {
+    text: async (message, context) => {
+      // This can take as long as needed (20s, 1min, etc.)
+      // Webhook already returned 200, so Meta is happy
+
+      // Process text message
+      console.log(`Received: ${message.text.body} from ${message.from}`);
+
+      // Store in database
+      await db.messages.create({
+        id: message.id,
+        from: message.from,
+        body: message.text.body,
+        phoneNumberId: context.metadata.phoneNumberId,
+      });
+
+      // Send response
+      await client.messages.sendText({
+        to: `+${message.from}`,
+        text: { body: "Got it!" },
+      });
+    },
+  });
+
+  // Returns 200 IMMEDIATELY (handlers continue in background)
+  res.json({ success: true });
+});
+```
+
+## Webhook Verification
+
+Meta sends GET requests to verify your webhook endpoint:
+
+```typescript
+app.get("/webhook", (req, res) => {
+  const challenge = client.webhooks.verify(req.query, process.env.VERIFY_TOKEN);
+  if (challenge) {
+    return res.send(challenge);
+  }
+  return res.status(403).send("Forbidden");
+});
+```
+
+## Low-Level API
+
+For more control, extract messages manually:
+
+```typescript
+const messages = client.webhooks.extractMessages(payload);
+for (const message of messages) {
+  // Custom processing
+}
+```
+
+## API Reference
+
+- `client.webhooks.verify(query, token)` - Verify GET request, returns challenge or null
+- `client.webhooks.extractMessages(payload)` - Extract messages from payload
+- `client.webhooks.extractStatuses(payload)` - Extract status updates
+- `client.webhooks.handle(payload, handlers, options?)` - Handle with type-safe callbacks

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whatsapp-cloud",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Work in progress. A WhatsApp client tailored for LLMs—built to actually work.",
   "type": "module",
   "main": "dist/index.js",
@@ -11,7 +11,10 @@
   "license": "MIT",
   "devDependencies": {
     "@changesets/cli": "^2.29.8",
+    "@types/node": "^25.0.3",
+    "dotenv": "^17.2.3",
     "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
   "dependencies": {
@@ -19,6 +22,7 @@
   },
   "scripts": {
     "build": "tsup src/index.ts --format cjs,esm --dts",
-    "lint": "tsc"
+    "lint": "tsc",
+    "example": "tsx src/examples/main.ts"
   }
 }

package/src/client/HttpClient.ts

@@ -1,5 +1,12 @@
 import type { ClientConfig } from "../types/client";
 
+interface APIErrorResponse {
+  error?: {
+    message?: string;
+    code?: number;
+  };
+}
+
 /**
  * HTTP client for making requests to the WhatsApp Cloud API
  */
@@ -42,12 +49,12 @@ export class HttpClient {
     });
 
     if (!response.ok) {
-      const error = await response.json().catch(() => ({
+      const error = (await response.json().catch(() => ({
         error: {
           message: response.statusText,
           code: response.status,
         },
-      }));
+      }))) as APIErrorResponse;
       throw new Error(
         `API Error: ${error.error?.message || response.statusText} (${
           error.error?.code || response.status
@@ -72,12 +79,12 @@ export class HttpClient {
     });
 
     if (!response.ok) {
-      const error = await response.json().catch(() => ({
+      const error = (await response.json().catch(() => ({
         error: {
           message: response.statusText,
           code: response.status,
         },
-      }));
+      }))) as APIErrorResponse;
       throw new Error(
         `API Error: ${error.error?.message || response.statusText} (${
           error.error?.code || response.status
@@ -104,12 +111,42 @@ export class HttpClient {
     });
 
     if (!response.ok) {
-      const error = await response.json().catch(() => ({
+      const error = (await response.json().catch(() => ({
+        error: {
+          message: response.statusText,
+          code: response.status,
+        },
+      }))) as APIErrorResponse;
+      throw new Error(
+        `API Error: ${error.error?.message || response.statusText} (${
+          error.error?.code || response.status
+        })`
+      );
+    }
+
+    return response.json() as Promise<T>;
+  }
+
+  /**
+   * Make a DELETE request
+   */
+  async delete<T>(path: string): Promise<T> {
+    const url = `${this.baseURL}/${this.apiVersion}${path}`;
+
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${this.accessToken}`,
+      },
+    });
+
+    if (!response.ok) {
+      const error = (await response.json().catch(() => ({
         error: {
           message: response.statusText,
           code: response.status,
         },
-      }));
+      }))) as APIErrorResponse;
       throw new Error(
         `API Error: ${error.error?.message || response.statusText} (${
           error.error?.code || response.status

package/src/client/WhatsAppClient.ts

@@ -4,6 +4,8 @@ import { HttpClient } from "./HttpClient";
 import { MessagesService } from "../services/messages/index";
 import { AccountsService } from "../services/accounts/index";
 import { BusinessService } from "../services/business/index";
+import { TemplatesService } from "../services/templates/index";
+import { WebhooksService } from "../services/webhooks/index";
 import { ZodError } from "zod";
 import { transformZodError } from "../utils/zod-error";
 import type { DebugTokenResponse } from "../types/debug";
@@ -15,6 +17,8 @@ export class WhatsAppClient {
   public readonly messages: MessagesService;
   public readonly accounts: AccountsService;
   public readonly business: BusinessService;
+  public readonly templates: TemplatesService;
+  public readonly webhooks: WebhooksService;
 
   private readonly httpClient: HttpClient;
 
@@ -37,6 +41,8 @@ export class WhatsAppClient {
     this.messages = new MessagesService(this.httpClient);
     this.accounts = new AccountsService(this.httpClient);
     this.business = new BusinessService(this.httpClient);
+    this.templates = new TemplatesService(this.httpClient);
+    this.webhooks = new WebhooksService(this.httpClient);
   }
 
   /**

package/src/examples/main.ts

@@ -0,0 +1,9 @@
+import "dotenv/config";
+import { WhatsAppClient } from "../client";
+
+const client = new WhatsAppClient({
+  accessToken: process.env.WHATSAPP_ACCESS_TOKEN!,
+});
+
+const debugInfo = await client.debugToken();
+console.log(debugInfo);

package/src/examples/template.ts

@@ -0,0 +1,134 @@
+import "dotenv/config";
+import { WhatsAppClient } from "../client";
+
+const client = new WhatsAppClient({
+  accessToken: process.env.WHATSAPP_ACCESS_TOKEN!,
+  businessAccountId: process.env.WHATSAPP_BUSINESS_ACCOUNT_ID!,
+});
+
+async function testTemplates() {
+  try {
+    console.log("🧪 Testing Templates API...\n");
+
+    // Test 1: Create a template
+    console.log("1️⃣ Creating template...");
+    const createResponse = await client.templates.create({
+      name: `test_template_${Date.now()}`, // Unique name to avoid conflicts
+      language: "en",
+      category: "UTILITY",
+      components: [
+        {
+          type: "BODY",
+          text: "Hello! This is a test template. Thank you for testing our WhatsApp Cloud API SDK.",
+        },
+        {
+          type: "FOOTER",
+          text: "This is a test footer",
+        },
+        {
+          type: "BUTTONS",
+          buttons: [
+            {
+              type: "QUICK_REPLY",
+              text: "Get Started",
+            },
+            {
+              type: "QUICK_REPLY",
+              text: "Learn More",
+            },
+          ],
+        },
+      ],
+    });
+
+    console.log("✅ Template created successfully!");
+    console.log("Response:", JSON.stringify(createResponse, null, 2));
+    console.log("\n");
+
+    // Verify create response structure
+    if (!createResponse.id) {
+      throw new Error("Create response missing 'id' field");
+    }
+    if (!createResponse.status) {
+      throw new Error("Create response missing 'status' field");
+    }
+    if (!createResponse.category) {
+      throw new Error("Create response missing 'category' field");
+    }
+    console.log("✅ Create response structure verified\n");
+
+    // Test 2: Get template by ID
+    console.log("2️⃣ Getting template by ID...");
+    const templateId = createResponse.id;
+    const getResponse = await client.templates.get(templateId);
+
+    console.log("✅ Template retrieved successfully!");
+    console.log("Response:", JSON.stringify(getResponse, null, 2));
+    console.log("\n");
+
+    // Verify get response structure
+    if (!getResponse.id) {
+      throw new Error("Get response missing 'id' field");
+    }
+    if (!getResponse.name) {
+      throw new Error("Get response missing 'name' field");
+    }
+    if (!getResponse.language) {
+      throw new Error("Get response missing 'language' field");
+    }
+    if (!getResponse.status) {
+      throw new Error("Get response missing 'status' field");
+    }
+    if (!getResponse.category) {
+      throw new Error("Get response missing 'category' field");
+    }
+    if (!Array.isArray(getResponse.components)) {
+      throw new Error("Get response missing 'components' array");
+    }
+    console.log("✅ Get response structure verified\n");
+
+    // Verify components
+    const bodyComponent = getResponse.components.find((c) => c.type === "BODY");
+    if (!bodyComponent) {
+      throw new Error("BODY component not found in response");
+    }
+    if (bodyComponent.type !== "BODY") {
+      throw new Error("BODY component type mismatch");
+    }
+    console.log("✅ Components verified\n");
+
+    // Test 3: List templates
+    console.log("3️⃣ Listing templates...");
+    const listResponse = await client.templates.list();
+    console.log(`✅ Found ${listResponse.data.length} template(s)`);
+    console.log("Response:", JSON.stringify(listResponse, null, 2));
+    console.log("\n");
+
+    // Verify list response structure
+    if (!Array.isArray(listResponse.data)) {
+      throw new Error("List response missing 'data' array");
+    }
+    console.log("✅ List response structure verified\n");
+
+    // Verify our created template is in the list
+    const foundTemplate = listResponse.data.find((t) => t.id === templateId);
+    if (!foundTemplate) {
+      console.log(
+        "⚠️  Note: Created template may not appear in list immediately (async processing)"
+      );
+    } else {
+      console.log("✅ Created template found in list\n");
+    }
+
+    console.log("🎉 All tests passed!");
+  } catch (error) {
+    console.error("❌ Test failed:", error);
+    if (error instanceof Error) {
+      console.error("Error message:", error.message);
+      console.error("Error stack:", error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+testTemplates();

package/src/index.ts

@@ -7,6 +7,13 @@ export * from "./schemas/index";
 // Export types (primary export point)
 export type * from "./types/index";
 
+// Export webhook handler types (convenience exports)
+export type {
+  MessageContext,
+  MessageHandlers,
+  HandleOptions,
+} from "./services/webhooks/index";
+
 // Export errors for error handling
 export {
   WhatsAppError,