@scell/sdk 1.2.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scell/sdk",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Official TypeScript SDK for Scell.io - Electronic invoicing (Factur-X) and signatures (eIDAS) API",
   "author": "Scell.io <contact@scell.io>",
   "license": "MIT",

package/src/client.ts

@@ -14,7 +14,7 @@ import { withRetry, type RetryOptions } from './utils/retry.js';
 /**
  * Authentication mode
  */
-export type AuthMode = 'bearer' | 'api-key';
+export type AuthMode = 'bearer' | 'api-key' | 'tenant-key';
 
 /**
  * Client configuration options
@@ -116,6 +116,8 @@ export class HttpClient {
 
     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;
     }

package/src/index.ts

@@ -5,7 +5,7 @@
  *
  * @example
  * ```typescript
- * import { ScellClient, ScellApiClient, ScellAuth, ScellWebhooks } from '@scell/sdk';
+ * import { ScellClient, ScellApiClient, ScellTenantClient, ScellAuth, ScellWebhooks } from '@scell/sdk';
  *
  * // Dashboard client (Bearer token)
  * const auth = await ScellAuth.login({ email, password });
@@ -14,9 +14,15 @@
  * // API client (X-API-Key)
  * const apiClient = new ScellApiClient('your-api-key');
  *
+ * // Tenant client (X-Tenant-Key) - for multi-tenant operations
+ * const tenantClient = new ScellTenantClient('your-tenant-key');
+ *
  * // Create invoice
  * const invoice = await apiClient.invoices.create({...});
  *
+ * // Create direct invoice (tenant)
+ * const directInvoice = await tenantClient.directInvoices.create({...});
+ *
  * // Verify webhook
  * const isValid = await ScellWebhooks.verifySignature(payload, signature, secret);
  * ```
@@ -25,6 +31,9 @@
 // Client
 import { HttpClient, type ClientConfig } from './client.js';
 
+// Tenant Client
+import { ScellTenantClient } from './tenant-client.js';
+
 // Resources
 import { ApiKeysResource } from './resources/api-keys.js';
 import { AuthResource, ScellAuth } from './resources/auth.js';
@@ -32,6 +41,7 @@ import { BalanceResource } from './resources/balance.js';
 import { CompaniesResource } from './resources/companies.js';
 import { InvoicesResource } from './resources/invoices.js';
 import { SignaturesResource } from './resources/signatures.js';
+import { TenantCreditNotesResource } from './resources/tenant-credit-notes.js';
 import { WebhooksResource } from './resources/webhooks.js';
 
 // Utilities
@@ -143,6 +153,8 @@ export class ScellApiClient {
   public readonly invoices: InvoicesResource;
   /** Signature operations (create, download, remind, cancel) */
   public readonly signatures: SignaturesResource;
