pi-spi-sdk 0.1.2 → 0.2.0

package/dist/index.cjs

@@ -0,0 +1,4754 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+// src/generated/core/ApiError.ts
+var ApiError;
+var init_ApiError = __esm({
+  "src/generated/core/ApiError.ts"() {
+    "use strict";
+    ApiError = class extends Error {
+      constructor(request2, response, message) {
+        super(message);
+        this.name = "ApiError";
+        this.url = response.url;
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.body = response.body;
+        this.request = request2;
+      }
+    };
+  }
+});
+
+// src/generated/core/CancelablePromise.ts
+var CancelError, _isResolved, _isRejected, _isCancelled, _cancelHandlers, _promise, _resolve, _reject, CancelablePromise;
+var init_CancelablePromise = __esm({
+  "src/generated/core/CancelablePromise.ts"() {
+    "use strict";
+    CancelError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "CancelError";
+      }
+      get isCancelled() {
+        return true;
+      }
+    };
+    CancelablePromise = class {
+      constructor(executor) {
+        __privateAdd(this, _isResolved);
+        __privateAdd(this, _isRejected);
+        __privateAdd(this, _isCancelled);
+        __privateAdd(this, _cancelHandlers);
+        __privateAdd(this, _promise);
+        __privateAdd(this, _resolve);
+        __privateAdd(this, _reject);
+        __privateSet(this, _isResolved, false);
+        __privateSet(this, _isRejected, false);
+        __privateSet(this, _isCancelled, false);
+        __privateSet(this, _cancelHandlers, []);
+        __privateSet(this, _promise, new Promise((resolve2, reject) => {
+          __privateSet(this, _resolve, resolve2);
+          __privateSet(this, _reject, reject);
+          const onResolve = (value) => {
+            if (__privateGet(this, _isResolved) || __privateGet(this, _isRejected) || __privateGet(this, _isCancelled)) {
+              return;
+            }
+            __privateSet(this, _isResolved, true);
+            if (__privateGet(this, _resolve)) __privateGet(this, _resolve).call(this, value);
+          };
+          const onReject = (reason) => {
+            if (__privateGet(this, _isResolved) || __privateGet(this, _isRejected) || __privateGet(this, _isCancelled)) {
+              return;
+            }
+            __privateSet(this, _isRejected, true);
+            if (__privateGet(this, _reject)) __privateGet(this, _reject).call(this, reason);
+          };
+          const onCancel = (cancelHandler) => {
+            if (__privateGet(this, _isResolved) || __privateGet(this, _isRejected) || __privateGet(this, _isCancelled)) {
+              return;
+            }
+            __privateGet(this, _cancelHandlers).push(cancelHandler);
+          };
+          Object.defineProperty(onCancel, "isResolved", {
+            get: () => __privateGet(this, _isResolved)
+          });
+          Object.defineProperty(onCancel, "isRejected", {
+            get: () => __privateGet(this, _isRejected)
+          });
+          Object.defineProperty(onCancel, "isCancelled", {
+            get: () => __privateGet(this, _isCancelled)
+          });
+          return executor(onResolve, onReject, onCancel);
+        }));
+      }
+      get [Symbol.toStringTag]() {
+        return "Cancellable Promise";
+      }
+      then(onFulfilled, onRejected) {
+        return __privateGet(this, _promise).then(onFulfilled, onRejected);
+      }
+      catch(onRejected) {
+        return __privateGet(this, _promise).catch(onRejected);
+      }
+      finally(onFinally) {
+        return __privateGet(this, _promise).finally(onFinally);
+      }
+      cancel() {
+        if (__privateGet(this, _isResolved) || __privateGet(this, _isRejected) || __privateGet(this, _isCancelled)) {
+          return;
+        }
+        __privateSet(this, _isCancelled, true);
+        if (__privateGet(this, _cancelHandlers).length) {
+          try {
+            for (const cancelHandler of __privateGet(this, _cancelHandlers)) {
+              cancelHandler();
+            }
+          } catch (error) {
+            console.warn("Cancellation threw an error", error);
+            return;
+          }
+        }
+        __privateGet(this, _cancelHandlers).length = 0;
+        if (__privateGet(this, _reject)) __privateGet(this, _reject).call(this, new CancelError("Request aborted"));
+      }
+      get isCancelled() {
+        return __privateGet(this, _isCancelled);
+      }
+    };
+    _isResolved = new WeakMap();
+    _isRejected = new WeakMap();
+    _isCancelled = new WeakMap();
+    _cancelHandlers = new WeakMap();
+    _promise = new WeakMap();
+    _resolve = new WeakMap();
+    _reject = new WeakMap();
+  }
+});
+
+// src/generated/core/OpenAPI.ts
+var OpenAPI2;
+var init_OpenAPI = __esm({
+  "src/generated/core/OpenAPI.ts"() {
+    "use strict";
+    OpenAPI2 = {
+      BASE: "https://sandbox.api.pi-bceao.com/piz/v1",
+      VERSION: "1.0.0",
+      WITH_CREDENTIALS: false,
+      CREDENTIALS: "include",
+      TOKEN: void 0,
+      USERNAME: void 0,
+      PASSWORD: void 0,
+      HEADERS: void 0,
+      ENCODE_PATH: void 0
+    };
+  }
+});
+
+// src/generated/models/AnnulationStatut.ts
+var AnnulationStatut;
+var init_AnnulationStatut = __esm({
+  "src/generated/models/AnnulationStatut.ts"() {
+    "use strict";
+    AnnulationStatut = /* @__PURE__ */ ((AnnulationStatut2) => {
+      AnnulationStatut2["INITIE"] = "INITIE";
+      AnnulationStatut2["ENVOYE"] = "ENVOYE";
+      AnnulationStatut2["IRREVOCABLE"] = "IRREVOCABLE";
+      AnnulationStatut2["REJETE"] = "REJETE";
+      return AnnulationStatut2;
+    })(AnnulationStatut || {});
+  }
+});
+
+// src/generated/models/CompteOperation.ts
+var CompteOperation;
+var init_CompteOperation = __esm({
+  "src/generated/models/CompteOperation.ts"() {
+    "use strict";
+    ((CompteOperation2) => {
+      let statut;
+      ((statut2) => {
+        statut2["INITIE"] = "INITIE";
+      })(statut = CompteOperation2.statut || (CompteOperation2.statut = {}));
+      let statutRaison;
+      ((statutRaison2) => {
+        statutRaison2["SOLDE_INSUFFISANT"] = "SOLDE_INSUFFISANT";
+      })(statutRaison = CompteOperation2.statutRaison || (CompteOperation2.statutRaison = {}));
+    })(CompteOperation || (CompteOperation = {}));
+  }
+});
+
+// src/generated/models/CompteSolde.ts
+var CompteSolde;
+var init_CompteSolde = __esm({
+  "src/generated/models/CompteSolde.ts"() {
+    "use strict";
+    ((CompteSolde2) => {
+      let type;
+      ((type2) => {
+        type2["CACC"] = "CACC";
+        type2["CARD"] = "CARD";
+        type2["CASH"] = "CASH";
+        type2["CHAR"] = "CHAR";
+        type2["CISH"] = "CISH";
+        type2["COMM"] = "COMM";
+        type2["CPAC"] = "CPAC";
+        type2["LLSV"] = "LLSV";
+        type2["LOAN"] = "LOAN";
+        type2["MGLD"] = "MGLD";
+        type2["MOMA"] = "MOMA";
+        type2["NREX"] = "NREX";
+        type2["ODFT"] = "ODFT";
+        type2["ONDP"] = "ONDP";
+        type2["OTHR"] = "OTHR";
+        type2["SACC"] = "SACC";
+        type2["SLRY"] = "SLRY";
+        type2["SVGS"] = "SVGS";
+        type2["TAXE"] = "TAXE";
+        type2["TRAN"] = "TRAN";
+        type2["TRAS"] = "TRAS";
+        type2["VACC"] = "VACC";
+      })(type = CompteSolde2.type || (CompteSolde2.type = {}));
+      let statut;
+      ((statut2) => {
+        statut2["OUVERT"] = "OUVERT";
+        statut2["BLOQUE"] = "BLOQUE";
+        statut2["CLOTURE"] = "CLOTURE";
+      })(statut = CompteSolde2.statut || (CompteSolde2.statut = {}));
+    })(CompteSolde || (CompteSolde = {}));
+  }
+});
+
+// src/generated/models/CompteTransfertIntraReponse.ts
+var CompteTransfertIntraReponse;
+var init_CompteTransfertIntraReponse = __esm({
+  "src/generated/models/CompteTransfertIntraReponse.ts"() {
+    "use strict";
+    ((CompteTransfertIntraReponse2) => {
+      let statut;
+      ((statut2) => {
+        statut2["INITIE"] = "INITIE";
+      })(statut = CompteTransfertIntraReponse2.statut || (CompteTransfertIntraReponse2.statut = {}));
+    })(CompteTransfertIntraReponse || (CompteTransfertIntraReponse = {}));
+  }
+});
+
+// src/generated/models/DemandePaiementConfirmationAnnulationRaison.ts
+var DemandePaiementConfirmationAnnulationRaison;
+var init_DemandePaiementConfirmationAnnulationRaison = __esm({
+  "src/generated/models/DemandePaiementConfirmationAnnulationRaison.ts"() {
+    "use strict";
+    DemandePaiementConfirmationAnnulationRaison = /* @__PURE__ */ ((DemandePaiementConfirmationAnnulationRaison2) => {
+      DemandePaiementConfirmationAnnulationRaison2["ERREUR_ALIAS"] = "ERREUR_ALIAS";
+      DemandePaiementConfirmationAnnulationRaison2["ERREUR_MONTANT"] = "ERREUR_MONTANT";
+      DemandePaiementConfirmationAnnulationRaison2["ERREUR_TXID"] = "ERREUR_TXID";
+      DemandePaiementConfirmationAnnulationRaison2["PAYEUR_INCONNU"] = "PAYEUR_INCONNU";
+      return DemandePaiementConfirmationAnnulationRaison2;
+    })(DemandePaiementConfirmationAnnulationRaison || {});
+  }
+});
+
+// src/generated/models/DemandePaiementConfirmationReponse.ts
+var DemandePaiementConfirmationReponse;
+var init_DemandePaiementConfirmationReponse = __esm({
+  "src/generated/models/DemandePaiementConfirmationReponse.ts"() {
+    "use strict";
+    ((DemandePaiementConfirmationReponse2) => {
+      let statut;
+      ((statut2) => {
+        statut2["ENVOYE"] = "ENVOYE";
+        statut2["ANNULE"] = "ANNULE";
+      })(statut = DemandePaiementConfirmationReponse2.statut || (DemandePaiementConfirmationReponse2.statut = {}));
+    })(DemandePaiementConfirmationReponse || (DemandePaiementConfirmationReponse = {}));
+  }
+});
+
+// src/generated/models/DemandePaiementConsultationReponse.ts
+var DemandePaiementConsultationReponse;
+var init_DemandePaiementConsultationReponse = __esm({
+  "src/generated/models/DemandePaiementConsultationReponse.ts"() {
+    "use strict";
+    ((DemandePaiementConsultationReponse2) => {
+      let categorie;
+      ((categorie2) => {
+        categorie2["_631"] = "631";
+        categorie2["_500"] = "500";
+        categorie2["_521"] = "521";
+        categorie2["_401"] = "401";
+      })(categorie = DemandePaiementConsultationReponse2.categorie || (DemandePaiementConsultationReponse2.categorie = {}));
+      let statut;
+      ((statut2) => {
+        statut2["INITIE"] = "INITIE";
+        statut2["ENVOYE"] = "ENVOYE";
+        statut2["IRREVOCABLE"] = "IRREVOCABLE";
+        statut2["REJETE"] = "REJETE";
+      })(statut = DemandePaiementConsultationReponse2.statut || (DemandePaiementConsultationReponse2.statut = {}));
+    })(DemandePaiementConsultationReponse || (DemandePaiementConsultationReponse = {}));
+  }
+});
+
+// src/generated/models/DemandePaiementEnMasseStatutReponse.ts
+var DemandePaiementEnMasseStatutReponse;
+var init_DemandePaiementEnMasseStatutReponse = __esm({
+  "src/generated/models/DemandePaiementEnMasseStatutReponse.ts"() {
+    "use strict";
+    ((DemandePaiementEnMasseStatutReponse2) => {
+      let statut;
+      ((statut2) => {
+        statut2["INITIE"] = "INITIE";
+        statut2["CONFIRME"] = "CONFIRME";
+        statut2["ANNULE"] = "ANNULE";
+      })(statut = DemandePaiementEnMasseStatutReponse2.statut || (DemandePaiementEnMasseStatutReponse2.statut = {}));
+    })(DemandePaiementEnMasseStatutReponse || (DemandePaiementEnMasseStatutReponse = {}));
+  }
+});
+
+// src/generated/models/DemandePaiementListeItem.ts
+var DemandePaiementListeItem;
+var init_DemandePaiementListeItem = __esm({
+  "src/generated/models/DemandePaiementListeItem.ts"() {
+    "use strict";
+    ((DemandePaiementListeItem2) => {
+      let categorie;
+      ((categorie2) => {
+        categorie2["_631"] = "631";
+        categorie2["_500"] = "500";
+        categorie2["_521"] = "521";
+        categorie2["_401"] = "401";
+      })(categorie = DemandePaiementListeItem2.categorie || (DemandePaiementListeItem2.categorie = {}));
+      let statut;
+      ((statut2) => {
+        statut2["INITIE"] = "INITIE";
+        statut2["ENVOYE"] = "ENVOYE";
+        statut2["IRREVOCABLE"] = "IRREVOCABLE";
+        statut2["REJETE"] = "REJETE";
+      })(statut = DemandePaiementListeItem2.statut || (DemandePaiementListeItem2.statut = {}));
+    })(DemandePaiementListeItem || (DemandePaiementListeItem = {}));
+  }
+});
+
+// src/generated/models/DemandePaiementReponseRequest.ts
+var DemandePaiementReponseRequest;
+var init_DemandePaiementReponseRequest = __esm({
+  "src/generated/models/DemandePaiementReponseRequest.ts"() {
+    "use strict";
+    ((DemandePaiementReponseRequest2) => {
+      let raison;
+      ((raison2) => {
+        raison2["BE05"] = "BE05";
+        raison2["AM09"] = "AM09";
+        raison2["APAR"] = "APAR";
+        raison2["RR07"] = "RR07";
+        raison2["FR01"] = "FR01";
+      })(raison = DemandePaiementReponseRequest2.raison || (DemandePaiementReponseRequest2.raison = {}));
+    })(DemandePaiementReponseRequest || (DemandePaiementReponseRequest = {}));
+  }
+});
+
+// src/generated/models/DemandePaiementRequest.ts
+var DemandePaiementRequest;
+var init_DemandePaiementRequest = __esm({
+  "src/generated/models/DemandePaiementRequest.ts"() {
+    "use strict";
+    ((DemandePaiementRequest2) => {
+      let categorie;
+      ((categorie2) => {
+        categorie2["_500"] = "500";
+      })(categorie = DemandePaiementRequest2.categorie || (DemandePaiementRequest2.categorie = {}));
+    })(DemandePaiementRequest || (DemandePaiementRequest = {}));
+  }
+});
+
+// src/generated/models/DemandePaiementRequestCategorie.ts
+var DemandePaiementRequestCategorie;
+var init_DemandePaiementRequestCategorie = __esm({
+  "src/generated/models/DemandePaiementRequestCategorie.ts"() {
+    "use strict";
+    DemandePaiementRequestCategorie = /* @__PURE__ */ ((DemandePaiementRequestCategorie2) => {
+      DemandePaiementRequestCategorie2["_500"] = "500";
+      DemandePaiementRequestCategorie2["_521"] = "521";
+      DemandePaiementRequestCategorie2["_401"] = "401";
+      return DemandePaiementRequestCategorie2;
+    })(DemandePaiementRequestCategorie || {});
+  }
+});
+
+// src/generated/models/DemandePaiementStatut.ts
+var DemandePaiementStatut;
+var init_DemandePaiementStatut = __esm({
+  "src/generated/models/DemandePaiementStatut.ts"() {
+    "use strict";
+    DemandePaiementStatut = /* @__PURE__ */ ((DemandePaiementStatut2) => {
+      DemandePaiementStatut2["INITIE"] = "INITIE";
+      DemandePaiementStatut2["ENVOYE"] = "ENVOYE";
+      DemandePaiementStatut2["IRREVOCABLE"] = "IRREVOCABLE";
+      DemandePaiementStatut2["REJETE"] = "REJETE";
+      return DemandePaiementStatut2;
+    })(DemandePaiementStatut || {});
+  }
+});
+
+// src/generated/models/DemandePaiementStatutRaison.ts
+var DemandePaiementStatutRaison;
+var init_DemandePaiementStatutRaison = __esm({
+  "src/generated/models/DemandePaiementStatutRaison.ts"() {
+    "use strict";
+    DemandePaiementStatutRaison = /* @__PURE__ */ ((DemandePaiementStatutRaison2) => {
+      DemandePaiementStatutRaison2["BE23"] = "BE23";
+      DemandePaiementStatutRaison2["DU03"] = "DU03";
+      DemandePaiementStatutRaison2["AC04"] = "AC04";
+      DemandePaiementStatutRaison2["AC06"] = "AC06";
+      DemandePaiementStatutRaison2["AEXR"] = "AEXR";
+      DemandePaiementStatutRaison2["AG03"] = "AG03";
+      DemandePaiementStatutRaison2["AG10"] = "AG10";
+      DemandePaiementStatutRaison2["AG11"] = "AG11";
+      DemandePaiementStatutRaison2["ALAC"] = "ALAC";
+      DemandePaiementStatutRaison2["AM02"] = "AM02";
+      DemandePaiementStatutRaison2["AM09"] = "AM09";
+      DemandePaiementStatutRaison2["AM14"] = "AM14";
+      DemandePaiementStatutRaison2["APAR"] = "APAR";
+      DemandePaiementStatutRaison2["ARFR"] = "ARFR";
+      DemandePaiementStatutRaison2["ARJR"] = "ARJR";
+      DemandePaiementStatutRaison2["BE01"] = "BE01";
+      DemandePaiementStatutRaison2["BE05"] = "BE05";
+      DemandePaiementStatutRaison2["FR01"] = "FR01";
+      DemandePaiementStatutRaison2["RR07"] = "RR07";
+      return DemandePaiementStatutRaison2;
+    })(DemandePaiementStatutRaison || {});
+  }
+});
+
+// src/generated/models/Paiement.ts
+var Paiement;
+var init_Paiement = __esm({
+  "src/generated/models/Paiement.ts"() {
+    "use strict";
+    ((Paiement2) => {
+      let categorie;
+      ((categorie2) => {
+        categorie2["_631"] = "631";
+        categorie2["_000"] = "000";
+        categorie2["_400"] = "400";
+        categorie2["_733"] = "733";
+        categorie2["_300"] = "300";
+        categorie2["_999"] = "999";
+        categorie2["_500"] = "500";
+        categorie2["_521"] = "521";
+        categorie2["_401"] = "401";
+      })(categorie = Paiement2.categorie || (Paiement2.categorie = {}));
+    })(Paiement || (Paiement = {}));
+  }
+});
+
+// src/generated/models/PaiementAnnulationMotif.ts
+var PaiementAnnulationMotif;
+var init_PaiementAnnulationMotif = __esm({
+  "src/generated/models/PaiementAnnulationMotif.ts"() {
+    "use strict";
+    PaiementAnnulationMotif = /* @__PURE__ */ ((PaiementAnnulationMotif2) => {
+      PaiementAnnulationMotif2["AC03"] = "AC03";
+      PaiementAnnulationMotif2["AM09"] = "AM09";
+      PaiementAnnulationMotif2["SVNR"] = "SVNR";
+      PaiementAnnulationMotif2["DUPL"] = "DUPL";
+      PaiementAnnulationMotif2["FRAD"] = "FRAD";
+      return PaiementAnnulationMotif2;
+    })(PaiementAnnulationMotif || {});
+  }
+});
+
+// src/generated/models/PaiementAnnulationStatutRaison.ts
+var PaiementAnnulationStatutRaison;
+var init_PaiementAnnulationStatutRaison = __esm({
+  "src/generated/models/PaiementAnnulationStatutRaison.ts"() {
+    "use strict";
+    PaiementAnnulationStatutRaison = /* @__PURE__ */ ((PaiementAnnulationStatutRaison2) => {
+      PaiementAnnulationStatutRaison2["CUST"] = "CUST";
+      PaiementAnnulationStatutRaison2["AC04"] = "AC04";
+      PaiementAnnulationStatutRaison2["ARDT"] = "ARDT";
+      PaiementAnnulationStatutRaison2["AG10"] = "AG10";
+      PaiementAnnulationStatutRaison2["AG11"] = "AG11";
+      PaiementAnnulationStatutRaison2["FR01"] = "FR01";
+      PaiementAnnulationStatutRaison2["RR04"] = "RR04";
+      return PaiementAnnulationStatutRaison2;
+    })(PaiementAnnulationStatutRaison || {});
+  }
+});
+
+// src/generated/models/PaiementEnMasseReponseStatut.ts
+var PaiementEnMasseReponseStatut;
+var init_PaiementEnMasseReponseStatut = __esm({
+  "src/generated/models/PaiementEnMasseReponseStatut.ts"() {
+    "use strict";
+    ((PaiementEnMasseReponseStatut2) => {
+      let statut;
+      ((statut2) => {
+        statut2["INITIE"] = "INITIE";
+        statut2["CONFIRME"] = "CONFIRME";
+        statut2["ANNULE"] = "ANNULE";
+      })(statut = PaiementEnMasseReponseStatut2.statut || (PaiementEnMasseReponseStatut2.statut = {}));
+    })(PaiementEnMasseReponseStatut || (PaiementEnMasseReponseStatut = {}));
+  }
+});
+
+// src/generated/models/PaiementImmediatConfirmationReponse.ts
+var PaiementImmediatConfirmationReponse;
+var init_PaiementImmediatConfirmationReponse = __esm({
+  "src/generated/models/PaiementImmediatConfirmationReponse.ts"() {
+    "use strict";
+    ((PaiementImmediatConfirmationReponse2) => {
+      let statut;
+      ((statut2) => {
+        statut2["ENVOYE"] = "ENVOYE";
+      })(statut = PaiementImmediatConfirmationReponse2.statut || (PaiementImmediatConfirmationReponse2.statut = {}));
+    })(PaiementImmediatConfirmationReponse || (PaiementImmediatConfirmationReponse = {}));
+  }
+});
+
+// src/generated/models/PaiementImmediatReponse.ts
+var PaiementImmediatReponse;
+var init_PaiementImmediatReponse = __esm({
+  "src/generated/models/PaiementImmediatReponse.ts"() {
+    "use strict";
+    ((PaiementImmediatReponse2) => {
+      let statut;
+      ((statut2) => {
+        statut2["INITIE"] = "INITIE";
+      })(statut = PaiementImmediatReponse2.statut || (PaiementImmediatReponse2.statut = {}));
+    })(PaiementImmediatReponse || (PaiementImmediatReponse = {}));
+  }
+});
+
+// src/generated/models/PaiementStatut.ts
+var PaiementStatut;
+var init_PaiementStatut = __esm({
+  "src/generated/models/PaiementStatut.ts"() {
+    "use strict";
+    PaiementStatut = /* @__PURE__ */ ((PaiementStatut2) => {
+      PaiementStatut2["INITIE"] = "INITIE";
+      PaiementStatut2["ENVOYE"] = "ENVOYE";
+      PaiementStatut2["IRREVOCABLE"] = "IRREVOCABLE";
+      PaiementStatut2["REJETE"] = "REJETE";
+      return PaiementStatut2;
+    })(PaiementStatut || {});
+  }
+});
+
+// src/generated/models/PaiementStatutRaison.ts
+var PaiementStatutRaison;
+var init_PaiementStatutRaison = __esm({
+  "src/generated/models/PaiementStatutRaison.ts"() {
+    "use strict";
+    PaiementStatutRaison = /* @__PURE__ */ ((PaiementStatutRaison2) => {
+      PaiementStatutRaison2["BE23"] = "BE23";
+      PaiementStatutRaison2["DU03"] = "DU03";
+      PaiementStatutRaison2["AB03"] = "AB03";
+      PaiementStatutRaison2["AB04"] = "AB04";
+      PaiementStatutRaison2["AB08"] = "AB08";
+      PaiementStatutRaison2["AB09"] = "AB09";
+      PaiementStatutRaison2["AC03"] = "AC03";
+      PaiementStatutRaison2["AC06"] = "AC06";
+      PaiementStatutRaison2["AC07"] = "AC07";
+      PaiementStatutRaison2["AG01"] = "AG01";
+      PaiementStatutRaison2["AG10"] = "AG10";
+      PaiementStatutRaison2["AG11"] = "AG11";
+      PaiementStatutRaison2["AEXR"] = "AEXR";
+      PaiementStatutRaison2["ALAC"] = "ALAC";
+      PaiementStatutRaison2["AM02"] = "AM02";
+      PaiementStatutRaison2["AM04"] = "AM04";
+      PaiementStatutRaison2["AM09"] = "AM09";
+      PaiementStatutRaison2["AM21"] = "AM21";
+      PaiementStatutRaison2["ARFR"] = "ARFR";
+      PaiementStatutRaison2["ARJR"] = "ARJR";
+      PaiementStatutRaison2["BE01"] = "BE01";
+      PaiementStatutRaison2["FR01"] = "FR01";
+      PaiementStatutRaison2["IRNR"] = "IRNR";
+      PaiementStatutRaison2["RR04"] = "RR04";
+      return PaiementStatutRaison2;
+    })(PaiementStatutRaison || {});
+  }
+});
+
+// src/generated/models/RefDocType.ts
+var RefDocType;
+var init_RefDocType = __esm({
+  "src/generated/models/RefDocType.ts"() {
+    "use strict";
+    RefDocType = /* @__PURE__ */ ((RefDocType2) => {
+      RefDocType2["CINV"] = "CINV";
+      RefDocType2["CMCN"] = "CMCN";
+      RefDocType2["DISP"] = "DISP";
+      RefDocType2["PUOR"] = "PUOR";
+      RefDocType2["CONT"] = "CONT";
+      RefDocType2["HIRI"] = "HIRI";
+      RefDocType2["INVS"] = "INVS";
+      RefDocType2["MSIN"] = "MSIN";
+      RefDocType2["PROF"] = "PROF";
+      RefDocType2["QUOT"] = "QUOT";
+      RefDocType2["SPRR"] = "SPRR";
+      RefDocType2["TISH"] = "TISH";
+      RefDocType2["USAR"] = "USAR";
+      RefDocType2["BOLD"] = "BOLD";
+      RefDocType2["SOAC"] = "SOAC";
+      RefDocType2["VCHR"] = "VCHR";
+      return RefDocType2;
+    })(RefDocType || {});
+  }
+});
+
+// src/generated/models/RetourStatut.ts
+var RetourStatut;
+var init_RetourStatut = __esm({
+  "src/generated/models/RetourStatut.ts"() {
+    "use strict";
+    RetourStatut = /* @__PURE__ */ ((RetourStatut2) => {
+      RetourStatut2["INITIE"] = "INITIE";
+      RetourStatut2["ENVOYE"] = "ENVOYE";
+      RetourStatut2["IRREVOCABLE"] = "IRREVOCABLE";
+      RetourStatut2["REJETE"] = "REJETE";
+      return RetourStatut2;
+    })(RetourStatut || {});
+  }
+});
+
+// src/generated/models/RetourStatutRaison.ts
+var RetourStatutRaison;
+var init_RetourStatutRaison = __esm({
+  "src/generated/models/RetourStatutRaison.ts"() {
+    "use strict";
+    RetourStatutRaison = /* @__PURE__ */ ((RetourStatutRaison2) => {
+      RetourStatutRaison2["AB03"] = "AB03";
+      RetourStatutRaison2["AB04"] = "AB04";
+      RetourStatutRaison2["AC06"] = "AC06";
+      RetourStatutRaison2["AG10"] = "AG10";
+      RetourStatutRaison2["AG11"] = "AG11";
+      RetourStatutRaison2["AM04"] = "AM04";
+      RetourStatutRaison2["AM09"] = "AM09";
+      RetourStatutRaison2["FR01"] = "FR01";
+      RetourStatutRaison2["RR04"] = "RR04";
+      return RetourStatutRaison2;
+    })(RetourStatutRaison || {});
+  }
+});
+
+// src/generated/models/WebhookEvent.ts
+var WebhookEvent;
+var init_WebhookEvent = __esm({
+  "src/generated/models/WebhookEvent.ts"() {
+    "use strict";
+    ((WebhookEvent2) => {
+      let refDocType;
+      ((refDocType2) => {
+        refDocType2["CINV"] = "CINV";
+        refDocType2["CMCN"] = "CMCN";
+        refDocType2["DISP"] = "DISP";
+        refDocType2["PUOR"] = "PUOR";
+        refDocType2["CONT"] = "CONT";
+        refDocType2["HIRI"] = "HIRI";
+        refDocType2["INVS"] = "INVS";
+        refDocType2["MSIN"] = "MSIN";
+        refDocType2["PROF"] = "PROF";
+        refDocType2["QUOT"] = "QUOT";
+        refDocType2["SPRR"] = "SPRR";
+        refDocType2["TISH"] = "TISH";
+        refDocType2["USAR"] = "USAR";
+        refDocType2["BOLD"] = "BOLD";
+        refDocType2["SOAC"] = "SOAC";
+        refDocType2["VCHR"] = "VCHR";
+      })(refDocType = WebhookEvent2.refDocType || (WebhookEvent2.refDocType = {}));
+    })(WebhookEvent || (WebhookEvent = {}));
+  }
+});
+
+// src/generated/models/WebhooksEvents.ts
+var WebhooksEvents;
+var init_WebhooksEvents = __esm({
+  "src/generated/models/WebhooksEvents.ts"() {
+    "use strict";
+    WebhooksEvents = /* @__PURE__ */ ((WebhooksEvents2) => {
+      WebhooksEvents2["PAIEMENT_RECU"] = "PAIEMENT_RECU";
+      WebhooksEvents2["PAIEMENT_ENVOYE"] = "PAIEMENT_ENVOYE";
+      WebhooksEvents2["PAIEMENT_REJETE"] = "PAIEMENT_REJETE";
+      WebhooksEvents2["RTP_RECU"] = "RTP_RECU";
+      WebhooksEvents2["RTP_REJETE"] = "RTP_REJETE";
+      WebhooksEvents2["ANNULATION_DEMANDE"] = "ANNULATION_DEMANDE";
+      WebhooksEvents2["ANNULATION_REJETE"] = "ANNULATION_REJETE";
+      WebhooksEvents2["RETOUR_ENVOYE"] = "RETOUR_ENVOYE";
+      WebhooksEvents2["RETOUR_REJETE"] = "RETOUR_REJETE";
+      WebhooksEvents2["RETOUR_RECU"] = "RETOUR_RECU";
+      return WebhooksEvents2;
+    })(WebhooksEvents || {});
+  }
+});
+
+// src/generated/core/request.ts
+var import_axios, import_form_data, isDefined, isString, isStringWithValue, isBlob, isFormData, isSuccess, base64, getQueryString, getUrl, getFormData, resolve, getHeaders, getRequestBody, sendRequest, getResponseHeader, getResponseBody, catchErrorCodes, request;
+var init_request = __esm({
+  "src/generated/core/request.ts"() {
+    "use strict";
+    import_axios = __toESM(require("axios"), 1);
+    import_form_data = __toESM(require("form-data"), 1);
+    init_ApiError();
+    init_CancelablePromise();
+    isDefined = (value) => {
+      return value !== void 0 && value !== null;
+    };
+    isString = (value) => {
+      return typeof value === "string";
+    };
+    isStringWithValue = (value) => {
+      return isString(value) && value !== "";
+    };
+    isBlob = (value) => {
+      return typeof value === "object" && typeof value.type === "string" && typeof value.stream === "function" && typeof value.arrayBuffer === "function" && typeof value.constructor === "function" && typeof value.constructor.name === "string" && /^(Blob|File)$/.test(value.constructor.name) && /^(Blob|File)$/.test(value[Symbol.toStringTag]);
+    };
+    isFormData = (value) => {
+      return value instanceof import_form_data.default;
+    };
+    isSuccess = (status) => {
+      return status >= 200 && status < 300;
+    };
+    base64 = (str) => {
+      try {
+        return btoa(str);
+      } catch (err) {
+        return Buffer.from(str).toString("base64");
+      }
+    };
+    getQueryString = (params) => {
+      const qs = [];
+      const append = (key, value) => {
+        qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+      };
+      const process = (key, value) => {
+        if (isDefined(value)) {
+          if (Array.isArray(value)) {
+            value.forEach((v) => {
+              process(key, v);
+            });
+          } else if (typeof value === "object") {
+            Object.entries(value).forEach(([k, v]) => {
+              process(`${key}[${k}]`, v);
+            });
+          } else {
+            append(key, value);
+          }
+        }
+      };
+      Object.entries(params).forEach(([key, value]) => {
+        process(key, value);
+      });
+      if (qs.length > 0) {
+        return `?${qs.join("&")}`;
+      }
+      return "";
+    };
+    getUrl = (config, options) => {
+      const encoder = config.ENCODE_PATH || encodeURI;
+      const path = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+        if (options.path?.hasOwnProperty(group)) {
+          return encoder(String(options.path[group]));
+        }
+        return substring;
+      });
+      const url = `${config.BASE}${path}`;
+      if (options.query) {
+        return `${url}${getQueryString(options.query)}`;
+      }
+      return url;
+    };
+    getFormData = (options) => {
+      if (options.formData) {
+        const formData = new import_form_data.default();
+        const process = (key, value) => {
+          if (isString(value) || isBlob(value)) {
+            formData.append(key, value);
+          } else {
+            formData.append(key, JSON.stringify(value));
+          }
+        };
+        Object.entries(options.formData).filter(([_, value]) => isDefined(value)).forEach(([key, value]) => {
+          if (Array.isArray(value)) {
+            value.forEach((v) => process(key, v));
+          } else {
+            process(key, value);
+          }
+        });
+        return formData;
+      }
+      return void 0;
+    };
+    resolve = async (options, resolver) => {
+      if (typeof resolver === "function") {
+        return resolver(options);
+      }
+      return resolver;
+    };
+    getHeaders = async (config, options, formData) => {
+      const [token, username, password, additionalHeaders] = await Promise.all([
+        resolve(options, config.TOKEN),
+        resolve(options, config.USERNAME),
+        resolve(options, config.PASSWORD),
+        resolve(options, config.HEADERS)
+      ]);
+      const formHeaders = typeof formData?.getHeaders === "function" && formData?.getHeaders() || {};
+      const headers = Object.entries({
+        Accept: "application/json",
+        ...additionalHeaders,
+        ...options.headers,
+        ...formHeaders
+      }).filter(([_, value]) => isDefined(value)).reduce((headers2, [key, value]) => ({
+        ...headers2,
+        [key]: String(value)
+      }), {});
+      if (isStringWithValue(token)) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+      if (isStringWithValue(username) && isStringWithValue(password)) {
+        const credentials = base64(`${username}:${password}`);
+        headers["Authorization"] = `Basic ${credentials}`;
+      }
+      if (options.body !== void 0) {
+        if (options.mediaType) {
+          headers["Content-Type"] = options.mediaType;
+        } else if (isBlob(options.body)) {
+          headers["Content-Type"] = options.body.type || "application/octet-stream";
+        } else if (isString(options.body)) {
+          headers["Content-Type"] = "text/plain";
+        } else if (!isFormData(options.body)) {
+          headers["Content-Type"] = "application/json";
+        }
+      }
+      return headers;
+    };
+    getRequestBody = (options) => {
+      if (options.body) {
+        return options.body;
+      }
+      return void 0;
+    };
+    sendRequest = async (config, options, url, body, formData, headers, onCancel, axiosClient) => {
+      const source = import_axios.default.CancelToken.source();
+      const requestConfig = {
+        url,
+        headers,
+        data: body ?? formData,
+        method: options.method,
+        withCredentials: config.WITH_CREDENTIALS,
+        withXSRFToken: config.CREDENTIALS === "include" ? config.WITH_CREDENTIALS : false,
+        cancelToken: source.token
+      };
+      onCancel(() => source.cancel("The user aborted a request."));
+      try {
+        return await axiosClient.request(requestConfig);
+      } catch (error) {
+        const axiosError = error;
+        if (axiosError.response) {
+          return axiosError.response;
+        }
+        throw error;
+      }
+    };
+    getResponseHeader = (response, responseHeader) => {
+      if (responseHeader) {
+        const content = response.headers[responseHeader];
+        if (isString(content)) {
+          return content;
+        }
+      }
+      return void 0;
+    };
+    getResponseBody = (response) => {
+      if (response.status !== 204) {
+        return response.data;
+      }
+      return void 0;
+    };
+    catchErrorCodes = (options, result) => {
+      const errors = {
+        400: "Bad Request",
+        401: "Unauthorized",
+        403: "Forbidden",
+        404: "Not Found",
+        500: "Internal Server Error",
+        502: "Bad Gateway",
+        503: "Service Unavailable",
+        ...options.errors
+      };
+      const error = errors[result.status];
+      if (error) {
+        throw new ApiError(options, result, error);
+      }
+      if (!result.ok) {
+        const errorStatus = result.status ?? "unknown";
+        const errorStatusText = result.statusText ?? "unknown";
+        const errorBody = (() => {
+          try {
+            return JSON.stringify(result.body, null, 2);
+          } catch (e) {
+            return void 0;
+          }
+        })();
+        throw new ApiError(
+          options,
+          result,
+          `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`
+        );
+      }
+    };
+    request = (config, options, axiosClient = import_axios.default) => {
+      return new CancelablePromise(async (resolve2, reject, onCancel) => {
+        try {
+          const url = getUrl(config, options);
+          const formData = getFormData(options);
+          const body = getRequestBody(options);
+          const headers = await getHeaders(config, options, formData);
+          if (!onCancel.isCancelled) {
+            const response = await sendRequest(config, options, url, body, formData, headers, onCancel, axiosClient);
+            const responseBody = getResponseBody(response);
+            const responseHeader = getResponseHeader(response, options.responseHeader);
+            const result = {
+              url,
+              ok: isSuccess(response.status),
+              status: response.status,
+              statusText: response.statusText,
+              body: responseHeader ?? responseBody
+            };
+            catchErrorCodes(options, result);
+            resolve2(result.body);
+          }
+        } catch (error) {
+          reject(error);
+        }
+      });
+    };
+  }
+});
+
+// src/generated/services/AliasService.ts
+var AliasService2;
+var init_AliasService = __esm({
+  "src/generated/services/AliasService.ts"() {
+    "use strict";
+    init_OpenAPI();
+    init_request();
+    AliasService2 = class {
+      /**
+       * Créer un alias
+       * Le répertoire des alias de compte permet de créer les types d'alias suivants :
+       * - Une adresse de paiement, codifiée par SHID: cet alias est obtenu par génération d'une clé aléatoire unique sur 36 positions par le système.
+       * - Un identifiant de compte marchand, codifié par MCOD: ce type d'alias est prévu pour supporter les paiements par code USSD.
+       * - Un numéro de téléphone mobile, codifié par MBNO.
+       *
+       * Les types d'alias qu'on peut créer dépendent du type de client.
+       * Les clients de type P (particuliers, personnes physiques) peuvent créer des alias de types MBNO et SHID.
+       * Les clients de types C, B, et G (commerçants ou entreprises individuelles, entreprises, entités gouvernementales) peuvent créer des alias de types SHID et MCOD.
+       *
+       * Un client business peut créer plusieurs alias pour un compte donné.
+       * Une limite de 20 alias par compte est fixée par défaut. Cette limite peut être augmentée selon les besoins du client.
+       *
+       * @returns AliasCreationReponse Opération effectuée avec succès
+       * @throws ApiError
+       */
+      static aliasCreer({
+        numero,
+        requestBody
+      }) {
+        return request(OpenAPI2, {
+          method: "POST",
+          url: "/comptes/{numero}/alias",
+          path: {
+            "numero": numero
+          },
+          body: requestBody,
+          mediaType: "application/json",
+          errors: {
+            400: `La requ\xEAte est malform\xE9e`,
+            401: `Autorisations manquantes`,
+            403: `Op\xE9ration interdite`,
+            404: `La ressource n'existe pas dans le syst\xE8me`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Lister les alias
+       * Ce point de terminaison permet de consulter la liste des alias d'un compte.
+       *
+       * @returns AliasReponseListe Succès de l'opération
+       * @throws ApiError
+       */
+      static aliasLister({
+        numero
+      }) {
+        return request(OpenAPI2, {
+          method: "GET",
+          url: "/comptes/{numero}/alias",
+          path: {
+            "numero": numero
+          },
+          errors: {
+            401: `Autorisations manquantes`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Supprimer un alias
+       * Le client peut supprimer à tout moment un alias de compte.
+       *
+       * @returns void
+       * @throws ApiError
+       */
+      static aliasSupprimer({
+        numero,
+        cle
+      }) {
+        return request(OpenAPI2, {
+          method: "DELETE",
+          url: "/comptes/{numero}/alias/{cle}",
+          path: {
+            "numero": numero,
+            "cle": cle
+          },
+          errors: {
+            401: `Autorisations manquantes`,
+            404: `La ressource n'existe pas dans le syst\xE8me`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/generated/services/ComptesService.ts
+var ComptesService2;
+var init_ComptesService = __esm({
+  "src/generated/services/ComptesService.ts"() {
+    "use strict";
+    init_OpenAPI();
+    init_request();
+    ComptesService2 = class {
+      /**
+       * Détails d'un compte
+       * Cet endpoint permet au client de consulter à tout moment les informations détaillées relatives à un compte spécifique.
+       *
+       * Les informations retournées incluent :
+       * - Le type de compte (compte courant, épargne, etc.)
+       * - Le numéro du compte
+       * - La date d'ouverture du compte
+       * - Le solde actuel du compte
+       * - Le statut du compte (ouvert, bloqué ou clôturé)
+       * - L'indicateur de pré-confirmation pour les opérations
+       *
+       * Cette consultation permet au client business de surveiller l'état de ses comptes en temps réel et de prendre des décisions éclairées concernant ses opérations financières.
+       *
+       * @returns CompteSolde Succès de l'opération
+       * @throws ApiError
+       */
+      static compteSoldeConsulter({
+        numero
+      }) {
+        return request(OpenAPI2, {
+          method: "GET",
+          url: "/comptes/{numero}",
+          path: {
+            "numero": numero
+          },
+          errors: {
+            401: `Autorisations manquantes`,
+            404: `La ressource n'existe pas dans le syst\xE8me`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Transfert intra-comptes
+       * Le transfert intra-comptes est un transfert de fonds entre deux comptes détenus par la même entité juridique et domiciliés au sein de la même institution financière. Le compte source (débiteur/payeur) et le compte destination (créditeur/bénéficiaire) appartiennent donc au même client.
+       *
+       * @returns CompteTransfertIntraReponse Transfert initié avec succès.
+       * @throws ApiError
+       */
+      static compteTransfertIntraCreer({
+        requestBody
+      }) {
+        return request(OpenAPI2, {
+          method: "POST",
+          url: "/comptes/transactions",
+          body: requestBody,
+          mediaType: "application/json",
+          errors: {
+            400: `La requ\xEAte est malform\xE9e`,
+            401: `Autorisations manquantes`,
+            403: `Interdiction d'effectuer le paiement`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Lister les transferts intra-comptes
+       * @returns CompteOperationListe Succès de l'opération
+       * @throws ApiError
+       */
+      static compteTransfertIntraLister({
+        statut,
+        comptePayeur,
+        comptePaye,
+        dateEnvoi,
+        dateIrrevocabilite,
+        motif,
+        page,
+        size,
+        sort,
+        fields
+      }) {
+        return request(OpenAPI2, {
+          method: "GET",
+          url: "/comptes/transactions",
+          query: {
+            "statut": statut,
+            "comptePayeur": comptePayeur,
+            "comptePaye": comptePaye,
+            "dateEnvoi": dateEnvoi,
+            "dateIrrevocabilite": dateIrrevocabilite,
+            "motif": motif,
+            "page": page,
+            "size": size,
+            "sort": sort,
+            "fields": fields
+          },
+          errors: {
+            401: `Autorisations manquantes`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/generated/services/DemandeAnnulationService.ts
+var DemandeAnnulationService;
+var init_DemandeAnnulationService = __esm({
+  "src/generated/services/DemandeAnnulationService.ts"() {
+    "use strict";
+    init_OpenAPI();
+    init_request();
+    DemandeAnnulationService = class {
+      /**
+       * Demander l'annulation d'un paiement
+       * Ce point de terminaison permet de demander l'annulation d'un paiement envoyé.
+       *
+       * À l'acceptation de la demande d'annulation, le payé effectue un retour de fonds et le business recevra une notification `RETOUR_RECU` s'il a souscrit au service de webhook.
+       *
+       * Si le payé refuse la demande d'annulation, le business recevra une notification `ANNULATION_REJETE`.
+       *
+       * **Note importante sur l'idempotence :**
+       *
+       * Cet endpoint utilise **POST (pas PUT)** car chaque appel envoie une **nouvelle demande d'annulation** au PSP bénéficiaire.
+       *
+       * **Comportement :**
+       * - Premier appel → Nouvelle demande d'annulation envoyée
+       * - Deuxième appel → **Nouvelle demande d'annulation envoyée** (pas idempotent)
+       * - Troisième appel → **Nouvelle demande d'annulation envoyée**
+       *
+       * **Cas d'usage :**
+       * - La première demande a été refusée, vous réessayez
+       * - Vous voulez relancer une demande en attente
+       * - Vous avez de nouvelles informations justifiant l'annulation
+       *
+       * @returns Paiement Demande d'annulation envoyée
+       * @throws ApiError
+       */
+      static demandeAnnulationEnvoyer({
+        end2EndId,
+        requestBody
+      }) {
+        return request(OpenAPI2, {
+          method: "POST",
+          url: "/paiements/{end2endId}/annulations",
+          path: {
+            "end2endId": end2EndId
+          },
+          body: requestBody,
+          mediaType: "application/json",
+          errors: {
+            401: `Autorisations manquantes`,
+            403: `Interdiction d'effectuer la demande d'annulation`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Répondre à une demande d'annulation
+       * Ce point de terminaison permet au business de répondre à une demande d'annulation de paiement.
+       *
+       * Le business peut accepter ou refuser la demande d'annulation :
+       * - `decision: true` : Accepte la demande d'annulation (le business effectuera un retour de fonds)
+       * - `decision: false` : Refuse la demande d'annulation
+       *
+       * **Idempotence** : Cet endpoint est idempotent.
+       * - Premier appel avec `decision: true` → Accepte la demande, retourne `200 OK {statut: "ACCEPTEE"}`
+       * - Appels suivants avec `decision: true` → Retourne `200 OK` avec l'état actuel - idempotent
+       * - Premier appel avec `decision: false` → Refuse la demande, retourne `200 OK {statut: "REJETEE"}`
+       * - Appels suivants avec `decision: false` → Retourne `200 OK {statut: "REJETEE"}` (idempotent)
+       * - `decision: true` après `decision: false` → Retourne `403 Forbidden` (déjà refusée)
+       * - `decision: false` après `decision: true` → Retourne `403 Forbidden` (déjà acceptée)
+       *
+       * @returns Paiement Réponse à la demande d'annulation enregistrée.
+       *
+       * La réponse retourne l'objet `Paiement` complet avec les champs mis à jour selon la décision :
+       *
+       * **En cas d'acceptation (`decision: true`)** :
+       * - `annulationStatut` : Mis à jour pour indiquer l'acceptation
+       * - `annulationDateReponse` : Date et heure de la réponse à la demande d'annulation
+       * - Un retour de fonds est automatiquement initié par le participant, donc les champs suivants sont également renseignés :
+       * - `retourStatut` : Statut du retour de fonds (ex: `INITIE`, `ENVOYE`, `IRREVOCABLE`)
+       * - `retourStatutRaison` : Raison du statut du retour de fonds
+       * - `retourDateDemande` : Date de création du retour de fonds
+       * - `retourDateIrrevocabilite` : Date à laquelle le retour de fonds est irrévocable (si applicable)
+       *
+       * **En cas de rejet (`decision: false`)** :
+       * - `annulationStatut` : Mis à jour pour indiquer le rejet (ex: `REJETE`)
+       * - `annulationDateReponse` : Date et heure de la réponse à la demande d'annulation
+       * - Les champs `retour*` ne sont **pas** renseignés car aucun retour de fonds n'est effectué
+       *
+       * @throws ApiError
+       */
+      static demandeAnnulationRepondre({
+        end2EndId,
+        requestBody
+      }) {
+        return request(OpenAPI2, {
+          method: "PUT",
+          url: "/paiements/{end2endId}/annulations/reponses",
+          path: {
+            "end2endId": end2EndId
+          },
+          body: requestBody,
+          mediaType: "application/json",
+          errors: {
+            401: `Autorisations manquantes`,
+            403: `Op\xE9ration interdite`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/generated/services/DemandesDePaiementService.ts
+var DemandesDePaiementService;
+var init_DemandesDePaiementService = __esm({
+  "src/generated/services/DemandesDePaiementService.ts"() {
+    "use strict";
+    init_OpenAPI();
+    init_request();
+    DemandesDePaiementService = class {
+      /**
+       * Envoyer une demande
+       * Ce point de terminaison permet d'envoyer une demande de paiement.
+       *
+       * Le business peut définir le champ `confirmation` à `true` pour demander une validation en deux étapes : le PSP retournera d'abord le résultat de la recherche d'alias (avec le nom et le pays du payeur), puis attendra une confirmation explicite avant d'envoyer la demande de paiement au payeur via l'endpoint `PUT /demandes-paiements/{txId}/confirmations`.
+       *
+       * Si le champ `confirmation` n'est pas défini ou est à `false`, le système envoie directement la demande de paiement au payeur.
+       *
+       * **Timeout de confirmation** : Si le business demande une validation en deux étapes , il dispose de **24 heures** pour confirmer ou annuler. Passé ce délai, la demande expire automatiquement.
+       *
+       * @returns DemandePaiementReponse Demande de paiement traitée. Le champ `statut` indique le résultat :
+       * - `INITIE` : En attente de confirmation (si `confirmation: true`)
+       * - `ENVOYE` : Demande envoyée au payeur avec succès (si `confirmation: false`)
+       * - `REJETE` : Demande rejetée. Le champ `statutRaison` contient le code d'erreur :
+       * - `DU03` : txId dupliqué (déjà utilisé)
+       * - `BE23` : Alias payeur invalide
+       * - Autres codes ISO 20022
+       *
+       * @throws ApiError
+       */
+      static demandePaiementCreer({
+        requestBody
+      }) {
+        return request(OpenAPI2, {
+          method: "POST",
+          url: "/demandes-paiements",
+          body: requestBody,
+          mediaType: "application/json",
+          errors: {
+            400: `La requ\xEAte est malform\xE9e`,
+            401: `Autorisations manquantes`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Lister les demandes
+       * Ce point de terminaison permet de lister les demandes de paiements effectuées par le client.
+       * @returns DemandePaiementListe Succès de l'opération
+       * @throws ApiError
+       */
+      static demandePaiementLister({
+        payeAlias,
+        payeCompte,
+        dateEnvoi,
+        dateLimitePaiement,
+        statut,
+        categorie,
+        payeurAlias,
+        payeurCompte,
+        montantAchat,
+        montantRetrait,
+        debitDiffere,
+        remise,
+        motif,
+        refDocType,
+        instructionId,
+        page,
+        size,
+        sort,
+        fields
+      }) {
+        return request(OpenAPI2, {
+          method: "GET",
+          url: "/demandes-paiements",
+          query: {
+            "payeAlias": payeAlias,
+            "payeCompte": payeCompte,
+            "dateEnvoi": dateEnvoi,
+            "dateLimitePaiement": dateLimitePaiement,
+            "statut": statut,
+            "categorie": categorie,
+            "payeurAlias": payeurAlias,
+            "payeurCompte": payeurCompte,
+            "montantAchat": montantAchat,
+            "montantRetrait": montantRetrait,
+            "debitDiffere": debitDiffere,
+            "remise": remise,
+            "motif": motif,
+            "refDocType": refDocType,
+            "instructionId": instructionId,
+            "page": page,
+            "size": size,
+            "sort": sort,
+            "fields": fields
+          },
+          errors: {
+            401: `Autorisations manquantes`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Consulter une demande
+       * Cet point de terminaison permet de consulter les details d'une demande de paiement.
+       *
+       * @returns DemandePaiementConsultationReponse Opération effectuée avec succès
+       * @throws ApiError
+       */
+      static demandePaiementRecuperer({
+        txId
+      }) {
+        return request(OpenAPI2, {
+          method: "GET",
+          url: "/demandes-paiements/{txId}",
+          path: {
+            "txId": txId
+          },
+          errors: {
+            401: `Autorisations manquantes`,
+            404: `La ressource n'existe pas dans le syst\xE8me`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Confirmer la demande
+       * Ce point de terminaison permet d'envoyer la confirmation de l'envoi d'une demande de paiement.
+       *
+       * Le client business confirme oui ou non si le PSP peut envoyer la demande au payeur après vérification des informations d'identification (nom et pays du payeur).
+       *
+       * **Idempotence** : Cet endpoint est idempotent.
+       * - Premier appel avec `decision: true` → Envoie la demande, retourne `200 OK {statut: "ENVOYE"}`
+       * - Appels suivants avec `decision: true` → Retourne `200 OK` avec l'état actuel (ENVOYE, IRREVOCABLE, ou REJETE) - idempotent
+       * - Premier appel avec `decision: false` → Annule, retourne `200 OK {statut: "ANNULE"}`
+       * - Appels suivants avec `decision: false` → Retourne `200 OK {statut: "ANNULE"}` (idempotent)
+       * - `decision: true` après `decision: false` → Retourne `403 Forbidden` (déjà annulé)
+       * - `decision: false` après `decision: true` → Retourne `403 Forbidden` (déjà confirmé)
+       *
+       * **Timeout** : La confirmation doit être envoyée dans les **24 heures** suivant la création de la demande. Passé ce délai, la demande expire automatiquement et ne peut plus être confirmée.
+       *
+       * **Changement de décision** : Une fois une décision prise, elle est définitive. Impossible de confirmer après avoir annulé, et vice-versa.
+       *
+       * @returns DemandePaiementConfirmationReponse Opération effectuée avec succès
+       * @throws ApiError
+       */
+      static demandePaiementConfirmer({
+        txId,
+        requestBody
+      }) {
+        return request(OpenAPI2, {
+          method: "PUT",
+          url: "/demandes-paiements/{txId}/confirmations",
+          path: {
+            "txId": txId
+          },
+          body: requestBody,
+          mediaType: "application/json",
+          errors: {
+            401: `Autorisations manquantes`,
+            403: `Op\xE9ration interdite`,
+            404: `La ressource n'existe pas dans le syst\xE8me`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Accepter ou rejeter la demande
+       * Ce point de terminaison permet au client d'accepter ou de rejeter une demande de paiement reçue.
+       * @returns any Opération effectuée avec succès
+       * @throws ApiError
+       */
+      static demandePaiementRepondre({
+        txId,
+        requestBody
+      }) {
+        return request(OpenAPI2, {
+          method: "POST",
+          url: "/demandes-paiements/{txId}/reponses",
+          path: {
+            "txId": txId
+          },
+          body: requestBody,
+          mediaType: "application/json",
+          errors: {
+            401: `Autorisations manquantes`,
+            403: `Interdiction d'effectuer le paiement`,
+            404: `La ressource n'existe pas dans le syst\xE8me`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/generated/services/DemandesDePaiementEnMasseService.ts
+var DemandesDePaiementEnMasseService;
+var init_DemandesDePaiementEnMasseService = __esm({
+  "src/generated/services/DemandesDePaiementEnMasseService.ts"() {
+    "use strict";
+    init_OpenAPI();
+    init_request();
+    DemandesDePaiementEnMasseService = class {
+      /**
+       * Envoyer une demande de paiement en masse
+       * Ce point de terminaison permet au client business d'envoyer plusieurs demandes de paiement à la fois.
+       *
+       * La catégorie des demandes de paiement en masse est toujours `401` (Autres demandes de paiement de facture).
+       *
+       * **Traitement asynchrone :** La création retourne immédiatement `202 Accepted`. Le traitement des transactions se fait de manière asynchrone.
+       *
+       * **Sans confirmation (`confirmation: false` ou non spécifié) :**
+       * - Les transactions sont créées et validées (unicité des txId)
+       * - Les demandes de paiement sont envoyées directement aux payeurs
+       * - Les transactions avec txId dupliqué sont automatiquement rejetées avec le code `DU03`
+       * - Les transactions avec alias de payeur invalide sont automatiquement rejetées avec le code `BE23`
+       *
+       * **Avec confirmation (`confirmation: true`) :**
+       * - Les transactions sont créées et validées (unicité des txId + recherche d'alias des payeurs)
+       * - Les transactions avec alias de payeur invalide sont rejetées avec le code `BE23`
+       * - Les transactions avec txId dupliqué sont rejetées avec le code `DU03`
+       * - Les transactions valides passent à l'état `INITIE` avec les noms et pays des payeurs
+       * - Le business dispose d'un **délai adaptatif** pour confirmer ou annuler via `PUT /demandes-paiements-groupes/{instructionId}/confirmations` :
+       * - **1 à 500 transactions** : 24 heures
+       * - **501 à 1000 transactions** : 48 heures
+       * - **Plus de 1000 transactions** : 72 heures
+       * - Lors de la confirmation, seules les transactions `INITIE` sont envoyées (les transactions `REJETE` sont automatiquement exclues)
+       * - Passé le délai, la demande expire automatiquement
+       *
+       * **Consultation des détails :**
+       * - Statut global du bulk : `GET /demandes-paiements-groupes/{instructionId}`
+       * - Liste de toutes les transactions : `GET /demandes-paiements?instructionId={instructionId}`
+       * - Seulement les rejetées (validation) : `GET /demandes-paiements?instructionId={instructionId}&statut=REJETE`
+       * - Seulement les valides (avec noms/pays des payeurs) : `GET /demandes-paiements?instructionId={instructionId}&statut=INITIE`
+       *
+       * **Convention de nommage des instructionId (important) :**
+       *
+       * L'`instructionId` doit être **unique** pour chaque création de bulk. Pour faciliter le suivi métier, nous recommandons la convention suivante :
+       *
+       * ```
+       * <IDENTIFIANT_METIER>-<NUMERO_TENTATIVE>
+       * ```
+       *
+       * **Exemples :**
+       * - Première tentative : `FACTURES-2025-01-1` (factures de janvier 2025, tentative 1)
+       * - Deuxième tentative : `FACTURES-2025-01-2` (corrections après échecs)
+       * - Troisième tentative : `FACTURES-2025-01-3` (nouvelles corrections)
+       *
+       * **Avantages :**
+       * - ✅ Chaque bulk a un statut indépendant (INITIE, CONFIRME, ANNULE)
+       * - ✅ Traçabilité claire des tentatives successives
+       * - ✅ Possibilité de filtrer par identifiant métier : `GET /demandes-paiements?instructionId[beginsWith]=FACTURES-2025-01`
+       * - ✅ Respect de l'unicité de l'instructionId
+       *
+       * @returns string La demande a été acceptée et est en cours de traitement.
+       *
+       * Consultez le statut via `GET /demandes-paiements-groupes/{instructionId}`.
+       *
+       * @throws ApiError
+       */
+      static demandePaiementGroupeCreer({
+        requestBody
+      }) {
+        return request(OpenAPI2, {
+          method: "POST",
+          url: "/demandes-paiements-groupes",
+          body: requestBody,
+          mediaType: "application/json",
+          responseHeader: "Location",
+          errors: {
+            400: `La requ\xEAte est malform\xE9e`,
+            401: `Autorisations manquantes`,
+            409: `Conflit - instructionId d\xE9j\xE0 utilis\xE9`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Détails d'une demande de paiement en masse
+       * Ce point de terminaison permet de consulter les détails d'une demande de paiement en masse.
+       *
+       * **Statut du bulk :**
+       * - `INITIE` : Créée avec confirmation demandée, en attente de confirmation
+       * - `CONFIRME` : Confirmée par le business (si confirmation demandée) ou en cours de traitement (si sans confirmation)
+       * - `ANNULE` : Annulée par le business avant confirmation (seulement si confirmation demandée)
+       *
+       * **Note :**
+       * - Si créée **avec confirmation** (`confirmation: true`) : Le statut évolue de `INITIE` → `CONFIRME` ou `ANNULE`
+       * - Si créée **sans confirmation** (`confirmation: false`) : Le statut est directement `CONFIRME` (aucune action requise du business)
+       *
+       * **Vérification de fin de validation (important pour confirmation) :**
+       *
+       * Lorsque `confirmation: true`, la validation des transactions se fait de manière asynchrone.
+       * Pour savoir si la validation est terminée et que vous pouvez confirmer, vérifiez que :
+       *
+       * ```
+       * transactionsInitiees + transactionsRejetees = transactionsTotal
+       * ```
+       *
+       * - Si égalité → Validation terminée, vous pouvez confirmer ✅
+       * - Si inégalité → Validation en cours, attendez encore (consultez à nouveau plus tard) ⏳
+       *
+       * Le détail de chaque transaction se consulte via `GET /demandes-paiements?txId={txId}`.
+       *
+       * **Consultation des transactions individuelles :**
+       * Pour obtenir la liste détaillée des transactions (avec noms des payeurs, codes d'erreur, etc.), utilisez :
+       * - Toutes les transactions : `GET /demandes-paiements?instructionId={instructionId}`
+       * - Seulement les rejetées : `GET /demandes-paiements?instructionId={instructionId}&statut=REJETE`
+       * - Seulement les réussies : `GET /demandes-paiements?instructionId={instructionId}&statut=IRREVOCABLE`
+       *
+       * @returns DemandePaiementEnMasseStatutReponse Opération effectuée avec succès
+       * @throws ApiError
+       */
+      static demandePaiementGroupeConsulter({
+        instructionId
+      }) {
+        return request(OpenAPI2, {
+          method: "GET",
+          url: "/demandes-paiements-groupes/{instructionId}",
+          path: {
+            "instructionId": instructionId
+          },
+          errors: {
+            401: `Autorisations manquantes`,
+            404: `La ressource n'existe pas dans le syst\xE8me`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Confirmer la demande de paiement en masse
+       * Ce point de terminaison permet de confirmer ou d'annuler une demande de paiement en masse créée avec `confirmation: true`.
+       *
+       * **Processus de vérification :**
+       * 1. Après la création (`POST /demandes-paiements-groupes`), le participant valide toutes les transactions (unicité des txId + recherche d'alias des payeurs)
+       * 2. Les transactions invalides sont automatiquement rejetées (`statut: REJETE`) avec codes `BE23` (alias invalide) ou `DU03` (txId dupliqué)
+       * 3. Les transactions valides passent à l'état `INITIE` avec les noms et pays des payeurs
+       * 4. Le business consulte via `GET /demandes-paiements-groupes/{instructionId}` pour vérifier la progression de la validation
+       * 5. **La validation (unicité des txId + recherche d'alias) est terminée quand** : `transactionsInitiees + transactionsRejetees = transactionsTotal`
+       * 6. Le business peut alors confirmer ou annuler l'envoi des demandes de paiement
+       *
+       * **Important :** La confirmation n'est possible que lorsque la validation de toutes les transactions est terminée.
+       * Si le business tente de confirmer pendant que la validation est en cours, une erreur 403 sera retournée avec la progression actuelle.
+       *
+       * **Comportement de la confirmation :**
+       * - `decision: true` → Le système envoie **automatiquement SEULEMENT** les demandes de paiement pour les transactions avec `statut: INITIE`
+       * - Les transactions `REJETE` (erreurs de validation) sont **automatiquement exclues** (pas besoin de les lister)
+       * - Le statut du bulk passe de `INITIE` à `CONFIRME`
+       *
+       * **Idempotence** : Cet endpoint est idempotent.
+       * - Premier appel avec `decision: true` → Envoie les demandes, retourne `200 OK {statut: "CONFIRME"}`
+       * - Appels suivants avec `decision: true` → Retourne `200 OK {statut: "CONFIRME"}` (idempotent, ne relance pas)
+       * - Premier appel avec `decision: false` → Annule, retourne `200 OK {statut: "ANNULE"}`
+       * - Appels suivants avec `decision: false` → Retourne `200 OK {statut: "ANNULE"}` (idempotent)
+       * - `decision: true` après `decision: false` → Retourne `403 Forbidden` (déjà annulé)
+       * - `decision: false` après `decision: true` → Retourne `403 Forbidden` (déjà confirmé)
+       *
+       * **Timeout adaptatif** : Le délai pour confirmer dépend automatiquement du nombre de transactions :
+       * - **1 à 500 transactions** : 24 heures
+       * - **501 à 1000 transactions** : 48 heures
+       * - **Plus de 1000 transactions** : 72 heures
+       *
+       * Passé ce délai, la demande expire automatiquement et ne peut plus être confirmée. Le délai exact est indiqué dans le champ `dateExpiration` retourné par `GET /demandes-paiements-groupes/{instructionId}`.
+       *
+       * **Changement de décision** : Une fois une décision prise, elle est définitive. Impossible de confirmer après avoir annulé, et vice-versa.
+       *
+       * @returns DemandePaiementEnMasseStatutReponse Confirmation enregistrée avec succès.
+       * - Si `decision: true`, le statut passe à `CONFIRME` et les demandes de paiement sont envoyées
+       * - Si `decision: false`, le statut passe à `ANNULE`
+       *
+       * @throws ApiError
+       */
+      static demandePaiementGroupeConfirmer({
+        instructionId,
+        requestBody
+      }) {
+        return request(OpenAPI2, {
+          method: "PUT",
+          url: "/demandes-paiements-groupes/{instructionId}/confirmations",
+          path: {
+            "instructionId": instructionId
+          },
+          body: requestBody,
+          mediaType: "application/json",
+          errors: {
+            401: `Autorisations manquantes`,
+            403: `Op\xE9ration interdite`,
+            404: `La ressource n'existe pas dans le syst\xE8me`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/generated/services/NotificationService.ts
+var NotificationService;
+var init_NotificationService = __esm({
+  "src/generated/services/NotificationService.ts"() {
+    "use strict";
+    init_OpenAPI();
+    init_request();
+    NotificationService = class {
+      /**
+       * Créer un lien de rappel.
+       * Cet endpoint permet au client de configurer des webhooks (liens de rappel) pour recevoir des notifications en temps réel.
+       *
+       * Le client dispose d'une grande flexibilité dans la configuration de ses webhooks et peut choisir parmi plusieurs stratégies :
+       *
+       * **1. Callback URL général**
+       * - Un seul point de rappel pour toutes les notifications
+       * - Tous les événements de tous les comptes/alias sont envoyés à la même URL
+       * - Configuration simple, idéale pour centraliser toutes les notifications
+       *
+       * **2. Callback URL par alias**
+       * - Un point de rappel distinct pour chaque alias de compte
+       * - Permet de router les notifications vers des systèmes différents selon le compte concerné
+       * - Utile pour isoler les flux de notifications par compte ou par service
+       *
+       * **3. Callback URL par événement**
+       * - Un point de rappel spécifique pour chaque type d'événement (PAIEMENT_RECU, RTP_RECU, etc.)
+       * - Permet de traiter différemment chaque catégorie d'événement
+       * - Facilite la séparation des traitements métier (paiements vs demandes vs retours)
+       *
+       * **4. Callback URL par événement et alias**
+       * - Granularité maximale : un point de rappel pour chaque combinaison événement/alias
+       * - Configuration la plus fine pour des besoins très spécifiques
+       * - Permet de router précisément chaque notification vers le système approprié
+       *
+       * Cette flexibilité permet aux clients d'adapter la configuration des webhooks à leur architecture technique et à leurs besoins métier.
+       *
+       * @returns WebhookCreationResponse Webhook créé avec succès
+       * @throws ApiError
+       */
+      static webhookCreer({
+        requestBody
+      }) {
+        return request(OpenAPI2, {
+          method: "POST",
+          url: "/webhooks",
+          body: requestBody,
+          mediaType: "application/json",
+          errors: {
+            400: `La requ\xEAte est malform\xE9e`,
+            401: `Autorisations manquantes`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Lister les webhooks
+       * Endpoint pour lister les webhooks
+       *
+       * @returns WebhookList Liste des webhooks configurés
+       * @throws ApiError
+       */
+      static webhookLister() {
+        return request(OpenAPI2, {
+          method: "GET",
+          url: "/webhooks",
+          errors: {
+            400: `La requ\xEAte est malform\xE9e`,
+            401: `Autorisations manquantes`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Modifier un Webhook
+       * Endpoint pour la modification d'un webhook.
+       *
+       * @returns any Le Webhook a été modifié avec succès
+       * @throws ApiError
+       */
+      static webhookModifier({
+        id,
+        requestBody
+      }) {
+        return request(OpenAPI2, {
+          method: "PUT",
+          url: "/webhooks/{id}",
+          path: {
+            "id": id
+          },
+          body: requestBody,
+          mediaType: "application/json",
+          errors: {
+            401: `Autorisations manquantes`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Supprimer un Webhook
+       * Endpoint pour la suppression d'un webhook.
+       *
+       * @returns void
+       * @throws ApiError
+       */
+      static webhookSupprimer({
+        id
+      }) {
+        return request(OpenAPI2, {
+          method: "DELETE",
+          url: "/webhooks/{id}",
+          path: {
+            "id": id
+          },
+          errors: {
+            401: `Autorisations manquantes`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Recuperer un webhook
+       * Endpoint pour la consultation des informations d'un Webhook
+       * @returns WebhookData Details du webhook
+       * @throws ApiError
+       */
+      static webhookConsulter({
+        id
+      }) {
+        return request(OpenAPI2, {
+          method: "GET",
+          url: "/webhooks/{id}",
+          path: {
+            "id": id
+          },
+          errors: {
+            401: `Autorisations manquantes`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/generated/services/PaiementEnMasseService.ts
+var PaiementEnMasseService;
+var init_PaiementEnMasseService = __esm({
+  "src/generated/services/PaiementEnMasseService.ts"() {
+    "use strict";
+    init_OpenAPI();
+    init_request();
+    PaiementEnMasseService = class {
+      /**
+       * Envoyer un paiement en masse
+       * Ce point de terminaison permet au client d'envoyer des paiements en masse.
+       *
+       * **Traitement asynchrone :** La création d'un paiement en masse retourne immédiatement `202 Accepted`. Le traitement des transactions se fait de manière asynchrone.
+       *
+       * **Sans confirmation (`confirmation: false` ou non spécifié) :**
+       * - Les transactions sont créées et validées (unicité des txId)
+       * - Les paiements sont exécutés directement
+       * - Les transactions invalides (txId dupliqué) sont automatiquement rejetées avec le code `DU03`
+       * - Le business peut suivre la progression via `GET /paiements-groupes/{instructionId}` et `GET /paiements?instructionId={instructionId}`
+       *
+       * **Avec confirmation (`confirmation: true`) :**
+       * - Les transactions sont créées et validées (unicité des txId + recherche d'alias)
+       * - Les transactions avec alias invalide sont automatiquement rejetées avec le code `BE23`
+       * - Les transactions avec txId dupliqué sont rejetées avec le code `DU03`
+       * - Les transactions valides passent à l'état `INITIE` et peuvent être consultées via `GET /paiements?instructionId={instructionId}&statut=INITIE`
+       * - Le business dispose d'un **délai adaptatif** pour confirmer ou annuler via `PUT /paiements-groupes/{instructionId}/confirmations` :
+       * - **1 à 500 transactions** : 24 heures
+       * - **501 à 1000 transactions** : 48 heures
+       * - **Plus de 1000 transactions** : 72 heures
+       * - Lors de la confirmation, seules les transactions `INITIE` sont envoyées (les transactions `REJETE` sont automatiquement exclues)
+       * - Passé le délai, la demande expire automatiquement
+       *
+       * **Consultation des détails :**
+       * - Statut global du bulk : `GET /paiements-groupes/{instructionId}`
+       * - Liste de toutes les transactions : `GET /paiements?instructionId={instructionId}`
+       * - Seulement les rejetées (validation) : `GET /paiements?instructionId={instructionId}&statut=REJETE`
+       * - Seulement les valides (avec noms/pays) : `GET /paiements?instructionId={instructionId}&statut=INITIE`
+       *
+       * **Convention de nommage des instructionId (important) :**
+       *
+       * L'`instructionId` doit être **unique** pour chaque création de bulk. Pour faciliter le suivi métier, nous recommandons la convention suivante :
+       *
+       * ```
+       * <IDENTIFIANT_METIER>-<NUMERO_TENTATIVE>
+       * ```
+       *
+       * **Exemples :**
+       * - Première tentative : `SALAIRES-2025-01-1` (salaires de janvier 2025, tentative 1)
+       * - Deuxième tentative : `SALAIRES-2025-01-2` (corrections après échecs)
+       * - Troisième tentative : `SALAIRES-2025-01-3` (nouvelles corrections)
+       *
+       * **Avantages :**
+       * - ✅ Chaque bulk a un statut indépendant (INITIE, CONFIRME, ANNULE)
+       * - ✅ Traçabilité claire des tentatives successives
+       * - ✅ Possibilité de filtrer par identifiant métier : `GET /paiements?instructionId[beginsWith]=SALAIRES-2025-01`
+       * - ✅ Respect de l'unicité de l'instructionId
+       *
+       * @returns string La demande a été acceptée et est en cours de traitement.
+       *
+       * Consultez le statut via `GET /paiements-groupes/{instructionId}`.
+       *
+       * @throws ApiError
+       */
+      static paiementGroupeCreer({
+        requestBody
+      }) {
+        return request(OpenAPI2, {
+          method: "POST",
+          url: "/paiements-groupes",
+          body: requestBody,
+          mediaType: "application/json",
+          responseHeader: "Location",
+          errors: {
+            400: `La requ\xEAte est malform\xE9e`,
+            401: `Autorisations manquantes`,
+            409: `Conflit - instructionId d\xE9j\xE0 utilis\xE9`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Détails d'un paiement en masse
+       * Ce point de terminaison permet de consulter les détails d'un paiement en masse.
+       *
+       * **Statut du bulk :**
+       * - `INITIE` : Créé avec confirmation demandée, en attente de confirmation
+       * - `CONFIRME` : Confirmé par le business (si confirmation demandée) ou en cours de traitement (si sans confirmation)
+       * - `ANNULE` : Annulé par le business avant confirmation (seulement si confirmation demandée)
+       *
+       * **Note :**
+       * - Si créé **avec confirmation** (`confirmation: true`) : Le statut évolue de `INITIE` → `CONFIRME` ou `ANNULE`
+       * - Si créé **sans confirmation** (`confirmation: false`) : Le statut est directement `CONFIRME` (aucune action requise du business)
+       *
+       * **Vérification de fin de validation (important pour confirmation) :**
+       *
+       * Lorsque `confirmation: true`, la validation des transactions se fait de manière asynchrone.
+       * Pour savoir si la validation est terminée et si vous pouvez confirmer, vérifiez que :
+       *
+       * ```
+       * transactionsInitiees + transactionsRejetees = transactionsTotal
+       * ```
+       *
+       * - Si égalité → Validation terminée, vous pouvez confirmer ✅
+       * - Si inégalité → Validation en cours, attendez encore (consultez à nouveau dans quelques secondes) ⏳
+       *
+       * La progression détaillée de chaque transaction se consulte via `GET /paiements?txId={txId}`.
+       *
+       * **Consultation des transactions individuelles :**
+       * Pour obtenir la liste détaillée des transactions (avec noms des bénéficiaires, codes d'erreur, etc.), utilisez :
+       * - Toutes les transactions : `GET /paiements?instructionId={instructionId}`
+       * - Seulement les rejetées : `GET /paiements?instructionId={instructionId}&statut=REJETE`
+       * - Seulement les réussies : `GET /paiements?instructionId={instructionId}&statut=IRREVOCABLE`
+       *
+       * @returns PaiementEnMasseReponseStatut Opération effectuée avec succès
+       * @throws ApiError
+       */
+      static paiementGroupeConsulter({
+        instructionId
+      }) {
+        return request(OpenAPI2, {
+          method: "GET",
+          url: "/paiements-groupes/{instructionId}",
+          path: {
+            "instructionId": instructionId
+          },
+          errors: {
+            401: `Autorisations manquantes`,
+            404: `La ressource n'existe pas dans le syst\xE8me`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Confirmer le paiement en masse
+       * Ce point de terminaison permet de confirmer ou d'annuler un paiement en masse créé avec `confirmation: true`.
+       *
+       * **Processus de vérification :**
+       * 1. Après la création (`POST /paiements-groupes`), le participant valide asynchronement toutes les transactions (unicité des txId + recherche d'alias)
+       * 2. Les transactions invalides sont automatiquement rejetées (`statut: REJETE`) avec codes `BE23` (alias invalide) ou `DU03` (txId dupliqué)
+       * 3. Les transactions valides passent à l'état `INITIE` avec les noms et pays des bénéficiaires
+       * 4. Le business consulte via `GET /paiements-groupes/{instructionId}` pour vérifier la progression de la validation
+       * 5. **La validation est terminée quand** : `transactionsInitiees + transactionsRejetees = transactionsTotal`
+       * 6. Le business peut alors confirmer ou annuler
+       *
+       * **Important :** La confirmation n'est possible que lorsque la validation de toutes les transactions est terminée.
+       * Si le business tente de confirmer pendant que la validation est en cours, une erreur 403 sera retournée avec la progression actuelle.
+       *
+       * **Comportement de la confirmation :**
+       * - `decision: true` → Le système envoie **automatiquement SEULEMENT** les transactions avec `statut: INITIE`
+       * - Les transactions `REJETE` (erreurs de validation) sont **automatiquement exclues** (pas besoin de les lister)
+       * - Le statut du bulk passe de `INITIE` à `CONFIRME`
+       *
+       * **Idempotence** : Cet endpoint est idempotent.
+       * - Premier appel avec `decision: true` → Lance les paiements, retourne `200 OK {statut: "CONFIRME"}`
+       * - Appels suivants avec `decision: true` → Retourne `200 OK {statut: "CONFIRME"}` (idempotent, ne relance pas)
+       * - Premier appel avec `decision: false` → Annule, retourne `200 OK {statut: "ANNULE"}`
+       * - Appels suivants avec `decision: false` → Retourne `200 OK {statut: "ANNULE"}` (idempotent)
+       * - `decision: true` après `decision: false` → Retourne `403 Forbidden` (déjà annulé)
+       * - `decision: false` après `decision: true` → Retourne `403 Forbidden` (déjà confirmé)
+       *
+       * **Timeout adaptatif** : Le délai pour confirmer dépend automatiquement du nombre de transactions :
+       * - **1 à 500 transactions** : 24 heures
+       * - **501 à 1000 transactions** : 48 heures
+       * - **Plus de 1000 transactions** : 72 heures
+       *
+       * Passé ce délai, la demande expire automatiquement et ne peut plus être confirmée. Le délai exact est indiqué dans le champ `dateExpiration` retourné par `GET /paiements-groupes/{instructionId}`.
+       *
+       * **Changement de décision** : Une fois une décision prise, elle est définitive. Impossible de confirmer après avoir annulé, et vice-versa.
+       *
+       * @returns PaiementEnMasseReponseStatut Confirmation enregistrée avec succès.
+       * - Si `decision: true`, le statut passe à `CONFIRME` et les paiements sont lancés
+       * - Si `decision: false`, le statut passe à `ANNULE`
+       *
+       * @throws ApiError
+       */
+      static paiementGroupeConfirmer({
+        instructionId,
+        requestBody
+      }) {
+        return request(OpenAPI2, {
+          method: "PUT",
+          url: "/paiements-groupes/{instructionId}/confirmations",
+          path: {
+            "instructionId": instructionId
+          },
+          body: requestBody,
+          mediaType: "application/json",
+          errors: {
+            401: `Autorisations manquantes`,
+            403: `Op\xE9ration interdite`,
+            404: `La ressource n'existe pas dans le syst\xE8me`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/generated/services/PaiementImmediatService.ts
+var PaiementImmediatService;
+var init_PaiementImmediatService = __esm({
+  "src/generated/services/PaiementImmediatService.ts"() {
+    "use strict";
+    init_OpenAPI();
+    init_request();
+    PaiementImmediatService = class {
+      /**
+       * Envoyer un paiement
+       * Ce point de terminaison permet au business d'effectuer des paiements.
+       *
+       * Le destinataire du paiement est identifié par son alias de compte.
+       *
+       * Le business peut définir le champ `confirmation` à `true` pour demander une validation en deux étapes : le PSP retournera d'abord le résultat de la recherche d'alias (avec le nom et le pays du bénéficiaire), puis attendra une confirmation explicite avant d'exécuter le paiement via l'endpoint `PUT /paiements/{txId}/confirmations`.
+       *
+       * **Timeout de confirmation** : Si le business demande une confirmation, il dispose de **24 heures** pour confirmer. Passé ce délai, la demande expire automatiquement.
+       *
+       * @returns PaiementImmediatReponse Paiement traité. Le champ `statut` indique le résultat :
+       * - `INITIE` : En attente de confirmation (si `confirmation: true`)
+       * - `ENVOYE` : Paiement envoyé avec succès (si `confirmation: false`)
+       * - `REJETE` : Paiement rejeté. Le champ `statutRaison` contient le code d'erreur :
+       * - `DU03` : txId dupliqué (déjà utilisé)
+       * - `BE23` : Alias bénéficiaire invalide
+       * - Autres codes ISO 20022
+       *
+       * @throws ApiError
+       */
+      static paiementCreer({
+        requestBody
+      }) {
+        return request(OpenAPI2, {
+          method: "POST",
+          url: "/paiements",
+          body: requestBody,
+          mediaType: "application/json",
+          errors: {
+            400: `La requ\xEAte est malform\xE9e`,
+            401: `Autorisations manquantes`,
+            403: `Interdiction d'effectuer le paiement (erreurs m\xE9tier non-retriables)`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Lister les paiements
+       * Ce point de terminaison permet de lister les paiements effectués par le client.
+       * @returns PaiementListe Succès de l'opération
+       * @throws ApiError
+       */
+      static paiementLister({
+        payeAlias,
+        payeCompte,
+        payeurAlias,
+        payeurCompte,
+        dateEnvoi,
+        dateIrrevocabilite,
+        statut,
+        categorie,
+        montantAchat,
+        montantRetrait,
+        motif,
+        refDocType,
+        instructionId,
+        txId,
+        annulationStatut,
+        annulationMotif,
+        retourStatut,
+        page,
+        size,
+        sort,
+        fields
+      }) {
+        return request(OpenAPI2, {
+          method: "GET",
+          url: "/paiements",
+          query: {
+            "payeAlias": payeAlias,
+            "payeCompte": payeCompte,
+            "payeurAlias": payeurAlias,
+            "payeurCompte": payeurCompte,
+            "dateEnvoi": dateEnvoi,
+            "dateIrrevocabilite": dateIrrevocabilite,
+            "statut": statut,
+            "categorie": categorie,
+            "montantAchat": montantAchat,
+            "montantRetrait": montantRetrait,
+            "motif": motif,
+            "refDocType": refDocType,
+            "instructionId": instructionId,
+            "txId": txId,
+            "annulationStatut": annulationStatut,
+            "annulationMotif": annulationMotif,
+            "retourStatut": retourStatut,
+            "page": page,
+            "size": size,
+            "sort": sort,
+            "fields": fields
+          },
+          errors: {
+            401: `Autorisations manquantes`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Détails d'un paiement
+       * Cet point de terminaison permet de consulter les details d'un paiement.
+       *
+       * @returns Paiement Opération effectuée avec succès
+       * @throws ApiError
+       */
+      static paiementRecuperer({
+        txId
+      }) {
+        return request(OpenAPI2, {
+          method: "GET",
+          url: "/paiements/{txId}",
+          path: {
+            "txId": txId
+          },
+          errors: {
+            401: `Autorisations manquantes`,
+            404: `La ressource n'existe pas dans le syst\xE8me`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Confirmer le paiement
+       * Ce point de terminaison permet d'envoyer la confirmation de l'envoi d'un paiement immédiat
+       * après vérification du nom et du pays du bénéficiaire.
+       *
+       * **Idempotence** : Cet endpoint est idempotent.
+       * - Premier appel avec `decision: true` → Lance le paiement, retourne `200 OK {statut: "ENVOYE"}`
+       * - Appels suivants avec `decision: true` → Retourne `200 OK` avec l'état actuel (ENVOYE, IRREVOCABLE, ou REJETE) - idempotent
+       * - Premier appel avec `decision: false` → Annule, retourne `200 OK {statut: "ANNULE"}`
+       * - Appels suivants avec `decision: false` → Retourne `200 OK {statut: "ANNULE"}` (idempotent)
+       * - `decision: true` après `decision: false` → Retourne `403 Forbidden` (déjà annulé)
+       * - `decision: false` après `decision: true` → Retourne `403 Forbidden` (déjà confirmé)
+       *
+       * **Timeout** : La confirmation doit être envoyée dans les **24 heures** suivant la création de la demande. Passé ce délai, la demande expire automatiquement et ne peut plus être confirmée.
+       *
+       * **Changement de décision** : Une fois une décision prise, elle est définitive. Impossible de confirmer après avoir annulé, et vice-versa.
+       *
+       * @returns PaiementImmediatConfirmationReponse Paiement en cours d'envoi
+       * @throws ApiError
+       */
+      static paiementConfirmer({
+        txId,
+        requestBody
+      }) {
+        return request(OpenAPI2, {
+          method: "PUT",
+          url: "/paiements/{txId}/confirmations",
+          path: {
+            "txId": txId
+          },
+          body: requestBody,
+          mediaType: "application/json",
+          errors: {
+            401: `Autorisations manquantes`,
+            403: `Op\xE9ration interdite`,
+            404: `La ressource n'existe pas dans le syst\xE8me`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+      /**
+       * Vérifier un paiement
+       * Ce point de terminaison permet de vérifier la réception d’un paiement à partir de l’`end2endId`.
+       *
+       * Dans certains cas, le **client business** peut ne pas avoir reçu la notification de paiement.
+       * Le **client payeur** peut alors lui communiquer l’`end2endId` afin qu’il puisse vérifier manuellement le statut du paiement.
+       *
+       * Le **participant** doit, dans ce cas, vérifier dans sa base de données et s'il ne trouve pas le paiement, il doit interroger l’endpoint de PI-SPI permettant de **récupérer le statut d’un paiement**,  puis **retourner ce statut** dans sa réponse.
+       *
+       * Le statut retourné doit être soit :
+       * - `IRREVOCABLE` (paiement irrévocable), ou
+       * - `REJETE` (paiement rejeté).
+       *
+       * Un transfert **ne peut pas** être signalé comme « en cours de traitement » dans ce contexte.
+       *
+       * ⚠️ **Remarques :**
+       * - La vérification ne doit concerner que les paiements réalisés depuis **moins de 3 mois (90 jours)** afin de garantir la disponibilité de la réponse.
+       * - La garantie de réponse n’est assurée qu’à partir de **20 secondes après l’envoi du transfert**.
+       *
+       * @returns Paiement Opération effectuée avec succès
+       * @throws ApiError
+       */
+      static paiementVerifier({
+        end2EndId
+      }) {
+        return request(OpenAPI2, {
+          method: "GET",
+          url: "/paiements/{end2endId}/statuts",
+          path: {
+            "end2endId": end2EndId
+          },
+          errors: {
+            401: `Autorisations manquantes`,
+            404: `Ce paiement n'a pas \xE9t\xE9 trouv\xE9`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/generated/services/RetoursdeFondsService.ts
+var RetoursdeFondsService;
+var init_RetoursdeFondsService = __esm({
+  "src/generated/services/RetoursdeFondsService.ts"() {
+    "use strict";
+    init_OpenAPI();
+    init_request();
+    RetoursdeFondsService = class {
+      /**
+       * Retourner les fonds
+       * Ce point de terminaison permet au business de retourner les fonds d'un paiement reçu.
+       *
+       * **Idempotence** : Cet endpoint est idempotent. Plusieurs appels avec le même `end2endId` produiront le même résultat.
+       * Si le retour de fonds a déjà été envoyé et irrévocable, le champ `retourStatut` de la réponse sera `IRREVOCABLE`.
+       * Si le retour de fonds a été envoyé et rejeté, le retour de fonds sera envoyé à nouveau.
+       * Si le retour de fonds est en cours d'envoi, le champ `retourStatut` de la réponse sera `INITIE`.
+       *
+       * **Notifications webhook** : Après envoi du retour de fonds, si le business a souscrit au service de webhook, il recevra :
+       * - Une notification `RETOUR_ENVOYE` en cas de succès du retour de fonds
+       * - Une notification `RETOUR_REJETE` en cas de rejet de la demande
+       *
+       * **Vérification du statut** : Pour obtenir le statut d'un retour de fonds envoyé, vous pouvez invoquer l'endpoint `GET /paiements/{end2endId}` et le champ `retourStatut` de la réponse indiquera l'état du retour de fonds.
+       *
+       * @returns Paiement Retour de fonds enregistré avec succès
+       * @throws ApiError
+       */
+      static retourFondsEnvoyer({
+        end2EndId
+      }) {
+        return request(OpenAPI2, {
+          method: "PUT",
+          url: "/paiements/{end2endId}/retours",
+          path: {
+            "end2endId": end2EndId
+          },
+          errors: {
+            401: `Autorisations manquantes`,
+            403: `Interdiction d'effectuer le retour de fonds`,
+            429: `Erreur inattendue`,
+            503: `Erreur inattendue du serveur`
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/generated/index.ts
+var init_generated = __esm({
+  "src/generated/index.ts"() {
+    "use strict";
+    init_ApiError();
+    init_CancelablePromise();
+    init_OpenAPI();
+    init_AnnulationStatut();
+    init_CompteOperation();
+    init_CompteSolde();
+    init_CompteTransfertIntraReponse();
+    init_DemandePaiementConfirmationAnnulationRaison();
+    init_DemandePaiementConfirmationReponse();
+    init_DemandePaiementConsultationReponse();
+    init_DemandePaiementEnMasseStatutReponse();
+    init_DemandePaiementListeItem();
+    init_DemandePaiementReponseRequest();
+    init_DemandePaiementRequest();
+    init_DemandePaiementRequestCategorie();
+    init_DemandePaiementStatut();
+    init_DemandePaiementStatutRaison();
+    init_Paiement();
+    init_PaiementAnnulationMotif();
+    init_PaiementAnnulationStatutRaison();
+    init_PaiementEnMasseReponseStatut();
+    init_PaiementImmediatConfirmationReponse();
+    init_PaiementImmediatReponse();
+    init_PaiementStatut();
+    init_PaiementStatutRaison();
+    init_RefDocType();
+    init_RetourStatut();
+    init_RetourStatutRaison();
+    init_WebhookEvent();
+    init_WebhooksEvents();
+    init_AliasService();
+    init_ComptesService();
+    init_DemandeAnnulationService();
+    init_DemandesDePaiementService();
+    init_DemandesDePaiementEnMasseService();
+    init_NotificationService();
+    init_PaiementEnMasseService();
+    init_PaiementImmediatService();
+    init_RetoursdeFondsService();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ACCOUNT_STATUS: () => ACCOUNT_STATUS,
+  ACCOUNT_TYPE: () => ACCOUNT_TYPE,
+  ALIAS_TYPES: () => ALIAS_TYPES2,
+  AliasService: () => AliasService2,
+  AliasType: () => AliasType,
+  AnnulationStatut: () => AnnulationStatut,
+  ApiError: () => ApiError,
+  CLIENT_TYPE: () => CLIENT_TYPE,
+  CURRENCY: () => CURRENCY,
+  CancelError: () => CancelError,
+  CancelablePromise: () => CancelablePromise,
+  CompteOperation: () => CompteOperation,
+  CompteSolde: () => CompteSolde,
+  CompteTransfertIntraReponse: () => CompteTransfertIntraReponse,
+  ComptesService: () => ComptesService2,
+  DEFAULT_LIMITS: () => DEFAULT_LIMITS,
+  DEFAULT_PISPI_LOGO_DATA_URL: () => DEFAULT_PISPI_LOGO_DATA_URL,
+  DemandeAnnulationService: () => DemandeAnnulationService,
+  DemandePaiementConfirmationAnnulationRaison: () => DemandePaiementConfirmationAnnulationRaison,
+  DemandePaiementConfirmationReponse: () => DemandePaiementConfirmationReponse,
+  DemandePaiementConsultationReponse: () => DemandePaiementConsultationReponse,
+  DemandePaiementEnMasseStatutReponse: () => DemandePaiementEnMasseStatutReponse,
+  DemandePaiementListeItem: () => DemandePaiementListeItem,
+  DemandePaiementReponseRequest: () => DemandePaiementReponseRequest,
+  DemandePaiementRequest: () => DemandePaiementRequest,
+  DemandePaiementRequestCategorie: () => DemandePaiementRequestCategorie,
+  DemandePaiementStatut: () => DemandePaiementStatut,
+  DemandePaiementStatutRaison: () => DemandePaiementStatutRaison,
+  DemandesDePaiementEnMasseService: () => DemandesDePaiementEnMasseService,
+  DemandesDePaiementService: () => DemandesDePaiementService,
+  NotificationService: () => NotificationService,
+  OpenAPI: () => OpenAPI2,
+  PAYMENT_STATUS: () => PAYMENT_STATUS,
+  PISPI_AMBER_LOGO_DATA_URL: () => PISPI_AMBER_LOGO_DATA_URL,
+  PISPI_QRCODE_LOGO_DATA_URL: () => PISPI_QRCODE_LOGO_DATA_URL,
+  PI_SPI_ENDPOINTS: () => PI_SPI_ENDPOINTS,
+  Paiement: () => Paiement,
+  PaiementAnnulationMotif: () => PaiementAnnulationMotif,
+  PaiementAnnulationStatutRaison: () => PaiementAnnulationStatutRaison,
+  PaiementEnMasseReponseStatut: () => PaiementEnMasseReponseStatut,
+  PaiementEnMasseService: () => PaiementEnMasseService,
+  PaiementImmediatConfirmationReponse: () => PaiementImmediatConfirmationReponse,
+  PaiementImmediatReponse: () => PaiementImmediatReponse,
+  PaiementImmediatService: () => PaiementImmediatService,
+  PaiementStatut: () => PaiementStatut,
+  PaiementStatutRaison: () => PaiementStatutRaison,
+  PiSpiAuthError: () => PiSpiAuthError,
+  PiSpiError: () => PiSpiError,
+  PiSpiNotFoundError: () => PiSpiNotFoundError,
+  PiSpiRateLimitError: () => PiSpiRateLimitError,
+  PiSpiSDK: () => PiSpiSDK,
+  PiSpiValidationError: () => PiSpiValidationError,
+  QRCode: () => QRCode,
+  QueryBuilder: () => QueryBuilder,
+  RefDocType: () => RefDocType,
+  RetourStatut: () => RetourStatut,
+  RetourStatutRaison: () => RetourStatutRaison,
+  RetoursdeFondsService: () => RetoursdeFondsService,
+  UEMOA_COUNTRIES: () => UEMOA_COUNTRIES2,
+  WEBHOOK_EVENTS: () => WEBHOOK_EVENTS,
+  WebhookEvent: () => WebhookEvent,
+  WebhooksEvents: () => WebhooksEvents,
+  buildLomiCustomerQr: () => buildLomiCustomerQr,
+  buildPayloadString: () => buildPayloadString,
+  centimesToXof: () => centimesToXof,
+  computeCrc16: () => computeCrc16,
+  createQrPayload: () => createQrPayload,
+  formatAmount: () => formatAmount,
+  generateQrCodeSvg: () => generateQrCodeSvg,
+  getAvailableAliasTypes: () => getAvailableAliasTypes,
+  getCountryFromAccount: () => getCountryFromAccount,
+  handleApiError: () => handleApiError,
+  isValidAccountNumber: () => isValidAccountNumber,
+  isValidAliasType: () => isValidAliasType,
+  isValidPhoneNumber: () => isValidPhoneNumber,
+  isValidPispiQrPayload: () => isValidPispiQrPayload,
+  isValidShidAlias: () => isValidShidAlias,
+  parseLomiCustomerQr: () => parseLomiCustomerQr,
+  retryWithBackoff: () => retryWithBackoff,
+  serializeLomiCustomerQr: () => serializeLomiCustomerQr,
+  sleep: () => sleep,
+  xofToCentimes: () => xofToCentimes
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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 ComptesService = 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 AliasService = 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(request2) {
+    return this.request("POST", "/demandes-paiements", request2);
+  }
+  /**
+   * 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(request2) {
+    const transactions = request2.transactions.map((t) => ({
+      ...t,
+      categorie: t.categorie || "401"
+    }));
+    return this.request("POST", "/demandes-paiements-groupes", {
+      ...request2,
+      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(request2) {
+    const end2endId = request2.end2endId ?? request2.txId;
+    if (!end2endId) {
+      throw new Error("end2endId or txId is required for cancellation requests");
+    }
+    return this.request(
+      "POST",
+      `/paiements/${encodeURIComponent(end2endId)}/annulations`,
+      { raison: request2.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(module2) {
+  if (module2?.create) {
+    return module2;
+  }
+  if (module2?.default?.create) {
+    return module2.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 module2 = await import("qrcode");
+  const resolved = resolveQrCodeModule(module2);
+  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 module2 = await getQrCodeModule();
+  const qr = module2.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 OpenAPI;
+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 {
+      OpenAPI = this._config;
+    } catch {
+      OpenAPI = this._config;
+    }
+    this.comptes = new ComptesService(this._config);
+    this.alias = new AliasService(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 (OpenAPI) {
+      OpenAPI.TOKEN = token;
+      OpenAPI.HEADERS = {
+        ...OpenAPI.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((resolve2) => setTimeout(resolve2, 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"
+};
+
+// src/index.ts
+init_generated();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACCOUNT_STATUS,
+  ACCOUNT_TYPE,
+  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_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
+});