mailbreeze 0.1.0

package/dist/index.js

@@ -0,0 +1,995 @@
+// src/http/errors.ts
+var MailBreezeError = class extends Error {
+  /** Error code for programmatic handling */
+  code;
+  /** HTTP status code (if applicable) */
+  statusCode;
+  /** Unique request ID for debugging with support */
+  requestId;
+  /** Additional error details (e.g., field-level validation errors) */
+  details;
+  constructor(message, code, statusCode, requestId, details) {
+    super(message);
+    this.name = "MailBreezeError";
+    this.code = code;
+    if (statusCode !== void 0) this.statusCode = statusCode;
+    if (requestId !== void 0) this.requestId = requestId;
+    if (details !== void 0) this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Serialize error to JSON-friendly object.
+   * Useful for logging and error reporting.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      statusCode: this.statusCode,
+      requestId: this.requestId,
+      details: this.details
+    };
+  }
+};
+var AuthenticationError = class extends MailBreezeError {
+  constructor(message, code = "AUTHENTICATION_ERROR", requestId) {
+    super(message, code, 401, requestId);
+    this.name = "AuthenticationError";
+  }
+};
+var ValidationError = class extends MailBreezeError {
+  constructor(message, code = "VALIDATION_ERROR", requestId, details) {
+    super(message, code, 400, requestId, details);
+    this.name = "ValidationError";
+  }
+};
+var NotFoundError = class extends MailBreezeError {
+  constructor(message, code = "NOT_FOUND", requestId) {
+    super(message, code, 404, requestId);
+    this.name = "NotFoundError";
+  }
+};
+var RateLimitError = class extends MailBreezeError {
+  /** Seconds to wait before retrying */
+  retryAfter;
+  constructor(message, code = "RATE_LIMIT_EXCEEDED", requestId, retryAfter) {
+    super(message, code, 429, requestId);
+    this.name = "RateLimitError";
+    if (retryAfter !== void 0) this.retryAfter = retryAfter;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      retryAfter: this.retryAfter
+    };
+  }
+};
+var ServerError = class extends MailBreezeError {
+  constructor(message, code = "SERVER_ERROR", statusCode = 500, requestId) {
+    super(message, code, statusCode, requestId);
+    this.name = "ServerError";
+  }
+};
+function createErrorFromResponse(statusCode, body, requestId, retryAfter) {
+  const message = body?.message ?? "Unknown error";
+  const code = body?.code ?? "UNKNOWN_ERROR";
+  const details = body?.details;
+  switch (statusCode) {
+    case 400:
+      return new ValidationError(message, code, requestId, details);
+    case 401:
+      return new AuthenticationError(message, code, requestId);
+    case 404:
+      return new NotFoundError(message, code, requestId);
+    case 429:
+      return new RateLimitError(message, code, requestId, retryAfter);
+    default:
+      if (statusCode >= 500) {
+        return new ServerError(message, code, statusCode, requestId);
+      }
+      return new MailBreezeError(message, code, statusCode, requestId, details);
+  }
+}
+
+// src/http/fetcher.ts
+var SDK_VERSION = "0.1.0";
+var Fetcher = class {
+  config;
+  constructor(config) {
+    this.config = {
+      ...config,
+      baseUrl: config.baseUrl.replace(/\/$/, "")
+      // Remove trailing slash
+    };
+  }
+  /**
+   * Make an HTTP request to the API.
+   *
+   * @param method - HTTP method
+   * @param path - API path (will be appended to baseUrl)
+   * @param body - Request body (for POST/PUT/PATCH)
+   * @param query - Query parameters
+   * @param options - Additional request options
+   * @returns Parsed response data
+   */
+  async request(method, path, body, query, options) {
+    const url = this.buildUrl(path, query);
+    const headers = this.buildHeaders(options?.idempotencyKey);
+    const timeout = options?.timeout ?? this.config.timeout;
+    let lastError;
+    let attempt = 0;
+    const maxAttempts = this.config.maxRetries + 1;
+    while (attempt < maxAttempts) {
+      attempt++;
+      try {
+        const result = await this.executeRequest(method, url, headers, body, timeout);
+        return result;
+      } catch (error) {
+        lastError = error;
+        if (!this.isRetryable(lastError, error)) {
+          throw lastError;
+        }
+        if (attempt >= maxAttempts) {
+          throw lastError;
+        }
+        const delay = this.getRetryDelay(lastError, attempt);
+        await this.sleep(delay);
+      }
+    }
+    throw lastError ?? new MailBreezeError("Unexpected error during request", "UNEXPECTED_ERROR");
+  }
+  async executeRequest(method, url, headers, body, timeout) {
+    const controller = new AbortController();
+    const timeoutId = timeout ? setTimeout(() => controller.abort(), timeout) : void 0;
+    try {
+      const fetchOptions = {
+        method,
+        headers,
+        signal: controller.signal
+      };
+      if (body && method !== "GET" && method !== "HEAD") {
+        fetchOptions.body = JSON.stringify(body);
+      }
+      const response = await fetch(url, fetchOptions);
+      return await this.handleResponse(response);
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new MailBreezeError("Request timeout", "TIMEOUT_ERROR", 0);
+      }
+      if (error instanceof Error && !(error instanceof MailBreezeError)) {
+        throw new ServerError(`Network error: ${error.message}`, "NETWORK_ERROR", 0);
+      }
+      throw error;
+    } finally {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+  async handleResponse(response) {
+    const requestId = response.headers.get("X-Request-Id") ?? void 0;
+    const retryAfter = response.headers.get("Retry-After");
+    const retryAfterSeconds = retryAfter ? Number.parseInt(retryAfter, 10) : void 0;
+    if (response.status === 204) {
+      return void 0;
+    }
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      if (!response.ok) {
+        throw createErrorFromResponse(response.status, void 0, requestId);
+      }
+      return void 0;
+    }
+    if (!body.success) {
+      const errorBody = body.error;
+      const statusCode = response.ok ? 400 : response.status;
+      throw createErrorFromResponse(statusCode, errorBody, requestId, retryAfterSeconds);
+    }
+    if (!response.ok) {
+      throw createErrorFromResponse(response.status, void 0, requestId, retryAfterSeconds);
+    }
+    return body.data;
+  }
+  buildUrl(path, query) {
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    const url = new URL(`${this.config.baseUrl}${normalizedPath}`);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.append(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  buildHeaders(idempotencyKey) {
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": `mailbreeze-js/${SDK_VERSION}`
+    };
+    if (this.config.authStyle === "bearer") {
+      headers.Authorization = `Bearer ${this.config.apiKey}`;
+    } else {
+      headers["X-API-Key"] = this.config.apiKey;
+    }
+    if (idempotencyKey) {
+      if (/[\r\n]/.test(idempotencyKey)) {
+        throw new MailBreezeError("Invalid idempotency key: contains invalid characters", "INVALID_IDEMPOTENCY_KEY");
+      }
+      headers["X-Idempotency-Key"] = idempotencyKey;
+    }
+    return headers;
+  }
+  isRetryable(error, originalError) {
+    if (originalError instanceof Error && originalError.name === "AbortError") {
+      return false;
+    }
+    if (error.statusCode === 429 || error.statusCode !== void 0 && error.statusCode >= 500) {
+      return true;
+    }
+    if (error.statusCode === 0 && error.code === "NETWORK_ERROR") {
+      return true;
+    }
+    return false;
+  }
+  getRetryDelay(error, attempt) {
+    if (error instanceof RateLimitError && error.retryAfter) {
+      return error.retryAfter * 1e3;
+    }
+    return 2 ** (attempt - 1) * 1e3;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/resources/base.ts
+var BaseResource = class {
+  fetcher;
+  domainId;
+  constructor(fetcher, domainId) {
+    this.fetcher = fetcher;
+    if (domainId !== void 0) this.domainId = domainId;
+  }
+  /**
+   * Make a GET request.
+   */
+  _get(path, query, options) {
+    return this.fetcher.request("GET", this.buildPath(path), void 0, this.addDomainId(query), options);
+  }
+  /**
+   * Make a POST request.
+   */
+  _post(path, body, query, options) {
+    return this.fetcher.request(
+      "POST",
+      this.buildPath(path),
+      body,
+      this.addDomainId(query),
+      options
+    );
+  }
+  /**
+   * Make a PUT request.
+   */
+  _put(path, body, query, options) {
+    return this.fetcher.request(
+      "PUT",
+      this.buildPath(path),
+      body,
+      this.addDomainId(query),
+      options
+    );
+  }
+  /**
+   * Make a PATCH request.
+   */
+  _patch(path, body, query, options) {
+    return this.fetcher.request(
+      "PATCH",
+      this.buildPath(path),
+      body,
+      this.addDomainId(query),
+      options
+    );
+  }
+  /**
+   * Make a DELETE request.
+   */
+  _delete(path, query, options) {
+    return this.fetcher.request("DELETE", this.buildPath(path), void 0, this.addDomainId(query), options);
+  }
+  /**
+   * Build the full path including any base path for the resource.
+   */
+  buildPath(path) {
+    return path;
+  }
+  /**
+   * Add domain ID to query params if configured.
+   */
+  addDomainId(query) {
+    if (!this.domainId) {
+      return query;
+    }
+    return { ...query, domainId: this.domainId };
+  }
+  /**
+   * Helper to extract pagination from list response.
+   */
+  extractPaginatedList(response) {
+    if (Array.isArray(response)) {
+      return {
+        data: response,
+        pagination: {
+          page: 1,
+          limit: response.length,
+          total: response.length,
+          totalPages: 1,
+          hasNext: false,
+          hasPrev: false
+        }
+      };
+    }
+    return {
+      data: response.data,
+      pagination: response.pagination
+    };
+  }
+  /**
+   * Convert list params to query object.
+   */
+  listParamsToQuery(params) {
+    if (!params) return void 0;
+    const query = {};
+    if (params.page !== void 0) query.page = params.page;
+    if (params.limit !== void 0) query.limit = params.limit;
+    return Object.keys(query).length > 0 ? query : void 0;
+  }
+};
+
+// src/resources/attachments.ts
+var Attachments = class extends BaseResource {
+  /**
+   * Create a presigned URL for uploading an attachment.
+   *
+   * @param params - Attachment metadata
+   * @returns Upload URL and attachment ID
+   *
+   * @example
+   * ```ts
+   * const { attachmentId, uploadUrl, uploadToken, expiresAt } =
+   *   await mailbreeze.attachments.createUpload({
+   *     fileName: "document.pdf",
+   *     contentType: "application/pdf",
+   *     fileSize: 2048000,
+   *   });
+   * ```
+   */
+  async createUpload(params) {
+    return this._post("/attachments/upload", params);
+  }
+  /**
+   * Confirm that an attachment has been uploaded.
+   *
+   * Must be called after uploading the file to the presigned URL.
+   * The attachment is only available for use after confirmation.
+   *
+   * @param params - Confirmation parameters including upload token
+   * @returns Confirmed attachment record
+   *
+   * @example
+   * ```ts
+   * const attachment = await mailbreeze.attachments.confirm({
+   *   uploadToken: "token_xxx",
+   * });
+   * console.log(attachment.status); // "uploaded"
+   * ```
+   */
+  async confirm(params) {
+    return this._post("/attachments/confirm", params);
+  }
+};
+
+// src/resources/automations.ts
+var Automations = class extends BaseResource {
+  /**
+   * Enrollments sub-resource for listing and cancelling.
+   */
+  enrollments;
+  constructor(fetcher, domainId) {
+    super(fetcher, domainId);
+    this.enrollments = new AutomationEnrollments(fetcher, domainId);
+  }
+  /**
+   * Enroll a contact in an automation.
+   *
+   * @param params - Enrollment parameters
+   * @returns Enrollment result
+   *
+   * @example
+   * ```ts
+   * const enrollment = await mailbreeze.automations.enroll({
+   *   automationId: "auto_welcome",
+   *   contactId: "contact_xxx",
+   *   variables: { firstName: "John" },
+   * });
+   * console.log(enrollment.enrollmentId);
+   * ```
+   */
+  async enroll(params) {
+    return this._post(`/automations/${params.automationId}/enroll`, {
+      contactId: params.contactId,
+      variables: params.variables
+    });
+  }
+};
+var AutomationEnrollments = class extends BaseResource {
+  /**
+   * List automation enrollments.
+   *
+   * @param params - Filter and pagination options
+   * @returns Paginated list of enrollments
+   *
+   * @example
+   * ```ts
+   * const { data, pagination } = await mailbreeze.automations.enrollments.list({
+   *   automationId: "auto_xxx",
+   *   status: "active",
+   * });
+   * ```
+   */
+  async list(params) {
+    const query = {
+      ...this.listParamsToQuery(params)
+    };
+    if (params?.automationId) query.automationId = params.automationId;
+    if (params?.status) query.status = params.status;
+    const response = await this._get("/automation-enrollments", Object.keys(query).length > 0 ? query : void 0);
+    return this.extractPaginatedList(response);
+  }
+  /**
+   * Cancel an enrollment.
+   *
+   * The contact will stop receiving emails from this automation.
+   *
+   * @param enrollmentId - Enrollment ID
+   * @returns Cancellation result
+   *
+   * @example
+   * ```ts
+   * const result = await mailbreeze.automations.enrollments.cancel("enroll_xxx");
+   * console.log(result.cancelled); // true
+   * ```
+   */
+  async cancel(enrollmentId) {
+    return this._post(`/automation-enrollments/${enrollmentId}/cancel`, {});
+  }
+};
+
+// src/resources/contacts.ts
+var Contacts = class extends BaseResource {
+  listId;
+  constructor(fetcher, listId, domainId) {
+    super(fetcher, domainId);
+    this.listId = listId;
+  }
+  buildPath(path) {
+    return `/contact-lists/${this.listId}/contacts${path}`;
+  }
+  /**
+   * Create a new contact in the list.
+   *
+   * @param params - Contact data
+   * @returns Created contact record
+   *
+   * @example
+   * ```ts
+   * const contact = await contacts.create({
+   *   email: "user@example.com",
+   *   firstName: "Jane",
+   *   lastName: "Smith",
+   *   customFields: { plan: "pro" },
+   * });
+   * ```
+   */
+  async create(params) {
+    return this._post("", params);
+  }
+  /**
+   * List contacts in the list.
+   *
+   * @param params - Filter and pagination options
+   * @returns Paginated list of contacts
+   *
+   * @example
+   * ```ts
+   * const { data, pagination } = await contacts.list({
+   *   status: "active",
+   *   page: 1,
+   *   limit: 50,
+   * });
+   * ```
+   */
+  async list(params) {
+    const query = {
+      ...this.listParamsToQuery(params)
+    };
+    if (params?.status) query.status = params.status;
+    const response = await this._get(
+      "",
+      Object.keys(query).length > 0 ? query : void 0
+    );
+    return this.extractPaginatedList(response);
+  }
+  /**
+   * Get a contact by ID.
+   *
+   * @param id - Contact ID
+   * @returns Contact record
+   *
+   * @example
+   * ```ts
+   * const contact = await contacts.get("contact_xxx");
+   * ```
+   */
+  async get(id) {
+    return this._get(`/${id}`);
+  }
+  /**
+   * Update a contact.
+   *
+   * @param id - Contact ID
+   * @param params - Fields to update
+   * @returns Updated contact record
+   *
+   * @example
+   * ```ts
+   * const contact = await contacts.update("contact_xxx", {
+   *   firstName: "Updated Name",
+   *   customFields: { plan: "enterprise" },
+   * });
+   * ```
+   */
+  async update(id, params) {
+    return this._put(`/${id}`, params);
+  }
+  /**
+   * Delete a contact.
+   *
+   * @param id - Contact ID
+   * @returns void
+   *
+   * @example
+   * ```ts
+   * await contacts.delete("contact_xxx");
+   * ```
+   */
+  async delete(id) {
+    await this._delete(`/${id}`);
+  }
+  /**
+   * Suppress a contact.
+   *
+   * Suppressed contacts will not receive any emails.
+   * This is different from unsubscribing - suppression is
+   * typically used for bounces, complaints, or manual removal.
+   *
+   * @param id - Contact ID
+   * @param reason - Reason for suppression
+   * @returns void
+   *
+   * @example
+   * ```ts
+   * await contacts.suppress("contact_xxx", "manual");
+   * ```
+   */
+  async suppress(id, reason) {
+    await this._post(`/${id}/suppress`, { reason });
+  }
+};
+
+// src/resources/emails.ts
+var Emails = class extends BaseResource {
+  /**
+   * Send an email.
+   *
+   * @param params - Email parameters
+   * @returns Send result with email ID and status
+   *
+   * @example
+   * ```ts
+   * const result = await mailbreeze.emails.send({
+   *   from: "hello@yourdomain.com",
+   *   to: "user@example.com",
+   *   subject: "Hello",
+   *   html: "<p>Hello World!</p>",
+   * });
+   * console.log(result.id); // email_xxx
+   * ```
+   */
+  async send(params) {
+    const { idempotencyKey, ...body } = params;
+    const normalizedBody = {
+      ...body,
+      to: Array.isArray(body.to) ? body.to : [body.to],
+      cc: body.cc ? Array.isArray(body.cc) ? body.cc : [body.cc] : void 0,
+      bcc: body.bcc ? Array.isArray(body.bcc) ? body.bcc : [body.bcc] : void 0
+    };
+    return this._post(
+      "/emails",
+      normalizedBody,
+      void 0,
+      idempotencyKey ? { idempotencyKey } : void 0
+    );
+  }
+  /**
+   * List sent emails with optional filtering.
+   *
+   * @param params - Filter and pagination options
+   * @returns Paginated list of emails
+   *
+   * @example
+   * ```ts
+   * const { data, pagination } = await mailbreeze.emails.list({
+   *   status: "delivered",
+   *   page: 1,
+   *   limit: 20,
+   * });
+   * ```
+   */
+  async list(params) {
+    const query = {
+      ...this.listParamsToQuery(params)
+    };
+    if (params?.status) query.status = params.status;
+    if (params?.to) query.to = params.to;
+    if (params?.from) query.from = params.from;
+    if (params?.startDate) query.startDate = params.startDate;
+    if (params?.endDate) query.endDate = params.endDate;
+    const response = await this._get(
+      "/emails",
+      Object.keys(query).length > 0 ? query : void 0
+    );
+    return this.extractPaginatedList(response);
+  }
+  /**
+   * Get a single email by ID.
+   *
+   * @param id - Email ID
+   * @returns Email record
+   *
+   * @example
+   * ```ts
+   * const email = await mailbreeze.emails.get("email_xxx");
+   * console.log(email.status); // "delivered"
+   * ```
+   */
+  async get(id) {
+    return this._get(`/emails/${id}`);
+  }
+  /**
+   * Get email statistics for the domain.
+   *
+   * @returns Email statistics including delivery rates
+   *
+   * @example
+   * ```ts
+   * const stats = await mailbreeze.emails.stats();
+   * console.log(stats.deliveryRate); // 0.98
+   * ```
+   */
+  async stats() {
+    return this._get("/emails/stats");
+  }
+};
+
+// src/resources/lists.ts
+var Lists = class extends BaseResource {
+  /**
+   * Create a new contact list.
+   *
+   * @param params - List configuration
+   * @returns Created list record
+   *
+   * @example
+   * ```ts
+   * const list = await mailbreeze.lists.create({
+   *   name: "VIP Customers",
+   *   customFields: [
+   *     { key: "tier", label: "Tier", type: "select", options: ["gold", "platinum"] },
+   *   ],
+   * });
+   * ```
+   */
+  async create(params) {
+    return this._post("/contact-lists", params);
+  }
+  /**
+   * List all contact lists.
+   *
+   * @param params - Pagination options
+   * @returns Paginated list of contact lists
+   *
+   * @example
+   * ```ts
+   * const { data, pagination } = await mailbreeze.lists.list({ page: 1, limit: 10 });
+   * ```
+   */
+  async list(params) {
+    const response = await this._get(
+      "/contact-lists",
+      this.listParamsToQuery(params)
+    );
+    return this.extractPaginatedList(response);
+  }
+  /**
+   * Get a contact list by ID.
+   *
+   * @param id - List ID
+   * @returns Contact list record
+   *
+   * @example
+   * ```ts
+   * const list = await mailbreeze.lists.get("list_xxx");
+   * ```
+   */
+  async get(id) {
+    return this._get(`/contact-lists/${id}`);
+  }
+  /**
+   * Update a contact list.
+   *
+   * @param id - List ID
+   * @param params - Fields to update
+   * @returns Updated list record
+   *
+   * @example
+   * ```ts
+   * const list = await mailbreeze.lists.update("list_xxx", {
+   *   name: "Updated List Name",
+   * });
+   * ```
+   */
+  async update(id, params) {
+    return this._patch(`/contact-lists/${id}`, params);
+  }
+  /**
+   * Delete a contact list.
+   *
+   * Warning: This will also delete all contacts in the list.
+   *
+   * @param id - List ID
+   * @returns void
+   *
+   * @example
+   * ```ts
+   * await mailbreeze.lists.delete("list_xxx");
+   * ```
+   */
+  async delete(id) {
+    await this._delete(`/contact-lists/${id}`);
+  }
+  /**
+   * Get statistics for a contact list.
+   *
+   * @param id - List ID
+   * @returns List statistics
+   *
+   * @example
+   * ```ts
+   * const stats = await mailbreeze.lists.stats("list_xxx");
+   * console.log(`Active: ${stats.activeContacts}, Bounced: ${stats.bouncedContacts}`);
+   * ```
+   */
+  async stats(id) {
+    return this._get(`/contact-lists/${id}/stats`);
+  }
+};
+
+// src/resources/verification.ts
+var Verification = class extends BaseResource {
+  /**
+   * Verify a single email address.
+   *
+   * This is a synchronous operation - the result is returned immediately.
+   * Results are cached for 24 hours.
+   *
+   * @param email - Email address to verify
+   * @returns Verification result
+   *
+   * @example
+   * ```ts
+   * const result = await mailbreeze.verification.verify("test@example.com");
+   * console.log(result.isValid); // true
+   * console.log(result.result); // "valid"
+   * console.log(result.details?.isDisposable); // false
+   * ```
+   */
+  async verify(email) {
+    return this._post("/email-verification/single", { email });
+  }
+  /**
+   * Start batch verification.
+   *
+   * Submits a batch of emails for verification. For large batches,
+   * results are processed asynchronously - poll with `get()` for status.
+   *
+   * If all emails are cached, results are returned immediately.
+   *
+   * @param params - Batch parameters including emails array
+   * @returns Batch verification result with ID for polling
+   *
+   * @example
+   * ```ts
+   * const batch = await mailbreeze.verification.batch({
+   *   emails: ["user1@example.com", "user2@example.com", "user3@example.com"],
+   * });
+   *
+   * if (batch.results) {
+   *   // All cached - results available immediately
+   *   console.log(batch.results);
+   * } else {
+   *   // Poll for results
+   *   const status = await mailbreeze.verification.get(batch.verificationId);
+   * }
+   * ```
+   */
+  async batch(params) {
+    return this._post("/email-verification/batch", params);
+  }
+  /**
+   * Get verification batch status and results.
+   *
+   * @param verificationId - Verification batch ID
+   * @returns Current status and results when complete
+   *
+   * @example
+   * ```ts
+   * const status = await mailbreeze.verification.get("ver_xxx");
+   * if (status.status === "completed") {
+   *   console.log(status.results);
+   *   console.log(status.analytics);
+   * }
+   * ```
+   */
+  async get(verificationId) {
+    return this._get(`/email-verification/${verificationId}`, {
+      includeResults: true
+    });
+  }
+  /**
+   * List verification batches.
+   *
+   * @param params - Filter and pagination options
+   * @returns Paginated list of verification batches
+   *
+   * @example
+   * ```ts
+   * const { data, pagination } = await mailbreeze.verification.list({
+   *   status: "completed",
+   *   page: 1,
+   * });
+   * ```
+   */
+  async list(params) {
+    const query = {
+      ...this.listParamsToQuery(params)
+    };
+    if (params?.status) query.status = params.status;
+    const response = await this._get("/email-verification", Object.keys(query).length > 0 ? query : void 0);
+    return this.extractPaginatedList(response);
+  }
+  /**
+   * Get verification statistics.
+   *
+   * @returns Aggregate verification stats
+   *
+   * @example
+   * ```ts
+   * const stats = await mailbreeze.verification.stats();
+   * console.log(`Verified: ${stats.totalVerified}, Valid: ${stats.valid}`);
+   * ```
+   */
+  async stats() {
+    return this._get("/email-verification/stats");
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.mailbreeze.com";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var MailBreeze = class {
+  /**
+   * Email sending and management.
+   */
+  emails;
+  /**
+   * Email attachment handling.
+   */
+  attachments;
+  /**
+   * Contact list management.
+   */
+  lists;
+  /**
+   * Email verification services.
+   */
+  verification;
+  /**
+   * Automation enrollment management.
+   */
+  automations;
+  fetcher;
+  domainId;
+  /**
+   * Create a new MailBreeze client.
+   *
+   * @param config - Client configuration
+   *
+   * @example
+   * ```ts
+   * // Basic usage
+   * const mailbreeze = new MailBreeze({
+   *   apiKey: "sk_live_xxx",
+   * });
+   *
+   * // With custom options
+   * const mailbreeze = new MailBreeze({
+   *   apiKey: "sk_live_xxx",
+   *   baseUrl: "https://api.eu.mailbreeze.com",
+   *   timeout: 60000,
+   *   maxRetries: 5,
+   * });
+   * ```
+   */
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("API key is required");
+    }
+    this.fetcher = new Fetcher({
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT,
+      maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,
+      authStyle: config.authStyle ?? "header"
+    });
+    this.emails = new Emails(this.fetcher, this.domainId);
+    this.attachments = new Attachments(this.fetcher, this.domainId);
+    this.lists = new Lists(this.fetcher, this.domainId);
+    this.verification = new Verification(this.fetcher, this.domainId);
+    this.automations = new Automations(this.fetcher, this.domainId);
+  }
+  /**
+   * Get a contacts resource for a specific list.
+   *
+   * @param listId - Contact list ID
+   * @returns Contacts resource bound to the list
+   *
+   * @example
+   * ```ts
+   * const contacts = mailbreeze.contacts("list_xxx");
+   *
+   * // Create a contact in this list
+   * const contact = await contacts.create({
+   *   email: "user@example.com",
+   * });
+   *
+   * // List contacts in this list
+   * const { data } = await contacts.list();
+   * ```
+   */
+  contacts(listId) {
+    return new Contacts(this.fetcher, listId, this.domainId);
+  }
+};
+
+export { AuthenticationError, MailBreeze, MailBreezeError, NotFoundError, RateLimitError, ServerError, ValidationError };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map