@notifica/node 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1751 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Analytics: () => Analytics,
+  ApiError: () => ApiError,
+  ApiKeys: () => ApiKeys,
+  Billing: () => Billing,
+  Channels: () => Channels,
+  Domains: () => Domains,
+  Inbox: () => Inbox,
+  InboxEmbed: () => InboxEmbed,
+  Notifica: () => Notifica,
+  NotificaClient: () => NotificaClient,
+  NotificaError: () => NotificaError,
+  Notifications: () => Notifications,
+  RateLimitError: () => RateLimitError,
+  Sms: () => Sms,
+  Subscribers: () => Subscribers,
+  Templates: () => Templates,
+  TimeoutError: () => TimeoutError,
+  ValidationError: () => ValidationError,
+  Webhooks: () => Webhooks,
+  Workflows: () => Workflows
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var NotificaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NotificaError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ApiError = class extends NotificaError {
+  /** HTTP status code */
+  status;
+  /** Código do erro retornado pela API (ex: "validation_failed") */
+  code;
+  /** Detalhes de validação por campo */
+  details;
+  /** ID da request para suporte/debugging */
+  requestId;
+  constructor(message, status, code, details = {}, requestId = null) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    this.requestId = requestId;
+  }
+};
+var ValidationError = class extends ApiError {
+  constructor(message, details = {}, requestId = null) {
+    super(message, 422, "validation_failed", details, requestId);
+    this.name = "ValidationError";
+  }
+};
+var RateLimitError = class extends ApiError {
+  /** Segundos até poder tentar novamente */
+  retryAfter;
+  constructor(message, retryAfter = null, requestId = null) {
+    super(message, 429, "rate_limit_exceeded", {}, requestId);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var TimeoutError = class extends NotificaError {
+  constructor(timeoutMs) {
+    super(`Request timed out after ${timeoutMs}ms`);
+    this.name = "TimeoutError";
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://app.usenotifica.com.br/v1";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var NotificaClient = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  maxRetries;
+  autoIdempotency;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new NotificaError(
+        'API key \xE9 obrigat\xF3ria. Passe via: new Notifica("nk_live_...")'
+      );
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.autoIdempotency = config.autoIdempotency ?? true;
+  }
+  // ── Public methods ──────────────────────────────────
+  async get(path, query, options) {
+    return this.request("GET", path, void 0, query, options);
+  }
+  async post(path, body, options) {
+    return this.request("POST", path, body, void 0, options);
+  }
+  async put(path, body, options) {
+    return this.request("PUT", path, body, void 0, options);
+  }
+  async patch(path, body, options) {
+    return this.request("PATCH", path, body, void 0, options);
+  }
+  async delete(path, options) {
+    return this.request("DELETE", path, void 0, void 0, options);
+  }
+  // ── Pagination helpers ──────────────────────────────
+  /**
+   * Lista com paginação manual.
+   * Retorna { data, meta } com cursor para próxima página.
+   */
+  async list(path, query, options) {
+    return this.get(path, query, options);
+  }
+  /**
+   * Async iterator para auto-paginação.
+   *
+   * @example
+   * ```ts
+   * for await (const notification of client.paginate<Notification>('/notifications')) {
+   *   console.log(notification.id);
+   * }
+   * ```
+   */
+  async *paginate(path, query) {
+    let cursor;
+    do {
+      const params = { ...query, ...cursor ? { cursor } : {} };
+      const response = await this.list(path, params);
+      for (const item of response.data) {
+        yield item;
+      }
+      cursor = response.meta.has_more && response.meta.cursor ? response.meta.cursor : void 0;
+    } while (cursor);
+  }
+  /**
+   * Wrapper para respostas { data: T }.
+   */
+  async getOne(path, options) {
+    const response = await this.get(path, void 0, options);
+    return response.data;
+  }
+  // ── Private methods ─────────────────────────────────
+  async request(method, path, body, query, options) {
+    const url = this.buildUrl(path, query);
+    const headers = this.buildHeaders(method, options);
+    const timeoutMs = options?.timeout ?? this.timeout;
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      if (attempt > 0) {
+        await this.backoff(attempt, lastError);
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+      if (options?.signal) {
+        if (options.signal.aborted) {
+          clearTimeout(timeoutId);
+          throw new NotificaError("Request aborted");
+        }
+        options.signal.addEventListener("abort", () => controller.abort(), { once: true });
+      }
+      try {
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: body !== void 0 ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (response.ok) {
+          if (response.status === 204) {
+            return void 0;
+          }
+          return await response.json();
+        }
+        const errorBody = await this.safeParseJson(response);
+        const requestId = response.headers.get("x-request-id");
+        if (response.status === 429) {
+          const retryAfter = this.parseRetryAfter(response);
+          const error = new RateLimitError(
+            errorBody?.error?.message ?? "Rate limit exceeded",
+            retryAfter,
+            requestId
+          );
+          if (attempt < this.maxRetries) {
+            lastError = error;
+            continue;
+          }
+          throw error;
+        }
+        if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < this.maxRetries) {
+          lastError = new ApiError(
+            errorBody?.error?.message ?? `Server error (${response.status})`,
+            response.status,
+            errorBody?.error?.code ?? "server_error",
+            errorBody?.error?.details ?? {},
+            requestId
+          );
+          continue;
+        }
+        if (response.status === 422) {
+          throw new ValidationError(
+            errorBody?.error?.message ?? "Validation failed",
+            errorBody?.error?.details ?? {},
+            requestId
+          );
+        }
+        throw new ApiError(
+          errorBody?.error?.message ?? `API error (${response.status})`,
+          response.status,
+          errorBody?.error?.code ?? "api_error",
+          errorBody?.error?.details ?? {},
+          requestId
+        );
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof NotificaError) {
+          throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          if (attempt < this.maxRetries) {
+            lastError = new TimeoutError(timeoutMs);
+            continue;
+          }
+          throw new TimeoutError(timeoutMs);
+        }
+        if (attempt < this.maxRetries) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          continue;
+        }
+        throw new NotificaError(
+          `Request failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    throw lastError ?? new NotificaError("Request failed after max retries");
+  }
+  buildUrl(path, query) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  buildHeaders(method, options) {
+    const headers = {
+      "Authorization": `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      "User-Agent": "@notifica/node/0.1.0"
+    };
+    if (method === "POST") {
+      if (options?.idempotencyKey) {
+        headers["Idempotency-Key"] = options.idempotencyKey;
+      } else if (this.autoIdempotency) {
+        headers["Idempotency-Key"] = this.generateIdempotencyKey();
+      }
+    }
+    return headers;
+  }
+  generateIdempotencyKey() {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+      return crypto.randomUUID();
+    }
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+  }
+  async backoff(attempt, lastError) {
+    let delayMs;
+    if (lastError instanceof RateLimitError && lastError.retryAfter !== null) {
+      delayMs = lastError.retryAfter * 1e3;
+    } else {
+      const base = 500 * Math.pow(2, attempt - 1);
+      const jitter = Math.random() * base * 0.5;
+      delayMs = base + jitter;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+  parseRetryAfter(response) {
+    const header = response.headers.get("retry-after");
+    if (!header) return null;
+    const seconds = Number(header);
+    if (!Number.isNaN(seconds)) return seconds;
+    const date = Date.parse(header);
+    if (!Number.isNaN(date)) {
+      return Math.max(0, Math.ceil((date - Date.now()) / 1e3));
+    }
+    return null;
+  }
+  async safeParseJson(response) {
+    try {
+      return await response.json();
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/resources/notifications.ts
+var Notifications = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Envia uma notificação.
+   * A notificação é enfileirada para entrega assíncrona.
+   *
+   * @example
+   * ```ts
+   * const notification = await notifica.notifications.send({
+   *   channel: 'whatsapp',
+   *   to: '+5511999999999',
+   *   template: 'welcome',
+   *   data: { name: 'João' },
+   * });
+   * ```
+   */
+  async send(params, options) {
+    const response = await this.client.post(
+      "/notifications",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Lista notificações com paginação.
+   *
+   * @example
+   * ```ts
+   * const { data, meta } = await notifica.notifications.list({ channel: 'email', limit: 50 });
+   * ```
+   */
+  async list(params, options) {
+    return this.client.list("/notifications", params, options);
+  }
+  /**
+   * Itera automaticamente por todas as notificações.
+   *
+   * @example
+   * ```ts
+   * for await (const notification of notifica.notifications.listAll({ channel: 'email' })) {
+   *   console.log(notification.id);
+   * }
+   * ```
+   */
+  listAll(params) {
+    return this.client.paginate("/notifications", params);
+  }
+  /**
+   * Obtém detalhes de uma notificação.
+   */
+  async get(id, options) {
+    return this.client.getOne(`/notifications/${id}`, options);
+  }
+  /**
+   * Lista tentativas de entrega de uma notificação.
+   */
+  async listAttempts(notificationId, options) {
+    const response = await this.client.get(
+      `/notifications/${notificationId}/attempts`,
+      void 0,
+      options
+    );
+    return response.data;
+  }
+};
+
+// src/resources/templates.ts
+var Templates = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Cria um novo template.
+   *
+   * @example
+   * ```ts
+   * const template = await notifica.templates.create({
+   *   channel: 'email',
+   *   slug: 'welcome-email',
+   *   name: 'Email de Boas-Vindas',
+   *   content: 'Olá {{name}}, bem-vindo!',
+   * });
+   * ```
+   */
+  async create(params, options) {
+    const response = await this.client.post(
+      "/templates",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Lista templates com paginação.
+   */
+  async list(params, options) {
+    return this.client.list("/templates", params, options);
+  }
+  /**
+   * Itera automaticamente por todos os templates.
+   */
+  listAll(params) {
+    return this.client.paginate("/templates", params);
+  }
+  /**
+   * Obtém detalhes de um template.
+   */
+  async get(id, options) {
+    return this.client.getOne(`/templates/${id}`, options);
+  }
+  /**
+   * Atualiza um template.
+   */
+  async update(id, params, options) {
+    const response = await this.client.put(
+      `/templates/${id}`,
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Deleta um template.
+   */
+  async delete(id, options) {
+    await this.client.delete(`/templates/${id}`, options);
+  }
+  /**
+   * Preview de um template salvo com variáveis.
+   *
+   * @example
+   * ```ts
+   * const preview = await notifica.templates.preview('tpl_abc', {
+   *   variables: { name: 'João' },
+   * });
+   * ```
+   */
+  async preview(id, params, options) {
+    const response = await this.client.post(
+      `/templates/${id}/preview`,
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Preview de conteúdo arbitrário (útil para editor em tempo real).
+   */
+  async previewContent(params, options) {
+    const response = await this.client.post(
+      "/templates/preview",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Valida um template salvo.
+   */
+  async validate(id, options) {
+    const response = await this.client.post(
+      `/templates/${id}/validate`,
+      void 0,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Valida conteúdo arbitrário.
+   */
+  async validateContent(params, options) {
+    const response = await this.client.post(
+      "/templates/validate",
+      params,
+      options
+    );
+    return response.data;
+  }
+};
+
+// src/resources/workflows.ts
+var Workflows = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Cria um novo workflow.
+   *
+   * @example
+   * ```ts
+   * const workflow = await notifica.workflows.create({
+   *   slug: 'welcome-flow',
+   *   name: 'Fluxo de Boas-Vindas',
+   *   steps: [
+   *     { type: 'send', channel: 'email', template: 'welcome-email' },
+   *     { type: 'delay', duration: '1h' },
+   *     { type: 'send', channel: 'whatsapp', template: 'welcome-whatsapp' },
+   *   ],
+   * });
+   * ```
+   */
+  async create(params, options) {
+    const response = await this.client.post(
+      "/workflows",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Lista workflows com paginação.
+   */
+  async list(params, options) {
+    return this.client.list("/workflows", params, options);
+  }
+  /**
+   * Itera automaticamente por todos os workflows.
+   */
+  listAll(params) {
+    return this.client.paginate("/workflows", params);
+  }
+  /**
+   * Obtém detalhes de um workflow.
+   */
+  async get(id, options) {
+    return this.client.getOne(`/workflows/${id}`, options);
+  }
+  /**
+   * Atualiza um workflow (cria nova versão).
+   */
+  async update(id, params, options) {
+    const response = await this.client.put(
+      `/workflows/${id}`,
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Deleta um workflow (soft delete).
+   */
+  async delete(id, options) {
+    await this.client.delete(`/workflows/${id}`, options);
+  }
+  /**
+   * Dispara a execução de um workflow.
+   *
+   * @param slug — Slug do workflow
+   * @param params — Recipient e dados
+   *
+   * @example
+   * ```ts
+   * const run = await notifica.workflows.trigger('welcome-flow', {
+   *   recipient: '+5511999999999',
+   *   data: { name: 'João', plan: 'pro' },
+   * });
+   * ```
+   */
+  async trigger(slug, params, options) {
+    const response = await this.client.post(
+      `/workflows/${slug}/trigger`,
+      params,
+      options
+    );
+    return response.data;
+  }
+  // ── Workflow Runs ───────────────────────────────────
+  /**
+   * Lista execuções de workflows.
+   */
+  async listRuns(params, options) {
+    return this.client.list("/workflow-runs", params, options);
+  }
+  /**
+   * Obtém detalhes de uma execução (incluindo step_results).
+   */
+  async getRun(id, options) {
+    return this.client.getOne(`/workflow-runs/${id}`, options);
+  }
+  /**
+   * Cancela uma execução em andamento.
+   */
+  async cancelRun(id, options) {
+    const response = await this.client.post(
+      `/workflow-runs/${id}/cancel`,
+      void 0,
+      options
+    );
+    return response.data;
+  }
+};
+
+// src/resources/subscribers.ts
+var Subscribers = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Cria ou atualiza um subscriber (upsert por external_id).
+   * LGPD: registra consentimento automaticamente.
+   *
+   * @example
+   * ```ts
+   * const subscriber = await notifica.subscribers.create({
+   *   external_id: 'user-123',
+   *   email: 'joao@empresa.com.br',
+   *   phone: '+5511999998888',
+   *   name: 'João Silva',
+   * });
+   * ```
+   */
+  async create(params, options) {
+    const response = await this.client.post(
+      "/subscribers",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Lista subscribers com paginação.
+   */
+  async list(params, options) {
+    return this.client.list("/subscribers", params, options);
+  }
+  /**
+   * Itera automaticamente por todos os subscribers.
+   */
+  listAll(params) {
+    return this.client.paginate("/subscribers", params);
+  }
+  /**
+   * Obtém detalhes de um subscriber.
+   */
+  async get(id, options) {
+    return this.client.getOne(`/subscribers/${id}`, options);
+  }
+  /**
+   * Atualiza um subscriber.
+   */
+  async update(id, params, options) {
+    const response = await this.client.put(
+      `/subscribers/${id}`,
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Deleta um subscriber (soft delete com nullificação de PII — LGPD).
+   * ⚠️ Irreversível: email, telefone e nome são removidos.
+   */
+  async delete(id, options) {
+    await this.client.delete(`/subscribers/${id}`, options);
+  }
+  // ── Preferences ─────────────────────────────────────
+  /**
+   * Obtém preferências de notificação do subscriber.
+   */
+  async getPreferences(id, options) {
+    return this.client.getOne(`/subscribers/${id}/preferences`, options);
+  }
+  /**
+   * Atualiza preferências de notificação do subscriber.
+   *
+   * @example
+   * ```ts
+   * await notifica.subscribers.updatePreferences('sub_123', {
+   *   preferences: [
+   *     { category: 'marketing', channel: 'email', enabled: false },
+   *     { category: 'transactional', channel: 'whatsapp', enabled: true },
+   *   ],
+   * });
+   * ```
+   */
+  async updatePreferences(id, params, options) {
+    const response = await this.client.put(
+      `/subscribers/${id}/preferences`,
+      params,
+      options
+    );
+    return response.data;
+  }
+  // ── Bulk import ─────────────────────────────────────
+  /**
+   * Importa subscribers em lote (upsert transacional).
+   * Se um subscriber falhar validação, todo o lote é revertido.
+   */
+  async bulkImport(params, options) {
+    const response = await this.client.post(
+      "/subscribers/import",
+      params,
+      options
+    );
+    return response.data;
+  }
+  // ── In-App Notifications ────────────────────────────
+  /**
+   * Lista notificações in-app de um subscriber.
+   */
+  async listNotifications(subscriberId, params, options) {
+    return this.client.get(
+      `/subscribers/${subscriberId}/notifications`,
+      params,
+      options
+    );
+  }
+  /**
+   * Marca uma notificação in-app como lida.
+   */
+  async markRead(subscriberId, notificationId, options) {
+    await this.client.post(
+      `/subscribers/${subscriberId}/notifications/${notificationId}/read`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * Marca todas as notificações in-app como lidas.
+   */
+  async markAllRead(subscriberId, options) {
+    await this.client.post(
+      `/subscribers/${subscriberId}/notifications/read-all`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * Obtém contagem de notificações não lidas.
+   */
+  async getUnreadCount(subscriberId, options) {
+    const response = await this.client.get(
+      `/subscribers/${subscriberId}/notifications/unread-count`,
+      void 0,
+      options
+    );
+    return response.data.count;
+  }
+};
+
+// src/resources/channels.ts
+var Channels = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Configura um canal de notificação.
+   *
+   * @example
+   * ```ts
+   * const channel = await notifica.channels.create({
+   *   channel: 'email',
+   *   provider: 'aws_ses',
+   *   credentials: {
+   *     access_key_id: 'AKIA...',
+   *     secret_access_key: '...',
+   *     region: 'us-east-1',
+   *   },
+   *   settings: {
+   *     from_address: 'noreply@empresa.com.br',
+   *     from_name: 'Empresa',
+   *   },
+   * });
+   * ```
+   */
+  async create(params, options) {
+    const response = await this.client.post(
+      "/channels",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Lista todas as configurações de canal.
+   */
+  async list(options) {
+    const response = await this.client.get(
+      "/channels",
+      void 0,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Obtém a configuração de um canal específico.
+   */
+  async get(channel, options) {
+    return this.client.getOne(`/channels/${channel}`, options);
+  }
+  /**
+   * Atualiza a configuração de um canal.
+   */
+  async update(channel, params, options) {
+    const response = await this.client.put(
+      `/channels/${channel}`,
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Remove a configuração de um canal.
+   */
+  async delete(channel, options) {
+    await this.client.delete(`/channels/${channel}`, options);
+  }
+  /**
+   * Envia uma notificação de teste usando a configuração atual do canal.
+   */
+  async test(channel, options) {
+    const response = await this.client.post(
+      `/channels/${channel}/test`,
+      void 0,
+      options
+    );
+    return response.data;
+  }
+};
+
+// src/resources/domains.ts
+var Domains = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Registra um novo domínio de envio.
+   *
+   * @example
+   * ```ts
+   * const domain = await notifica.domains.create({ domain: 'suaempresa.com.br' });
+   * // Configure os registros DNS retornados em domain.dns_records
+   * ```
+   */
+  async create(params, options) {
+    const response = await this.client.post(
+      "/domains",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Lista domínios registrados.
+   */
+  async list(params, options) {
+    return this.client.list("/domains", params, options);
+  }
+  /**
+   * Obtém detalhes de um domínio.
+   */
+  async get(id, options) {
+    return this.client.getOne(`/domains/${id}`, options);
+  }
+  /**
+   * Dispara verificação DNS do domínio.
+   */
+  async verify(id, options) {
+    const response = await this.client.post(
+      `/domains/${id}/verify`,
+      void 0,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Remove um domínio.
+   */
+  async delete(id, options) {
+    await this.client.delete(`/domains/${id}`, options);
+  }
+  // ── Health ──────────────────────────────────────────
+  /**
+   * Obtém status de saúde do domínio.
+   */
+  async getHealth(domainId, options) {
+    return this.client.getOne(`/domains/${domainId}/health`, options);
+  }
+  /**
+   * Força verificação de saúde (rate limit: 1/min).
+   */
+  async checkHealth(domainId, options) {
+    const response = await this.client.post(
+      `/domains/${domainId}/health/check`,
+      void 0,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Lista alertas de domínio.
+   */
+  async listAlerts(options) {
+    const response = await this.client.get(
+      "/domains/alerts",
+      void 0,
+      options
+    );
+    return response.data;
+  }
+};
+
+// src/resources/webhooks.ts
+var Webhooks = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Cria um novo webhook.
+   * ⚠️ O signing_secret é retornado apenas na criação. Salve-o!
+   *
+   * @example
+   * ```ts
+   * const webhook = await notifica.webhooks.create({
+   *   url: 'https://meuapp.com.br/webhooks/notifica',
+   *   events: ['notification.delivered', 'notification.failed'],
+   * });
+   * // Salve: webhook.signing_secret
+   * ```
+   */
+  async create(params, options) {
+    const response = await this.client.post(
+      "/webhooks",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Lista webhooks com paginação.
+   */
+  async list(params, options) {
+    return this.client.list("/webhooks", params, options);
+  }
+  /**
+   * Obtém detalhes de um webhook.
+   */
+  async get(id, options) {
+    return this.client.getOne(`/webhooks/${id}`, options);
+  }
+  /**
+   * Atualiza um webhook.
+   */
+  async update(id, params, options) {
+    const response = await this.client.put(
+      `/webhooks/${id}`,
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Deleta um webhook.
+   */
+  async delete(id, options) {
+    await this.client.delete(`/webhooks/${id}`, options);
+  }
+  /**
+   * Envia um evento de teste para o webhook.
+   */
+  async test(id, options) {
+    await this.client.post(`/webhooks/${id}/test`, void 0, options);
+  }
+  /**
+   * Lista entregas recentes de um webhook.
+   */
+  async listDeliveries(id, params, options) {
+    const response = await this.client.get(
+      `/webhooks/${id}/deliveries`,
+      params,
+      options
+    );
+    return response.data;
+  }
+  // ── Webhook signature verification ──────────────────
+  /**
+   * Verifica a assinatura HMAC de um payload de webhook.
+   *
+   * Use para validar que o payload foi realmente enviado pelo Notifica.
+   *
+   * @param payload — Body da request (string ou Buffer)
+   * @param signature — Valor do header `X-Notifica-Signature`
+   * @param secret — signing_secret do webhook
+   * @returns true se a assinatura é válida
+   *
+   * @example
+   * ```ts
+   * app.post('/webhooks/notifica', (req, res) => {
+   *   const payload = req.body; // raw body string
+   *   const signature = req.headers['x-notifica-signature'];
+   *   const secret = process.env.WEBHOOK_SECRET;
+   *
+   *   if (!notifica.webhooks.verify(payload, signature, secret)) {
+   *     return res.status(401).send('Invalid signature');
+   *   }
+   *
+   *   // Processar evento...
+   *   res.status(200).send('OK');
+   * });
+   * ```
+   */
+  async verify(payload, signature, secret) {
+    if (!payload || !signature || !secret) {
+      return false;
+    }
+    try {
+      const encoder = new TextEncoder();
+      const key = await crypto.subtle.importKey(
+        "raw",
+        encoder.encode(secret),
+        { name: "HMAC", hash: "SHA-256" },
+        false,
+        ["sign"]
+      );
+      const payloadBytes = typeof payload === "string" ? encoder.encode(payload) : payload instanceof ArrayBuffer ? new Uint8Array(payload) : payload;
+      const signatureBytes = await crypto.subtle.sign("HMAC", key, payloadBytes);
+      const computed = this.toHex(new Uint8Array(signatureBytes));
+      return this.timingSafeEqual(computed, signature);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Verifica a assinatura e lança erro se inválida.
+   * Versão "fail-fast" do verify().
+   */
+  async verifyOrThrow(payload, signature, secret) {
+    const valid = await this.verify(payload, signature, secret);
+    if (!valid) {
+      throw new NotificaError("Invalid webhook signature");
+    }
+  }
+  toHex(bytes) {
+    return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  /**
+   * Constant-time string comparison to prevent timing attacks.
+   */
+  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/resources/api-keys.ts
+var ApiKeys = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Cria uma nova API key.
+   * ⚠️ O raw_key é retornado apenas na criação. Salve-o!
+   *
+   * @example
+   * ```ts
+   * const key = await notifica.apiKeys.create({
+   *   key_type: 'secret',
+   *   label: 'Backend Production',
+   *   environment: 'production',
+   * });
+   * // Salve: key.raw_key
+   * ```
+   */
+  async create(params, options) {
+    const response = await this.client.post(
+      "/api-keys",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Lista API keys (sem raw_key).
+   */
+  async list(options) {
+    const response = await this.client.get(
+      "/api-keys",
+      void 0,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Revoga (deleta) uma API key.
+   */
+  async revoke(id, options) {
+    await this.client.delete(`/api-keys/${id}`, options);
+  }
+};
+
+// src/resources/analytics.ts
+var Analytics = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Métricas gerais (total enviado, entregue, falhas, taxa de entrega).
+   *
+   * @example
+   * ```ts
+   * const overview = await notifica.analytics.overview({ period: '7d' });
+   * console.log(`Taxa de entrega: ${overview.delivery_rate}%`);
+   * ```
+   */
+  async overview(params, options) {
+    const response = await this.client.get(
+      "/analytics/overview",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Métricas por canal.
+   */
+  async byChannel(params, options) {
+    const response = await this.client.get(
+      "/analytics/channels",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Série temporal de envios.
+   */
+  async timeseries(params, options) {
+    const response = await this.client.get(
+      "/analytics/timeseries",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Templates mais utilizados.
+   */
+  async topTemplates(params, options) {
+    const response = await this.client.get(
+      "/analytics/templates",
+      params,
+      options
+    );
+    return response.data;
+  }
+};
+
+// src/resources/sms.ts
+var SmsProviders = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Lista todos os provedores SMS configurados.
+   */
+  async list(options) {
+    const response = await this.client.get(
+      "/channels/sms/providers",
+      void 0,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Cria um novo provedor SMS (idempotent).
+   */
+  async create(params, options) {
+    const response = await this.client.post(
+      "/channels/sms/providers",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Obtém detalhes de um provedor SMS.
+   */
+  async get(id, options) {
+    return this.client.getOne(`/channels/sms/providers/${id}`, options);
+  }
+  /**
+   * Atualiza um provedor SMS (PATCH parcial).
+   */
+  async update(id, params, options) {
+    const response = await this.client.patch(
+      `/channels/sms/providers/${id}`,
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Ativa um provedor SMS.
+   */
+  async activate(id, options) {
+    const response = await this.client.post(
+      `/channels/sms/providers/${id}/activate`,
+      void 0,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Remove um provedor SMS.
+   */
+  async delete(id, options) {
+    await this.client.delete(`/channels/sms/providers/${id}`, options);
+  }
+  /**
+   * Valida a configuração de um provedor SMS.
+   */
+  async validate(params, options) {
+    const response = await this.client.post(
+      "/channels/sms/providers/validate",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Envia um SMS de teste.
+   */
+  async test(params, options) {
+    const response = await this.client.post(
+      "/channels/sms/providers/test",
+      params,
+      options
+    );
+    return response.data;
+  }
+};
+var SmsCompliance = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Obtém as configurações de compliance SMS.
+   */
+  async show(options) {
+    return this.client.getOne("/channels/sms/compliance", options);
+  }
+  /**
+   * Atualiza as configurações de compliance SMS (PATCH parcial).
+   */
+  async update(params, options) {
+    const response = await this.client.patch(
+      "/channels/sms/compliance",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Obtém estatísticas de compliance.
+   */
+  async analytics(options) {
+    return this.client.getOne("/channels/sms/compliance/analytics", options);
+  }
+  /**
+   * Lista logs de compliance com paginação.
+   */
+  async logs(params, options) {
+    return this.client.list("/channels/sms/compliance/logs", params, options);
+  }
+};
+var SmsConsents = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Lista consentimentos SMS com paginação.
+   */
+  async list(params, options) {
+    return this.client.list("/channels/sms/consents", params, options);
+  }
+  /**
+   * Obtém resumo estatístico dos consentimentos.
+   */
+  async summary(options) {
+    return this.client.getOne("/channels/sms/consents/summary", options);
+  }
+  /**
+   * Obtém o consentimento de um número específico.
+   */
+  async get(phone, options) {
+    return this.client.getOne(`/channels/sms/consents/${encodeURIComponent(phone)}`, options);
+  }
+  /**
+   * Revoga o consentimento de um número (DELETE).
+   */
+  async revoke(phone, options) {
+    await this.client.delete(`/channels/sms/consents/${encodeURIComponent(phone)}`, options);
+  }
+  /**
+   * Cria ou atualiza um consentimento SMS (idempotent).
+   */
+  async create(params, options) {
+    const response = await this.client.post(
+      "/channels/sms/consents",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Importa consentimentos em lote.
+   */
+  async import(params, options) {
+    const response = await this.client.post(
+      "/channels/sms/consents/import",
+      params,
+      options
+    );
+    return response.data;
+  }
+};
+var Sms = class {
+  providers;
+  compliance;
+  consents;
+  constructor(client) {
+    this.providers = new SmsProviders(client);
+    this.compliance = new SmsCompliance(client);
+    this.consents = new SmsConsents(client);
+  }
+};
+
+// src/resources/billing.ts
+var BillingPlans = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Lista todos os planos disponíveis.
+   */
+  async list(options) {
+    const response = await this.client.get(
+      "/billing/plans",
+      void 0,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Obtém detalhes de um plano específico.
+   */
+  async get(name, options) {
+    return this.client.getOne(`/billing/plans/${name}`, options);
+  }
+};
+var BillingSettingsResource = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Obtém as configurações de faturamento do tenant.
+   */
+  async get(options) {
+    return this.client.getOne("/billing/settings", options);
+  }
+};
+var BillingSubscription = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Obtém a assinatura atual.
+   */
+  async get(options) {
+    return this.client.getOne("/billing/subscription", options);
+  }
+  /**
+   * Cria uma nova assinatura (idempotent).
+   */
+  async subscribe(params, options) {
+    const response = await this.client.post(
+      "/billing/subscribe",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Altera o plano da assinatura (idempotent).
+   */
+  async changePlan(params, options) {
+    const response = await this.client.post(
+      "/billing/change-plan",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Cancela a assinatura (idempotent).
+   */
+  async cancel(params, options) {
+    const response = await this.client.post(
+      "/billing/cancel",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Calcula o valor de proration para mudança de plano.
+   */
+  async calculateProration(params, options) {
+    const response = await this.client.post(
+      "/billing/calculate-proration",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Reativa uma assinatura cancelada (idempotent).
+   */
+  async reactivate(params, options) {
+    const response = await this.client.post(
+      "/billing/reactivate",
+      params,
+      options
+    );
+    return response.data;
+  }
+};
+var BillingUsageResource = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Obtém o uso atual e quotas do tenant.
+   */
+  async get(options) {
+    return this.client.getOne("/billing/usage", options);
+  }
+};
+var BillingInvoices = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Lista faturas com paginação.
+   */
+  async list(params, options) {
+    return this.client.list("/billing/invoices", params, options);
+  }
+  /**
+   * Obtém detalhes de uma fatura.
+   */
+  async get(id, options) {
+    return this.client.getOne(`/billing/invoices/${id}`, options);
+  }
+};
+var BillingPaymentMethods = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Lista métodos de pagamento.
+   */
+  async list(options) {
+    const response = await this.client.get(
+      "/billing/payment-methods",
+      void 0,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Cria um novo método de pagamento (idempotent).
+   */
+  async create(params, options) {
+    const response = await this.client.post(
+      "/billing/payment-methods",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Obtém detalhes de um método de pagamento.
+   */
+  async get(id, options) {
+    return this.client.getOne(`/billing/payment-methods/${id}`, options);
+  }
+  /**
+   * Atualiza um método de pagamento.
+   */
+  async update(id, params, options) {
+    const response = await this.client.put(
+      `/billing/payment-methods/${id}`,
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Remove um método de pagamento.
+   */
+  async delete(id, options) {
+    await this.client.delete(`/billing/payment-methods/${id}`, options);
+  }
+  /**
+   * Define um método de pagamento como padrão.
+   */
+  async setDefault(id, options) {
+    const response = await this.client.post(
+      `/billing/payment-methods/${id}/set-default`,
+      void 0,
+      options
+    );
+    return response.data;
+  }
+};
+var Billing = class {
+  plans;
+  settings;
+  subscription;
+  usage;
+  invoices;
+  paymentMethods;
+  constructor(client) {
+    this.plans = new BillingPlans(client);
+    this.settings = new BillingSettingsResource(client);
+    this.subscription = new BillingSubscription(client);
+    this.usage = new BillingUsageResource(client);
+    this.invoices = new BillingInvoices(client);
+    this.paymentMethods = new BillingPaymentMethods(client);
+  }
+};
+
+// src/resources/inbox-embed.ts
+var InboxEmbed = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Obtém as configurações do inbox embed.
+   */
+  async getSettings(options) {
+    return this.client.getOne("/inbox-embed/settings", options);
+  }
+  /**
+   * Atualiza as configurações do inbox embed.
+   */
+  async updateSettings(params, options) {
+    const response = await this.client.put(
+      "/inbox-embed/settings",
+      params,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Rotaciona a chave de embed.
+   * A chave antiga continua funcionando por um período de grace period.
+   */
+  async rotateKey(options) {
+    const response = await this.client.post(
+      "/inbox-embed/keys/rotate",
+      void 0,
+      options
+    );
+    return response.data;
+  }
+};
+
+// src/resources/inbox.ts
+var Inbox = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Lista notificações do inbox.
+   * Requer subscriber_id ou external_id como parâmetro de query.
+   */
+  async listNotifications(subscriberId, params, options) {
+    return this.client.list(
+      "/inbox/notifications",
+      { subscriber_id: subscriberId, ...params },
+      options
+    );
+  }
+  /**
+   * Obtém a contagem de notificações não lidas.
+   */
+  async getUnreadCount(subscriberId, options) {
+    const response = await this.client.get(
+      "/inbox/notifications/unread-count",
+      { subscriber_id: subscriberId },
+      options
+    );
+    return response.data.count;
+  }
+  /**
+   * Marca uma notificação como lida.
+   */
+  async markRead(notificationId, options) {
+    const response = await this.client.post(
+      `/inbox/notifications/${notificationId}/read`,
+      void 0,
+      options
+    );
+    return response.data;
+  }
+  /**
+   * Marca todas as notificações como lidas.
+   * Requer subscriber_id como parâmetro de query.
+   */
+  async markAllRead(subscriberId, options) {
+    const response = await this.client.post(
+      "/inbox/notifications/read-all",
+      { subscriber_id: subscriberId },
+      options
+    );
+    return response.data;
+  }
+};
+
+// src/index.ts
+var Notifica = class {
+  notifications;
+  templates;
+  workflows;
+  subscribers;
+  channels;
+  domains;
+  webhooks;
+  apiKeys;
+  analytics;
+  sms;
+  billing;
+  inboxEmbed;
+  inbox;
+  /**
+   * Cria uma nova instância do cliente Notifica.
+   *
+   * @param apiKeyOrConfig — API key (string) ou objeto de configuração completo
+   *
+   * @example
+   * ```ts
+   * // Simples — apenas API key
+   * const notifica = new Notifica('nk_live_...');
+   *
+   * // Configuração completa
+   * const notifica = new Notifica({
+   *   apiKey: 'nk_live_...',
+   *   baseUrl: 'https://app.usenotifica.com.br/v1',
+   *   timeout: 15000,
+   *   maxRetries: 5,
+   * });
+   * ```
+   */
+  constructor(apiKeyOrConfig) {
+    const config = typeof apiKeyOrConfig === "string" ? { apiKey: apiKeyOrConfig } : apiKeyOrConfig;
+    const client = new NotificaClient(config);
+    this.notifications = new Notifications(client);
+    this.templates = new Templates(client);
+    this.workflows = new Workflows(client);
+    this.subscribers = new Subscribers(client);
+    this.channels = new Channels(client);
+    this.domains = new Domains(client);
+    this.webhooks = new Webhooks(client);
+    this.apiKeys = new ApiKeys(client);
+    this.analytics = new Analytics(client);
+    this.sms = new Sms(client);
+    this.billing = new Billing(client);
+    this.inboxEmbed = new InboxEmbed(client);
+    this.inbox = new Inbox(client);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Analytics,
+  ApiError,
+  ApiKeys,
+  Billing,
+  Channels,
+  Domains,
+  Inbox,
+  InboxEmbed,
+  Notifica,
+  NotificaClient,
+  NotificaError,
+  Notifications,
+  RateLimitError,
+  Sms,
+  Subscribers,
+  Templates,
+  TimeoutError,
+  ValidationError,
+  Webhooks,
+  Workflows
+});