@beel_es/sdk 1.0.0 → 1.1.0

package/dist/index.mjs

@@ -0,0 +1,756 @@
+// src/http/client.ts
+import createClient from "openapi-fetch";
+
+// src/http/middleware.ts
+import { randomUUID } from "crypto";
+
+// src/core/errors.ts
+var BeeLApiError = class extends Error {
+  constructor(message, statusCode, code, details, requestId) {
+    super(message);
+    this.name = "BeeLApiError";
+    this.statusCode = statusCode;
+    this.code = code;
+    this.details = details;
+    this.requestId = requestId;
+  }
+};
+var BeeLRateLimitError = class extends BeeLApiError {
+  constructor(message, retryAfterSeconds, requestId) {
+    super(message, 429, "RATE_LIMIT_EXCEEDED", void 0, requestId);
+    this.name = "BeeLRateLimitError";
+    this.retryAfterSeconds = retryAfterSeconds;
+  }
+};
+var BeeLValidationError = class extends BeeLApiError {
+  constructor(message, details, requestId) {
+    super(message, 422, "UNPROCESSABLE_ENTITY", details, requestId);
+    this.name = "BeeLValidationError";
+  }
+};
+var BeeLAuthError = class extends BeeLApiError {
+  constructor(message, statusCode, requestId) {
+    super(
+      message,
+      statusCode,
+      statusCode === 401 ? "UNAUTHORIZED" : "FORBIDDEN",
+      void 0,
+      requestId
+    );
+    this.name = "BeeLAuthError";
+  }
+};
+var BeeLNotFoundError = class extends BeeLApiError {
+  constructor(message, requestId) {
+    super(message, 404, "NOT_FOUND", void 0, requestId);
+    this.name = "BeeLNotFoundError";
+  }
+};
+var BeeLConflictError = class extends BeeLApiError {
+  constructor(message, requestId) {
+    super(message, 409, "CONFLICT", void 0, requestId);
+    this.name = "BeeLConflictError";
+  }
+};
+function throwApiError(status, body) {
+  const parsed = body;
+  const errorData = parsed?.error ?? parsed;
+  const message = errorData?.message ?? `API error ${status}`;
+  const code = errorData?.code ?? "UNKNOWN";
+  const details = errorData?.details;
+  const requestId = parsed?.meta?.request_id;
+  switch (status) {
+    case 401:
+    case 403:
+      throw new BeeLAuthError(message, status, requestId);
+    case 404:
+      throw new BeeLNotFoundError(message, requestId);
+    case 409:
+      throw new BeeLConflictError(message, requestId);
+    case 422:
+      throw new BeeLValidationError(message, details, requestId);
+    case 429: {
+      const retryAfter = errorData?.retry_after ?? 60;
+      throw new BeeLRateLimitError(message, retryAfter, requestId);
+    }
+    default:
+      throw new BeeLApiError(message, status, code, details, requestId);
+  }
+}
+
+// src/http/middleware.ts
+var requestMiddleware = {
+  async onRequest({ request }) {
+    const method = request.method;
+    if (["POST", "PUT", "PATCH"].includes(method)) {
+      const hasBody = request.headers.get("content-type")?.includes("application/json");
+      if (!hasBody) {
+        const clone = new Request(request, {
+          body: request.body ?? "{}",
+          headers: new Headers(request.headers)
+        });
+        clone.headers.set("Content-Type", "application/json");
+        if (method === "POST" && !clone.headers.has("Idempotency-Key")) {
+          clone.headers.set("Idempotency-Key", randomUUID());
+        }
+        return clone;
+      }
+    }
+    if (method === "POST" && !request.headers.has("Idempotency-Key")) {
+      request.headers.set("Idempotency-Key", randomUUID());
+    }
+    return request;
+  }
+};
+var errorMiddleware = {
+  async onResponse({ response }) {
+    if (!response.ok) {
+      const body = await response.json().catch(() => null);
+      throwApiError(response.status, body);
+    }
+    return response;
+  }
+};
+function createRetryMiddleware(options) {
+  return {
+    async onError({ error, request }) {
+      if (!(error instanceof BeeLApiError)) return;
+      if (!(error instanceof BeeLRateLimitError) && error.statusCode < 500) return;
+      for (let attempt = 0; attempt < options.maxRetries; attempt++) {
+        const delay = error instanceof BeeLRateLimitError ? error.retryAfterSeconds * 1e3 : Math.min(
+          options.initialDelayMs * Math.pow(2, attempt) + Math.random() * options.initialDelayMs,
+          options.maxDelayMs
+        );
+        await new Promise((r) => setTimeout(r, delay));
+        try {
+          if (request.method === "POST") {
+            request.headers.set("Idempotency-Key", randomUUID());
+          }
+          const response = await fetch(request.clone());
+          if (response.ok) return response;
+          const body = await response.json().catch(() => null);
+          throwApiError(response.status, body);
+        } catch (retryError) {
+          if (!(retryError instanceof BeeLApiError)) throw retryError;
+          if (!(retryError instanceof BeeLRateLimitError) && retryError.statusCode < 500) throw retryError;
+          if (attempt === options.maxRetries - 1) throw retryError;
+        }
+      }
+    }
+  };
+}
+
+// src/http/client.ts
+function createBeeLClient(config) {
+  const client = createClient({
+    baseUrl: config.baseUrl ?? "https://app.beel.es/api",
+    headers: {
+      Authorization: `Bearer ${config.apiKey}`
+    }
+  });
+  client.use(requestMiddleware);
+  client.use(errorMiddleware);
+  client.use(
+    createRetryMiddleware({
+      maxRetries: config.maxRetries ?? 3,
+      initialDelayMs: config.retryDelayMs ?? 500,
+      maxDelayMs: config.maxRetryDelayMs ?? 3e4
+    })
+  );
+  return client;
+}
+
+// src/resources/invoices.ts
+var InvoicesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List invoices with optional filters and pagination.
+   *
+   * @example
+   * const { invoices, pagination } = await beel.invoices.list({ status: 'ISSUED', limit: 20 });
+   */
+  async list(params) {
+    const { data } = await this.client.GET("/v1/invoices", { params: { query: params } });
+    return data.data;
+  }
+  /**
+   * Create a new invoice. An idempotency key is automatically added.
+   *
+   * @example
+   * const invoice = await beel.invoices.create({
+   *   type: 'STANDARD',
+   *   recipient: { customer_id: 'uuid' },
+   *   lines: [{ description: 'Service', quantity: 1, unit_price: 100, discount_percentage: 0 }],
+   * });
+   */
+  async create(body) {
+    const { data } = await this.client.POST("/v1/invoices", { body });
+    return data.data;
+  }
+  /** Get an invoice by ID. */
+  async get(id) {
+    const { data } = await this.client.GET("/v1/invoices/{invoice_id}", { params: { path: { invoice_id: id } } });
+    return data.data;
+  }
+  /** Update a draft invoice. Only draft invoices can be updated. */
+  async update(id, body) {
+    const { data } = await this.client.PUT("/v1/invoices/{invoice_id}", { params: { path: { invoice_id: id } }, body });
+    return data.data;
+  }
+  /** Delete a draft invoice. Only draft invoices can be deleted. */
+  async delete(id) {
+    await this.client.DELETE("/v1/invoices/{invoice_id}", { params: { path: { invoice_id: id } } });
+  }
+  /** Duplicate an invoice, optionally into a different series. */
+  async duplicate(id, options) {
+    const { data } = await this.client.POST("/v1/invoices/{invoice_id}/duplicate", { params: { path: { invoice_id: id } }, body: options });
+    return data.data;
+  }
+  /**
+   * Issue a draft invoice. Assigns an invoice number and triggers VeriFactu submission.
+   * @param options.wait_for_pdf - If true, waits for PDF generation before returning.
+   */
+  async issue(id, options) {
+    const { data } = await this.client.POST("/v1/invoices/{invoice_id}/issue", { params: { path: { invoice_id: id }, query: options } });
+    return data.data;
+  }
+  /**
+   * Mark an invoice as paid.
+   * @param options.payment_date - Payment date (defaults to today).
+   * @param options.payment_method - Payment method details.
+   */
+  async markPaid(id, options) {
+    const { data } = await this.client.POST("/v1/invoices/{invoice_id}/mark-paid", { params: { path: { invoice_id: id } }, body: options });
+    return data.data;
+  }
+  /** Mark an invoice as sent (e.g. delivered by other means). */
+  async markSent(id, options) {
+    const { data } = await this.client.POST("/v1/invoices/{invoice_id}/mark-sent", { params: { path: { invoice_id: id } }, body: options });
+    return data.data;
+  }
+  /** Revert a paid/sent invoice back to issued status. */
+  async revertToIssued(id) {
+    const { data } = await this.client.POST("/v1/invoices/{invoice_id}/revert-to-issued", { params: { path: { invoice_id: id } } });
+    return data.data;
+  }
+  /**
+   * Void an issued invoice. Requires a reason (min 10 chars).
+   *
+   * @example
+   * await beel.invoices.void('id', { reason: 'Duplicate invoice sent in error' });
+   */
+  async void(id, params) {
+    const { data } = await this.client.POST("/v1/invoices/{invoice_id}/void", { params: { path: { invoice_id: id } }, body: params });
+    return data.data;
+  }
+  /** Create a corrective invoice that references the original. */
+  async createCorrective(id, body) {
+    const { data } = await this.client.POST("/v1/invoices/{invoice_id}/corrective", { params: { path: { invoice_id: id } }, body });
+    return data.data;
+  }
+  /** Schedule a draft invoice to be issued on a future date. */
+  async schedule(id, params) {
+    const { data } = await this.client.POST("/v1/invoices/{invoice_id}/schedule", { params: { path: { invoice_id: id } }, body: params });
+    return data.data;
+  }
+  /** Cancel a scheduled invoice, returning it to draft. */
+  async unschedule(id) {
+    const { data } = await this.client.POST("/v1/invoices/{invoice_id}/unschedule", { params: { path: { invoice_id: id } } });
+    return data.data;
+  }
+  /** Change the scheduled date of a scheduled invoice. */
+  async reschedule(id, params) {
+    const { data } = await this.client.PATCH("/v1/invoices/{invoice_id}/reschedule", { params: { path: { invoice_id: id } }, body: params });
+    return data.data;
+  }
+  /**
+   * Get a pre-signed URL to download the invoice PDF.
+   * The URL expires in 5 minutes. Use `beel.downloadPdf(id)` for a simpler Buffer download.
+   */
+  async getPdf(id) {
+    const { data } = await this.client.GET("/v1/invoices/{invoice_id}/pdf", { params: { path: { invoice_id: id } } });
+    return data.data;
+  }
+  /** Send an invoice by email. Uses the customer's email by default. */
+  async sendEmail(id, options) {
+    const { data } = await this.client.POST("/v1/invoices/{invoice_id}/send", { params: { path: { invoice_id: id } }, body: options });
+    return data.data;
+  }
+};
+
+// src/resources/customers.ts
+var CustomersResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List customers with optional filters and pagination.
+   *
+   * @example
+   * const { customers, pagination } = await beel.customers.list({ search: 'Acme', limit: 10 });
+   */
+  async list(params) {
+    const { data } = await this.client.GET("/v1/customers", { params: { query: params } });
+    return data.data;
+  }
+  /**
+   * Create a new customer.
+   *
+   * @example
+   * const customer = await beel.customers.create({
+   *   legal_name: 'Acme SL',
+   *   nif: 'B12345678',
+   *   address: { street: 'Calle Mayor', number: '1', postal_code: '28001', city: 'Madrid', province: 'Madrid', country: 'Spain', country_code: 'ES' },
+   * });
+   */
+  async create(body) {
+    const { data } = await this.client.POST("/v1/customers", { body });
+    return data.data;
+  }
+  /** Get a customer by ID. */
+  async get(id) {
+    const { data } = await this.client.GET("/v1/customers/{customer_id}", { params: { path: { customer_id: id } } });
+    return data.data;
+  }
+  /** Update a customer. Only provided fields are changed. */
+  async update(id, body) {
+    const { data } = await this.client.PUT("/v1/customers/{customer_id}", { params: { path: { customer_id: id } }, body });
+    return data.data;
+  }
+  /** Deactivate (soft-delete) a customer. */
+  async deactivate(id) {
+    await this.client.DELETE("/v1/customers/{customer_id}", { params: { path: { customer_id: id } } });
+  }
+};
+
+// src/resources/products.ts
+var ProductsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List products with optional filters and pagination.
+   *
+   * @example
+   * const { products, pagination } = await beel.products.list({ category: 'SERVICE' });
+   */
+  async list(params) {
+    const { data } = await this.client.GET("/v1/products", { params: { query: params } });
+    return data.data;
+  }
+  /**
+   * Create a new product or service.
+   *
+   * @example
+   * const product = await beel.products.create({
+   *   name: 'Consulting',
+   *   code: 'CONS-001',
+   *   category: 'SERVICE',
+   *   default_price: 100,
+   *   main_tax: { type: 'IVA', percentage: 21 },
+   * });
+   */
+  async create(body) {
+    const { data } = await this.client.POST("/v1/products", { body });
+    return data.data;
+  }
+  /** Get a product by ID. */
+  async get(id) {
+    const { data } = await this.client.GET("/v1/products/{product_id}", { params: { path: { product_id: id } } });
+    return data.data;
+  }
+  /** Update a product. Only provided fields are changed. */
+  async update(id, body) {
+    const { data } = await this.client.PUT("/v1/products/{product_id}", { params: { path: { product_id: id } }, body });
+    return data.data;
+  }
+  /** Delete a product permanently. */
+  async delete(id) {
+    await this.client.DELETE("/v1/products/{product_id}", { params: { path: { product_id: id } } });
+  }
+  /**
+   * Search products by name or code. Returns up to `limit` results.
+   *
+   * @example
+   * const results = await beel.products.search('consulting', 5);
+   */
+  async search(q, limit) {
+    const { data } = await this.client.GET("/v1/products/search", { params: { query: { q, limit } } });
+    return data.data;
+  }
+};
+
+// src/resources/configuration.ts
+var ConfigurationResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get the current tax configuration (default VAT, IRPF, etc.). */
+  async getTaxConfig() {
+    const { data } = await this.client.GET("/v1/configuration/taxes");
+    return data.data;
+  }
+  /** Update tax configuration. */
+  async updateTaxConfig(body) {
+    const { data } = await this.client.PUT("/v1/configuration/taxes", { body });
+    return data.data;
+  }
+  /** Get available tax types (IVA/IGIC rates, IRPF types, equivalence surcharges). */
+  async getTaxTypes() {
+    const { data } = await this.client.GET("/v1/configuration/tax-types");
+    return data.data;
+  }
+  /** Get invoice customization options (logo, colors, footer text, etc.). */
+  async getInvoiceCustomizationOptions() {
+    const { data } = await this.client.GET("/v1/configuration/invoice-customization-options");
+    return data.data;
+  }
+  /** Update the user's preferred language (es, en, ca). */
+  async updateLanguage(language) {
+    const { data } = await this.client.PUT("/v1/configuration/language", { body: { language } });
+    return data.data;
+  }
+  /** Get VeriFactu configuration (enabled, certificate status, etc.). */
+  async getVerifactu() {
+    const { data } = await this.client.GET("/v1/configuration/verifactu");
+    return data.data;
+  }
+  /** Update VeriFactu configuration. */
+  async updateVerifactu(body) {
+    const { data } = await this.client.PUT("/v1/configuration/verifactu", { body });
+    return data.data;
+  }
+};
+
+// src/resources/series.ts
+var SeriesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List all invoice series. Optionally filter by active status.
+   *
+   * @example
+   * const series = await beel.series.list();
+   * const activeSeries = await beel.series.list(true);
+   */
+  async list(active) {
+    const { data } = await this.client.GET("/v1/configuration/series", {
+      params: { query: active !== void 0 ? { active } : void 0 }
+    });
+    return data.data;
+  }
+  /** Create a new invoice series (e.g. "A-2026", "RECT"). */
+  async create(body) {
+    const { data } = await this.client.POST("/v1/configuration/series", { body });
+    return data.data;
+  }
+  /** Update a series (name, description, etc.). */
+  async update(id, body) {
+    const { data } = await this.client.PUT("/v1/configuration/series/{series_id}", {
+      params: { path: { series_id: id } },
+      body
+    });
+    return data.data;
+  }
+  /** Delete an invoice series. Only empty series can be deleted. */
+  async delete(id) {
+    await this.client.DELETE("/v1/configuration/series/{series_id}", {
+      params: { path: { series_id: id } }
+    });
+  }
+  /** Set a series as the default for new invoices. */
+  async setDefault(id) {
+    const { data } = await this.client.POST("/v1/configuration/series/{series_id}/default", {
+      params: { path: { series_id: id } }
+    });
+    return data.data;
+  }
+};
+
+// src/resources/nif.ts
+var NifResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Validate a Spanish NIF/CIF against the AEAT tax registry.
+   *
+   * @example
+   * const result = await beel.nif.validate('B12345678');
+   * console.log(result.valid, result.name);
+   */
+  async validate(nif) {
+    const { data } = await this.client.POST("/v1/nif/validate", { body: { nif } });
+    return data.data;
+  }
+};
+
+// src/client.ts
+var BeeL = class {
+  constructor(config) {
+    const client = createBeeLClient(config);
+    this.invoices = new InvoicesResource(client);
+    this.customers = new CustomersResource(client);
+    this.products = new ProductsResource(client);
+    this.configuration = new ConfigurationResource(client);
+    this.series = new SeriesResource(client);
+    this.nif = new NifResource(client);
+  }
+  /**
+   * Download an invoice PDF as a Buffer.
+   *
+   * @example
+   * ```typescript
+   * const { buffer, fileName } = await beel.downloadPdf('invoice-uuid');
+   * fs.writeFileSync(fileName, buffer);
+   * ```
+   */
+  async downloadPdf(invoiceId) {
+    const pdf = await this.invoices.getPdf(invoiceId);
+    const response = await fetch(pdf.download_url);
+    if (!response.ok) throw new Error(`Failed to download PDF: ${response.status}`);
+    const arrayBuffer = await response.arrayBuffer();
+    return { buffer: Buffer.from(arrayBuffer), fileName: pdf.file_name };
+  }
+};
+
+// src/webhooks/verifier.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var WebhookVerifier = class {
+  /**
+   * Creates a new WebhookVerifier
+   * 
+   * @param secret - Your webhook secret from BeeL dashboard
+   * @param toleranceSeconds - Maximum age of webhook events (default: 300 = 5 minutes)
+   */
+  constructor(secret, toleranceSeconds = 300) {
+    if (!secret || secret.trim().length === 0) {
+      throw new Error("Webhook secret is required");
+    }
+    this.secret = secret;
+    this.toleranceSeconds = toleranceSeconds;
+  }
+  /**
+   * Verify a webhook signature and return the parsed event
+   * 
+   * @param rawBody - Raw request body (string or Buffer, before JSON parsing)
+   * @param signatureHeader - Value of the `BeeL-Signature` header
+   * @returns Parsed webhook event
+   * @throws {WebhookVerificationError} If signature is invalid or event is too old
+   * 
+   * @example Basic usage
+   * ```typescript
+   * const verifier = new WebhookVerifier('your_secret');
+   * const event = verifier.verify(rawBody, signature);
+   * 
+   * if (event.type === 'verifactu.status.updated') {
+   *   console.log('Invoice:', event.data.invoice_number);
+   *   console.log('Status:', event.data.new_status);
+   * }
+   * ```
+   */
+  verify(rawBody, signatureHeader) {
+    if (!signatureHeader) {
+      throw new WebhookVerificationError("Missing BeeL-Signature header");
+    }
+    const { timestamp, signature } = this.parseSignatureHeader(signatureHeader);
+    const now = Math.floor(Date.now() / 1e3);
+    const age = Math.abs(now - timestamp);
+    if (age > this.toleranceSeconds) {
+      throw new WebhookVerificationError(
+        `Webhook timestamp too old (${age}s ago, max ${this.toleranceSeconds}s allowed)`
+      );
+    }
+    const bodyString = Buffer.isBuffer(rawBody) ? rawBody.toString("utf8") : rawBody;
+    const expectedSignature = this.computeSignature(timestamp, bodyString);
+    if (!this.secureCompare(signature, expectedSignature)) {
+      throw new WebhookVerificationError("Invalid webhook signature");
+    }
+    try {
+      return JSON.parse(bodyString);
+    } catch (error) {
+      throw new WebhookVerificationError("Invalid JSON in webhook body");
+    }
+  }
+  /**
+   * Parse the BeeL-Signature header
+   * 
+   * Format: `t=1741362026,v1=3c4f7a2e...`
+   */
+  parseSignatureHeader(header) {
+    const parts = header.split(",");
+    let timestamp;
+    let signature;
+    for (const part of parts) {
+      const [key, value] = part.split("=", 2);
+      if (key === "t") {
+        timestamp = parseInt(value, 10);
+      } else if (key === "v1") {
+        signature = value;
+      }
+    }
+    if (!timestamp || !signature) {
+      throw new WebhookVerificationError(
+        "Invalid signature header format (expected: t=timestamp,v1=signature)"
+      );
+    }
+    if (isNaN(timestamp)) {
+      throw new WebhookVerificationError("Invalid timestamp in signature header");
+    }
+    return { timestamp, signature };
+  }
+  /**
+   * Compute HMAC-SHA256 signature
+   * 
+   * Algorithm:
+   * 1. Build signed payload: `{timestamp}.{raw_body}`
+   * 2. Compute: HMAC-SHA256(secret, signed_payload)
+   * 3. Return hex digest
+   */
+  computeSignature(timestamp, body) {
+    const signedPayload = `${timestamp}.${body}`;
+    return createHmac("sha256", this.secret).update(signedPayload, "utf8").digest("hex");
+  }
+  /**
+   * Constant-time string comparison to prevent timing attacks
+   */
+  secureCompare(a, b) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    const bufferA = Buffer.from(a, "utf8");
+    const bufferB = Buffer.from(b, "utf8");
+    return timingSafeEqual(bufferA, bufferB);
+  }
+};
+var WebhookVerificationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WebhookVerificationError";
+  }
+};
+
+// src/builders/customer-builder.ts
+var CustomerBuilder = class _CustomerBuilder {
+  constructor() {
+  }
+  static create() {
+    return new _CustomerBuilder();
+  }
+  name(name) {
+    this._name = name;
+    return this;
+  }
+  nif(nif) {
+    this._nif = nif;
+    return this;
+  }
+  email(email) {
+    this._email = email;
+    return this;
+  }
+  phone(phone) {
+    this._phone = phone;
+    return this;
+  }
+  address(street, number, postalCode, city, province, country, countryCode = "ES") {
+    this._address = { street, number, postal_code: postalCode, city, province, country, country_code: countryCode };
+    return this;
+  }
+  notes(notes) {
+    this._notes = notes;
+    return this;
+  }
+  build() {
+    if (!this._name || this._name.trim().length === 0) throw new Error("Legal name is required");
+    if (!this._nif || this._nif.trim().length === 0) throw new Error("NIF/CIF is required");
+    if (!this._address) throw new Error("Address is required");
+    return {
+      legal_name: this._name,
+      nif: this._nif,
+      email: this._email,
+      phone: this._phone,
+      address: this._address,
+      notes: this._notes
+    };
+  }
+};
+
+// src/builders/invoice-builder.ts
+var InvoiceBuilder = class _InvoiceBuilder {
+  constructor() {
+    this._type = "STANDARD";
+    this._lines = [];
+  }
+  static create() {
+    return new _InvoiceBuilder();
+  }
+  type(type) {
+    this._type = type;
+    return this;
+  }
+  forCustomer(customerId) {
+    this._customerId = customerId;
+    return this;
+  }
+  operationDate(date) {
+    this._operationDate = date instanceof Date ? date.toISOString().split("T")[0] : date;
+    return this;
+  }
+  dueDate(date) {
+    this._dueDate = date instanceof Date ? date.toISOString().split("T")[0] : date;
+    return this;
+  }
+  addLine(description, quantity, unitPrice, discountPercentage = 0) {
+    this._lines.push({ description, quantity, unit_price: unitPrice, discount_percentage: discountPercentage });
+    return this;
+  }
+  addLineObject(line) {
+    this._lines.push(line);
+    return this;
+  }
+  notes(notes) {
+    this._notes = notes;
+    return this;
+  }
+  series(id) {
+    this._seriesId = id;
+    return this;
+  }
+  metadata(data) {
+    this._metadata = data;
+    return this;
+  }
+  build() {
+    if (!this._customerId) throw new Error("Customer ID is required");
+    if (this._lines.length === 0) throw new Error("At least one invoice line is required");
+    const recipient = { customer_id: this._customerId };
+    return {
+      type: this._type,
+      operation_date: this._operationDate,
+      due_date: this._dueDate,
+      recipient,
+      lines: this._lines,
+      notes: this._notes,
+      series_id: this._seriesId,
+      metadata: this._metadata
+    };
+  }
+};
+export {
+  BeeL,
+  BeeLApiError,
+  BeeLAuthError,
+  BeeLConflictError,
+  BeeLNotFoundError,
+  BeeLRateLimitError,
+  BeeLValidationError,
+  CustomerBuilder,
+  InvoiceBuilder,
+  WebhookVerificationError,
+  WebhookVerifier
+};
+//# sourceMappingURL=index.mjs.map