bavimail 0.1.0

package/dist/index.js

@@ -0,0 +1,866 @@
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/errors.ts
+var BavimailError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BavimailError";
+  }
+};
+var APIError = class extends BavimailError {
+  constructor(message, statusCode, code = null, category = null, context = null, requestId = null) {
+    super(message);
+    this.name = "APIError";
+    this.statusCode = statusCode;
+    this.code = code;
+    this.category = category;
+    this.context = context;
+    this.requestId = requestId;
+  }
+};
+var NotFoundError = class extends APIError {
+  constructor(message, code = null, category = null, context = null, requestId = null) {
+    super(message, 404, code, category, context, requestId);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends APIError {
+  constructor(message, code = null, category = null, context = null, requestId = null) {
+    super(message, 400, code, category, context, requestId);
+    this.name = "ValidationError";
+  }
+};
+var ConflictError = class extends APIError {
+  constructor(message, code = null, category = null, context = null, requestId = null) {
+    super(message, 409, code, category, context, requestId);
+    this.name = "ConflictError";
+  }
+};
+var AuthenticationError = class extends APIError {
+  constructor(message, code = null, category = null, context = null, requestId = null) {
+    super(message, 401, code, category, context, requestId);
+    this.name = "AuthenticationError";
+  }
+};
+var ForbiddenError = class extends APIError {
+  constructor(message, code = null, category = null, context = null, requestId = null) {
+    super(message, 403, code, category, context, requestId);
+    this.name = "ForbiddenError";
+  }
+};
+var RateLimitError = class extends APIError {
+  constructor(message, code = null, category = null, context = null, requestId = null) {
+    super(message, 429, code, category, context, requestId);
+    this.name = "RateLimitError";
+  }
+};
+var InternalServerError = class extends APIError {
+  constructor(message, code = null, category = null, context = null, requestId = null) {
+    super(message, 500, code, category, context, requestId);
+    this.name = "InternalServerError";
+  }
+};
+var ProviderError = class extends APIError {
+  constructor(message, statusCode = 502, code = null, category = null, context = null, requestId = null) {
+    super(message, statusCode, code, category, context, requestId);
+    this.name = "ProviderError";
+  }
+};
+var WebhookVerificationError = class extends BavimailError {
+  constructor(message) {
+    super(message);
+    this.name = "WebhookVerificationError";
+  }
+};
+var STATUS_TO_FACTORY = {
+  400: (m, c, cat, ctx, r) => new ValidationError(m, c, cat, ctx, r),
+  401: (m, c, cat, ctx, r) => new AuthenticationError(m, c, cat, ctx, r),
+  403: (m, c, cat, ctx, r) => new ForbiddenError(m, c, cat, ctx, r),
+  404: (m, c, cat, ctx, r) => new NotFoundError(m, c, cat, ctx, r),
+  409: (m, c, cat, ctx, r) => new ConflictError(m, c, cat, ctx, r),
+  422: (m, c, cat, ctx, r) => new ValidationError(m, c, cat, ctx, r),
+  429: (m, c, cat, ctx, r) => new RateLimitError(m, c, cat, ctx, r),
+  500: (m, c, cat, ctx, r) => new InternalServerError(m, c, cat, ctx, r),
+  502: (m, c, cat, ctx, r) => new ProviderError(m, 502, c, cat, ctx, r),
+  503: (m, c, cat, ctx, r) => new ProviderError(m, 503, c, cat, ctx, r)
+};
+function raiseForStatus(statusCode, body, requestId) {
+  let message = `API error (${statusCode})`;
+  let code = null;
+  let category = null;
+  let context = null;
+  if (body && typeof body === "object") {
+    const detail = body.detail;
+    if (detail && typeof detail === "object" && !Array.isArray(detail)) {
+      const d = detail;
+      message = d.message ?? message;
+      code = d.code ?? null;
+      category = d.category ?? null;
+      context = d.context ?? null;
+    } else if (typeof detail === "string") {
+      message = detail;
+    } else if (typeof body.error === "string") {
+      message = body.error;
+    }
+  }
+  const factory = STATUS_TO_FACTORY[statusCode];
+  if (factory) {
+    throw factory(message, code, category, context, requestId);
+  }
+  throw new APIError(message, statusCode, code, category, context, requestId);
+}
+
+// src/utils.ts
+function toSnakeCase(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function toCamelCase(str) {
+  return str.replace(
+    /_([a-z0-9])/g,
+    (_, letter) => letter.toUpperCase()
+  );
+}
+function keysToSnake(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(keysToSnake);
+  }
+  if (obj !== null && typeof obj === "object" && !(obj instanceof Date)) {
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => [
+        toSnakeCase(key),
+        keysToSnake(value)
+      ])
+    );
+  }
+  return obj;
+}
+function keysToCamel(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(keysToCamel);
+  }
+  if (obj !== null && typeof obj === "object" && !(obj instanceof Date)) {
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => [
+        toCamelCase(key),
+        keysToCamel(value)
+      ])
+    );
+  }
+  return obj;
+}
+function stripUndefined(obj) {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([, v]) => v !== void 0)
+  );
+}
+
+// src/http.ts
+var HttpClient = class {
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.baseUrl = (options.baseUrl ?? "https://api.bavimail.com").replace(
+      /\/$/,
+      ""
+    );
+  }
+  headers() {
+    return {
+      "x-api-key": this.apiKey,
+      "Content-Type": "application/json",
+      "User-Agent": `bavimail-typescript/${VERSION}`
+    };
+  }
+  async request(method, path, options) {
+    const url = this.buildUrl(path, options?.params);
+    const init = {
+      method,
+      headers: this.headers()
+    };
+    if (options?.body) {
+      const cleaned = stripUndefined(options.body);
+      init.body = JSON.stringify(keysToSnake(cleaned));
+    }
+    const response = await fetch(url, init);
+    const requestId = response.headers.get("x-request-id");
+    if (!response.ok) {
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        body = null;
+      }
+      raiseForStatus(response.status, body, requestId);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    const json = await response.json();
+    return keysToCamel(json);
+  }
+  async requestBytes(method, path, options) {
+    const url = this.buildUrl(path, options?.params);
+    const init = {
+      method,
+      headers: this.headers()
+    };
+    const response = await fetch(url, init);
+    const requestId = response.headers.get("x-request-id");
+    if (!response.ok) {
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        body = null;
+      }
+      raiseForStatus(response.status, body, requestId);
+    }
+    return response.arrayBuffer();
+  }
+  buildUrl(path, params) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (params) {
+      const cleaned = stripUndefined(params);
+      for (const [key, value] of Object.entries(cleaned)) {
+        if (value === null || value === void 0) continue;
+        if (Array.isArray(value)) {
+          for (const v of value) {
+            url.searchParams.append(key, String(v));
+          }
+        } else {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+};
+
+// src/resources/base.ts
+var BaseResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+};
+
+// src/resources/domains.ts
+var Domains = class extends BaseResource {
+  /** Register a new domain. */
+  async create(params) {
+    return this.http.request("POST", "/domains", {
+      body: params
+    });
+  }
+  /** List all domains. */
+  async list() {
+    return this.http.request("GET", "/domains");
+  }
+  /** Get a domain by ID. */
+  async get(domainId) {
+    return this.http.request("GET", `/domains/${domainId}`);
+  }
+  /** Get DNS setup instructions for a domain. */
+  async getSetup(domainId) {
+    return this.http.request(
+      "GET",
+      `/domains/${domainId}/setup`
+    );
+  }
+  /** Get live DNS verification status. */
+  async getDnsStatus(domainId, options) {
+    return this.http.request(
+      "GET",
+      `/domains/${domainId}/dns-status`,
+      { params: { force_refresh: options?.forceRefresh } }
+    );
+  }
+  /** Trigger domain verification. */
+  async verify(domainId, options) {
+    return this.http.request(
+      "POST",
+      `/domains/${domainId}/verify`,
+      { body: { force: options?.force ?? false } }
+    );
+  }
+  /** Update domain settings. */
+  async update(domainId, params) {
+    return this.http.request("PUT", `/domains/${domainId}`, {
+      body: params
+    });
+  }
+  /** Delete a domain. */
+  async delete(domainId) {
+    await this.http.request("DELETE", `/domains/${domainId}`);
+  }
+};
+
+// src/resources/aliases.ts
+var Aliases = class extends BaseResource {
+  /** Create a new email alias. */
+  async create(params) {
+    return this.http.request("POST", "/aliases", {
+      body: params
+    });
+  }
+  /** List aliases, optionally filtered by domain. */
+  async list(options) {
+    return this.http.request("GET", "/aliases", {
+      params: { domain_id: options?.domainId }
+    });
+  }
+  /** Get an alias by ID. */
+  async get(aliasId) {
+    return this.http.request("GET", `/aliases/${aliasId}`);
+  }
+  /** Update an alias. */
+  async update(aliasId, params) {
+    return this.http.request("PUT", `/aliases/${aliasId}`, {
+      body: params
+    });
+  }
+  /** Delete an alias. */
+  async delete(aliasId) {
+    await this.http.request("DELETE", `/aliases/${aliasId}`);
+  }
+};
+
+// src/resources/emails.ts
+var Emails = class extends BaseResource {
+  /** Send an email. */
+  async send(params) {
+    return this.http.request("POST", "/emails", {
+      body: params
+    });
+  }
+  /** List sent emails with optional filters. */
+  async list(options) {
+    return this.http.request("GET", "/emails", {
+      params: {
+        alias_id: options?.aliasId,
+        limit: options?.limit,
+        offset: options?.offset
+      }
+    });
+  }
+  /** Get a sent email by ID. */
+  async get(emailId) {
+    return this.http.request("GET", `/emails/${emailId}`);
+  }
+  /** Send a batch of emails. */
+  async batchSend(emails) {
+    return this.http.request(
+      "POST",
+      "/emails/batch",
+      { body: { emails } }
+    );
+  }
+  /** Cancel a scheduled email. */
+  async cancel(emailId) {
+    return this.http.request(
+      "POST",
+      `/emails/${emailId}/cancel`
+    );
+  }
+  /** List click events for an email. */
+  async listClicks(emailId, options) {
+    return this.http.request(
+      "GET",
+      `/emails/${emailId}/clicks`,
+      {
+        params: {
+          link_id: options?.linkId,
+          include_bots: options?.includeBots,
+          limit: options?.limit,
+          offset: options?.offset
+        }
+      }
+    );
+  }
+  /** List tracked links in an email. */
+  async listLinks(emailId) {
+    return this.http.request(
+      "GET",
+      `/emails/${emailId}/links`
+    );
+  }
+};
+
+// src/resources/inbound-emails.ts
+var InboundEmails = class extends BaseResource {
+  /** List inbound emails with optional filters. */
+  async list(options) {
+    return this.http.request(
+      "GET",
+      "/inbound-emails",
+      {
+        params: {
+          alias_id: options?.aliasId,
+          tag_ids: options?.tagIds,
+          tag_match: options?.tagMatch,
+          limit: options?.limit,
+          offset: options?.offset
+        }
+      }
+    );
+  }
+  /** Get full details of an inbound email. */
+  async get(emailId) {
+    return this.http.request(
+      "GET",
+      `/inbound-emails/${emailId}`
+    );
+  }
+  /** Download the raw RFC822 email. */
+  async downloadRaw(emailId) {
+    return this.http.requestBytes(
+      "GET",
+      `/inbound-emails/${emailId}/raw`
+    );
+  }
+  /** Download an attachment by zero-based index. */
+  async downloadAttachment(emailId, index) {
+    return this.http.requestBytes(
+      "GET",
+      `/inbound-emails/${emailId}/attachments/${index}`
+    );
+  }
+  /** Delete an inbound email. */
+  async delete(emailId) {
+    await this.http.request(
+      "DELETE",
+      `/inbound-emails/${emailId}`
+    );
+  }
+  /** Add tags to an inbound email. */
+  async addTags(emailId, tagIds, note) {
+    return this.http.request(
+      "POST",
+      `/inbound-emails/${emailId}/tags`,
+      { body: { tagIds, note } }
+    );
+  }
+  /** Get tags for an inbound email. */
+  async getTags(emailId) {
+    return this.http.request(
+      "GET",
+      `/inbound-emails/${emailId}/tags`
+    );
+  }
+  /** Replace all tags on an inbound email. */
+  async replaceTags(emailId, tagIds, note) {
+    return this.http.request(
+      "PUT",
+      `/inbound-emails/${emailId}/tags`,
+      { body: { tagIds, note } }
+    );
+  }
+  /** Remove a single tag from an inbound email. */
+  async removeTag(emailId, tagId) {
+    await this.http.request(
+      "DELETE",
+      `/inbound-emails/${emailId}/tags/${tagId}`
+    );
+  }
+};
+
+// src/resources/conversations.ts
+var Conversations = class extends BaseResource {
+  /** List conversation threads with optional filters. */
+  async list(options) {
+    return this.http.request(
+      "GET",
+      "/conversations",
+      {
+        params: {
+          alias_id: options?.aliasId,
+          domain_id: options?.domainId,
+          limit: options?.limit,
+          offset: options?.offset
+        }
+      }
+    );
+  }
+  /** Get a conversation with all messages. */
+  async get(conversationId) {
+    return this.http.request(
+      "GET",
+      `/conversations/${conversationId}`
+    );
+  }
+};
+
+// src/resources/tags.ts
+var Tags = class extends BaseResource {
+  /** Create a new tag. */
+  async create(params) {
+    return this.http.request("POST", "/tags", {
+      body: params
+    });
+  }
+  /** List tags. */
+  async list(options) {
+    return this.http.request("GET", "/tags", {
+      params: { include_hidden: options?.includeHidden }
+    });
+  }
+  /** Get a tag by ID. */
+  async get(tagId) {
+    return this.http.request("GET", `/tags/${tagId}`);
+  }
+  /** Update a tag. */
+  async update(tagId, params) {
+    return this.http.request("PUT", `/tags/${tagId}`, {
+      body: params
+    });
+  }
+  /** Delete a tag. */
+  async delete(tagId) {
+    await this.http.request("DELETE", `/tags/${tagId}`);
+  }
+};
+
+// src/resources/webhooks.ts
+var Webhooks = class extends BaseResource {
+  /** Create a new webhook subscription. Returns secret (shown once). */
+  async create(params) {
+    return this.http.request("POST", "/webhooks", {
+      body: params
+    });
+  }
+  /** List all webhooks. */
+  async list() {
+    return this.http.request("GET", "/webhooks");
+  }
+  /** Get a webhook by ID. */
+  async get(webhookId) {
+    return this.http.request("GET", `/webhooks/${webhookId}`);
+  }
+  /** Update a webhook. */
+  async update(webhookId, params) {
+    return this.http.request(
+      "PATCH",
+      `/webhooks/${webhookId}`,
+      { body: params }
+    );
+  }
+  /** Delete a webhook. */
+  async delete(webhookId) {
+    await this.http.request("DELETE", `/webhooks/${webhookId}`);
+  }
+  /** Verify a webhook URL with the verification code. */
+  async verify(webhookId, verificationCode) {
+    return this.http.request(
+      "POST",
+      `/webhooks/${webhookId}/verify`,
+      { body: { verificationCode } }
+    );
+  }
+  /** Resend the verification code for a webhook. */
+  async resendVerification(webhookId) {
+    return this.http.request(
+      "POST",
+      `/webhooks/${webhookId}/resend-verification`
+    );
+  }
+  /** Send a test event to the webhook. */
+  async test(webhookId) {
+    return this.http.request(
+      "POST",
+      `/webhooks/${webhookId}/test`
+    );
+  }
+  /** Rotate the webhook's HMAC signing secret. */
+  async rotateSecret(webhookId) {
+    return this.http.request(
+      "POST",
+      `/webhooks/${webhookId}/rotate-secret`
+    );
+  }
+};
+
+// src/webhook-verification.ts
+async function verifyWebhookSignature(payload, signature, timestamp, secret, toleranceSeconds = 300) {
+  const tsSeconds = parseInt(timestamp, 10);
+  if (isNaN(tsSeconds)) {
+    throw new WebhookVerificationError("Invalid timestamp");
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  if (Math.abs(now - tsSeconds) > toleranceSeconds) {
+    throw new WebhookVerificationError(
+      "Timestamp outside tolerance window"
+    );
+  }
+  const message = `${timestamp}.${payload}`;
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const sig = await crypto.subtle.sign("HMAC", key, encoder.encode(message));
+  const expectedHex = Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const providedHex = signature.startsWith("sha256=") ? signature.slice(7) : signature;
+  if (!timingSafeEqual(expectedHex, providedHex)) {
+    throw new WebhookVerificationError("Signature mismatch");
+  }
+  const raw = JSON.parse(payload);
+  return keysToCamel(raw);
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let result = 0;
+  for (let i = 0; i < a.length; i++) {
+    result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return result === 0;
+}
+
+// src/handler.ts
+async function dispatchEvent(event, handlers, onError) {
+  const fns = handlers.get(event.eventType) ?? [];
+  for (const handler of fns) {
+    try {
+      await handler(event);
+    } catch (err) {
+      if (onError) {
+        try {
+          await onError(err, event);
+        } catch {
+        }
+      }
+    }
+  }
+}
+var JSON_HEADERS = { "Content-Type": "application/json" };
+function jsonResponse(status, body) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: JSON_HEADERS
+  });
+}
+var WebhookRequestHandler = class {
+  constructor(options) {
+    this.handlers = options.handlers;
+    this.secret = options.secret;
+    this.path = options.path ?? "/webhooks";
+    this.onError = options.onError;
+  }
+  /** Handle an incoming Web Standard Request. */
+  async fetch(request) {
+    const url = new URL(request.url);
+    if (url.pathname !== this.path) {
+      return jsonResponse(404, { error: "Not found" });
+    }
+    if (request.method === "GET") {
+      return jsonResponse(200, { status: "ok" });
+    }
+    if (request.method !== "POST") {
+      return jsonResponse(405, { error: "Method not allowed" });
+    }
+    const signature = request.headers.get("x-webhook-signature");
+    const timestamp = request.headers.get("x-webhook-timestamp");
+    if (!signature || !timestamp) {
+      return jsonResponse(401, { error: "Missing signature or timestamp" });
+    }
+    const body = await request.text();
+    let event;
+    try {
+      event = await verifyWebhookSignature(body, signature, timestamp, this.secret);
+    } catch {
+      return jsonResponse(403, { error: "Invalid signature" });
+    }
+    await dispatchEvent(event, this.handlers, this.onError);
+    return jsonResponse(200, { status: "ok" });
+  }
+};
+
+// src/listener.ts
+async function startListener(handlers, webhooksResource, options) {
+  if (handlers.size === 0) {
+    throw new Error(
+      "No event handlers registered. Call client.on() before client.listen()."
+    );
+  }
+  if (!options.webhookUrl && !options.secret) {
+    throw new Error(
+      "Either webhookUrl (auto-create) or secret (pre-existing) is required."
+    );
+  }
+  const port = options.port ?? 8e3;
+  const host = options.host ?? "0.0.0.0";
+  const path = options.path ?? "/webhooks";
+  let secret;
+  let webhookId;
+  if (options.secret) {
+    secret = options.secret;
+  } else {
+    const eventTypes = [...handlers.keys()];
+    const webhook = await webhooksResource.create({
+      url: options.webhookUrl,
+      eventTypes,
+      description: options.description ?? "Auto-created by Bavimail TypeScript SDK"
+    });
+    secret = webhook.secret;
+    webhookId = webhook.id;
+  }
+  const { createServer } = await import('http');
+  const server = createServer(async (req, res) => {
+    const reqUrl = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    if (reqUrl.pathname !== path) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found" }));
+      return;
+    }
+    if (req.method === "GET") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok" }));
+      return;
+    }
+    if (req.method !== "POST") {
+      res.writeHead(405, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Method not allowed" }));
+      return;
+    }
+    const chunks = [];
+    for await (const chunk of req) {
+      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
+    const body = Buffer.concat(chunks).toString("utf-8");
+    const signature = req.headers["x-webhook-signature"];
+    const timestamp = req.headers["x-webhook-timestamp"];
+    if (!signature || !timestamp) {
+      res.writeHead(401, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Missing signature or timestamp" }));
+      return;
+    }
+    let event;
+    try {
+      event = await verifyWebhookSignature(body, signature, timestamp, secret);
+    } catch {
+      res.writeHead(403, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Invalid signature" }));
+      return;
+    }
+    await dispatchEvent(event, handlers, options.onError);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ status: "ok" }));
+  });
+  let shuttingDown = false;
+  async function shutdown() {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    server.close();
+    if (webhookId && options.cleanup !== false) {
+      try {
+        await webhooksResource.delete(webhookId);
+      } catch {
+      }
+    }
+  }
+  const onSignal = () => {
+    shutdown();
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  if (options.signal) {
+    if (options.signal.aborted) {
+      await shutdown();
+      return;
+    }
+    options.signal.addEventListener("abort", () => {
+      shutdown();
+    }, { once: true });
+  }
+  return new Promise((resolve, reject) => {
+    server.on("error", reject);
+    server.on("close", () => {
+      process.off("SIGINT", onSignal);
+      process.off("SIGTERM", onSignal);
+      resolve();
+    });
+    server.listen(port, host, () => {
+      console.log(`Bavimail webhook listener running on http://${host}:${port}${path}`);
+    });
+  });
+}
+
+// src/client.ts
+var Bavimail = class {
+  constructor(options) {
+    this._handlers = /* @__PURE__ */ new Map();
+    if (!options.apiKey) {
+      throw new Error("apiKey is required");
+    }
+    this.http = new HttpClient({
+      apiKey: options.apiKey,
+      baseUrl: options.baseUrl
+    });
+    this.domains = new Domains(this.http);
+    this.aliases = new Aliases(this.http);
+    this.emails = new Emails(this.http);
+    this.inboundEmails = new InboundEmails(this.http);
+    this.conversations = new Conversations(this.http);
+    this.tags = new Tags(this.http);
+    this.webhooks = new Webhooks(this.http);
+  }
+  on(eventType, handler) {
+    const types = Array.isArray(eventType) ? eventType : [eventType];
+    for (const et of types) {
+      const list = this._handlers.get(et) ?? [];
+      list.push(handler);
+      this._handlers.set(et, list);
+    }
+  }
+  /**
+   * Start a standalone HTTP server that receives and dispatches webhook events.
+   *
+   * If `webhookUrl` is provided, a webhook is auto-created via the API and
+   * cleaned up on shutdown. If `secret` is provided instead, the server uses
+   * the pre-existing webhook secret directly.
+   */
+  async listen(options) {
+    return startListener(this._handlers, this.webhooks, options);
+  }
+  /**
+   * Create a Web Standard webhook request handler for framework integration.
+   *
+   * The returned handler's `.fetch(request)` method accepts a `Request` and
+   * returns a `Response`, compatible with Next.js App Router, Hono, Bun, Deno,
+   * Cloudflare Workers, and similar runtimes.
+   */
+  createHandler(options) {
+    return new WebhookRequestHandler({
+      handlers: this._handlers,
+      secret: options.secret,
+      path: options.path,
+      onError: options.onError
+    });
+  }
+};
+
+// src/pagination.ts
+async function* iterPages(method, options) {
+  const pageSize = options?.pageSize ?? 50;
+  let offset = 0;
+  while (true) {
+    const params = {
+      ...options?.params,
+      limit: pageSize,
+      offset
+    };
+    const page = await method(params);
+    for (const item of page) {
+      yield item;
+    }
+    if (page.length < pageSize) {
+      break;
+    }
+    offset += pageSize;
+  }
+}
+
+export { APIError, AuthenticationError, Bavimail, BavimailError, ConflictError, ForbiddenError, InternalServerError, NotFoundError, ProviderError, RateLimitError, VERSION, ValidationError, WebhookRequestHandler, WebhookVerificationError, iterPages, verifyWebhookSignature };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map