+  /** Tenant credit notes operations (create, send, download) */
+  public readonly tenantCreditNotes: TenantCreditNotesResource;
 
   /**
    * Create a new Scell API Client
@@ -166,12 +178,16 @@ export class ScellApiClient {
 
     this.invoices = new InvoicesResource(this.http);
     this.signatures = new SignaturesResource(this.http);
+    this.tenantCreditNotes = new TenantCreditNotesResource(this.http);
   }
 }
 
 // Re-export utilities
 export { ScellAuth, ScellWebhooks, withRetry, createRetryWrapper };
 
+// Re-export tenant client
+export { ScellTenantClient };
+
 // Re-export types
 export type { ClientConfig } from './client.js';
 export type { RetryOptions } from './utils/retry.js';

package/src/resources/billing.ts

@@ -0,0 +1,49 @@
+/**
+ * Billing Resource
+ * @packageDocumentation
+ */
+
+import type { HttpClient, RequestOptions } from '../client.js';
+import type { MessageResponse, PaginatedResponse, SingleResponse } from '../types/common.js';
+import type {
+  BillingInvoice,
+  BillingInvoiceListOptions,
+  BillingTopUpConfirmInput,
+  BillingTopUpInput,
+  BillingTransaction,
+  BillingTransactionListOptions,
+  BillingUsage,
+  BillingUsageOptions,
+} from '../types/billing.js';
+
+export class BillingResource {
+  constructor(private readonly http: HttpClient) {}
+
+  async invoices(options: BillingInvoiceListOptions = {}, requestOptions?: RequestOptions): Promise<PaginatedResponse<BillingInvoice>> {
+    return this.http.get<PaginatedResponse<BillingInvoice>>('/tenant/billing/invoices', options as Record<string, string | number | boolean | undefined>, requestOptions);
+  }
+
+  async showInvoice(invoiceId: string, requestOptions?: RequestOptions): Promise<SingleResponse<BillingInvoice>> {
+    return this.http.get<SingleResponse<BillingInvoice>>(`/tenant/billing/invoices/${invoiceId}`, undefined, requestOptions);
+  }
+
+  async downloadInvoice(invoiceId: string, requestOptions?: RequestOptions): Promise<ArrayBuffer> {
+    return this.http.getRaw(`/tenant/billing/invoices/${invoiceId}/download`, undefined, requestOptions);
+  }
+
+  async usage(options: BillingUsageOptions = {}, requestOptions?: RequestOptions): Promise<SingleResponse<BillingUsage>> {
+    return this.http.get<SingleResponse<BillingUsage>>('/tenant/billing/usage', options as Record<string, string | number | boolean | undefined>, requestOptions);
+  }
+
+  async topUp(input: BillingTopUpInput, requestOptions?: RequestOptions): Promise<MessageResponse> {
+    return this.http.post<MessageResponse>('/tenant/billing/top-up', input, requestOptions);
+  }
+
+  async confirmTopUp(input: BillingTopUpConfirmInput, requestOptions?: RequestOptions): Promise<MessageResponse> {
+    return this.http.post<MessageResponse>('/tenant/billing/top-up/confirm', input, requestOptions);
+  }
+
+  async transactions(options: BillingTransactionListOptions = {}, requestOptions?: RequestOptions): Promise<PaginatedResponse<BillingTransaction>> {
+    return this.http.get<PaginatedResponse<BillingTransaction>>('/tenant/billing/transactions', options as Record<string, string | number | boolean | undefined>, requestOptions);
+  }
+}

package/src/resources/fiscal.ts

