@scell/sdk 1.0.0 → 1.2.0

package/dist/index.mjs

@@ -401,6 +401,60 @@ 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 ScellTimeoutError(
+            `Request timed out after ${requestTimeout}ms`
+          );
+        }
+        if (error.name === "TypeError" && error.message.includes("fetch")) {
+          throw new ScellNetworkError("Network request failed", error);
+        }
+      }
+      throw error;
+    }
+  }
 };
 
 // src/resources/api-keys.ts
@@ -1135,6 +1189,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