pi-spi-sdk 0.1.3 → 0.2.0

package/dist/index.mjs

@@ -0,0 +1,2359 @@
+import {
+  AliasService,
+  AnnulationStatut,
+  ApiError,
+  CancelError,
+  CancelablePromise,
+  CompteOperation,
+  CompteSolde,
+  CompteTransfertIntraReponse,
+  ComptesService,
+  DemandeAnnulationService,
+  DemandePaiementConfirmationAnnulationRaison,
+  DemandePaiementConfirmationReponse,
+  DemandePaiementConsultationReponse,
+  DemandePaiementEnMasseStatutReponse,
+  DemandePaiementListeItem,
+  DemandePaiementReponseRequest,
+  DemandePaiementRequest,
+  DemandePaiementRequestCategorie,
+  DemandePaiementStatut,
+  DemandePaiementStatutRaison,
+  DemandesDePaiementEnMasseService,
+  DemandesDePaiementService,
+  NotificationService,
+  OpenAPI,
+  Paiement,
+  PaiementAnnulationMotif,
+  PaiementAnnulationStatutRaison,
+  PaiementEnMasseReponseStatut,
+  PaiementEnMasseService,
+  PaiementImmediatConfirmationReponse,
+  PaiementImmediatReponse,
+  PaiementImmediatService,
+  PaiementStatut,
+  PaiementStatutRaison,
+  RefDocType,
+  RetourStatut,
+  RetourStatutRaison,
+  RetoursdeFondsService,
+  WebhookEvent,
+  WebhooksEvents
+} from "./chunk-7W56NW2S.mjs";
+
+// src/errors.ts
+var PiSpiError = class extends Error {
+  constructor(message, statusCode, statusText, type, detail, instance) {
+    super(message);
+    this.name = "PiSpiError";
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+    this.type = type;
+    this.detail = detail;
+    this.instance = instance;
+  }
+};
+var PiSpiValidationError = class extends PiSpiError {
+  constructor(message, statusCode, statusText, errors, type, detail) {
+    super(message, statusCode, statusText, type, detail);
+    this.name = "PiSpiValidationError";
+    this.errors = errors;
+  }
+};
+var PiSpiAuthError = class extends PiSpiError {
+  constructor(message, statusCode, statusText) {
+    super(message, statusCode, statusText);
+    this.name = "PiSpiAuthError";
+  }
+};
+var PiSpiNotFoundError = class extends PiSpiError {
+  constructor(message, statusCode, statusText) {
+    super(message, statusCode, statusText);
+    this.name = "PiSpiNotFoundError";
+  }
+};
+var PiSpiRateLimitError = class extends PiSpiError {
+  constructor(message, statusCode, statusText, retryAfter) {
+    super(message, statusCode, statusText);
+    this.name = "PiSpiRateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+
+// src/error-handler.ts
+function handleApiError(error) {
+  const isApiError = error && typeof error === "object" && "status" in error && "statusText" in error && "body" in error;
+  if (isApiError) {
+    const apiError = error;
+    const status = apiError.status;
+    const body = apiError.body;
+    const type = body?.type;
+    const title = body?.title || apiError.statusText;
+    const detail = body?.detail || apiError.message;
+    const instance = body?.instance;
+    if (status === 400) {
+      const invalidParams = body?.invalidParams || body?.errors;
+      throw new PiSpiValidationError(
+        detail || title || "Validation error",
+        status,
+        apiError.statusText,
+        invalidParams,
+        type,
+        detail
+      );
+    }
+    if (status === 401) {
+      throw new PiSpiAuthError(
+        detail || title || "Authentication failed",
+        status,
+        apiError.statusText
+      );
+    }
+    if (status === 403) {
+      throw new PiSpiError(
+        detail || title || "Forbidden",
+        status,
+        apiError.statusText,
+        type,
+        detail,
+        instance
+      );
+    }
+    if (status === 404) {
+      throw new PiSpiNotFoundError(
+        detail || title || "Resource not found",
+        status,
+        apiError.statusText
+      );
+    }
+    if (status === 429) {
+      throw new PiSpiRateLimitError(
+        detail || title || "Rate limit exceeded",
+        status,
+        apiError.statusText
+      );
+    }
+    throw new PiSpiError(
+      detail || title || apiError.message || "API error",
+      status,
+      apiError.statusText,
+      type,
+      detail,
+      instance
+    );
+  }
+  throw error;
+}
+
+// src/services/base.ts
+var BaseService = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Wrap an async operation with error handling
+   */
+  async execute(operation) {
+    try {
+      return await operation();
+    } catch (error) {
+      throw handleApiError(error);
+    }
+  }
+  /**
+   * Make an HTTP request
+   */
+  async request(method, path, body, params) {
+    return this.execute(async () => {
+      const url = new URL(`${this.config.BASE}${path}`);
+      if (params) {
+        Object.entries(params).forEach(([key, value]) => {
+          if (value !== void 0 && value !== null) {
+            url.searchParams.append(key, String(value));
+          }
+        });
+      }
+      const headers = {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        ...this.config.HEADERS
+      };
+      if (this.config.TOKEN) {
+        headers["Authorization"] = `Bearer ${this.config.TOKEN}`;
+      }
+      const fetchOptions = {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0
+      };
+      if (this.config.dispatcher) {
+        fetchOptions.dispatcher = this.config.dispatcher;
+      }
+      const response = await fetch(url.toString(), fetchOptions);
+      if (!response.ok) {
+        let errorBody;
+        try {
+          const parsed = await response.json();
+          errorBody = {
+            ...parsed,
+            status: response.status,
+            statusText: response.statusText
+          };
+        } catch {
+          errorBody = {
+            status: response.status,
+            statusText: response.statusText
+          };
+        }
+        throw errorBody;
+      }
+      if (response.status === 204) {
+        return {};
+      }
+      return await response.json();
+    });
+  }
+};
+
+// src/services/comptes.ts
+var ComptesService2 = class extends BaseService {
+  /**
+   * Get account details and balance
+   *
+   * **Returns:**
+   * - Account type (CACC, SVGS, etc.)
+   * - Account number
+   * - Current balance (`solde` in centimes)
+   * - Account status (OUVERT, BLOQUE, CLOTURE)
+   * - Opening date
+   * - Pre-confirmation indicator
+   *
+   * @param numero - Account number (e.g., 'CIC2344256727788288822')
+   * @returns Account details including balance
+   * @throws {PiSpiNotFoundError} If account not found
+   * @throws {PiSpiAuthError} If authentication fails
+   *
+   * @example
+   * ```typescript
+   * const account = await sdk.comptes.getAccount('CIC2344256727788288822');
+   * // Returns: {
+   * //   type: 'CACC',
+   * //   numero: 'CIC2344256727788288822',
+   * //   solde: 150000000, // 1,500,000 XOF in centimes
+   * //   statut: 'OUVERT',
+   * //   dateOuverture: '2023-02-21T15:30:01.250Z'
+   * // }
+   * ```
+   */
+  async getAccount(numero) {
+    return this.request("GET", `/comptes/${encodeURIComponent(numero)}`);
+  }
+  /**
+   * List account operations (transactions)
+   *
+   * **Filtering Options:**
+   * - Filter by account number (`comptePayeur`, `comptePaye`)
+   * - Filter by status (`statut`: INITIE, ENVOYE, IRREVOCABLE, REJETE)
+   * - Filter by dates (`dateEnvoi`, `dateIrrevocabilite`)
+   * - Use QueryBuilder for advanced filtering
+   *
+   * @param params - Query parameters for filtering and pagination
+   * @param params.comptePayeur - Filter by payer account number
+   * @param params.comptePaye - Filter by payee account number
+   * @param params.statut - Filter by transaction status
+   * @param params.dateEnvoi - Filter by send date
+   * @param params.dateIrrevocabilite - Filter by irrevocability date
+   * @param params.page - Page number (default: 1)
+   * @param params.size - Page size (default: 20, max: 100)
+   * @returns Paginated list of operations
+   *
+   * @example
+   * ```typescript
+   * // List all operations for an account
+   * const operations = await sdk.comptes.listOperations({
+   *   comptePayeur: 'CIC2344256727788288822',
+   *   page: 1,
+   *   size: 20
+   * });
+   *
+   * // Filter by status
+   * const completed = await sdk.comptes.listOperations({
+   *   comptePayeur: 'CIC2344256727788288822',
+   *   statut: 'IRREVOCABLE'
+   * });
+   * ```
+   */
+  async listOperations(params) {
+    return this.request("GET", "/comptes/transactions", void 0, params);
+  }
+  /**
+   * Transfer funds between accounts owned by the same client
+   *
+   * **Intra-Account Transfer:**
+   * - Transfers between accounts owned by the same legal entity
+   * - Accounts must be at the same financial institution
+   * - Can use account numbers or aliases
+   *
+   * **Transfer Methods:**
+   * - Using account numbers: `comptePayeur` and `comptePaye`
+   * - Using aliases: `payeurAlias` and `payeAlias`
+   *
+   * @param transfer - Transfer request details
+   * @param transfer.comptePayeur - Payer account number (if using account numbers)
+   * @param transfer.comptePaye - Payee account number (if using account numbers)
+   * @param transfer.payeurAlias - Payer alias (if using aliases)
+   * @param transfer.payeAlias - Payee alias (if using aliases)
+   * @param transfer.montant - Amount in centimes (e.g., 150000 = 1,500 XOF)
+   * @param transfer.motif - Transfer reason/description
+   * @param transfer.txId - Unique transaction ID (optional, auto-generated if not provided)
+   * @returns Transfer response with status
+   * @throws {PiSpiValidationError} If transfer fails validation
+   * @throws {PiSpiError} If account blocked or insufficient funds
+   *
+   * @example
+   * ```typescript
+   * // Transfer using account numbers
+   * await sdk.comptes.transfer({
+   *   comptePayeur: 'CIC2344256727788288822',
+   *   comptePaye: 'SNC2344256727788288822',
+   *   montant: 150000, // 1,500 XOF
+   *   motif: 'Transfert de fonds',
+   *   txId: '23511722'
+   * });
+   *
+   * // Transfer using aliases
+   * await sdk.comptes.transfer({
+   *   payeurAlias: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f',
+   *   payeAlias: '4r5ty499-3e50-435b-b757-ac7a83d67juio',
+   *   montant: 150000,
+   *   motif: 'Transfert entre comptes'
+   * });
+   * ```
+   */
+  async transfer(transfer) {
+    const txId = transfer.txId ?? `TRF-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    return this.request("POST", "/comptes/transactions", {
+      txId,
+      comptePayeur: transfer.comptePayeur,
+      comptePaye: transfer.comptePaye,
+      payeurAlias: transfer.payeurAlias,
+      payeAlias: transfer.payeAlias,
+      montant: transfer.montant,
+      motif: transfer.motif
+    });
+  }
+};
+
+// src/services/alias.ts
+var AliasService2 = class extends BaseService {
+  /**
+   * Create an account alias
+   *
+   * **Alias Types:**
+   * - `SHID`: System-generated unique payment address (UUID format, 36 chars). Available for all client types (P, C, B, G)
+   * - `MCOD`: Merchant code for USSD payments. Available for business clients only (C, B, G)
+   * - `MBNO`: Mobile phone number. Available for individuals only (P)
+   *
+   * **Limits:**
+   * - Default: 20 aliases per account
+   * - Limit can be increased based on client needs
+   *
+   * @param alias - Alias creation data
+   * @param alias.compte - Account number (e.g., 'CIC2344256727788288822')
+   * @param alias.type - Alias type: 'SHID', 'MCOD', or 'MBNO'
+   * @returns Created alias with generated `cle` (key) value
+   * @throws {PiSpiError} If account not found or limit exceeded
+   *
+   * @example
+   * ```typescript
+   * // For business clients (C, B, G)
+   * await sdk.alias.create({
+   *   compte: 'SNC2344256727788288822',
+   *   type: AliasType.SHID
+   * });
+   * ```
+   */
+  async create(alias) {
+    return this.request(
+      "POST",
+      `/comptes/${encodeURIComponent(alias.compte)}/alias`,
+      { type: alias.type }
+    );
+  }
+  /**
+   * List aliases for an account
+   *
+   * @param compte - Account number
+   * @param params - Query parameters for pagination
+   * @returns Paginated list of aliases
+   */
+  async list(compte, params) {
+    return this.request("GET", `/comptes/${encodeURIComponent(compte)}/alias`, void 0, params);
+  }
+  /**
+   * Delete an alias
+   *
+   * @param alias - Alias identifier
+   */
+  async delete(alias, compte) {
+    if (!compte) {
+      throw new Error("Account number (compte) is required to delete an alias.");
+    }
+    return this.request(
+      "DELETE",
+      `/comptes/${encodeURIComponent(compte)}/alias/${encodeURIComponent(alias)}`
+    );
+  }
+};
+
+// src/services/webhooks.ts
+var WebhooksService = class extends BaseService {
+  /**
+   * Create a webhook configuration
+   *
+   * **Webhook Setup:**
+   * - URL must be HTTPS
+   * - Server must support mTLS with BCEAO-issued certificate
+   * - Server must validate HMAC signatures
+   * - Server must respond with 2xx status code
+   *
+   * **Event Types:**
+   * - `PAIEMENT_RECU`: Payment received
+   * - `PAIEMENT_ENVOYE`: Payment sent (irreversible)
+   * - `PAIEMENT_REJETE`: Payment rejected
+   * - `RTP_RECU`: Payment request received
+   * - `RTP_REJETE`: Payment request rejected
+   * - `RETOUR_ENVOYE`: Fund return sent
+   * - `RETOUR_REJETE`: Fund return rejected
+   * - `RETOUR_RECU`: Fund return received
+   * - `ANNULATION_DEMANDE`: Cancellation request received
+   * - `ANNULATION_REJETE`: Cancellation request rejected
+   *
+   * @param webhook - Webhook configuration
+   * @param webhook.callbackUrl - HTTPS URL to receive notifications (must support mTLS)
+   * @param webhook.events - Array of event types to subscribe to
+   * @param webhook.alias - Optional: Alias-specific webhook (only notifications for this alias)
+   * @returns Created webhook configuration
+   * @throws {PiSpiValidationError} If URL is invalid or events array is empty
+   *
+   * @example
+   * ```typescript
+   * // Webhook for all payment events
+   * await sdk.webhooks.create({
+   *   callbackUrl: 'https://business.example.com/api/webhooks/pi-spi',
+   *   events: ['PAIEMENT_RECU', 'PAIEMENT_ENVOYE', 'PAIEMENT_REJETE']
+   * });
+   *
+   * // Alias-specific webhook
+   * await sdk.webhooks.create({
+   *   callbackUrl: 'https://business.example.com/api/webhooks/pi-spi',
+   *   events: ['PAIEMENT_RECU'],
+   *   alias: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f'
+   * });
+   * ```
+   */
+  async create(webhook) {
+    return this.request("POST", "/webhooks", webhook);
+  }
+  /**
+   * List all configured webhooks
+   *
+   * @param params - Query parameters for pagination
+   * @returns Paginated list of webhooks
+   *
+   * @example
+   * ```typescript
+   * const webhooks = await sdk.webhooks.list({ page: 1, size: 20 });
+   * ```
+   */
+  async list(params) {
+    return this.request("GET", "/webhooks", void 0, params);
+  }
+  /**
+   * Get webhook details by ID
+   *
+   * @param id - Webhook ID
+   * @returns Webhook details
+   * @throws {PiSpiNotFoundError} If webhook not found
+   */
+  async get(id) {
+    return this.request("GET", `/webhooks/${encodeURIComponent(id)}`);
+  }
+  /**
+   * Update webhook configuration
+   *
+   * @param id - Webhook ID
+   * @param webhook - Updated webhook configuration
+   * @param webhook.callbackUrl - New callback URL (optional)
+   * @param webhook.events - New event subscriptions (optional)
+   * @param webhook.alias - New alias filter (optional)
+   * @returns Updated webhook configuration
+   * @throws {PiSpiNotFoundError} If webhook not found
+   * @throws {PiSpiValidationError} If update fails validation
+   *
+   * @example
+   * ```typescript
+   * await sdk.webhooks.update('webhook-001', {
+   *   callbackUrl: 'https://updated-url.com/webhooks/pi-spi',
+   *   events: ['PAIEMENT_RECU', 'RTP_RECU']
+   * });
+   * ```
+   */
+  async update(id, webhook) {
+    return this.request(
+      "PUT",
+      `/webhooks/${encodeURIComponent(id)}`,
+      webhook
+    );
+  }
+  /**
+   * Delete a webhook configuration
+   *
+   * @param id - Webhook ID
+   * @throws {PiSpiNotFoundError} If webhook not found
+   */
+  async delete(id) {
+    return this.request("DELETE", `/webhooks/${encodeURIComponent(id)}`);
+  }
+};
+
+// src/services/demandes-paiement.ts
+var DemandesPaiementService = class extends BaseService {
+  /**
+   * Create a payment request
+   *
+   * **Request Types:**
+   * - **E-commerce** (`categorie: 521`): Max 3 minutes validity
+   * - **POS** (`categorie: 500`): Max 24 hours validity
+   * - **Invoice** (`categorie: 401`): Custom due date (up to 90 days)
+   *
+   * **Confirmation Options:**
+   * - `confirmation: false`: Request sent immediately (default for POS)
+   * - `confirmation: true`: Returns payer info for verification before sending
+   *
+   * **Customer Actions:**
+   * - Accept & Pay Now: Payment processed immediately
+   * - Accept & Pay Later: Payment scheduled (if dateLimiteReponse > 24h)
+   * - Reject: Request rejected with reason
+   * - Ignore: Request expires after dateLimiteReponse
+   *
+   * @param request - Payment request creation data
+   * @param request.comptePaye - Business account number (payee)
+   * @param request.payeurAlias - Customer alias (payer)
+   * @param request.montant - Amount in centimes (e.g., 150000 = 1,500 XOF)
+   * @param request.categorie - Request category: '500' (POS), '521' (E-commerce), '401' (Invoice)
+   * @param request.motif - Payment reason/description
+   * @param request.txId - Unique transaction ID (optional)
+   * @param request.dateLimitePaiement - Payment due date (required for e-commerce and invoices)
+   * @param request.dateLimiteReponse - Response deadline (default: 90 days from creation)
+   * @param request.confirmation - Whether to require confirmation (default: false for POS, true for invoices)
+   * @param request.refDocType - Reference document type (e.g., 'CINV' for invoice)
+   * @param request.refDocNumero - Reference document number (e.g., invoice number)
+   * @returns Payment request response
+   * @throws {PiSpiValidationError} If request fails validation
+   *
+   * @example
+   * ```typescript
+   * // E-commerce payment request (3-minute expiry)
+   * await sdk.demandesPaiement.create({
+   *   comptePaye: 'CIC2344256727788288822',
+   *   payeurAlias: '9b1b3499-3e50-435b-b757-ac7a83d8aa96',
+   *   montant: 25000, // 250 XOF
+   *   categorie: '521',
+   *   dateLimitePaiement: '2023-02-21T15:37:00.000Z', // 3 minutes from now
+   *   motif: 'Paiement du livre Manuel des écritures comptables'
+   * });
+   *
+   * // Invoice payment request
+   * await sdk.demandesPaiement.create({
+   *   comptePaye: 'CIC2344256727788288822',
+   *   payeurAlias: '9b1b3499-3e50-435b-b757-ac7a83d8aa96',
+   *   montant: 150000, // 1,500 XOF
+   *   categorie: '401',
+   *   dateLimitePaiement: '2023-12-31T23:59:59.999Z',
+   *   motif: 'Facture électricité mars 2023',
+   *   refDocType: 'CINV',
+   *   refDocNumero: 'FACT-ELEC-202303',
+   *   confirmation: true
+   * });
+   * ```
+   */
+  async create(request) {
+    return this.request("POST", "/demandes-paiements", request);
+  }
+  /**
+   * List payment requests with filtering and pagination
+   *
+   * @param params - Query parameters for filtering and pagination
+   * @returns Paginated list of payment requests
+   */
+  async list(params) {
+    return this.request("GET", "/demandes-paiements", void 0, params);
+  }
+  /**
+   * Get payment request details
+   *
+   * @param id - Payment request transaction ID
+   * @returns Payment request details
+   * @throws {PiSpiNotFoundError} If request not found
+   */
+  async get(id) {
+    return this.request("GET", `/demandes-paiements/${encodeURIComponent(id)}`);
+  }
+  /**
+   * Accept a payment request
+   *
+   * **Note:** This is typically called by the customer's payment app, not the business.
+   * The business receives notification when customer accepts.
+   *
+   * @param id - Payment request transaction ID
+   * @param immediate - Whether to pay immediately (true) or schedule payment (false)
+   * @returns Payment confirmation response
+   */
+  async accept(id, immediate = true) {
+    return this.request(
+      "POST",
+      `/demandes-paiements/${encodeURIComponent(id)}/reponses`,
+      { decision: true, paiementImmediat: immediate }
+    );
+  }
+  /**
+   * Reject a payment request
+   *
+   * **Note:** This is typically called by the customer's payment app, not the business.
+   * The business receives notification when customer rejects.
+   *
+   * @param id - Payment request transaction ID
+   * @param reason - Rejection reason code (optional)
+   * @returns Rejection confirmation response
+   */
+  async reject(id, reason) {
+    return this.request(
+      "POST",
+      `/demandes-paiements/${encodeURIComponent(id)}/reponses`,
+      { decision: false, ...reason ? { raison: reason } : {} }
+    );
+  }
+  /**
+   * Confirm sending a payment request created with confirmation: true
+   */
+  async confirm(txId, decision) {
+    return this.request(
+      "PUT",
+      `/demandes-paiements/${encodeURIComponent(txId)}/confirmations`,
+      { decision }
+    );
+  }
+};
+
+// src/services/demandes-paiement-en-masse.ts
+var DemandesPaiementEnMasseService = class extends BaseService {
+  /**
+   * Create bulk payment requests
+   */
+  async create(request) {
+    const transactions = request.transactions.map((t) => ({
+      ...t,
+      categorie: t.categorie || "401"
+    }));
+    return this.request("POST", "/demandes-paiements-groupes", {
+      ...request,
+      transactions
+      // Use the mapped transactions with defaults
+    });
+  }
+  /**
+   * Get bulk payment request details and status
+   */
+  async get(instructionId) {
+    return this.request("GET", `/demandes-paiements-groupes/${instructionId}`);
+  }
+  /**
+   * Confirm and send bulk payment requests
+   */
+  async confirm(instructionId) {
+    return this.request("PUT", `/demandes-paiements-groupes/${instructionId}/confirmations`, {
+      decision: true
+    });
+  }
+};
+
+// src/services/paiements.ts
+var PaiementsService = class extends BaseService {
+  /**
+   * Create an immediate payment
+   *
+   * **Payment Flow:**
+   * - If `confirmation: false`: Payment is sent immediately (default)
+   * - If `confirmation: true`: Payment is initiated, returns payee info for confirmation
+   *
+   * **Supported Transaction Types:**
+   * - Bank-to-Bank (`categorie: 733`)
+   * - Bank-to-Wallet (via alias lookup)
+   * - Wallet-to-Wallet (via alias lookup)
+   * - Wallet-to-Bank (via alias lookup)
+   *
+   * **Status Values:**
+   * - `INITIE`: Waiting for confirmation (if confirmation: true)
+   * - `ENVOYE`: Payment sent successfully
+   * - `IRREVOCABLE`: Payment confirmed and cannot be reversed
+   * - `REJETE`: Payment rejected (check `statutRaison` for error code)
+   *
+   * @param payment - Payment creation data
+   * @param payment.comptePayeur - Payer account number (e.g., 'CIC2344256727788288822')
+   * @param payment.payeAlias - Payee alias (SHID, MCOD, or MBNO format)
+   * @param payment.montant - Amount in centimes (e.g., 150000 = 1,500 XOF)
+   * @param payment.motif - Payment reason/description
+   * @param payment.txId - Unique transaction ID (optional, auto-generated if not provided)
+   * @param payment.confirmation - Whether to require confirmation before sending (default: false)
+   * @param payment.categorie - Payment category/canal (default: 733 for API Business)
+   * @returns Payment response with status
+   * @throws {PiSpiValidationError} If payment fails validation (e.g., invalid alias, duplicate txId)
+   * @throws {PiSpiError} If account blocked or insufficient funds
+   *
+   * @example
+   * ```typescript
+   * // Immediate payment (no confirmation)
+   * const payment = await sdk.paiements.create({
+   *   comptePayeur: 'CIC2344256727788288822',
+   *   payeAlias: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f', // SHID alias
+   *   montant: 150000, // 1,500 XOF
+   *   motif: 'Paiement de services',
+   *   txId: '23552722'
+   * });
+   *
+   * // Payment with confirmation (returns payee info)
+   * const paymentWithConfirmation = await sdk.paiements.create({
+   *   comptePayeur: 'CIC2344256727788288822',
+   *   payeAlias: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f',
+   *   montant: 3000000, // 30,000 XOF
+   *   confirmation: true
+   * });
+   * ```
+   */
+  async create(payment) {
+    const txId = payment.txId ?? `PAY-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    const payeurAlias = payment.payeurAlias ?? payment.comptePayeur;
+    if (!payeurAlias) {
+      throw new Error("payeurAlias or comptePayeur is required for SPI payouts");
+    }
+    return this.request("POST", "/paiements", {
+      txId,
+      payeurAlias,
+      payeAlias: payment.payeAlias,
+      montant: payment.montant,
+      motif: payment.motif,
+      confirmation: payment.confirmation ?? false
+    });
+  }
+  /**
+   * Get payment details by transaction ID
+   *
+   * @param txId - Transaction ID
+   * @returns Payment details including status and history
+   * @throws {PiSpiNotFoundError} If payment not found
+   *
+   * @example
+   * ```typescript
+   * const payment = await sdk.paiements.get('23552722');
+   * console.log('Status:', payment.statut); // 'IRREVOCABLE'
+   * console.log('Amount:', payment.montant); // 150000
+   * ```
+   */
+  async get(txId) {
+    return this.request("GET", `/paiements/${encodeURIComponent(txId)}`);
+  }
+  /**
+   * List payments with filtering and pagination
+   *
+   * **Filter Options:**
+   * - Filter by account: `comptePayeur`
+   * - Filter by status: `statut` (INITIE, ENVOYE, IRREVOCABLE, REJETE)
+   * - Filter by dates: `dateEnvoi`, `dateIrrevocabilite`
+   * - Use QueryBuilder for advanced filtering
+   *
+   * @param params - Query parameters for filtering and pagination
+   * @returns Paginated list of payments
+   *
+   * @example
+   * ```typescript
+   * // List all payments for an account
+   * const payments = await sdk.paiements.list({
+   *   comptePayeur: 'CIC2344256727788288822',
+   *   page: 1,
+   *   size: 20
+   * });
+   *
+   * // Filter by status
+   * const completed = await sdk.paiements.list({
+   *   comptePayeur: 'CIC2344256727788288822',
+   *   statut: 'IRREVOCABLE'
+   * });
+   * ```
+   */
+  async list(params) {
+    return this.request("GET", "/paiements", void 0, params);
+  }
+  /**
+   * Confirm a payment that was created with confirmation: true
+   */
+  async confirm(txId, decision, body) {
+    return this.request(
+      "PUT",
+      `/paiements/${encodeURIComponent(txId)}/confirmations`,
+      { decision, ...body }
+    );
+  }
+  /**
+   * Verify payment status by end-to-end ID
+   */
+  async verifyStatus(end2endId) {
+    return this.request(
+      "GET",
+      `/paiements/${encodeURIComponent(end2endId)}/statuts`
+    );
+  }
+};
+
+// src/services/paiements-en-masse.ts
+var PaiementsEnMasseService = class extends BaseService {
+  /**
+   * Create bulk payments
+   *
+   * **Bulk Processing:**
+   * - All transactions share the same `instructionId`
+   * - Each transaction needs unique `txId`
+   * - Transactions are processed in parallel
+   * - Failed transactions can be retried
+   *
+   * **Performance Considerations:**
+   * - Larger bulks take longer to process
+   * - May hit HTTP timeout for very large bulks
+   * - Recommended: 500-5,000 transactions per bulk
+   * - For >10,000 transactions, split into multiple bulks
+   *
+   * **Response Status:**
+   * - `INITIE`: Bulk created, awaiting confirmation
+   * - `ENVOYE`: Bulk sent, transactions processing
+   * - `IRREVOCABLE`: All transactions completed
+   * - `PARTIEL`: Some transactions succeeded, some failed
+   * - `REJETE`: Bulk rejected (validation failed)
+   *
+   * @param payment - Bulk payment creation data
+   * @param payment.comptePayeur - Payer account number
+   * @param payment.instructionId - Unique bulk instruction ID
+   * @param payment.transactions - Array of payment transactions
+   * @param payment.transactions[].txId - Unique transaction ID (must be unique within bulk)
+   * @param payment.transactions[].payeAlias - Payee alias (SHID, MCOD, or MBNO)
+   * @param payment.transactions[].montant - Amount in centimes
+   * @param payment.transactions[].motif - Payment reason/description
+   * @param payment.transactions[].refDocType - Reference document type (optional)
+   * @param payment.transactions[].refDocNumero - Reference document number (optional)
+   * @returns Bulk payment response with status and summary
+   * @throws {PiSpiValidationError} If bulk fails validation (e.g., duplicate txId, invalid alias)
+   * @throws {PiSpiError} If account blocked or insufficient funds
+   *
+   * @example
+   * ```typescript
+   * // Create bulk payment for salary disbursement
+   * await sdk.paiementsEnMasse.createBulk({
+   *   comptePayeur: 'CIC2344256727788288822',
+   *   instructionId: 'SALARY-2023-03',
+   *   transactions: [
+   *     {
+   *       txId: 'SAL-001',
+   *       payeAlias: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f',
+   *       montant: 500000, // 5,000 XOF
+   *       motif: 'Salaire mars 2023'
+   *     },
+   *     {
+   *       txId: 'SAL-002',
+   *       payeAlias: '4r5ty499-3e50-435b-b757-ac7a83d67juio',
+   *       montant: 750000, // 7,500 XOF
+   *       motif: 'Salaire mars 2023'
+   *     }
+   *   ]
+   * });
+   * ```
+   */
+  async createBulk(payment) {
+    return this.request("POST", "/paiements-groupes", payment);
+  }
+  /**
+   * Get bulk payment details and status
+   *
+   * **Response Includes:**
+   * - Overall bulk status
+   * - Transaction counts (total, succeeded, failed)
+   * - Individual transaction statuses
+   * - Failed transaction details
+   *
+   * @param instructionId - Bulk instruction ID
+   * @returns Bulk payment details with transaction statuses
+   * @throws {PiSpiNotFoundError} If bulk payment not found
+   *
+   * @example
+   * ```typescript
+   * const bulk = await sdk.paiementsEnMasse.get('SALARY-2023-03');
+   * console.log('Status:', bulk.statut); // 'IRREVOCABLE'
+   * console.log('Succeeded:', bulk.nombreSuccess); // 98
+   * console.log('Failed:', bulk.nombreEchec); // 2
+   * ```
+   */
+  async get(instructionId) {
+    return this.request(
+      "GET",
+      `/paiements-groupes/${encodeURIComponent(instructionId)}`
+    );
+  }
+  /**
+   * Confirm or retry a bulk payment
+   */
+  async confirm(instructionId, decision = true) {
+    return this.request(
+      "PUT",
+      `/paiements-groupes/${encodeURIComponent(instructionId)}/confirmations`,
+      { decision }
+    );
+  }
+  /**
+   * Retry failed payments in a bulk payment
+   *
+   * **Retry Process:**
+   * - Only failed transactions are retried
+   * - Successful transactions are not affected
+   * - Uses same `instructionId`
+   * - Can retry multiple times if needed
+   *
+   * @param instructionId - Bulk instruction ID
+   * @returns Retry response with updated status
+   * @throws {PiSpiNotFoundError} If bulk payment not found
+   * @throws {PiSpiError} If no failed transactions to retry
+   *
+   * @example
+   * ```typescript
+   * // Retry failed transactions
+   * await sdk.paiementsEnMasse.retry('SALARY-2023-03');
+   * ```
+   */
+  async retry(instructionId) {
+    return this.confirm(instructionId, true);
+  }
+};
+
+// src/services/retours-fonds.ts
+var RetoursFondsService = class extends BaseService {
+  /**
+   * Create a fund return
+   *
+   * **Return Process:**
+   * 1. Business identifies original payment transaction
+   * 2. Creates return request (must be within 90 days)
+   * 3. Return is processed immediately
+   * 4. Funds are returned to original payer
+   *
+   * **Status Values:**
+   * - `ENVOYE`: Return sent successfully
+   * - `IRREVOCABLE`: Return confirmed and cannot be reversed
+   * - `REJETE`: Return rejected (check `statutRaison` for error code)
+   *
+   * **Rejection Reasons:**
+   * - `AM04`: Insufficient guarantee funds
+   * - `AM09`: Wrong amount
+   * - `AC06`: Blocked account
+   * - `FR01`: Fraud suspicion
+   * - `RR04`: Regulatory reason
+   *
+   * @param returnRequest - Fund return request data
+   * @param returnRequest.comptePaye - Business account number (original payee)
+   * @param returnRequest.txId - Original payment transaction ID
+   * @param returnRequest.montant - Amount to return in centimes (e.g., 150000 = 1,500 XOF)
+   * @param returnRequest.motif - Return reason code (e.g., 'CUST' for customer request)
+   * @returns Fund return response
+   * @throws {PiSpiValidationError} If return fails validation (e.g., > 90 days, invalid txId)
+   * @throws {PiSpiError} If account blocked or insufficient funds
+   *
+   * @example
+   * ```typescript
+   * // Return full payment amount
+   * await sdk.retoursFonds.create({
+   *   comptePaye: 'CIC2344256727788288822',
+   *   txId: '23552722', // Original payment ID
+   *   montant: 150000, // 1,500 XOF
+   *   motif: 'CUST' // Customer request
+   * });
+   * ```
+   */
+  async create(returnRequest) {
+    const end2endId = returnRequest.end2endId ?? returnRequest.txId;
+    if (!end2endId) {
+      throw new Error("end2endId or txId is required for fund returns");
+    }
+    return this.request(
+      "PUT",
+      `/paiements/${encodeURIComponent(end2endId)}/retours`
+    );
+  }
+  /**
+   * Get fund return details by end-to-end ID
+   */
+  async get(end2endId) {
+    return this.request(
+      "GET",
+      `/paiements/${encodeURIComponent(end2endId)}/statuts`
+    );
+  }
+  /**
+   * List payments with fund return status filter
+   */
+  async list(params) {
+    return this.request("GET", "/paiements", void 0, params);
+  }
+};
+
+// src/services/demandes-annulation.ts
+var DemandesAnnulationService = class extends BaseService {
+  /**
+   * Create a cancellation request
+   *
+   * **Cancellation Process:**
+   * 1. Business identifies payment to cancel
+   * 2. Creates cancellation request (must be within 90 days)
+   * 3. Payee receives cancellation request
+   * 4. Payee accepts or rejects
+   * 5. If accepted, funds are returned via fund return mechanism
+   *
+   * **Status Values:**
+   * - `INITIE`: Cancellation request sent, awaiting payee response
+   * - `ACCEPTE`: Payee accepted cancellation (funds returned)
+   * - `REJETE`: Payee rejected cancellation request
+   *
+   * **Rejection Reasons:**
+   * - `CUST`: Customer rejection (payee refuses cancellation)
+   * - `AM09`: Wrong amount
+   * - `AC06`: Blocked account
+   * - `FR01`: Fraud suspicion
+   *
+   * @param request - Cancellation request data
+   * @param request.comptePayeur - Business account number (original payer)
+   * @param request.txId - Original payment transaction ID to cancel
+   * @param request.motif - Cancellation reason code (e.g., 'CUST' for customer request)
+   * @returns Cancellation request response
+   * @throws {PiSpiValidationError} If cancellation fails validation (e.g., > 90 days, invalid txId)
+   * @throws {PiSpiNotFoundError} If payment not found
+   *
+   * @example
+   * ```typescript
+   * // Request cancellation
+   * await sdk.demandesAnnulation.create({
+   *   comptePayeur: 'CIC2344256727788288822',
+   *   txId: '23552722', // Payment to cancel
+   *   motif: 'CUST' // Customer request
+   * });
+   * ```
+   */
+  async create(request) {
+    const end2endId = request.end2endId ?? request.txId;
+    if (!end2endId) {
+      throw new Error("end2endId or txId is required for cancellation requests");
+    }
+    return this.request(
+      "POST",
+      `/paiements/${encodeURIComponent(end2endId)}/annulations`,
+      { raison: request.motif }
+    );
+  }
+  /**
+   * Get cancellation request details by end-to-end ID
+   */
+  async get(end2endId) {
+    return this.request(
+      "GET",
+      `/paiements/${encodeURIComponent(end2endId)}/statuts`
+    );
+  }
+  /**
+   * List payments with cancellation status filter
+   */
+  async list(params) {
+    return this.request("GET", "/paiements", void 0, params);
+  }
+  /**
+   * Respond to a cancellation request (accept or reject)
+   */
+  async respond(end2endId, decision) {
+    return this.request(
+      "PUT",
+      `/paiements/${encodeURIComponent(end2endId)}/annulations/reponses`,
+      { decision }
+    );
+  }
+};
+
+// src/qrcode/logo.ts
+var AMBER_LOGO_SEGMENTS = [
+  "iVBORw0KGgoAAAANSUhEUgAAAMAAAADACAMAAABlApw1AAACUlBMVEUAAAD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQBqFsbfAAAAxXRSTlMAAAUpaqDF2uPq7ezn",
+  "4djPzsvDwsC3trCdfVEdAgtJn977/vXUlUQIQK7087FHHJ7vKBmsLBqtyi8bMC3WuSs+v9EjvLM0ILW9",
+  "zR4yxh8Xphb9shil+Ov8bzND4BUh14g3pKgmmQdL+YsO7j8PupYKVSVKaKI15cETLnpkca+n08QN5gOX",
+  "XV5gTV9TbooU0HTdQYmOewaMIk8E6PZc0tyakN9CTPJaZcgBRngJJDs4gEhY8E5SEpwREGHi5JuU2/dw",
+  "ofG+YwjdAcYAAAZRSURBVHja7Z37XxRVGIfnhULYFQQlNJTLriGiSSiBGGFihVwqm0BJMfOGS2aE5C2z",
+  "q0ghGqXdyBQrIaKbUWSl2fX8X82wrCyX2Xln59zm8znfn4fZ59nznrOzh3POalqcgYTEO+5MmpNsJsXn",
+  "nxbf3OTJpM6ZSNq89PFkzF9gJvOuLCMLF92dvXgJxMsRL35Obl5+gNBJcOk9BctygKMDFC4vWkGJfiIr",
+  "713FTwGK7yuhiz+uULSakwGsKaWPb2bB/VwMoKycDT8hays4GDDk52LAlJ+9AcA6pvyGwQNMDaAyM8hW",
+  "gDy4jKEBlFUxxjcybz0zA8b1H8n8REYGnPiZGXDjZ2TAkZ+FAUBlFevxJzoZD1E2gOINHPGNVNMdi7jW",
+  "TzhUq0gAv2FA7+laCD8hGzZSMhDET8jDVAwAEh/hOf5EJ/NRCgZQkyQI30i1+54srH7CcV1FgvldGwjn",
+  "d2fA/vsXWwNj/Nkkmt5MbZxPFQZ/nWj2cNLjGosA6rNEk0eSVe/cwOCXon7C2eTYQC5+5way8Ts1ANgo",
+  "Gb9h4GA0BajIEM07MxnoWUejfjjMXzlPVT1OQL76j2RhGcZAXn5CyhEGMvNjDABqJOY3DNbF7skADY+J",
+  "ZoyZYGYlxOR/nPP8lfNUxagiues/Eut+4A1+awOv8BsGT4Cn+Ulw85MwC3+D9P33dvSnZsybgtD5K+ep",
+  "agSv1k84waYpVeQ5/mkGTviDW0q28omvGW2A5/cXPb1qWwWXVG5vsWuDHRMG8AySf+ezuwq5rQuDNWk2",
+  "OPrucE+GnD0o/EDTXq7L2mwFCNnXCmYH2L8Swx9qe47rykKMwIHnTYGDL6AaoD2H78pIjAApfxE06NiC",
+  "4U87xHllJ0pgRSdohagVfIGXeNY/WoAcTtCOHMUIHDvOfWktSiD1Ze2EjrhOf4V3AyAFmk9qr2Ia4Ggi",
+  "b36kAHlNex1z2RtvyiqQrr2F8jwlq0Cy5sNc1sW9C2AF/Jofc1k7d34loASUgBJQAkpACSgBeQRqT3ff",
+  "ztvbLGyg9Z2ebkR61lvdIOfM5A1O986lKECCkyFnrV7/3LvR11mG9FndoL5lygvRFIhOWwwBVKwFUh3D",
+  "KAEloASUgBJQAkpACSgBJaAElIASUAJKQAkoASWgBJSAElACSkAJKAFXAsXveVygtcnbAhoklqPWcUsr",
+  "oEHO+33n28K5gKonIQIfoLYFf4ja1SBE4CPMGkiZBXZjzjiWWeAYZiuCzAItH3tcIPSJxwWMOyA298ss",
+  "sBaxnUJqgaW5Hhcgef22BnILfLrL4wKk1PajAC2A2gBBXeDiZ3YDEVogRYgAuWS3sQ4tcFmMABlIABoC",
+  "yVqmIIGSDptTUnACddoVQQLk8y9iGiAFNmtfXhUkQFoGY23uwgmEhrQdX4kSIL7eVnApkL9agxPCBMjF",
+  "K42WZYQTyOvXYK/TcYieAAnWNgyDC4GrX4MGMILZz8pGwOgIIxZnNqEE9nxj7klffEmgANGr+76drTNj",
+  "BPzfmX8IsN/ZlKSlwPF4BAyF/KaT35/rn9YQCIHQD+EPQ4Bs1K7uSEqvdc6a3B/z4xIwEhytLj3fO5gd",
+  "fbef7E4b1AsiT4QAPzsxaA5ZxeX51Hpgyt1suqa+aGzybBJnBlIkmt+LBlP5TYMzzp+rJeI3DJYMoTbd",
+  "yBH98Mx5DS9V0cz331sGs/N7x8CK3ysG1vzjBtL35OYY/KbB0FbRhDb8v1yP/VV6WO4qChT8ajcdI3U/",
+  "CBQctJ+TlNgAwy+zAY5fXgMsv2nw2wHRtDOjD+DPiYNTHdK1QaD9OppfxirC14+cBk75ZTNwzi+XQTz8",
+  "psHgqGjycPSu+M6phIRBKdog0DUWF78sVRRf/chj4IZfBgN3/OIN3PKbBh0Cn4v0Avfn5EJ/z+/C3v8B",
+  "J88/1m3Q6XxJMx1+1/Uj1oAWvygDevxiDGjyj/8fjfOMF11+c76o+wZX/pt28z9yVxHt95+3AQt+ngZs",
+  "+PkZsOIfN0j2Mr9p0M18NG2+yY7fHE0drquI4/2nPX5ObwO2/YBl/fAwYM/P1iDwB3t+0+DaLTb8f57l",
+  "c8g+wPb0AAP+lBFev3ID0PjXTtq/XT/695EETvymwnBNX9I/9OhDl/ctb+WHH26FsdwL/95K8fld50Zd",
+  "03+H7Ld0WOR/rIwlUtPE/X8AAAAASUVORK5CYII="
+];
+var OCTO_QRCODE_LOGO_SEGMENTS = [
+  "iVBORw0KGgoAAAANSUhEUgAAAPYAAAD6CAYAAACS0LqzAAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAA",
+  "AAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAA9qADAAQAAAABAAAA+gAA",
+  "AAA4bIViAAAVTklEQVR4Ae2dW2xcx3nHZ5bcpVYXmEEkBPYDuXmI5ASoJVVGEyCwRD4YsFE5lquXpK0Q",
+  "CYUvDwYiG0iARkEkAbGLGkVsoyrgSwNLdYq4LRQ7qQEH9YNoGQGSoJIYP0ixXrr0g51ADkJDIpdcUns6",
+  "H9cUd8nl7jln5/LNzH8AWrvnMueb3zc/z+w5Z89KgZKaQFKrVRbEzTE5UNjZaIiKFGLXqp0rq94zeptM",
+  "CyHVn/ZS1VVjIsS0lCsxSplM31xsTA3IgcliuTyh6zgx1KP6Jko3AkmSDM/XZg4XCoUH1XZj3bbFOuME",
+  "JkTSOFPcsOmN1v8BGD+qhweA2OskjYRerM99K0kaR9VIN7zOZljshkBVyGSi2CiclOVy1U0IvI8KsTvk",
+  "Z3F+5kAjEa9A6A5weC2qNoR4fsOGjc/xCst9NBC7JQc0Si/UZ58ViTzcshgv+ROYKCbyCEbvlURB7E9Z",
+  "1NSJsYFC8rpI1pwQW6GFV5wJVEVh8KFSqTTJOUhbsUFsRXpJapmcUy8rtsDjOAYISDEt5OA45FYfIg3g",
+  "9apKSO1VunoHC7mXGEUtNqTu7YmXW0DueEdsSO2lsumDjlzuKEdsSJ3eD6+3jFju6MSG1F6rmif4qroU",
+  "Nh7bpbCoxF66Tj1fu6R6RyVPD8E+3hKITu6Ct6nKGHjz5pMaLmll5BbI5pUFdTmTvsQTSHt6NiOKEfuW",
+  "1Lj5pGeHCHyDaEbu4MWG1IGrmr15UcgdtNiQOnuvj2SP4OUOVmxIHYmi+ZsZtNxBig2p8/f2yPYMVu7g",
+  "xIbUkanZf3ODlDs4sevzs5fw1cv+e3tkNQQnd1DXsevzM69A6siU1NPc4K5zBzNiN6XGk0/09PNoawlm",
+  "5A5CbEgdrYgmGl4tDpV3+/4UVO+n4pDaRN+Ous7KQr12jk7C+kzB6xEbUvvc9ZjHLsVksVQe93Xk9lZs",
+  "blLPXJ8WVy68u/R37fdTYurqe0s9d/b6J4LWcSnb7hjVHsq227PXue32ETGyfaeobL9LfHHPPdpj0lKh",
+  "x3J7KTYnqa9cOC/eeu1floTmJLCWjm2pkk1bhsWefQ+Ig498V+T5n4TRMD2V2zuxF+Zmn02EOGo0mSkq",
+  "v/bRlHjx5KPishIbRR+BvfsP8RPcQ7m9EnthvnZcndQ4oa8b5avprddOiZ++9DSrKXa+lvDd6+Ajx8TB",
+  "h4/xCdAzub0Rm4vUZ19+Spx96Sk+HS7gSO4ee0A8+v0XBU3VWRSZnC4NbTrCIpYeQXghNqTukcWAV4+q",
+  "k2vfe+EXkDtjjtmLDakzZjTAzSF39qSyFhtSZ09oqHtA7myZZSs2pM6WyBi2htzps8xSbEidPoGxbQm5",
+  "02Wc3b3ikDpd4mLdiu7o+8Fj9/G51Kh+S72u7q3glg9WYkNqbt2DZzzs5FY3TFHf5USLzVQcUnPqFn7E",
+  "wm1arr4wckJ95fMkB3osxIbUHLqCnzFA7s55cy42pO6cGCxNTwByr2XlVGxIvTYhWJKPAORu5+ZMbEjd",
+  "ngi8658A5F5h6ERsSL2SALzSSwByN3laF7s+N/ctIRrP6U1n9trwLa3szHzZA3ILYVXsxXr9m43G4mnX",
+  "HQRSu86A+ePHLrc1sSG1+c6MI7QTiFluK2JD6vYOh3f2CMQqt3GxIbW9TowjdSZAcv/Dv/+q80oHS23c",
+  "oWb0XnEuUr/6w+/gcUYOOjCXQ9K95fTgSS6FnttHbpiMx9iIzUXqF1RCz7/5qkmGqNsTAvvUE1AfPf4i",
+  "m2gLhcHDg6XSGRMBGREbUptIFerUQSAWubWLvVCrjSUyOacjCf3UgZG6H3ph7xuD3Fo/Y9dv3NiVyMbr",
+  "rrsFpHadAd7Hf0d9NOP0mZvu7dD9mVvbiE1Si0GpRmrp9CHQkJq3VJyiC3nk1iI2pObUXRFLFgLc5JaJ",
+  "HC+WyxNZ2tBp276n4pC6E1Ys84UAt2l5Ukher9fru/rl19eIDan7xY/9uRBgNXJLMS3k4HipVJrMyye3",
+  "2JA6L3Lsx5VASHLnEhtSc+2aiKtfAqHInVnsWq1WGZCNSzj73W8Xwv5cCYQgd6aTZ02p6eYTXNLi2ikR",
+  "V/8EWJ1QS8SwSBbPZT2hlnrEXpFaVPpHl78GXKfOzw57ZiPAauQWolpUl8JkuVxN04pUYkPqNCixTYgE",
+  "fJW7p9iQOsTuijZlIeCj3F3FhtRZ0o9tQybgm9zrig2pQ+6maFseAj7J3VFsSJ0n7dgnBgK+yL1GbEgd",
+  "Q/dEG/shwE7uofJu9Ry16dY2rbmOXZCNZ9UGldaNbL/GJS3bxHG8LARYXedWri7UZ8nZttImNv1KhxTy",
+  "QNsWlt9AasvAcbhcBFjJncjDi/Mzbd7emopzmIJD6lx9DDs5JMBmWq6+EVYslT+/PCW/NWIPFBrHFZ+K",
+  "K0aQ2hV5HLcfAmxGbnXraX1u9uhyW5ZG7E9H6/9bXmj7X0htmziOp5sAi5G7ZdReGrEHxM0x3Q1NWx+k",
+  "TksK23EmwGLkVqP2/HztMHFqTsVlgabh1gukto4cBzRIgIPcSugHqYnS1TQcUhvsYajaKQHX0/LiUPkz",
+  "BRfTcEjttN/h4IYJuB65F+ZmDhREQe4z3M626iF1Gw68CZSAU7ml2DUokkJFiMQKXl+k3rhBiK/uFGLk",
+  "c0LcOSJEWb2nZSj+EPjle0L86Odu4yW5qdj+IcBGQ1YGldSVpaMb/s/Zl59i/6uXW4fVmYe9QuzeDpEN",
+  "d4doqie5t94xIg4+fMxamwsFuVOJbf6mFJL67EtPWWtYngPd+2Ul9T0QOg877NOdAPX9jVtuE/d//fHu",
+  "G+pbW7l155m+OttruvbRFHupaZT+xr2Quj1zeKeTAMlNLtgqxsXm9KuGnaCS1PSHAgImCcxe/8TqL3wa",
+  "FfvKhfPisvrjWugEGaTmmp3w4iIXLl9410rDjIp99uWnrTQiz0GWTpSpz9QoIGCTwFuvnbJyOGNi0+cJ",
+  "zqM1jdQkNwoI2CRAs9iZ69PGD2lM7CuWphx5CNE1abqkhQICtgnQZ+0LE28aP6wxsf934r+NB5/3ALt3",
+  "4Ax4XnbYr38CU1fV3TOGizGxP/7oA8Oh56/+ztH8+2JPEOiXwOWL5k+gGRPb5jW7rKC33pZ1D2wPAvoI",
+  "zPr8GdvGCYK8qCF2XnLYTwcBG4OesRFbBwDUAQIgkI8AxM7HDXuBAGsCEJt1ehAcCOQjALHzccNeIMCa",
+  "AMRmnR4EBwL5CEDsfNywFwiwJgCxWacHwYFAPgIQOx837AUCrAlAbNbpQXAgkI8AxM7HDXuBAGsCEJt1",
+  "ehAcCOQjALHzccNeIMCaAMRmnR4EBwL5CNBzxaMrF69mf9DCZ9VXPW19j/vS+0LMzvNOy44Re4+Wol/1",
+  "yFp+Z+9Jv1lDs7J9lGL/5H+ys/3qXfbEfvs3QnDvmH/3NXtiu/6pnuy9xf0emIq7zwEiAAHtBCC2dqSo",
+  "EATcE4DY7nOACEBAOwGIrR0pKgQB9wQgtvscIAIQ0E4AYmtHigpBwD0BiO0+B4gABLQTgNjakaJCEHBP",
+  "AGK7zwEiAAHtBCC2dqSoEATcE4DY7nOACEBAOwGIrR0pKgQB9wQgtvscIAIQ0E4AYmtHigpBwD0BiO0+",
+  "B4gABLQTgNjakaJCEHBPAGK7zwEiAAHtBCC2dqSoEATcE4DY7nOACEBAOwGIrR0pKgQB9wQgtvscIAIQ",
+  "0E4AYmtHigpBwD0BiO0+B4gABLQTgNjakaJCEHBPAGK7zwEiAAHtBCC2dqSoEATcE4DY7nOACEBAOwGI",
+  "rR0pKgQB9wQgtvscIAIQ0E4AYmtHigpBwD0BiO0+B4gABLQTgNjakaJCEHBPAGK7zwEiAAHtBCC2dqSo",
+  "EATcE4DY7nOACEBAOwGIrR0pKgQB9wQgtvscIAIQ0E4AYmtHigpBwD0BiO0+B4gABLQTgNjakaJCEHBP",
+  "AGK7zwEiAAHtBCC2dqSoEATcE4DY7nOACEBAOwGIrR0pKgQB9wQgtvscIIIeBDZu6LEBVq8hALHXIMECbgQe3MstIv7xDPIPERHG",
+  "TuDev2gSePs3Qnw8HTuNdO2H2Ok4YSvHBEhu+nt/Kl0gs3NC/PN/pds2xK0gdohZDbhNO0bTNS72kR2f",
+  "sdP1E2y1ikDs4qzCwe4txGaXEj8Cgti88wSxeeeHbXR//IRtaAhMEYDY6Aa5CHzwh1y7YSdLBCC2JdCh",
+  "HYbOOv8Rl57YphVis00N/8AuXuUfY6wRQuxYM6+h3Zfe11AJqjBCAGIbwRpHpb9TN4vQlByFHwGIzS8n",
+  "XkVEt3mi8CMAsfnlxKuISGyM2vxSBrH55cSriEhqjNr8Ugax+eXEu4gwavNLGcTmlxPvIqJR+2fvehd2",
+  "0AEbE3vTluGgwaFx7QTe/rUQdJYchQcBY2Jv3HIbjxYiCmsETqnvP+PLIb1xb7s95XdPe1e17hbGxB79",
+  "wl3rHhQrwiRAU/Jnfoyz5L2yu+0Oj8X+4p57erUP6wMkQCM25O6eWBuDnrER+0sQu3t2A177we8hd7f0",
+  "3mnBDWNij27fKb60B4+X7JbgkNeR3Cf+FZ+5O+XYxqBnTGxq0J59+zu1C8siIbA8Lce3wFYSvnf/3wob",
+  "V4yMir1v/yFh40TBCja84kaA5D71n0L85G2M3pSbg48cs5IiJXZi7OvydMnr0BPPWGkIDsKbAF3nppNq",
+  "v3yPd5wmo6PR2salLmqDElsaE5sOcPfYA0t/9BolbgI0ev/o50J851RTcHofSyGhbY3Wiml1UEoxmSSi",
+  "YhLwY99/Sfz91a+Iax/i1iSTnH2pe1lwivfPdwixW/3tGBFi67AvLcge56En/9HaaK2iqw7evCneKRTE",
+  "geyhpt+DpuTfe+EX4geP3eet3B+rp3LamkbG9DXIi+opLPRHhcQe+ZwQn1X/blU3LvbzY3ycGB58+Jia",
+  "tX6t2Ugr/238Vi7UamOJTM7ZON61j6a8ltsGIxwjLAIktcUpeBNeIo9IelWfm/mT+qxtZSIEucPquGjN",
+  "+gScSK3CKSby883LXY3kzPrh6V1DJxFoWo7LYHq5ojZeBFxJra5yTcpyuboktpQDb9jEArlt0saxbBNw",
+  "J7VqaVJ4ntq7JHaxXJ5QU3H1Z69AbnuscSR7BJxKrZpZFGKCWtuciqsXMhEnaYHNArlt0saxTBNwLbWQ",
+  "8jRNw6mdt8SmUTsRwuqUnAKA3EQBxXcCzqVW166LjZXB+ZbYBLY0NH9E/VOl1zYL5LZJG8fSTYCB1Oqz",
+  "tTy5PFpT+9rElvIz01JdA9Pd8DT1Qe40lLANNwIspFZT8FK5fLqVTZvYtKJ5Ik080bqRrdeQ2xZpHEcH",
+  "ARZSr5qCL7drjdi0orRh43NJklg/mUbHhtxEAYU7ATZSJ3K8dQq+zE0uv+j073xt5oSU8nindaaX4Q41",
+  "04RRf14C3KWmdnUVmzaA3EQBBQSaBHyQmiLtKTZtBLmJAkrsBHyRmvKUSmzaEHITBZRYCfCQOpkuJoXd",
+  "nT5Tr85Lx5Nnqzei90PlTSdwQq0TGSwLnQAXqcVi0vFEWSf+qUfs5Z0xci+TwL8xEOAkdWnz5sm0zDOL",
+  "TRVD7rR4sZ3PBHyVmpjnEpt2hNxEASVUAj5LTTnJLTbtDLmJAkrsBHyRmvKUSmzaEHITBZRYCfCQOpkuJoXd",
+  "AMXmnJLTbtDLmJAkpoBHyXmvLRl9hUwXztxmkpC9+k17YLr3LaJmz8e",
+  "pG4ytvoZe3Va6TP3TfUTJWp5dfU6G+9xQs0GZXvHgNQrrJ2O2Mth1Gq1yoBM1B1qGLmXmeDfbAQgdTsv",
+  "FmJTSJC7PTF4l54ApF7Lio3YFBrkXpsgLOlOAFJ35sNKbAoRcndOFJauJQCp1zJZXsJObAoMci+nB/+u",
+  "RwBSr0emuZyl2BQa5O6euJjXQure2WcrNoUOuXsnMLYtIHW6jLMWm5oAudMlMoatDj35jLj/G487byrd",
+  "++3iNtEsDWcvNjUGcmdJaZjbPnb8RbF3/yHnjfNBaoLkhdgUKOQmCnEWSJ09796ITU2D3NkT7PsekDpf",
+  "Bl0Sm5roWu7Z65+If/vht8X5N3+cjzj2SkWA7uN/8p/+Q4xuvyvV9iY38mX63crAO7EpeNdyUwzvvPmq",
+  "+OnLT4trH07RWxSNBO7/+uPirx75rti0ZVhjrfmq8lFqaqmXYlPgHOSmOCA4Uei/kMR7//JvxH1//big",
+  "0ZpDod+io5+t4hBL1hi8FZsaWr9xY5cYlPTccuf/a5+6+p64fOG8uHLxXfHxhx8I+q73zPXprPmIZvtt",
+  "d4wuCTz6hT8Td489IEbUlJvDCL2cAJ+lpjZ4LTY1gJPcFA+K/wR8l5oy4L3Y1AjITRRQdBAIQWriEITY",
+  "1BDITRRQ+iEQitTEIBixqTGQmyig5CEQktTU/qDEpgZBbqKAkoVAaFJT24MTmxoFuYkCShoCIUpN7Q5S",
+  "bGoY5CYKKN0IhCo1tTlYsalx9VrtsJDJK/QaBQTaCEgxWSyVx6WUQd5sELTYlEjI3dad8YYIBC51s4kR",
+  "pBpyR5DktE2MQOpoxKaGQu60PT/g7SKRmjIY/FS8tZtC7lYakb2OSGrKbFRiU4MhN1GIrEQmNWU3OrGp",
+  "0ZCbKERSIpSaMhul2NRwyE0UAi+RSk1Zdfozui67ValcPk1Px3AZA45tkEDEUhPVaMWmxtOzoSE3kQiu",
+  "VIsN+VCoN5+kyVa0U/FWOPO1mROqExxvXYbX3hKoFhM5Lsvlqrct0BA4xP4UYn1u9qh6+awGpqjCFYHI",
+  "p9+t2KOeireCKG3Y+JxYbOxWy6qty/HaFwKN50O+9ztrFiB2C7HS5s2TN9U0Tn3uPtOyGC9ZE0imC3Lg",
+  "odKGzUdj/ky9OkWYiq8m8un7hVptLJENNTWXu9bZBIudEkimk0Q8TzMtCL02ERB7LZO2JSR4QzQOSyke",
+  "VJIPt63EGxcEJtSM6h0I3R09xO7Op21tcxRPDijBdwrRIMkrkL0Nke43VSGSaSELk42byW+HpHwj9rPd",
+  "aQH/P0RzGOBNa7tyAAAAAElFTkSuQmCC"
+];
+var PISPI_AMBER_LOGO_DATA_URL = `data:image/png;base64,${AMBER_LOGO_SEGMENTS.join("")}`;
+var PISPI_QRCODE_LOGO_DATA_URL = `data:image/png;base64,${OCTO_QRCODE_LOGO_SEGMENTS.join("")}`;
+var DEFAULT_PISPI_LOGO_DATA_URL = PISPI_QRCODE_LOGO_DATA_URL;
+
+// src/qrcode/index.ts
+var cachedQrCodeModule = null;
+function resolveQrCodeModule(module) {
+  if (module?.create) {
+    return module;
+  }
+  if (module?.default?.create) {
+    return module.default;
+  }
+  throw new Error(`Le module "qrcode" n'expose pas l'API attendue.`);
+}
+async function getQrCodeModule() {
+  if (cachedQrCodeModule) {
+    return cachedQrCodeModule;
+  }
+  if (typeof window !== "undefined" && window.QRCode) {
+    const resolved2 = resolveQrCodeModule(window.QRCode);
+    cachedQrCodeModule = resolved2;
+    return resolved2;
+  }
+  const module = await import("qrcode");
+  const resolved = resolveQrCodeModule(module);
+  cachedQrCodeModule = resolved;
+  return resolved;
+}
+var DEFAULT_MERCHANT_CATEGORY_CODE = "0000";
+var DEFAULT_CURRENCY = "952";
+var DEFAULT_MERCHANT_NAME = "X";
+var DEFAULT_MERCHANT_CITY = "X";
+var DEFAULT_REFERENCE_LABEL_TAG = "05";
+var DEFAULT_MERCHANT_CHANNEL_TAG = "11";
+var DEFAULT_LOGO_SIZE_RATIO = 0.18;
+var DEFAULT_LOGO_PADDING_RATIO = 0;
+var DEFAULT_LOGO_BORDER_RADIUS_RATIO = 0.5;
+var DEFAULT_MARGIN = 0;
+var DEFAULT_SVG_SIZE = 400;
+var DEFAULT_DOT_COLOR = "#1A1A1A";
+var DEFAULT_BACKGROUND_COLOR = "#FFFFFF";
+var DOT_RADIUS_RATIO = 0.44;
+var FINDER_CORNER_RADIUS = 0.8;
+function createQrPayload(input, options = {}) {
+  const {
+    alias,
+    amount,
+    countryCode,
+    qrType,
+    referenceLabel
+  } = input;
+  if (!alias) {
+    throw new Error('Le param\xE8tre "alias" est obligatoire.');
+  }
+  validateAlias(alias);
+  if (!countryCode) {
+    throw new Error('Le param\xE8tre "countryCode" est obligatoire.');
+  }
+  validateCountryCode(countryCode);
+  if (!qrType) {
+    throw new Error('Le param\xE8tre "qrType" est obligatoire.');
+  }
+  if (!referenceLabel) {
+    throw new Error('Le param\xE8tre "referenceLabel" est obligatoire.');
+  }
+  validateReferenceLabel(referenceLabel);
+  if (amount !== void 0 && amount !== null && amount !== "") {
+    validateAmount(amount);
+  }
+  const payloadSegments = [];
+  payloadSegments.push(formatDataObject("00", "01"));
+  const merchantAccountInformation = [
+    formatDataObject("00", "int.bceao.pi"),
+    formatDataObject("01", alias)
+  ].join("");
+  payloadSegments.push(
+    formatDataObject("36", merchantAccountInformation),
+    formatDataObject("52", DEFAULT_MERCHANT_CATEGORY_CODE),
+    formatDataObject("53", DEFAULT_CURRENCY)
+  );
+  if (amount !== void 0 && amount !== null && amount !== "") {
+    payloadSegments.push(
+      formatDataObject("54", sanitizeAmount(amount))
+    );
+  }
+  payloadSegments.push(
+    formatDataObject("58", countryCode),
+    formatDataObject("59", DEFAULT_MERCHANT_NAME),
+    formatDataObject("60", DEFAULT_MERCHANT_CITY)
+  );
+  const normalizedQrType = normalizeQrType(qrType);
+  const additionalData = buildAdditionalData(
+    normalizedQrType,
+    referenceLabel,
+    options.additionalData
+  );
+  if (additionalData) {
+    payloadSegments.push(formatDataObject("62", additionalData));
+  }
+  const payloadWithoutCrc = payloadSegments.join("");
+  const crcInput = `${payloadWithoutCrc}6304`;
+  const crc = computeCrc16(crcInput);
+  return { payload: `${payloadWithoutCrc}6304${crc}` };
+}
+function buildAdditionalData(qrType, referenceLabel, overrides) {
+  const segments = [];
+  const referenceLabelTag = formatDataObject(
+    DEFAULT_REFERENCE_LABEL_TAG,
+    referenceLabel
+  );
+  segments.push(referenceLabelTag);
+  const merchantChannelValue = mapMerchantChannelFromType(qrType);
+  segments.push(
+    formatDataObject(DEFAULT_MERCHANT_CHANNEL_TAG, merchantChannelValue)
+  );
+  if (overrides?.purposeOfTransaction) {
+    segments.push(formatDataObject("12", overrides.purposeOfTransaction));
+  }
+  if (overrides?.custom) {
+    const entries = Object.entries(overrides.custom).sort(
+      ([a], [b]) => a.localeCompare(b)
+    );
+    for (const [tag, value] of entries) {
+      validateSubTag(tag);
+      segments.push(formatDataObject(tag, value));
+    }
+  }
+  return segments.join("");
+}
+function mapMerchantChannelFromType(value) {
+  return value === "DYNAMIC" ? "400" : "000";
+}
+function mapQrTypeFromChannel(channel) {
+  const normalized = channel?.trim().toUpperCase();
+  if (normalized === "400") {
+    return "DYNAMIC";
+  }
+  return "STATIC";
+}
+function formatDataObject(id, value) {
+  const length = value.length.toString().padStart(2, "0");
+  return `${id}${length}${value}`;
+}
+function sanitizeAmount(value) {
+  return typeof value === "number" ? value.toString() : value.trim();
+}
+function validateSubTag(tag) {
+  if (!/^[0-9A-Za-z]{2}$/.test(tag)) {
+    throw new Error(
+      `Le sous-tag additional data "${tag}" doit contenir exactement 2 caract\xE8res alphanum\xE9riques.`
+    );
+  }
+}
+function validateAlias(alias) {
+  const uuidV4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  if (!uuidV4Regex.test(alias)) {
+    throw new Error("L'alias doit \xEAtre un UUID v4 valide.");
+  }
+}
+function validateReferenceLabel(reference) {
+  if (reference.length > 25) {
+    throw new Error("Le referenceLabel ne doit pas d\xE9passer 25 caract\xE8res.");
+  }
+}
+function normalizeQrType(type) {
+  const normalized = type.trim().toUpperCase();
+  if (normalized === "STATIC" || normalized === "DYNAMIC") {
+    return normalized;
+  }
+  throw new Error('Le param\xE8tre "qrType" doit \xEAtre "STATIC" ou "DYNAMIC".');
+}
+var UEMOA_COUNTRIES = /* @__PURE__ */ new Set(["BJ", "BF", "CI", "ML", "NE", "SN", "TG", "GW"]);
+function validateCountryCode(code) {
+  if (!UEMOA_COUNTRIES.has(code.toUpperCase())) {
+    throw new Error("Le countryCode doit \xEAtre l'un des codes ISO2 de l'UEMOA (BJ, BF, CI, ML, NE, SN, TG, GW).");
+  }
+}
+function validateAmount(amount) {
+  const normalized = typeof amount === "number" ? amount.toString() : amount.trim();
+  if (!/^\d+$/.test(normalized)) {
+    throw new Error("Le montant doit contenir uniquement des chiffres.");
+  }
+  if (normalized.length > 13) {
+    throw new Error("Le montant ne doit pas d\xE9passer 13 chiffres.");
+  }
+}
+function computeCrc16(input) {
+  let crc = 65535;
+  const polynomial = 4129;
+  for (let i = 0; i < input.length; i += 1) {
+    crc ^= (input.codePointAt(i) ?? 0) << 8;
+    for (let j = 0; j < 8; j += 1) {
+      const hasHighBit = (crc & 32768) === 0;
+      crc = hasHighBit ? crc << 1 : crc << 1 ^ polynomial;
+      crc &= 65535;
+    }
+  }
+  return crc.toString(16).toUpperCase().padStart(4, "0");
+}
+function buildPayloadString(params, options) {
+  return createQrPayload(params, options).payload;
+}
+async function generateQrCodeSvg(input, options = {}) {
+  const { payload } = createQrPayload(input);
+  const size = options.size ?? DEFAULT_SVG_SIZE;
+  const margin = options.margin ?? DEFAULT_MARGIN;
+  const module = await getQrCodeModule();
+  const qr = module.create(payload, {
+    errorCorrectionLevel: "M"
+  });
+  const dotColor = options.dotColor ?? DEFAULT_DOT_COLOR;
+  const backgroundColor = options.backgroundColor ?? DEFAULT_BACKGROUND_COLOR;
+  return buildDotPatternSvg(qr, {
+    size,
+    margin,
+    dotColor,
+    backgroundColor,
+    logo: {
+      dataUrl: options.logoDataUrl ?? DEFAULT_PISPI_LOGO_DATA_URL,
+      sizeRatio: options.logoSizeRatio ?? DEFAULT_LOGO_SIZE_RATIO,
+      paddingRatio: options.logoPaddingRatio ?? DEFAULT_LOGO_PADDING_RATIO,
+      borderRadiusRatio: options.logoBorderRadiusRatio ?? DEFAULT_LOGO_BORDER_RADIUS_RATIO,
+      backgroundColor: options.logoBackgroundColor ?? DEFAULT_BACKGROUND_COLOR
+    }
+  });
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function formatSvgNumber(value) {
+  const normalized = Number.parseFloat(value.toFixed(3));
+  if (Number.isNaN(normalized)) {
+    return "0";
+  }
+  return normalized.toString();
+}
+var QRCode = {
+  // Original methods
+  createQrPayload,
+  buildPayloadString,
+  computeCrc16,
+  generateQrCodeSvg,
+  isValidPispiQrPayload,
+  // Simplified aliases
+  payload: buildPayloadString,
+  svg: generateQrCodeSvg,
+  validate: isValidPispiQrPayload,
+  raw: createQrPayload
+  // For when you need the object wrapper
+};
+function isValidPispiQrPayload(value) {
+  const basicErrors = validatePayloadBasics(value);
+  if (basicErrors.length > 0) {
+    return { valid: false, errors: basicErrors };
+  }
+  const { segments, errors: parseErrors } = parseEmvSegments(value);
+  if (parseErrors.length > 0) {
+    return { valid: false, errors: parseErrors };
+  }
+  const segmentValidation = validateSegmentContent(segments, value);
+  if (segmentValidation.errors.length > 0) {
+    return { valid: false, errors: segmentValidation.errors };
+  }
+  const data = buildValidationData(segments, segmentValidation);
+  return {
+    valid: true,
+    errors: [],
+    data
+  };
+}
+function validatePayloadBasics(value) {
+  if (!value) {
+    return ["La payload doit \xEAtre une cha\xEEne non vide."];
+  }
+  if (value.length < 12) {
+    return ["Payload trop courte pour contenir des segments EMV."];
+  }
+  return [];
+}
+function parseEmvSegments(value) {
+  const segments = {};
+  const errors = [];
+  let cursor = 0;
+  try {
+    while (cursor < value.length) {
+      const tag = value.slice(cursor, cursor + 2);
+      const lengthStr = value.slice(cursor + 2, cursor + 4);
+      const length = Number.parseInt(lengthStr, 10);
+      if (Number.isNaN(length) || length < 0) {
+        errors.push(`Longueur invalide pour le tag ${tag}.`);
+        break;
+      }
+      const valueStart = cursor + 4;
+      const valueEnd = valueStart + length;
+      if (valueEnd > value.length) {
+        errors.push(`Segment ${tag} tronqu\xE9.`);
+        break;
+      }
+      segments[tag] = value.slice(valueStart, valueEnd);
+      cursor = valueEnd;
+    }
+  } catch (error) {
+    errors.push(`Erreur lors de l'analyse de la payload: ${error?.message ?? error}`);
+  }
+  return { segments, errors };
+}
+function validateSegmentContent(segments, rawValue) {
+  const errors = [];
+  const formatErrors = validateFormatIndicator(segments["00"]);
+  const merchantInfoResult = extractMerchantInfo(segments["36"]);
+  const countryCodeResult = validateCountryCodeSegment(segments["58"]);
+  const additionalDataResult = extractAdditionalData(segments["62"]);
+  const crcErrors = validateCrcSegment(segments["63"], rawValue);
+  errors.push(
+    ...formatErrors,
+    ...merchantInfoResult.errors,
+    ...countryCodeResult.errors,
+    ...additionalDataResult.errors,
+    ...crcErrors
+  );
+  return {
+    errors,
+    merchantInfo: merchantInfoResult.merchantInfo,
+    referenceLabel: additionalDataResult.referenceLabel,
+    merchantChannel: additionalDataResult.merchantChannel,
+    countryCode: countryCodeResult.countryCode
+  };
+}
+function validateFormatIndicator(formatIndicator) {
+  if (!formatIndicator) {
+    return ["Tag 00 (format indicator) manquant."];
+  }
+  if (formatIndicator !== "01") {
+    return ["Tag 00 invalide (doit \xEAtre 01)."];
+  }
+  return [];
+}
+function extractMerchantInfo(segment) {
+  if (!segment) {
+    return {
+      merchantInfo: null,
+      errors: ["Tag 36 (Merchant Account Information) manquant."]
+    };
+  }
+  try {
+    const merchantInfo = parseSubFields(segment);
+    const errors = [];
+    if (!merchantInfo["01"]) {
+      errors.push("Alias manquant dans les informations marchand (tag 36).");
+    }
+    return { merchantInfo, errors };
+  } catch (error) {
+    return {
+      merchantInfo: null,
+      errors: [`Erreur lors de l'analyse des informations marchand: ${error?.message ?? error}`]
+    };
+  }
+}
+function validateCountryCodeSegment(countryCode) {
+  if (!countryCode) {
+    return {
+      errors: ["Tag 58 (Country Code) manquant."]
+    };
+  }
+  return {
+    countryCode,
+    errors: []
+  };
+}
+function extractAdditionalData(segment) {
+  if (!segment) {
+    return {
+      errors: ["Tag 62 (Additional Data Field) manquant."]
+    };
+  }
+  try {
+    const additionalSegments = parseSubFields(segment);
+    const referenceLabel = additionalSegments["05"];
+    const merchantChannel = additionalSegments[DEFAULT_MERCHANT_CHANNEL_TAG];
+    const errors = [];
+    if (!merchantChannel) {
+      errors.push("Tag 11 (Merchant Channel) manquant dans les donn\xE9es additionnelles.");
+    }
+    return {
+      referenceLabel,
+      merchantChannel,
+      errors
+    };
+  } catch (error) {
+    return {
+      errors: [`Erreur lors de l'analyse des donn\xE9es additionnelles: ${error?.message ?? error}`]
+    };
+  }
+}
+function validateCrcSegment(crc, rawValue) {
+  if (!crc) {
+    return ["Tag 63 (CRC) manquant."];
+  }
+  const payloadWithoutCrc = rawValue.slice(0, -4);
+  const computedCrc = computeCrc16(payloadWithoutCrc);
+  if (crc !== computedCrc) {
+    return ["CRC invalide."];
+  }
+  return [];
+}
+function buildValidationData(segments, context) {
+  const amountValue = segments["54"];
+  const data = {
+    alias: context.merchantInfo?.["01"] ?? "",
+    countryCode: context.countryCode ?? "",
+    qrType: mapQrTypeFromChannel(context.merchantChannel),
+    referenceLabel: context.referenceLabel ?? ""
+    // Chaîne vide si Tag 05 est absent (optionnel)
+  };
+  if (amountValue !== void 0) {
+    data.amount = amountValue;
+  }
+  return data;
+}
+function parseSubFields(data) {
+  const segments = {};
+  let cursor = 0;
+  while (cursor < data.length) {
+    const tag = data.slice(cursor, cursor + 2);
+    const lengthStr = data.slice(cursor + 2, cursor + 4);
+    const length = Number.parseInt(lengthStr, 10);
+    if (Number.isNaN(length) || length < 0) {
+      throw new Error(`Longueur invalide pour le sous-tag ${tag}`);
+    }
+    const valueStart = cursor + 4;
+    const valueEnd = valueStart + length;
+    if (valueEnd > data.length) {
+      throw new Error(`Sous-segment ${tag} tronqu\xE9`);
+    }
+    const segmentValue = data.slice(valueStart, valueEnd);
+    segments[tag] = segmentValue;
+    cursor = valueEnd;
+  }
+  return segments;
+}
+function buildDotPatternSvg(qr, options) {
+  const modules = qr.modules;
+  const moduleCount = typeof modules?.size === "number" ? modules.size : modules.length;
+  if (typeof moduleCount !== "number" || Number.isNaN(moduleCount)) {
+    throw new TypeError("Format du QR Code inattendu: impossible de d\xE9terminer la taille de la matrice.");
+  }
+  const svgSize = options.size;
+  const margin = options.margin;
+  const drawableSize = svgSize - margin * 2;
+  const cellSize = drawableSize / moduleCount;
+  const dotRadius = cellSize * DOT_RADIUS_RATIO;
+  const finderRadius = cellSize * FINDER_CORNER_RADIUS;
+  const paths = [];
+  const backgroundRect = `<rect fill="${options.backgroundColor}" width="${svgSize}" height="${svgSize}" rx="${formatSvgNumber(
+    finderRadius
+  )}" />`;
+  const finderSize = 7;
+  const finderOrigins = [
+    [0, 0],
+    [moduleCount - finderSize, 0],
+    [0, moduleCount - finderSize]
+  ];
+  for (const [fc, fr] of finderOrigins) {
+    paths.push(
+      ...generateFinderPatternRects(
+        margin + fc * cellSize,
+        margin + fr * cellSize,
+        cellSize,
+        options.dotColor,
+        options.backgroundColor
+      )
+    );
+  }
+  for (let row = 0; row < moduleCount; row += 1) {
+    for (let col = 0; col < moduleCount; col += 1) {
+      if (!isDarkModule(modules, moduleCount, row, col)) {
+        continue;
+      }
+      if (isFinderPattern(moduleCount, row, col)) {
+        continue;
+      }
+      const x = margin + col * cellSize + cellSize / 2;
+      const y = margin + row * cellSize + cellSize / 2;
+      paths.push(
+        `<circle cx="${formatSvgNumber(x)}" cy="${formatSvgNumber(y)}" r="${formatSvgNumber(
+          dotRadius
+        )}" fill="${options.dotColor}" />`
+      );
+    }
+  }
+  const logoSvg = generateLogoOverlay(
+    svgSize,
+    margin,
+    moduleCount,
+    cellSize,
+    options.logo
+  );
+  return [
+    `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 ${svgSize} ${svgSize}" shape-rendering="geometricPrecision">`,
+    backgroundRect,
+    ...paths,
+    logoSvg,
+    "</svg>"
+  ].join("");
+}
+function isFinderPattern(moduleCount, row, col) {
+  const patternSize = 7;
+  const inTop = row < patternSize;
+  const inBottom = row >= moduleCount - patternSize;
+  const inLeft = col < patternSize;
+  const inRight = col >= moduleCount - patternSize;
+  return inTop && inLeft || inTop && inRight || inBottom && inLeft;
+}
+function generateFinderPatternRects(originX, originY, cellSize, dotColor, backgroundColor) {
+  const fmt = formatSvgNumber;
+  const out7 = cellSize * 7;
+  const out5 = cellSize * 5;
+  const out3 = cellSize * 3;
+  const off1 = cellSize;
+  const off2 = cellSize * 2;
+  return [
+    `<rect x="${fmt(originX)}" y="${fmt(originY)}" width="${fmt(out7)}" height="${fmt(out7)}" fill="${dotColor}" />`,
+    `<rect x="${fmt(originX + off1)}" y="${fmt(originY + off1)}" width="${fmt(out5)}" height="${fmt(out5)}" fill="${backgroundColor}" />`,
+    `<rect x="${fmt(originX + off2)}" y="${fmt(originY + off2)}" width="${fmt(out3)}" height="${fmt(out3)}" fill="${dotColor}" />`
+  ];
+}
+function generateLogoOverlay(svgSize, margin, moduleCount, cellSize, logo) {
+  if (!logo.dataUrl) {
+    return "";
+  }
+  const qrDrawableSize = moduleCount * cellSize;
+  const logoSize = qrDrawableSize * clamp(logo.sizeRatio, 0.05, 0.5);
+  const logoPadding = logoSize * clamp(logo.paddingRatio, 0, 0.25);
+  const backgroundSize = logoSize + logoPadding * 2;
+  const logoBorderRadius = clamp(logo.borderRadiusRatio, 0, 0.5) * backgroundSize;
+  const originX = margin + (qrDrawableSize - backgroundSize) / 2;
+  const originY = margin + (qrDrawableSize - backgroundSize) / 2;
+  return [
+    `<g class="pispi-logo" transform="translate(${formatSvgNumber(originX)}, ${formatSvgNumber(originY)})" pointer-events="none">`,
+    `<rect width="${formatSvgNumber(backgroundSize)}" height="${formatSvgNumber(backgroundSize)}" rx="${formatSvgNumber(
+      logoBorderRadius
+    )}" fill="${logo.backgroundColor}" opacity="0.95"/>`,
+    `<image x="${formatSvgNumber(logoPadding)}" y="${formatSvgNumber(logoPadding)}" width="${formatSvgNumber(
+      logoSize
+    )}" height="${formatSvgNumber(logoSize)}" href="${logo.dataUrl}" xlink:href="${logo.dataUrl}" preserveAspectRatio="xMidYMid meet"/>`,
+    "</g>"
+  ].join("");
+}
+function isDarkModule(modules, moduleCount, row, col) {
+  if (modules?.data && Array.isArray(modules.data)) {
+    const index = row * moduleCount + col;
+    return Boolean(modules.data[index]);
+  }
+  if (typeof modules?.get === "function") {
+    return Boolean(modules.get(row, col));
+  }
+  if (Array.isArray(modules[row])) {
+    return Boolean(modules[row][col]);
+  }
+  return false;
+}
+
+// src/sdk.ts
+var OpenAPI2;
+var PiSpiSDK = class {
+  /**
+   * Initialize the PI-SPI SDK
+   *
+   * @param config - SDK configuration
+   *
+   * @example
+   * ```typescript
+   * const sdk = new PiSpiSDK({
+   *   baseUrl: 'https://sandbox.api.pi-bceao.com/piz/v1',
+   *   accessToken: 'your-oauth2-token',
+   * });
+   * ```
+   */
+  constructor(config) {
+    /**
+     * QR Code utilities
+     * Generate and validate BCEAO compatible QR codes
+     */
+    this.qr = QRCode;
+    this._config = {
+      BASE: config.baseUrl || "https://sandbox.api.pi-bceao.com/piz/v1",
+      TOKEN: config.accessToken,
+      dispatcher: config.dispatcher,
+      HEADERS: {
+        ...config.headers
+      }
+    };
+    try {
+      OpenAPI2 = this._config;
+    } catch {
+      OpenAPI2 = this._config;
+    }
+    this.comptes = new ComptesService2(this._config);
+    this.alias = new AliasService2(this._config);
+    this.webhooks = new WebhooksService(this._config);
+    this.demandesPaiement = new DemandesPaiementService(this._config);
+    this.demandesPaiementEnMasse = new DemandesPaiementEnMasseService(this._config);
+    this.paiements = new PaiementsService(this._config);
+    this.paiementsEnMasse = new PaiementsEnMasseService(this._config);
+    this.retoursFonds = new RetoursFondsService(this._config);
+    this.demandesAnnulation = new DemandesAnnulationService(this._config);
+  }
+  /**
+   * Update the access token
+   * Useful when tokens are refreshed
+   */
+  setAccessToken(token) {
+    if (this._config) {
+      this._config.TOKEN = token;
+    }
+    if (OpenAPI2) {
+      OpenAPI2.TOKEN = token;
+      OpenAPI2.HEADERS = {
+        ...OpenAPI2.HEADERS,
+        Authorization: `Bearer ${token}`
+      };
+    }
+  }
+  /**
+   * Get the current base URL
+   */
+  getBaseUrl() {
+    return this._config.BASE;
+  }
+};
+
+// src/customer-qr.ts
+var ALIAS_TYPES = ["SHID", "MBNO", "MCOD"];
+function buildLomiCustomerQr(input) {
+  const alias = input.alias.trim();
+  if (!alias) {
+    throw new Error("alias is required");
+  }
+  const aliasType = input.aliasType ?? "SHID";
+  if (!ALIAS_TYPES.includes(aliasType)) {
+    throw new Error(`Invalid aliasType: ${aliasType}`);
+  }
+  return {
+    t: "lomi.cust",
+    v: 1,
+    alias,
+    aliasType
+  };
+}
+function serializeLomiCustomerQr(qr) {
+  return JSON.stringify(qr);
+}
+function parseLomiCustomerQr(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed || trimmed.startsWith("000201")) {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return null;
+  }
+  const record = parsed;
+  if (record.t !== "lomi.cust" || record.v !== 1) {
+    return null;
+  }
+  const alias = record.alias;
+  if (typeof alias !== "string" || alias.trim().length === 0) {
+    return null;
+  }
+  const aliasType = record.aliasType;
+  if (typeof aliasType !== "string" || !ALIAS_TYPES.includes(aliasType)) {
+    return null;
+  }
+  return {
+    t: "lomi.cust",
+    v: 1,
+    alias: alias.trim(),
+    aliasType
+  };
+}
+
+// src/query-builder.ts
+var QueryBuilder = class {
+  constructor() {
+    this.params = {};
+    this.filters = /* @__PURE__ */ new Map();
+    this.sortOrder = "asc";
+  }
+  /**
+   * Add a filter condition
+   * @param field - Field name to filter on
+   * @param operator - Filter operator (default: 'eq')
+   * @param value - Filter value
+   */
+  filter(field, operatorOrValue, value) {
+    let operator;
+    let filterValue;
+    if (value === void 0) {
+      if (typeof operatorOrValue === "string" && this.isOperator(operatorOrValue)) {
+        throw new Error("Filter operator requires a value");
+      }
+      operator = "eq";
+      filterValue = operatorOrValue;
+    } else {
+      operator = operatorOrValue;
+      filterValue = value;
+    }
+    this.filters.set(field, { operator, value: filterValue });
+    return this;
+  }
+  /**
+   * Add an equality filter (shorthand)
+   */
+  eq(field, value) {
+    return this.filter(field, "eq", value);
+  }
+  /**
+   * Add a "not equal" filter (shorthand)
+   */
+  ne(field, value) {
+    return this.filter(field, "ne", value);
+  }
+  /**
+   * Add a "greater than" filter (shorthand)
+   */
+  gt(field, value) {
+    return this.filter(field, "gt", value);
+  }
+  /**
+   * Add a "greater than or equal" filter (shorthand)
+   */
+  gte(field, value) {
+    return this.filter(field, "gte", value);
+  }
+  /**
+   * Add a "less than" filter (shorthand)
+   */
+  lt(field, value) {
+    return this.filter(field, "lt", value);
+  }
+  /**
+   * Add a "less than or equal" filter (shorthand)
+   */
+  lte(field, value) {
+    return this.filter(field, "lte", value);
+  }
+  /**
+   * Add an "in" filter (shorthand)
+   */
+  in(field, values) {
+    return this.filter(field, "in", values);
+  }
+  /**
+   * Add a "contains" filter (shorthand)
+   */
+  contains(field, value) {
+    return this.filter(field, "contains", value);
+  }
+  /**
+   * Set sort field and order
+   * @param field - Field to sort by
+   * @param order - Sort order ('asc' or 'desc', default: 'asc')
+   */
+  sort(field, order = "asc") {
+    this.sortField = field;
+    this.sortOrder = order;
+    return this;
+  }
+  /**
+   * Sort in descending order (shorthand)
+   */
+  sortDesc(field) {
+    return this.sort(field, "desc");
+  }
+  /**
+   * Set page number
+   */
+  page(page) {
+    this.params.page = typeof page === "string" ? page : page.toString();
+    return this;
+  }
+  /**
+   * Set page size
+   */
+  size(size) {
+    if (size < 1) {
+      throw new Error("Page size must be at least 1");
+    }
+    if (size > 100) {
+      throw new Error("Page size cannot exceed 100");
+    }
+    this.params.size = size;
+    return this;
+  }
+  /**
+   * Add a custom parameter
+   */
+  param(key, value) {
+    this.params[key] = value;
+    return this;
+  }
+  /**
+   * Build the query parameters object
+   */
+  build() {
+    const result = { ...this.params };
+    for (const [field, { operator, value }] of this.filters.entries()) {
+      if (operator === "eq") {
+        result[field] = String(value);
+      } else if (operator === "exists") {
+        result[`${field}[exists]`] = String(value);
+      } else {
+        result[`${field}[${operator}]`] = Array.isArray(value) ? value.join(",") : String(value);
+      }
+    }
+    if (this.sortField) {
+      result.sort = this.sortOrder === "desc" ? `-${this.sortField}` : this.sortField;
+    }
+    return result;
+  }
+  /**
+   * Build query string
+   */
+  buildQueryString() {
+    const params = this.build();
+    const pairs = Object.entries(params).filter(([_, value]) => value !== void 0).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+    return pairs.length > 0 ? `?${pairs.join("&")}` : "";
+  }
+  /**
+   * Reset the builder
+   */
+  reset() {
+    this.params = {};
+    this.filters.clear();
+    this.sortField = void 0;
+    this.sortOrder = "asc";
+    return this;
+  }
+  isOperator(value) {
+    return [
+      "eq",
+      "ne",
+      "gt",
+      "gte",
+      "lt",
+      "lte",
+      "in",
+      "contains",
+      "notContains",
+      "beginsWith",
+      "endsWith",
+      "exists"
+    ].includes(value);
+  }
+};
+
+// src/types/alias.ts
+var AliasType = {
+  /**
+   * SHID - System-generated unique payment address (UUID format, 36 characters)
+   * Available for all client types: P, C, B, G
+   */
+  SHID: "SHID",
+  /**
+   * MCOD - Merchant code for USSD payment support
+   * Available for business clients only: C, B, G
+   */
+  MCOD: "MCOD",
+  /**
+   * MBNO - Mobile phone number alias
+   * Available for individual clients only: P
+   */
+  MBNO: "MBNO"
+};
+var ALIAS_TYPES2 = [AliasType.SHID, AliasType.MCOD, AliasType.MBNO];
+function isValidAliasType(value) {
+  return ALIAS_TYPES2.includes(value);
+}
+function getAvailableAliasTypes(clientType) {
+  switch (clientType) {
+    case "P":
+      return [AliasType.MBNO, AliasType.SHID];
+    case "C":
+    case "B":
+    case "G":
+      return [AliasType.SHID, AliasType.MCOD];
+    default:
+      return [];
+  }
+}
+
+// src/utils/index.ts
+function formatAmount(centimes) {
+  const xof = centimes / 100;
+  return new Intl.NumberFormat("fr-FR", {
+    style: "currency",
+    currency: "XOF",
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0
+  }).format(xof);
+}
+function xofToCentimes(xof) {
+  return Math.round(xof * 100);
+}
+function centimesToXof(centimes) {
+  return centimes / 100;
+}
+function isValidAccountNumber(accountNumber) {
+  return /^[A-Z]{2,3}\d{19,22}$/.test(accountNumber);
+}
+function isValidShidAlias(alias) {
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  return uuidRegex.test(alias);
+}
+function isValidPhoneNumber(phoneNumber) {
+  const phoneRegex = /^\+?[1-9]\d{8,12}$/;
+  return phoneRegex.test(phoneNumber.replace(/[\s-]/g, ""));
+}
+function getCountryFromAccount(accountNumber) {
+  const countryMap = {
+    CI: "C\xF4te d'Ivoire",
+    SN: "Senegal",
+    BJ: "Benin",
+    BF: "Burkina Faso",
+    ML: "Mali",
+    NE: "Niger",
+    TG: "Togo",
+    GW: "Guinea-Bissau"
+  };
+  const countryCode = accountNumber.substring(0, 2);
+  return countryMap[countryCode] || null;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retryWithBackoff(fn, maxRetries = 3, initialDelay = 1e3) {
+  let lastError;
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (i < maxRetries - 1) {
+        const delay = initialDelay * Math.pow(2, i);
+        await sleep(delay);
+      }
+    }
+  }
+  throw lastError ?? new Error("Retry failed with unknown error");
+}
+
+// src/utils/constants.ts
+var PI_SPI_ENDPOINTS = {
+  /** Production API endpoint */
+  PRODUCTION: "https://api.pi-bceao.com/piz/v1",
+  /** Sandbox API endpoint */
+  SANDBOX: "https://sandbox.api.pi-bceao.com/piz/v1",
+  /** Default endpoint (sandbox) */
+  DEFAULT: "https://sandbox.api.pi-bceao.com/piz/v1"
+};
+var PAYMENT_STATUS = {
+  /** Payment initiated (awaiting confirmation after alias lookup) */
+  INITIE: "INITIE",
+  /** Payment sent (validations passed, PSP has sent the request) */
+  ENVOYE: "ENVOYE",
+  /** Payment is confirmed/irreversible */
+  IRREVOCABLE: "IRREVOCABLE",
+  /** Payment has been rejected */
+  REJETE: "REJETE"
+};
+var ACCOUNT_STATUS = {
+  /** Account is open */
+  OPEN: "OUVERT",
+  /** Account is blocked */
+  BLOCKED: "BLOQUE",
+  /** Account is closed */
+  CLOSED: "CLOTURE"
+};
+var ACCOUNT_TYPE = {
+  /** Current account */
+  CURRENT: "CACC",
+  /** Savings account */
+  SAVINGS: "SVGS"
+};
+var CLIENT_TYPE = {
+  /** Individual person */
+  INDIVIDUAL: "P",
+  /** Merchant */
+  MERCHANT: "C",
+  /** Business */
+  BUSINESS: "B",
+  /** Government */
+  GOVERNMENT: "G"
+};
+var UEMOA_COUNTRIES2 = {
+  BENIN: "BJ",
+  BURKINA_FASO: "BF",
+  IVORY_COAST: "CI",
+  GUINEA_BISSAU: "GW",
+  MALI: "ML",
+  NIGER: "NE",
+  SENEGAL: "SN",
+  TOGO: "TG"
+};
+var CURRENCY = {
+  /** West African CFA Franc */
+  XOF: "XOF",
+  /** Amounts are specified in centimes (1 XOF = 100 centimes) */
+  CENTIMES_PER_XOF: 100
+};
+var DEFAULT_LIMITS = {
+  /** Maximum page size for paginated requests */
+  MAX_PAGE_SIZE: 100,
+  /** Default page size */
+  DEFAULT_PAGE_SIZE: 20,
+  /** Default aliases per account */
+  DEFAULT_ALIASES_PER_ACCOUNT: 20
+};
+var WEBHOOK_EVENTS = {
+  /** Payment received */
+  PAIEMENT_RECU: "PAIEMENT_RECU",
+  /** Payment sent */
+  PAIEMENT_ENVOYE: "PAIEMENT_ENVOYE",
+  /** Payment rejected */
+  PAIEMENT_REJETE: "PAIEMENT_REJETE",
+  /** Payment request (RTP) received */
+  RTP_RECU: "RTP_RECU",
+  /** Payment request (RTP) rejected */
+  RTP_REJETE: "RTP_REJETE",
+  /** Cancellation requested */
+  ANNULATION_DEMANDE: "ANNULATION_DEMANDE",
+  /** Cancellation rejected */
+  ANNULATION_REJETE: "ANNULATION_REJETE",
+  /** Fund return sent */
+  RETOUR_ENVOYE: "RETOUR_ENVOYE",
+  /** Fund return rejected */
+  RETOUR_REJETE: "RETOUR_REJETE",
+  /** Fund return received */
+  RETOUR_RECU: "RETOUR_RECU"
+};
+export {
+  ACCOUNT_STATUS,
+  ACCOUNT_TYPE,
+  ALIAS_TYPES2 as ALIAS_TYPES,
+  AliasService,
+  AliasType,
+  AnnulationStatut,
+  ApiError,
+  CLIENT_TYPE,
+  CURRENCY,
+  CancelError,
+  CancelablePromise,
+  CompteOperation,
+  CompteSolde,
+  CompteTransfertIntraReponse,
+  ComptesService,
+  DEFAULT_LIMITS,
+  DEFAULT_PISPI_LOGO_DATA_URL,
+  DemandeAnnulationService,
+  DemandePaiementConfirmationAnnulationRaison,
+  DemandePaiementConfirmationReponse,
+  DemandePaiementConsultationReponse,
+  DemandePaiementEnMasseStatutReponse,
+  DemandePaiementListeItem,
+  DemandePaiementReponseRequest,
+  DemandePaiementRequest,
+  DemandePaiementRequestCategorie,
+  DemandePaiementStatut,
+  DemandePaiementStatutRaison,
+  DemandesDePaiementEnMasseService,
+  DemandesDePaiementService,
+  NotificationService,
+  OpenAPI,
+  PAYMENT_STATUS,
+  PISPI_AMBER_LOGO_DATA_URL,
+  PISPI_QRCODE_LOGO_DATA_URL,
+  PI_SPI_ENDPOINTS,
+  Paiement,
+  PaiementAnnulationMotif,
+  PaiementAnnulationStatutRaison,
+  PaiementEnMasseReponseStatut,
+  PaiementEnMasseService,
+  PaiementImmediatConfirmationReponse,
+  PaiementImmediatReponse,
+  PaiementImmediatService,
+  PaiementStatut,
+  PaiementStatutRaison,
+  PiSpiAuthError,
+  PiSpiError,
+  PiSpiNotFoundError,
+  PiSpiRateLimitError,
+  PiSpiSDK,
+  PiSpiValidationError,
+  QRCode,
+  QueryBuilder,
+  RefDocType,
+  RetourStatut,
+  RetourStatutRaison,
+  RetoursdeFondsService,
+  UEMOA_COUNTRIES2 as UEMOA_COUNTRIES,
+  WEBHOOK_EVENTS,
+  WebhookEvent,
+  WebhooksEvents,
+  buildLomiCustomerQr,
+  buildPayloadString,
+  centimesToXof,
+  computeCrc16,
+  createQrPayload,
+  formatAmount,
+  generateQrCodeSvg,
+  getAvailableAliasTypes,
+  getCountryFromAccount,
+  handleApiError,
+  isValidAccountNumber,
+  isValidAliasType,
+  isValidPhoneNumber,
+  isValidPispiQrPayload,
+  isValidShidAlias,
+  parseLomiCustomerQr,
+  retryWithBackoff,
+  serializeLomiCustomerQr,
+  sleep,
+  xofToCentimes
+};