@@ -0,0 +1,128 @@
+/**
+ * Fiscal Compliance Resource
+ * @packageDocumentation
+ */
+
+import type { HttpClient, RequestOptions } from '../client.js';
+import type { MessageResponse, PaginatedResponse, SingleResponse } from '../types/common.js';
+import type {
+  FiscalAnchor,
+  FiscalAnchorsOptions,
+  FiscalAttestation,
+  FiscalClosing,
+  FiscalClosingsOptions,
+  FiscalComplianceData,
+  FiscalCreateRuleInput,
+  FiscalDailyClosingInput,
+  FiscalEntriesOptions,
+  FiscalEntry,
+  FiscalExportRulesOptions,
+  FiscalFecExportOptions,
+  FiscalFecExportResult,
+  FiscalForensicExportOptions,
+  FiscalIntegrityHistoryOptions,
+  FiscalIntegrityOptions,
+  FiscalIntegrityReport,
+  FiscalKillSwitchActivateInput,
+  FiscalKillSwitchStatus,
+  FiscalReplayRulesInput,
+  FiscalRule,
+  FiscalRulesOptions,
+  FiscalUpdateRuleInput,
+} from '../types/fiscal.js';
+
+export class FiscalResource {
+  constructor(private readonly http: HttpClient) {}
+
+  async compliance(requestOptions?: RequestOptions): Promise<SingleResponse<FiscalComplianceData>> {
+    return this.http.get<SingleResponse<FiscalComplianceData>>('/tenant/fiscal/compliance', undefined, requestOptions);
+  }
+
+  async integrity(options: FiscalIntegrityOptions = {}, requestOptions?: RequestOptions): Promise<SingleResponse<FiscalIntegrityReport>> {
+    return this.http.get<SingleResponse<FiscalIntegrityReport>>('/tenant/fiscal/integrity', options as unknown as Record<string, string | number | boolean | undefined>, requestOptions);
+  }
+
+  async integrityHistory(options: FiscalIntegrityHistoryOptions = {}, requestOptions?: RequestOptions): Promise<PaginatedResponse<FiscalIntegrityReport>> {
+    return this.http.get<PaginatedResponse<FiscalIntegrityReport>>('/tenant/fiscal/integrity/history', options as unknown as Record<string, string | number | boolean | undefined>, requestOptions);
+  }
+
+  async integrityForDate(date: string, requestOptions?: RequestOptions): Promise<SingleResponse<FiscalIntegrityReport>> {
+    return this.http.get<SingleResponse<FiscalIntegrityReport>>(`/tenant/fiscal/integrity/${date}`, undefined, requestOptions);
+  }
+
+  async closings(options: FiscalClosingsOptions = {}, requestOptions?: RequestOptions): Promise<PaginatedResponse<FiscalClosing>> {
+    return this.http.get<PaginatedResponse<FiscalClosing>>('/tenant/fiscal/closings', options as unknown as Record<string, string | number | boolean | undefined>, requestOptions);
+  }
+
+  async performDailyClosing(input: FiscalDailyClosingInput = {}, requestOptions?: RequestOptions): Promise<MessageResponse> {
+    return this.http.post<MessageResponse>('/tenant/fiscal/closings/daily', input, requestOptions);
+  }
+
+  async fecExport(options: FiscalFecExportOptions, requestOptions?: RequestOptions): Promise<SingleResponse<FiscalFecExportResult>> {
+    return this.http.get<SingleResponse<FiscalFecExportResult>>('/tenant/fiscal/fec', options as unknown as Record<string, string | number | boolean | undefined>, requestOptions);
+  }
+
+  async fecDownload(options: FiscalFecExportOptions, requestOptions?: RequestOptions): Promise<ArrayBuffer> {
+    return this.http.getRaw('/tenant/fiscal/fec', { ...options, download: true } as unknown as Record<string, string | number | boolean | undefined>, requestOptions);
+  }
+
+  async attestation(year: number, requestOptions?: RequestOptions): Promise<SingleResponse<FiscalAttestation>> {
+    return this.http.get<SingleResponse<FiscalAttestation>>(`/tenant/fiscal/attestation/${year}`, undefined, requestOptions);
+  }
+
+  async attestationDownload(year: number, requestOptions?: RequestOptions): Promise<ArrayBuffer> {
+    return this.http.getRaw(`/tenant/fiscal/attestation/${year}/download`, undefined, requestOptions);
+  }
+
+  async entries(options: FiscalEntriesOptions = {}, requestOptions?: RequestOptions): Promise<PaginatedResponse<FiscalEntry>> {
+    return this.http.get<PaginatedResponse<FiscalEntry>>('/tenant/fiscal/entries', options as unknown as Record<string, string | number | boolean | undefined>, requestOptions);
+  }
+
+  async killSwitchStatus(requestOptions?: RequestOptions): Promise<SingleResponse<FiscalKillSwitchStatus>> {
+    return this.http.get<SingleResponse<FiscalKillSwitchStatus>>('/tenant/fiscal/kill-switch/status', undefined, requestOptions);
+  }
+
+  async killSwitchActivate(input: FiscalKillSwitchActivateInput, requestOptions?: RequestOptions): Promise<MessageResponse> {
+    return this.http.post<MessageResponse>('/tenant/fiscal/kill-switch/activate', input, requestOptions);
+  }
+
+  async killSwitchDeactivate(requestOptions?: RequestOptions): Promise<MessageResponse> {
+    return this.http.post<MessageResponse>('/tenant/fiscal/kill-switch/deactivate', undefined, requestOptions);
+  }
+
+  async anchors(options: FiscalAnchorsOptions = {}, requestOptions?: RequestOptions): Promise<PaginatedResponse<FiscalAnchor>> {
+    return this.http.get<PaginatedResponse<FiscalAnchor>>('/tenant/fiscal/anchors', options as unknown as Record<string, string | number | boolean | undefined>, requestOptions);
+  }
+
+  async rules(options: FiscalRulesOptions = {}, requestOptions?: RequestOptions): Promise<PaginatedResponse<FiscalRule>> {
+    return this.http.get<PaginatedResponse<FiscalRule>>('/tenant/fiscal/rules', options as unknown as Record<string, string | number | boolean | undefined>, requestOptions);
+  }
+
+  async ruleDetail(key: string, requestOptions?: RequestOptions): Promise<SingleResponse<FiscalRule>> {
+    return this.http.get<SingleResponse<FiscalRule>>(`/tenant/fiscal/rules/${key}`, undefined, requestOptions);
+  }
+
+  async ruleHistory(key: string, requestOptions?: RequestOptions): Promise<PaginatedResponse<FiscalRule>> {
+    return this.http.get<PaginatedResponse<FiscalRule>>(`/tenant/fiscal/rules/${key}/history`, undefined, requestOptions);
+  }
+
+  async createRule(input: FiscalCreateRuleInput, requestOptions?: RequestOptions): Promise<SingleResponse<FiscalRule>> {
+    return this.http.post<SingleResponse<FiscalRule>>('/tenant/fiscal/rules', input, requestOptions);
+  }
+
+  async updateRule(id: string, input: FiscalUpdateRuleInput, requestOptions?: RequestOptions): Promise<SingleResponse<FiscalRule>> {
+    return this.http.post<SingleResponse<FiscalRule>>(`/tenant/fiscal/rules/${id}`, input, requestOptions);
+  }
+
+  async exportRules(options: FiscalExportRulesOptions, requestOptions?: RequestOptions): Promise<SingleResponse<Record<string, unknown>>> {
+    return this.http.get<SingleResponse<Record<string, unknown>>>('/tenant/fiscal/rules/export', options as unknown as Record<string, string | number | boolean | undefined>, requestOptions);
+  }
+
+  async replayRules(input: FiscalReplayRulesInput, requestOptions?: RequestOptions): Promise<MessageResponse> {
+    return this.http.post<MessageResponse>('/tenant/fiscal/rules/replay', input, requestOptions);
+  }
+
+  async forensicExport(options: FiscalForensicExportOptions, requestOptions?: RequestOptions): Promise<SingleResponse<Record<string, unknown>>> {
+    return this.http.get<SingleResponse<Record<string, unknown>>>('/tenant/fiscal/forensic-export', options as unknown as Record<string, string | number | boolean | undefined>, requestOptions);
+  }
+}

