@scell/sdk 1.0.0 → 1.4.0

package/dist/index.js

@@ -277,6 +277,8 @@ var HttpClient = class {
     };
     if (this.authMode === "bearer") {
       headers["Authorization"] = `Bearer ${this.authToken}`;
+    } else if (this.authMode === "tenant-key") {
+      headers["X-Tenant-Key"] = this.authToken;
     } else {
       headers["X-API-Key"] = this.authToken;
     }
@@ -403,6 +405,1315 @@ var HttpClient = class {
       ...options
     });
   }
+  /**
+   * GET request that returns raw binary data as ArrayBuffer
+   *
+   * Use this for downloading files (PDF, XML, etc.)
+   *
+   * @param path - API endpoint path
+   * @param query - Query parameters
+   * @param options - Request options
+   * @returns ArrayBuffer containing the file content
+   */
+  async getRaw(path, query, options) {
+    const url = this.buildUrl(path, query);
+    const requestHeaders = this.buildHeaders(options?.headers);
+    const requestTimeout = options?.timeout ?? this.timeout;
+    delete requestHeaders["Content-Type"];
+    requestHeaders["Accept"] = "*/*";
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), requestTimeout);
+    if (options?.signal) {
+      options.signal.addEventListener("abort", () => controller.abort());
+    }
+    try {
+      const response = await this.fetchFn(url, {
+        method: "GET",
+        headers: requestHeaders,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const contentType = response.headers.get("Content-Type") ?? "";
+        let responseBody;
+        if (contentType.includes("application/json")) {
+          responseBody = await response.json();
+        } else {
+          responseBody = await response.text();
+        }
+        parseApiError(response.status, responseBody, response.headers);
+      }
+      return response.arrayBuffer();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new exports.ScellTimeoutError(
+            `Request timed out after ${requestTimeout}ms`
+          );
+        }
+        if (error.name === "TypeError" && error.message.includes("fetch")) {
+          throw new exports.ScellNetworkError("Network request failed", error);
+        }
+      }
+      throw error;
+    }
+  }
+};
+
+// src/resources/tenant-direct-invoices.ts
+var TenantDirectInvoicesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new direct invoice
+   *
+   * Creates an outgoing invoice from the tenant to an external buyer.
+   * The invoice will be generated in the specified format (Factur-X by default).
+   *
+   * @param params - Invoice creation parameters
+   * @param requestOptions - Optional request configuration
+   * @returns Created invoice
+   *
+   * @example
+   * ```typescript
+   * const { data: invoice } = await client.directInvoices.create({
+   *   company_id: 'company-uuid',
+   *   buyer: {
+   *     company_name: 'Acme Corporation',
+   *     siret: '98765432109876',
+   *     address: {
+   *       line1: '456 Avenue Business',
+   *       postal_code: '69001',
+   *       city: 'Lyon',
+   *       country: 'FR'
+   *     },
+   *     email: 'accounts@acme.com'
+   *   },
+   *   lines: [{
+   *     description: 'Monthly subscription',
+   *     quantity: 1,
+   *     unit_price: 299,
+   *     tax_rate: 20,
+   *     total_ht: 299,
+   *     total_tax: 59.80,
+   *     total_ttc: 358.80
+   *   }],
+   *   issue_date: '2026-01-26',
+   *   due_date: '2026-02-26',
+   *   notes: 'Thank you for your business!'
+   * });
+   *
+   * console.log('Invoice created:', invoice.invoice_number);
+   * ```
+   */
+  async create(params, requestOptions) {
+    return this.http.post(
+      "/tenant/invoices",
+      params,
+      requestOptions
+    );
+  }
+  /**
+   * List all direct invoices
+   *
+   * Returns a paginated list of direct invoices created by the tenant.
+   * Supports filtering by status, date range, buyer, and amount.
+   *
+   * @param filters - Filter and pagination options
+   * @param requestOptions - Optional request configuration
+   * @returns Paginated list of invoices
+   *
+   * @example
+   * ```typescript
+   * // List all validated invoices
+   * const { data: invoices, meta } = await client.directInvoices.list({
+   *   status: 'validated',
+   *   per_page: 50
+   * });
+   *
+   * console.log(`Found ${meta.total} validated invoices`);
+   *
+   * // Filter by date range
+   * const januaryInvoices = await client.directInvoices.list({
+   *   date_from: '2026-01-01',
+   *   date_to: '2026-01-31'
+   * });
+   *
+   * // Search by buyer
+   * const acmeInvoices = await client.directInvoices.list({
+   *   search: 'Acme'
+   * });
+   * ```
+   */
+  async list(filters = {}, requestOptions) {
+    const query = {
+      ...filters,
+      status: Array.isArray(filters.status) ? filters.status.join(",") : filters.status
+    };
+    return this.http.get(
+      "/tenant/invoices",
+      query,
+      requestOptions
+    );
+  }
+  /**
+   * Get a specific direct invoice by ID
+   *
+   * @param invoiceId - Invoice UUID
+   * @param requestOptions - Optional request configuration
+   * @returns Invoice details
+   *
+   * @example
+   * ```typescript
+   * const { data: invoice } = await client.directInvoices.get('invoice-uuid');
+   *
+   * console.log('Invoice:', invoice.invoice_number);
+   * console.log('Status:', invoice.status);
+   * console.log('Total:', invoice.total_ttc, invoice.currency);
+   * ```
+   */
+  async get(invoiceId, requestOptions) {
+    return this.http.get(
+      `/tenant/invoices/${invoiceId}`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Update a direct invoice
+   *
+   * Only invoices in 'draft' status can be updated.
+   * Once validated or sent, invoices become immutable.
+   *
+   * @param invoiceId - Invoice UUID
+   * @param params - Update parameters
+   * @param requestOptions - Optional request configuration
+   * @returns Updated invoice
+   *
+   * @example
+   * ```typescript
+   * const { data: invoice } = await client.directInvoices.update(
+   *   'invoice-uuid',
+   *   {
+   *     due_date: '2026-03-15',
+   *     notes: 'Updated payment terms'
+   *   }
+   * );
+   *
+   * console.log('Invoice updated:', invoice.due_date);
+   * ```
+   */
+  async update(invoiceId, params, requestOptions) {
+    return this.http.patch(
+      `/tenant/invoices/${invoiceId}`,
+      params,
+      requestOptions
+    );
+  }
+  /**
+   * Delete a direct invoice
+   *
+   * Only invoices in 'draft' status can be deleted.
+   * Validated or sent invoices cannot be deleted for audit trail compliance.
+   *
+   * @param invoiceId - Invoice UUID
+   * @param requestOptions - Optional request configuration
+   *
+   * @example
+   * ```typescript
+   * await client.directInvoices.delete('draft-invoice-uuid');
+   * console.log('Invoice deleted successfully');
+   * ```
+   */
+  async delete(invoiceId, requestOptions) {
+    return this.http.delete(
+      `/tenant/invoices/${invoiceId}`,
+      requestOptions
+    );
+  }
+  /**
+   * Validate a direct invoice
+   *
+   * Validates the invoice, generates the electronic invoice file,
+   * and changes status from 'draft' to 'validated'.
+   *
+   * @param invoiceId - Invoice UUID
+   * @param requestOptions - Optional request configuration
+   * @returns Validated invoice
+   *
+   * @example
+   * ```typescript
+   * const { data: invoice } = await client.directInvoices.validate('invoice-uuid');
+   * console.log('Invoice validated:', invoice.status); // 'validated'
+   * console.log('Validated at:', invoice.validated_at);
+   * ```
+   */
+  async validate(invoiceId, requestOptions) {
+    return this.http.post(
+      `/tenant/invoices/${invoiceId}/validate`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Send a direct invoice to the buyer
+   *
+   * Sends the validated invoice to the buyer via email.
+   * The invoice must be in 'validated' status.
+   *
+   * @param invoiceId - Invoice UUID
+   * @param requestOptions - Optional request configuration
+   * @returns Updated invoice
+   *
+   * @example
+   * ```typescript
+   * const { data: invoice } = await client.directInvoices.send('invoice-uuid');
+   * console.log('Invoice sent to:', invoice.buyer.email);
+   * ```
+   */
+  async send(invoiceId, requestOptions) {
+    return this.http.post(
+      `/tenant/invoices/${invoiceId}/send`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Download invoice as PDF
+   *
+   * Downloads the electronic invoice file as a PDF (Factur-X).
+   *
+   * @param invoiceId - Invoice UUID
+   * @param requestOptions - Optional request configuration
+   * @returns ArrayBuffer containing the PDF file
+   *
+   * @example
+   * ```typescript
+   * // Download invoice PDF
+   * const pdfBuffer = await client.directInvoices.download('invoice-uuid');
+   *
+   * // In Node.js, save to file:
+   * import { writeFileSync } from 'fs';
+   * writeFileSync('invoice.pdf', Buffer.from(pdfBuffer));
+   *
+   * // In browser, trigger download:
+   * const blob = new Blob([pdfBuffer], { type: 'application/pdf' });
+   * const url = URL.createObjectURL(blob);
+   * const a = document.createElement('a');
+   * a.href = url;
+   * a.download = 'invoice.pdf';
+   * a.click();
+   * ```
+   */
+  async download(invoiceId, requestOptions) {
+    return this.http.getRaw(
+      `/tenant/invoices/${invoiceId}/download`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Download invoice XML
+   *
+   * Downloads the electronic invoice XML (UBL/CII format).
+   *
+   * @param invoiceId - Invoice UUID
+   * @param requestOptions - Optional request configuration
+   * @returns ArrayBuffer containing the XML file
+   *
+   * @example
+   * ```typescript
+   * const xmlBuffer = await client.directInvoices.downloadXml('invoice-uuid');
+   * const xmlString = new TextDecoder().decode(xmlBuffer);
+   * console.log('XML:', xmlString);
+   * ```
+   */
+  async downloadXml(invoiceId, requestOptions) {
+    return this.http.getRaw(
+      `/tenant/invoices/${invoiceId}/download`,
+      { format: "xml" },
+      requestOptions
+    );
+  }
+  /**
+   * Bulk create multiple invoices
+   */
+  async bulkCreate(invoices, requestOptions) {
+    return this.http.post(
+      "/tenant/invoices/bulk",
+      { invoices },
+      requestOptions
+    );
+  }
+  /**
+   * Bulk submit multiple invoices
+   */
+  async bulkSubmit(invoiceIds, requestOptions) {
+    return this.http.post(
+      "/tenant/invoices/bulk-submit",
+      { invoice_ids: invoiceIds },
+      requestOptions
+    );
+  }
+  /**
+   * Get status of multiple invoices
+   */
+  async bulkStatus(invoiceIds, requestOptions) {
+    return this.http.post(
+      "/tenant/invoices/bulk-status",
+      { invoice_ids: invoiceIds },
+      requestOptions
+    );
+  }
+};
+
+// src/resources/tenant-direct-credit-notes.ts
+var TenantDirectCreditNotesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new credit note for a direct invoice
+   *
+   * Creates a credit note (avoir) linked to a direct invoice.
+   * - For partial credit notes, specify the items and quantities to credit.
+   * - For total credit notes, all items are automatically credited.
+   *
+   * @param params - Credit note creation parameters
+   * @param requestOptions - Optional request configuration
+   * @returns Created credit note
+   *
+   * @example
+   * ```typescript
+   * // Partial credit note
+   * const { data: creditNote } = await client.directCreditNotes.create({
+   *   invoice_id: 'invoice-uuid',
+   *   reason: 'Returned items',
+   *   type: 'partial',
+   *   items: [
+   *     { invoice_line_id: 'line-1-uuid', quantity: 2 },
+   *     { invoice_line_id: 'line-2-uuid', quantity: 1 }
+   *   ]
+   * });
+   *
+   * // Total credit note (cancels entire invoice)
+   * const { data: totalCreditNote } = await client.directCreditNotes.create({
+   *   invoice_id: 'invoice-uuid',
+   *   reason: 'Invoice issued in error',
+   *   type: 'total'
+   * });
+   *
+   * console.log('Credit note number:', creditNote.credit_note_number);
+   * console.log('Amount:', creditNote.total, creditNote.currency);
+   * ```
+   */
+  async create(params, requestOptions) {
+    return this.http.post(
+      "/tenant/credit-notes",
+      params,
+      requestOptions
+    );
+  }
+  /**
+   * List all direct credit notes
+   *
+   * Returns a paginated list of credit notes for direct invoices.
+   *
+   * @param filters - Filter and pagination options
+   * @param requestOptions - Optional request configuration
+   * @returns Paginated list of credit notes
+   *
+   * @example
+   * ```typescript
+   * // List all sent credit notes
+   * const { data: creditNotes, meta } = await client.directCreditNotes.list({
+   *   status: 'sent',
+   *   per_page: 50
+   * });
+   *
+   * console.log(`Found ${meta.total} sent credit notes`);
+   *
+   * // Filter by date range
+   * const januaryCreditNotes = await client.directCreditNotes.list({
+   *   date_from: '2026-01-01',
+   *   date_to: '2026-01-31'
+   * });
+   * ```
+   */
+  async list(filters = {}, requestOptions) {
+    return this.http.get(
+      "/tenant/credit-notes",
+      filters,
+      requestOptions
+    );
+  }
+  /**
+   * Get a specific credit note by ID
+   *
+   * @param creditNoteId - Credit note UUID
+   * @param requestOptions - Optional request configuration
+   * @returns Credit note details
+   *
+   * @example
+   * ```typescript
+   * const { data: creditNote } = await client.directCreditNotes.get('credit-note-uuid');
+   *
+   * console.log('Credit note:', creditNote.credit_note_number);
+   * console.log('Status:', creditNote.status);
+   * console.log('Reason:', creditNote.reason);
+   * console.log('Total:', creditNote.total, creditNote.currency);
+   * ```
+   */
+  async get(creditNoteId, requestOptions) {
+    return this.http.get(
+      `/tenant/credit-notes/${creditNoteId}`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Update a credit note
+   *
+   * Only credit notes in 'draft' status can be updated.
+   *
+   * @param creditNoteId - Credit note UUID
+   * @param params - Update parameters
+   * @param requestOptions - Optional request configuration
+   * @returns Updated credit note
+   *
+   * @example
+   * ```typescript
+   * const { data: creditNote } = await client.directCreditNotes.update(
+   *   'credit-note-uuid',
+   *   {
+   *     reason: 'Updated reason: Customer complaint resolved',
+   *     items: [
+   *       { invoice_line_id: 'line-uuid', quantity: 3 }
+   *     ]
+   *   }
+   * );
+   * ```
+   */
+  async update(creditNoteId, params, requestOptions) {
+    return this.http.patch(
+      `/tenant/credit-notes/${creditNoteId}`,
+      params,
+      requestOptions
+    );
+  }
+  /**
+   * Delete a credit note
+   *
+   * Only credit notes in 'draft' status can be deleted.
+   *
+   * @param creditNoteId - Credit note UUID
+   * @param requestOptions - Optional request configuration
+   *
+   * @example
+   * ```typescript
+   * await client.directCreditNotes.delete('draft-credit-note-uuid');
+   * console.log('Credit note deleted');
+   * ```
+   */
+  async delete(creditNoteId, requestOptions) {
+    return this.http.delete(
+      `/tenant/credit-notes/${creditNoteId}`,
+      requestOptions
+    );
+  }
+  /**
+   * Send a credit note
+   *
+   * Validates and sends the credit note, changing status from 'draft' to 'sent'.
+   *
+   * @param creditNoteId - Credit note UUID
+   * @param requestOptions - Optional request configuration
+   * @returns Sent credit note
+   *
+   * @example
+   * ```typescript
+   * const { data: creditNote } = await client.directCreditNotes.send('credit-note-uuid');
+   * console.log('Credit note sent:', creditNote.status); // 'sent'
+   * ```
+   */
+  async send(creditNoteId, requestOptions) {
+    return this.http.post(
+      `/tenant/credit-notes/${creditNoteId}/send`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Download credit note as PDF
+   *
+   * @param creditNoteId - Credit note UUID
+   * @param requestOptions - Optional request configuration
+   * @returns ArrayBuffer containing the PDF file
+   *
+   * @example
+   * ```typescript
+   * const pdfBuffer = await client.directCreditNotes.download('credit-note-uuid');
+   *
+   * // In Node.js:
+   * import { writeFileSync } from 'fs';
+   * writeFileSync('credit-note.pdf', Buffer.from(pdfBuffer));
+   *
+   * // In browser:
+   * const blob = new Blob([pdfBuffer], { type: 'application/pdf' });
+   * const url = URL.createObjectURL(blob);
+   * window.open(url);
+   * ```
+   */
+  async download(creditNoteId, requestOptions) {
+    return this.http.getRaw(
+      `/tenant/credit-notes/${creditNoteId}/download`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Get remaining creditable amount for a direct invoice
+   *
+   * Returns information about how much can still be credited,
+   * including line-by-line breakdown.
+   *
+   * @param invoiceId - Invoice UUID
+   * @param requestOptions - Optional request configuration
+   * @returns Remaining creditable information
+   *
+   * @example
+   * ```typescript
+   * const remaining = await client.directCreditNotes.remainingCreditable('invoice-uuid');
+   *
+   * console.log('Invoice total:', remaining.invoice_total);
+   * console.log('Already credited:', remaining.credited_total);
+   * console.log('Can still credit:', remaining.remaining_total);
+   *
+   * // Check per-line
+   * remaining.lines.forEach(line => {
+   *   if (line.remaining_quantity > 0) {
+   *     console.log(`${line.description}: ${line.remaining_quantity} units remaining`);
+   *   }
+   * });
+   * ```
+   */
+  async remainingCreditable(invoiceId, requestOptions) {
+    return this.http.get(
+      `/tenant/invoices/${invoiceId}/remaining-creditable`,
+      void 0,
+      requestOptions
+    );
+  }
+};
+
+// src/resources/tenant-incoming-invoices.ts
+var TenantIncomingInvoicesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new incoming invoice for a sub-tenant
+   *
+   * Creates a purchase invoice received by a sub-tenant from an external supplier.
+   * The seller's SIREN is validated using the Luhn algorithm.
+   *
+   * @param subTenantId - Sub-tenant UUID
+   * @param params - Invoice creation parameters
+   * @param requestOptions - Optional request configuration
+   * @returns Created invoice
+   *
+   * @example
+   * ```typescript
+   * const { data: invoice } = await client.incomingInvoices.create(
+   *   'sub-tenant-uuid',
+   *   {
+   *     invoice_number: 'SUPP-2026-001',
+   *     company_id: 'company-uuid',
+   *     seller: {
+   *       company_name: 'Acme Supplies',
+   *       siren: '123456789',
+   *       siret: '12345678901234',
+   *       vat_number: 'FR12123456789',
+   *       address: {
+   *         line1: '123 Industrial Park',
+   *         postal_code: '31000',
+   *         city: 'Toulouse',
+   *         country: 'FR'
+   *       },
+   *       email: 'billing@acme-supplies.com'
+   *     },
+   *     lines: [
+   *       {
+   *         description: 'Widget A - Bulk order',
+   *         quantity: 500,
+   *         unit_price: 2.50,
+   *         tax_rate: 20,
+   *         total_ht: 1250,
+   *         total_tax: 250,
+   *         total_ttc: 1500
+   *       }
+   *     ],
+   *     issue_date: '2026-01-15',
+   *     due_date: '2026-02-15',
+   *     total_ht: 1250,
+   *     total_ttc: 1500
+   *   }
+   * );
+   *
+   * console.log('Incoming invoice created:', invoice.invoice_number);
+   * ```
+   */
+  async create(subTenantId, params, requestOptions) {
+    return this.http.post(
+      `/tenant/sub-tenants/${subTenantId}/incoming-invoices`,
+      params,
+      requestOptions
+    );
+  }
+  /**
+   * List incoming invoices for a sub-tenant
+   *
+   * Returns a paginated list of purchase invoices received by the sub-tenant.
+   *
+   * @param subTenantId - Sub-tenant UUID
+   * @param filters - Filter and pagination options
+   * @param requestOptions - Optional request configuration
+   * @returns Paginated list of invoices
+   *
+   * @example
+   * ```typescript
+   * // List all pending invoices
+   * const { data: invoices, meta } = await client.incomingInvoices.listForSubTenant(
+   *   'sub-tenant-uuid',
+   *   { status: 'pending', per_page: 50 }
+   * );
+   *
+   * console.log(`Found ${meta.total} pending invoices to review`);
+   *
+   * // Filter by supplier
+   * const acmeInvoices = await client.incomingInvoices.listForSubTenant(
+   *   'sub-tenant-uuid',
+   *   { seller_siret: '12345678901234' }
+   * );
+   * ```
+   */
+  async listForSubTenant(subTenantId, filters = {}, requestOptions) {
+    const query = {
+      ...filters,
+      status: Array.isArray(filters.status) ? filters.status.join(",") : filters.status
+    };
+    return this.http.get(
+      `/tenant/sub-tenants/${subTenantId}/incoming-invoices`,
+      query,
+      requestOptions
+    );
+  }
+  /**
+   * Get a specific incoming invoice by ID
+   *
+   * @param invoiceId - Invoice UUID
+   * @param requestOptions - Optional request configuration
+   * @returns Invoice details
+   *
+   * @example
+   * ```typescript
+   * const { data: invoice } = await client.incomingInvoices.get('invoice-uuid');
+   *
+   * console.log('Invoice from:', invoice.seller.name);
+   * console.log('Status:', invoice.status);
+   * console.log('Amount:', invoice.total_ttc, invoice.currency);
+   * ```
+   */
+  async get(invoiceId, requestOptions) {
+    return this.http.get(
+      `/tenant/incoming-invoices/${invoiceId}`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Accept an incoming invoice
+   *
+   * Marks the invoice as accepted, indicating approval for payment.
+   * Optionally specify an expected payment date.
+   *
+   * @param invoiceId - Invoice UUID
+   * @param input - Optional acceptance details
+   * @param requestOptions - Optional request configuration
+   * @returns Updated invoice
+   *
+   * @example
+   * ```typescript
+   * // Accept with payment date
+   * const { data: invoice } = await client.incomingInvoices.accept(
+   *   'invoice-uuid',
+   *   {
+   *     payment_date: '2026-02-15',
+   *     note: 'Approved by CFO'
+   *   }
+   * );
+   *
+   * console.log('Invoice accepted:', invoice.status); // 'accepted'
+   *
+   * // Simple acceptance
+   * await client.incomingInvoices.accept('invoice-uuid');
+   * ```
+   */
+  async accept(invoiceId, input, requestOptions) {
+    return this.http.post(
+      `/tenant/incoming-invoices/${invoiceId}/accept`,
+      input,
+      requestOptions
+    );
+  }
+  /**
+   * Reject an incoming invoice
+   *
+   * Marks the invoice as rejected with a reason and optional code.
+   *
+   * @param invoiceId - Invoice UUID
+   * @param reason - Reason for rejection
+   * @param code - Optional standardized rejection code
+   * @param requestOptions - Optional request configuration
+   * @returns Updated invoice
+   *
+   * @example
+   * ```typescript
+   * const { data: invoice } = await client.incomingInvoices.reject(
+   *   'invoice-uuid',
+   *   'Amount does not match purchase order PO-2026-042',
+   *   'incorrect_amount'
+   * );
+   *
+   * console.log('Invoice rejected:', invoice.status); // 'rejected'
+   * ```
+   */
+  async reject(invoiceId, reason, code, requestOptions) {
+    const input = { reason };
+    if (code) {
+      input.reason_code = code;
+    }
+    return this.http.post(
+      `/tenant/incoming-invoices/${invoiceId}/reject`,
+      input,
+      requestOptions
+    );
+  }
+  /**
+   * Mark an incoming invoice as paid
+   *
+   * Records payment information for an accepted invoice.
+   * This is a mandatory step in the French e-invoicing lifecycle.
+   *
+   * @param invoiceId - Invoice UUID
+   * @param input - Optional payment details
+   * @param requestOptions - Optional request configuration
+   * @returns Updated invoice with payment information
+   *
+   * @example
+   * ```typescript
+   * // Mark as paid with details
+   * const { data: invoice } = await client.incomingInvoices.markPaid(
+   *   'invoice-uuid',
+   *   {
+   *     payment_reference: 'VIR-2026-0150',
+   *     paid_at: '2026-02-14T14:30:00Z',
+   *     note: 'Payment via bank transfer'
+   *   }
+   * );
+   *
+   * console.log('Invoice paid:', invoice.status); // 'paid'
+   * console.log('Payment ref:', invoice.payment_reference);
+   *
+   * // Simple mark as paid (current date)
+   * await client.incomingInvoices.markPaid('invoice-uuid');
+   * ```
+   */
+  async markPaid(invoiceId, input, requestOptions) {
+    return this.http.post(
+      `/tenant/incoming-invoices/${invoiceId}/mark-paid`,
+      input,
+      requestOptions
+    );
+  }
+  /**
+   * Delete an incoming invoice
+   *
+   * Only invoices in 'pending' status can be deleted.
+   *
+   * @param invoiceId - Invoice UUID
+   * @param requestOptions - Optional request configuration
+   *
+   * @example
+   * ```typescript
+   * await client.incomingInvoices.delete('pending-invoice-uuid');
+   * console.log('Incoming invoice deleted');
+   * ```
+   */
+  async delete(invoiceId, requestOptions) {
+    return this.http.delete(
+      `/tenant/incoming-invoices/${invoiceId}`,
+      requestOptions
+    );
+  }
+  /**
+   * Download incoming invoice as PDF
+   *
+   * @param invoiceId - Invoice UUID
+   * @param requestOptions - Optional request configuration
+   * @returns ArrayBuffer containing the PDF file
+   *
+   * @example
+   * ```typescript
+   * const pdfBuffer = await client.incomingInvoices.download('invoice-uuid');
+   *
+   * // Save to file (Node.js)
+   * import { writeFileSync } from 'fs';
+   * writeFileSync('supplier-invoice.pdf', Buffer.from(pdfBuffer));
+   * ```
+   */
+  async download(invoiceId, requestOptions) {
+    return this.http.getRaw(
+      `/tenant/incoming-invoices/${invoiceId}/download`,
+      void 0,
+      requestOptions
+    );
+  }
+};
+
+// src/resources/tenant-credit-notes.ts
+var TenantCreditNotesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List credit notes for a sub-tenant
+   *
+   * @param subTenantId - Sub-tenant UUID
+   * @param options - Filter and pagination options
+   * @param requestOptions - Request options
+   * @returns Paginated list of credit notes
+   *
+   * @example
+   * ```typescript
+   * const { data, meta } = await client.tenantCreditNotes.list('sub-tenant-uuid', {
+   *   status: 'sent',
+   *   date_from: '2024-01-01',
+   *   per_page: 50
+   * });
+   * console.log(`Found ${meta.total} credit notes`);
+   * ```
+   */
+  async list(subTenantId, options = {}, requestOptions) {
+    return this.http.get(
+      `/tenant/sub-tenants/${subTenantId}/credit-notes`,
+      options,
+      requestOptions
+    );
+  }
+  /**
+   * Create a new credit note for a sub-tenant invoice
+   *
+   * @param subTenantId - Sub-tenant UUID
+   * @param input - Credit note creation data
+   * @param requestOptions - Request options
+   * @returns Created credit note
+   *
+   * @example
+   * ```typescript
+   * // Create a partial credit note
+   * const { data: creditNote } = await client.tenantCreditNotes.create(
+   *   'sub-tenant-uuid',
+   *   {
+   *     invoice_id: 'invoice-uuid',
+   *     reason: 'Product returned - damaged item',
+   *     type: 'partial',
+   *     items: [
+   *       { invoice_line_id: 'line-uuid-1', quantity: 2 }
+   *     ]
+   *   }
+   * );
+   *
+   * // Create a total credit note
+   * const { data: totalCreditNote } = await client.tenantCreditNotes.create(
+   *   'sub-tenant-uuid',
+   *   {
+   *     invoice_id: 'invoice-uuid',
+   *     reason: 'Order cancelled',
+   *     type: 'total'
+   *   }
+   * );
+   * ```
+   */
+  async create(subTenantId, input, requestOptions) {
+    return this.http.post(
+      `/tenant/sub-tenants/${subTenantId}/credit-notes`,
+      input,
+      requestOptions
+    );
+  }
+  /**
+   * Get a specific credit note by ID
+   *
+   * @param creditNoteId - Credit note UUID
+   * @param requestOptions - Request options
+   * @returns Credit note details
+   *
+   * @example
+   * ```typescript
+   * const { data: creditNote } = await client.tenantCreditNotes.get('credit-note-uuid');
+   * console.log('Credit note number:', creditNote.credit_note_number);
+   * console.log('Total:', creditNote.total, creditNote.currency);
+   * ```
+   */
+  async get(creditNoteId, requestOptions) {
+    return this.http.get(
+      `/tenant/credit-notes/${creditNoteId}`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Update a credit note
+   *
+   * Only credit notes in 'draft' status can be updated.
+   *
+   * @param creditNoteId - Credit note UUID
+   * @param input - Update data
+   * @param requestOptions - Request options
+   * @returns Updated credit note
+   *
+   * @example
+   * ```typescript
+   * const { data: creditNote } = await client.tenantCreditNotes.update(
+   *   'credit-note-uuid',
+   *   {
+   *     reason: 'Updated reason: Customer complaint resolved',
+   *     items: [
+   *       { invoice_line_id: 'line-uuid', quantity: 3 }
+   *     ]
+   *   }
+   * );
+   * console.log('Credit note updated:', creditNote.reason);
+   * ```
+   */
+  async update(creditNoteId, input, requestOptions) {
+    return this.http.patch(
+      `/tenant/credit-notes/${creditNoteId}`,
+      input,
+      requestOptions
+    );
+  }
+  /**
+   * Send a credit note
+   *
+   * Changes the status from 'draft' to 'sent'.
+   *
+   * @param creditNoteId - Credit note UUID
+   * @param requestOptions - Request options
+   * @returns Updated credit note
+   *
+   * @example
+   * ```typescript
+   * const { data: sentCreditNote } = await client.tenantCreditNotes.send('credit-note-uuid');
+   * console.log('Status:', sentCreditNote.status); // 'sent'
+   * ```
+   */
+  async send(creditNoteId, requestOptions) {
+    return this.http.post(
+      `/tenant/credit-notes/${creditNoteId}/send`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Delete a credit note (draft only)
+   *
+   * Only credit notes with status 'draft' can be deleted.
+   *
+   * @param creditNoteId - Credit note UUID
+   * @param requestOptions - Request options
+   *
+   * @example
+   * ```typescript
+   * await client.tenantCreditNotes.delete('credit-note-uuid');
+   * ```
+   */
+  async delete(creditNoteId, requestOptions) {
+    return this.http.delete(
+      `/tenant/credit-notes/${creditNoteId}`,
+      requestOptions
+    );
+  }
+  /**
+   * Download credit note as PDF
+   *
+   * @param creditNoteId - Credit note UUID
+   * @param requestOptions - Request options
+   * @returns ArrayBuffer containing the PDF file
+   *
+   * @example
+   * ```typescript
+   * // Download credit note PDF
+   * const pdfBuffer = await client.tenantCreditNotes.download('credit-note-uuid');
+   *
+   * // In Node.js, save to file:
+   * import { writeFileSync } from 'fs';
+   * writeFileSync('credit-note.pdf', Buffer.from(pdfBuffer));
+   *
+   * // In browser, trigger download:
+   * const blob = new Blob([pdfBuffer], { type: 'application/pdf' });
+   * const url = URL.createObjectURL(blob);
+   * const a = document.createElement('a');
+   * a.href = url;
+   * a.download = 'credit-note.pdf';
+   * a.click();
+   * ```
+   */
+  async download(creditNoteId, requestOptions) {
+    return this.http.getRaw(
+      `/tenant/credit-notes/${creditNoteId}/download`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Get remaining creditable amount for an invoice
+   *
+   * Returns information about how much can still be credited for an invoice,
+   * including per-line breakdown.
+   *
+   * @param invoiceId - Invoice UUID
+   * @param requestOptions - Request options
+   * @returns Remaining creditable information
+   *
+   * @example
+   * ```typescript
+   * const remaining = await client.tenantCreditNotes.remainingCreditable('invoice-uuid');
+   *
+   * console.log('Invoice total:', remaining.invoice_total);
+   * console.log('Already credited:', remaining.credited_total);
+   * console.log('Remaining to credit:', remaining.remaining_total);
+   *
+   * // Check remaining quantity per line
+   * remaining.lines.forEach(line => {
+   *   console.log(`${line.description}: ${line.remaining_quantity} remaining`);
+   * });
+   * ```
+   */
+  async remainingCreditable(invoiceId, requestOptions) {
+    return this.http.get(
+      `/tenant/invoices/${invoiceId}/remaining-creditable`,
+      void 0,
+      requestOptions
+    );
+  }
+};
+
+// src/resources/fiscal.ts
+var FiscalResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async compliance(requestOptions) {
+    return this.http.get("/tenant/fiscal/compliance", void 0, requestOptions);
+  }
+  async integrity(options = {}, requestOptions) {
+    return this.http.get("/tenant/fiscal/integrity", options, requestOptions);
+  }
+  async integrityHistory(options = {}, requestOptions) {
+    return this.http.get("/tenant/fiscal/integrity/history", options, requestOptions);
+  }
+  async integrityForDate(date, requestOptions) {
+    return this.http.get(`/tenant/fiscal/integrity/${date}`, void 0, requestOptions);
+  }
+  async closings(options = {}, requestOptions) {
+    return this.http.get("/tenant/fiscal/closings", options, requestOptions);
+  }
+  async performDailyClosing(input = {}, requestOptions) {
+    return this.http.post("/tenant/fiscal/closings/daily", input, requestOptions);
+  }
+  async fecExport(options, requestOptions) {
+    return this.http.get("/tenant/fiscal/fec", options, requestOptions);
+  }
+  async fecDownload(options, requestOptions) {
+    return this.http.getRaw("/tenant/fiscal/fec", { ...options, download: true }, requestOptions);
+  }
+  async attestation(year, requestOptions) {
+    return this.http.get(`/tenant/fiscal/attestation/${year}`, void 0, requestOptions);
+  }
+  async attestationDownload(year, requestOptions) {
+    return this.http.getRaw(`/tenant/fiscal/attestation/${year}/download`, void 0, requestOptions);
+  }
+  async entries(options = {}, requestOptions) {
+    return this.http.get("/tenant/fiscal/entries", options, requestOptions);
+  }
+  async killSwitchStatus(requestOptions) {
+    return this.http.get("/tenant/fiscal/kill-switch/status", void 0, requestOptions);
+  }
+  async killSwitchActivate(input, requestOptions) {
+    return this.http.post("/tenant/fiscal/kill-switch/activate", input, requestOptions);
+  }
+  async killSwitchDeactivate(requestOptions) {
+    return this.http.post("/tenant/fiscal/kill-switch/deactivate", void 0, requestOptions);
+  }
+  async anchors(options = {}, requestOptions) {
+    return this.http.get("/tenant/fiscal/anchors", options, requestOptions);
+  }
+  async rules(options = {}, requestOptions) {
+    return this.http.get("/tenant/fiscal/rules", options, requestOptions);
+  }
+  async ruleDetail(key, requestOptions) {
+    return this.http.get(`/tenant/fiscal/rules/${key}`, void 0, requestOptions);
+  }
+  async ruleHistory(key, requestOptions) {
+    return this.http.get(`/tenant/fiscal/rules/${key}/history`, void 0, requestOptions);
+  }
+  async createRule(input, requestOptions) {
+    return this.http.post("/tenant/fiscal/rules", input, requestOptions);
+  }
+  async updateRule(id, input, requestOptions) {
+    return this.http.post(`/tenant/fiscal/rules/${id}`, input, requestOptions);
+  }
+  async exportRules(options, requestOptions) {
+    return this.http.get("/tenant/fiscal/rules/export", options, requestOptions);
+  }
+  async replayRules(input, requestOptions) {
+    return this.http.post("/tenant/fiscal/rules/replay", input, requestOptions);
+  }
+  async forensicExport(options, requestOptions) {
+    return this.http.get("/tenant/fiscal/forensic-export", options, requestOptions);
+  }
+};
+
+// src/resources/billing.ts
+var BillingResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async invoices(options = {}, requestOptions) {
+    return this.http.get("/tenant/billing/invoices", options, requestOptions);
+  }
+  async showInvoice(invoiceId, requestOptions) {
+    return this.http.get(`/tenant/billing/invoices/${invoiceId}`, void 0, requestOptions);
+  }
+  async downloadInvoice(invoiceId, requestOptions) {
+    return this.http.getRaw(`/tenant/billing/invoices/${invoiceId}/download`, void 0, requestOptions);
+  }
+  async usage(options = {}, requestOptions) {
+    return this.http.get("/tenant/billing/usage", options, requestOptions);
+  }
+  async topUp(input, requestOptions) {
+    return this.http.post("/tenant/billing/top-up", input, requestOptions);
+  }
+  async confirmTopUp(input, requestOptions) {
+    return this.http.post("/tenant/billing/top-up/confirm", input, requestOptions);
+  }
+  async transactions(options = {}, requestOptions) {
+    return this.http.get("/tenant/billing/transactions", options, requestOptions);
+  }
+};
+
+// src/resources/stats.ts
+var StatsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async overview(options = {}, requestOptions) {
+    return this.http.get("/tenant/stats/overview", options, requestOptions);
+  }
+  async monthly(options = {}, requestOptions) {
+    return this.http.get("/tenant/stats/monthly", options, requestOptions);
+  }
+  async subTenantOverview(subTenantId, options = {}, requestOptions) {
+    return this.http.get(`/tenant/sub-tenants/${subTenantId}/stats/overview`, options, requestOptions);
+  }
+};
+
+// src/resources/sub-tenants.ts
+var SubTenantsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(options = {}, requestOptions) {
+    return this.http.get("/tenant/sub-tenants", options, requestOptions);
+  }
+  async create(input, requestOptions) {
+    return this.http.post("/tenant/sub-tenants", input, requestOptions);
+  }
+  async get(id, requestOptions) {
+    return this.http.get(`/tenant/sub-tenants/${id}`, void 0, requestOptions);
+  }
+  async update(id, input, requestOptions) {
+    return this.http.patch(`/tenant/sub-tenants/${id}`, input, requestOptions);
+  }
+  async delete(id, requestOptions) {
+    return this.http.delete(`/tenant/sub-tenants/${id}`, requestOptions);
+  }
+  async findByExternalId(externalId, requestOptions) {
+    return this.http.get(`/tenant/sub-tenants/by-external-id/${externalId}`, void 0, requestOptions);
+  }
+};
+
+// src/tenant-client.ts
+var ScellTenantClient = class {
+  http;
+  /** Direct invoices resource */
+  directInvoices;
+  /** Direct credit notes resource */
+  directCreditNotes;
+  /** Incoming invoices resource */
+  incomingInvoices;
+  /** Sub-tenant credit notes resource */
+  subTenantCreditNotes;
+  /** Fiscal compliance resource (LF 2026) */
+  fiscal;
+  /** Billing resource */
+  billing;
+  /** Stats resource */
+  stats;
+  /** Sub-tenants resource */
+  subTenants;
+  /**
+   * Create a new Scell Tenant Client
+   *
+   * @param tenantKey - Your tenant API key (from dashboard)
+   * @param config - Optional client configuration
+   */
+  constructor(tenantKey, config = {}) {
+    this.http = new HttpClient("tenant-key", tenantKey, config);
+    this.directInvoices = new TenantDirectInvoicesResource(this.http);
+    this.directCreditNotes = new TenantDirectCreditNotesResource(this.http);
+    this.incomingInvoices = new TenantIncomingInvoicesResource(this.http);
+    this.subTenantCreditNotes = new TenantCreditNotesResource(this.http);
+    this.fiscal = new FiscalResource(this.http);
+    this.billing = new BillingResource(this.http);
+    this.stats = new StatsResource(this.http);
+    this.subTenants = new SubTenantsResource(this.http);
+  }
+  // ── Tenant Profile Methods ──────────────────────────────
+  /** Get tenant profile */
+  async me(requestOptions) {
+    return this.http.get("/tenant/me", void 0, requestOptions);
+  }
+  /** Update tenant profile */
+  async updateProfile(input, requestOptions) {
+    return this.http.post("/tenant/me", input, requestOptions);
+  }
+  /** Get tenant balance */
+  async balance(requestOptions) {
+    return this.http.get("/tenant/balance", void 0, requestOptions);
+  }
+  /** Get quick stats */
+  async quickStats(requestOptions) {
+    return this.http.get("/tenant/stats", void 0, requestOptions);
+  }
+  /** Regenerate tenant key */
+  async regenerateKey(requestOptions) {
+    return this.http.post("/tenant/regenerate-key", void 0, requestOptions);
+  }
 };
 
 // src/resources/api-keys.ts
@@ -1137,6 +2448,188 @@ var InvoicesResource = class {
   async convert(input, requestOptions) {
     return this.http.post("/invoices/convert", input, requestOptions);
   }
+  /**
+   * List incoming invoices (from suppliers)
+   *
+   * Returns invoices where your company is the buyer.
+   *
+   * @param params - Filter and pagination options
+   * @param requestOptions - Request options
+   * @returns Paginated list of incoming invoices
+   *
+   * @example
+   * ```typescript
+   * // List all incoming invoices
+   * const { data, meta } = await client.invoices.incoming({
+   *   status: 'pending',
+   *   per_page: 50
+   * });
+   * console.log(`Found ${meta.total} incoming invoices`);
+   *
+   * // Filter by seller
+   * const fromSupplier = await client.invoices.incoming({
+   *   seller_siret: '12345678901234'
+   * });
+   * ```
+   */
+  async incoming(params = {}, requestOptions) {
+    return this.http.get(
+      "/invoices/incoming",
+      params,
+      requestOptions
+    );
+  }
+  /**
+   * Accept an incoming invoice
+   *
+   * Mark an incoming invoice as accepted, optionally specifying a payment date.
+   *
+   * @param id - Invoice UUID
+   * @param data - Optional acceptance data
+   * @param requestOptions - Request options
+   * @returns Updated invoice
+   *
+   * @example
+   * ```typescript
+   * // Accept with payment date
+   * const { data: invoice } = await client.invoices.accept('invoice-uuid', {
+   *   payment_date: '2024-02-15',
+   *   note: 'Approved by accounting'
+   * });
+   *
+   * // Simple acceptance
+   * await client.invoices.accept('invoice-uuid');
+   * ```
+   */
+  async accept(id, data, requestOptions) {
+    return this.http.post(
+      `/invoices/${id}/accept`,
+      data,
+      requestOptions
+    );
+  }
+  /**
+   * Reject an incoming invoice
+   *
+   * Mark an incoming invoice as rejected with a reason.
+   *
+   * @param id - Invoice UUID
+   * @param data - Rejection details
+   * @param requestOptions - Request options
+   * @returns Updated invoice
+   *
+   * @example
+   * ```typescript
+   * const { data: invoice } = await client.invoices.reject('invoice-uuid', {
+   *   reason: 'Invoice amount does not match purchase order',
+   *   reason_code: 'incorrect_amount'
+   * });
+   * ```
+   */
+  async reject(id, data, requestOptions) {
+    return this.http.post(
+      `/invoices/${id}/reject`,
+      data,
+      requestOptions
+    );
+  }
+  /**
+   * Dispute an incoming invoice
+   *
+   * Open a dispute on an incoming invoice for resolution.
+   *
+   * @param id - Invoice UUID
+   * @param data - Dispute details
+   * @param requestOptions - Request options
+   * @returns Updated invoice
+   *
+   * @example
+   * ```typescript
+   * const { data: invoice } = await client.invoices.dispute('invoice-uuid', {
+   *   reason: 'Billed amount exceeds agreed price',
+   *   dispute_type: 'amount_dispute',
+   *   expected_amount: 950.00
+   * });
+   * ```
+   */
+  async dispute(id, data, requestOptions) {
+    return this.http.post(
+      `/invoices/${id}/dispute`,
+      data,
+      requestOptions
+    );
+  }
+  /**
+   * Mark an incoming invoice as paid
+   *
+   * This is a mandatory step in the French e-invoicing lifecycle for incoming invoices.
+   * Once marked as paid, the invoice status changes to 'paid' and payment details are recorded.
+   *
+   * @param id - Invoice UUID
+   * @param data - Optional payment details (reference, date, note)
+   * @param requestOptions - Request options
+   * @returns Updated invoice with payment information
+   *
+   * @example
+   * ```typescript
+   * // Mark as paid with payment details
+   * const { data: invoice } = await client.invoices.markPaid('invoice-uuid', {
+   *   payment_reference: 'VIR-2026-0124',
+   *   paid_at: '2026-01-24T10:30:00Z',
+   *   note: 'Payment received via bank transfer'
+   * });
+   *
+   * // Simple mark as paid (uses current date/time)
+   * await client.invoices.markPaid('invoice-uuid');
+   * ```
+   */
+  async markPaid(id, data, requestOptions) {
+    return this.http.post(
+      `/invoices/${id}/mark-paid`,
+      data,
+      requestOptions
+    );
+  }
+  /**
+   * Download invoice source file as binary content
+   *
+   * Downloads the original invoice file (PDF with embedded XML for Factur-X,
+   * or standalone XML for UBL/CII formats).
+   *
+   * @param id - Invoice UUID
+   * @param format - File format to download: 'pdf' (default) or 'xml'
+   * @param requestOptions - Request options
+   * @returns ArrayBuffer containing the file content
+   *
+   * @example
+   * ```typescript
+   * // Download invoice as PDF (Factur-X)
+   * const pdfBuffer = await client.invoices.downloadFile('invoice-uuid');
+   *
+   * // In Node.js, save to file:
+   * import { writeFileSync } from 'fs';
+   * writeFileSync('invoice.pdf', Buffer.from(pdfBuffer));
+   *
+   * // Download XML version (UBL/CII)
+   * const xmlBuffer = await client.invoices.downloadFile('invoice-uuid', 'xml');
+   * writeFileSync('invoice.xml', Buffer.from(xmlBuffer));
+   *
+   * // In browser, trigger download:
+   * const blob = new Blob([pdfBuffer], { type: 'application/pdf' });
+   * const url = URL.createObjectURL(blob);
+   * const a = document.createElement('a');
+   * a.href = url;
+   * a.download = 'invoice.pdf';
+   * a.click();
+   * ```
+   */
+  async downloadFile(id, format = "pdf", requestOptions) {
+    return this.http.getRaw(
+      `/invoices/${id}/download`,
+      { format },
+      requestOptions
+    );
+  }
 };
 
 // src/resources/signatures.ts
@@ -1721,6 +3214,8 @@ var ScellApiClient = class {
   invoices;
   /** Signature operations (create, download, remind, cancel) */
   signatures;
+  /** Tenant credit notes operations (create, send, download) */
+  tenantCreditNotes;
   /**
    * Create a new Scell API Client
    *
@@ -1742,12 +3237,14 @@ var ScellApiClient = class {
     this.http = new HttpClient("api-key", apiKey, config);
     this.invoices = new InvoicesResource(this.http);
     this.signatures = new SignaturesResource(this.http);
+    this.tenantCreditNotes = new TenantCreditNotesResource(this.http);
   }
 };
 
 exports.ScellApiClient = ScellApiClient;
 exports.ScellAuth = ScellAuth;
 exports.ScellClient = ScellClient;
+exports.ScellTenantClient = ScellTenantClient;
 exports.ScellWebhooks = ScellWebhooks;
 exports.createRetryWrapper = createRetryWrapper;
 exports.withRetry = withRetry;