package/src/resources/stats.ts

@@ -0,0 +1,29 @@
+/**
+ * Stats Resource
+ * @packageDocumentation
+ */
+
+import type { HttpClient, RequestOptions } from '../client.js';
+import type { SingleResponse } from '../types/common.js';
+import type {
+  StatsMonthly,
+  StatsMonthlyOptions,
+  StatsOverview,
+  StatsOverviewOptions,
+} from '../types/stats.js';
+
+export class StatsResource {
+  constructor(private readonly http: HttpClient) {}
+
+  async overview(options: StatsOverviewOptions = {}, requestOptions?: RequestOptions): Promise<SingleResponse<StatsOverview>> {
+    return this.http.get<SingleResponse<StatsOverview>>('/tenant/stats/overview', options as Record<string, string | number | boolean | undefined>, requestOptions);
+  }
+
+  async monthly(options: StatsMonthlyOptions = {}, requestOptions?: RequestOptions): Promise<SingleResponse<StatsMonthly[]>> {
+    return this.http.get<SingleResponse<StatsMonthly[]>>('/tenant/stats/monthly', options as Record<string, string | number | boolean | undefined>, requestOptions);
+  }
+
+  async subTenantOverview(subTenantId: string, options: StatsOverviewOptions = {}, requestOptions?: RequestOptions): Promise<SingleResponse<StatsOverview>> {
+    return this.http.get<SingleResponse<StatsOverview>>(`/tenant/sub-tenants/${subTenantId}/stats/overview`, options as Record<string, string | number | boolean | undefined>, requestOptions);
+  }
+}

package/src/resources/sub-tenants.ts

@@ -0,0 +1,41 @@
+/**
+ * Sub-Tenants Resource
+ * @packageDocumentation
+ */
+
+import type { HttpClient, RequestOptions } from '../client.js';
+import type { MessageResponse, PaginatedResponse, SingleResponse } from '../types/common.js';
+import type {
+  CreateSubTenantInput,
+  SubTenant,
+  SubTenantListOptions,
+  UpdateSubTenantInput,
+} from '../types/sub-tenants.js';
+
+export class SubTenantsResource {
+  constructor(private readonly http: HttpClient) {}
+
+  async list(options: SubTenantListOptions = {}, requestOptions?: RequestOptions): Promise<PaginatedResponse<SubTenant>> {
+    return this.http.get<PaginatedResponse<SubTenant>>('/tenant/sub-tenants', options as Record<string, string | number | boolean | undefined>, requestOptions);
+  }
+
+  async create(input: CreateSubTenantInput, requestOptions?: RequestOptions): Promise<SingleResponse<SubTenant>> {
+    return this.http.post<SingleResponse<SubTenant>>('/tenant/sub-tenants', input, requestOptions);
+  }
+
+  async get(id: string, requestOptions?: RequestOptions): Promise<SingleResponse<SubTenant>> {
+    return this.http.get<SingleResponse<SubTenant>>(`/tenant/sub-tenants/${id}`, undefined, requestOptions);
+  }
+
+  async update(id: string, input: UpdateSubTenantInput, requestOptions?: RequestOptions): Promise<SingleResponse<SubTenant>> {
+    return this.http.patch<SingleResponse<SubTenant>>(`/tenant/sub-tenants/${id}`, input, requestOptions);
+  }
+
+  async delete(id: string, requestOptions?: RequestOptions): Promise<MessageResponse> {
+    return this.http.delete<MessageResponse>(`/tenant/sub-tenants/${id}`, requestOptions);
+  }
+
+  async findByExternalId(externalId: string, requestOptions?: RequestOptions): Promise<SingleResponse<SubTenant>> {
+    return this.http.get<SingleResponse<SubTenant>>(`/tenant/sub-tenants/by-external-id/${externalId}`, undefined, requestOptions);
+  }
+}

package/src/resources/tenant-credit-notes.ts

@@ -0,0 +1,301 @@
+/**
+ * Tenant Credit Notes Resource
+ *
+ * @packageDocumentation
+ */
+
+import type { HttpClient, RequestOptions } from '../client.js';
+import type {
+  MessageResponse,
+  PaginatedResponse,
+  SingleResponse,
+} from '../types/common.js';
+import type {
+  CreateTenantCreditNoteInput,
+  RemainingCreditable,
+  TenantCreditNote,
+  TenantCreditNoteListOptions,
+  UpdateTenantCreditNoteInput,
+} from '../types/tenant-credit-notes.js';
+
+/**
+ * Tenant Credit Notes API resource
+ *
+ * Manage credit notes for sub-tenant invoices.
+ *
+ * @example
+ * ```typescript
+ * // List credit notes for a sub-tenant
+ * const { data, meta } = await client.tenantCreditNotes.list('sub-tenant-uuid', {
+ *   status: 'sent'
+ * });
+ *
+ * // Create a credit note
+ * const creditNote = await client.tenantCreditNotes.create('sub-tenant-uuid', {
+ *   invoice_id: 'invoice-uuid',
+ *   reason: 'Product returned',
+ *   type: 'partial',
+ *   items: [{ invoice_line_id: 'line-uuid', quantity: 1 }]
+ * });
+ * ```
+ */
+export class TenantCreditNotesResource {
+  constructor(private readonly http: HttpClient) {}
+
+  /**
+   * 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: string,
+    options: TenantCreditNoteListOptions = {},
+    requestOptions?: RequestOptions
+  ): Promise<PaginatedResponse<TenantCreditNote>> {
+    return this.http.get<PaginatedResponse<TenantCreditNote>>(
+      `/tenant/sub-tenants/${subTenantId}/credit-notes`,
+      options as Record<string, string | number | boolean | undefined>,
+      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: string,
+    input: CreateTenantCreditNoteInput,
+    requestOptions?: RequestOptions
+  ): Promise<SingleResponse<TenantCreditNote>> {
+    return this.http.post<SingleResponse<TenantCreditNote>>(
+      `/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: string,
+    requestOptions?: RequestOptions
+  ): Promise<SingleResponse<TenantCreditNote>> {
+    return this.http.get<SingleResponse<TenantCreditNote>>(
+      `/tenant/credit-notes/${creditNoteId}`,
+      undefined,
+      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: string,
+    input: UpdateTenantCreditNoteInput,
+    requestOptions?: RequestOptions
+  ): Promise<SingleResponse<TenantCreditNote>> {
+    return this.http.patch<SingleResponse<TenantCreditNote>>(
+      `/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: string,
+    requestOptions?: RequestOptions
+  ): Promise<SingleResponse<TenantCreditNote>> {
+    return this.http.post<SingleResponse<TenantCreditNote>>(
+      `/tenant/credit-notes/${creditNoteId}/send`,
+      undefined,
+      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: string,
+    requestOptions?: RequestOptions
+  ): Promise<MessageResponse> {
+    return this.http.delete<MessageResponse>(
+      `/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: string,
+    requestOptions?: RequestOptions
+  ): Promise<ArrayBuffer> {
+    return this.http.getRaw(
+      `/tenant/credit-notes/${creditNoteId}/download`,
+      undefined,
+      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: string,
+    requestOptions?: RequestOptions
+  ): Promise<RemainingCreditable> {
+    return this.http.get<RemainingCreditable>(
+      `/tenant/invoices/${invoiceId}/remaining-creditable`,
+      undefined,
+      requestOptions
+    );
+  }
+}