pi-spi-sdk 0.1.2 → 0.2.0

package/dist/chunk-7W56NW2S.mjs

@@ -0,0 +1,2066 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 = 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 = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CancelError";
+  }
+  get isCancelled() {
+    return true;
+  }
+};
+var _isResolved, _isRejected, _isCancelled, _cancelHandlers, _promise, _resolve, _reject;
+var 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 OpenAPI = {
+  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 = /* @__PURE__ */ ((AnnulationStatut2) => {
+  AnnulationStatut2["INITIE"] = "INITIE";
+  AnnulationStatut2["ENVOYE"] = "ENVOYE";
+  AnnulationStatut2["IRREVOCABLE"] = "IRREVOCABLE";
+  AnnulationStatut2["REJETE"] = "REJETE";
+  return AnnulationStatut2;
+})(AnnulationStatut || {});
+
+// src/generated/models/CompteOperation.ts
+var CompteOperation;
+((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;
+((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;
+((CompteTransfertIntraReponse2) => {
+  let statut;
+  ((statut2) => {
+    statut2["INITIE"] = "INITIE";
+  })(statut = CompteTransfertIntraReponse2.statut || (CompteTransfertIntraReponse2.statut = {}));
+})(CompteTransfertIntraReponse || (CompteTransfertIntraReponse = {}));
+
+// src/generated/models/DemandePaiementConfirmationAnnulationRaison.ts
+var 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;
+((DemandePaiementConfirmationReponse2) => {
+  let statut;
+  ((statut2) => {
+    statut2["ENVOYE"] = "ENVOYE";
+    statut2["ANNULE"] = "ANNULE";
+  })(statut = DemandePaiementConfirmationReponse2.statut || (DemandePaiementConfirmationReponse2.statut = {}));
+})(DemandePaiementConfirmationReponse || (DemandePaiementConfirmationReponse = {}));
+
+// src/generated/models/DemandePaiementConsultationReponse.ts
+var DemandePaiementConsultationReponse;
+((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;
+((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;
+((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;
+((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;
+((DemandePaiementRequest2) => {
+  let categorie;
+  ((categorie2) => {
+    categorie2["_500"] = "500";
+  })(categorie = DemandePaiementRequest2.categorie || (DemandePaiementRequest2.categorie = {}));
+})(DemandePaiementRequest || (DemandePaiementRequest = {}));
+
+// src/generated/models/DemandePaiementRequestCategorie.ts
+var DemandePaiementRequestCategorie = /* @__PURE__ */ ((DemandePaiementRequestCategorie2) => {
+  DemandePaiementRequestCategorie2["_500"] = "500";
+  DemandePaiementRequestCategorie2["_521"] = "521";
+  DemandePaiementRequestCategorie2["_401"] = "401";
+  return DemandePaiementRequestCategorie2;
+})(DemandePaiementRequestCategorie || {});
+
+// src/generated/models/DemandePaiementStatut.ts
+var 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 = /* @__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;
+((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 = /* @__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 = /* @__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;
+((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;
+((PaiementImmediatConfirmationReponse2) => {
+  let statut;
+  ((statut2) => {
+    statut2["ENVOYE"] = "ENVOYE";
+  })(statut = PaiementImmediatConfirmationReponse2.statut || (PaiementImmediatConfirmationReponse2.statut = {}));
+})(PaiementImmediatConfirmationReponse || (PaiementImmediatConfirmationReponse = {}));
+
+// src/generated/models/PaiementImmediatReponse.ts
+var PaiementImmediatReponse;
+((PaiementImmediatReponse2) => {
+  let statut;
+  ((statut2) => {
+    statut2["INITIE"] = "INITIE";
+  })(statut = PaiementImmediatReponse2.statut || (PaiementImmediatReponse2.statut = {}));
+})(PaiementImmediatReponse || (PaiementImmediatReponse = {}));
+
+// src/generated/models/PaiementStatut.ts
+var 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 = /* @__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 = /* @__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 = /* @__PURE__ */ ((RetourStatut2) => {
+  RetourStatut2["INITIE"] = "INITIE";
+  RetourStatut2["ENVOYE"] = "ENVOYE";
+  RetourStatut2["IRREVOCABLE"] = "IRREVOCABLE";
+  RetourStatut2["REJETE"] = "REJETE";
+  return RetourStatut2;
+})(RetourStatut || {});
+
+// src/generated/models/RetourStatutRaison.ts
+var 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;
+((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 = /* @__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
+import axios from "axios";
+import FormData from "form-data";
+var isDefined = (value) => {
+  return value !== void 0 && value !== null;
+};
+var isString = (value) => {
+  return typeof value === "string";
+};
+var isStringWithValue = (value) => {
+  return isString(value) && value !== "";
+};
+var 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]);
+};
+var isFormData = (value) => {
+  return value instanceof FormData;
+};
+var isSuccess = (status) => {
+  return status >= 200 && status < 300;
+};
+var base64 = (str) => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    return Buffer.from(str).toString("base64");
+  }
+};
+var 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 "";
+};
+var 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;
+};
+var getFormData = (options) => {
+  if (options.formData) {
+    const formData = new FormData();
+    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;
+};
+var resolve = async (options, resolver) => {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+};
+var 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;
+};
+var getRequestBody = (options) => {
+  if (options.body) {
+    return options.body;
+  }
+  return void 0;
+};
+var sendRequest = async (config, options, url, body, formData, headers, onCancel, axiosClient) => {
+  const source = axios.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;
+  }
+};
+var getResponseHeader = (response, responseHeader) => {
+  if (responseHeader) {
+    const content = response.headers[responseHeader];
+    if (isString(content)) {
+      return content;
+    }
+  }
+  return void 0;
+};
+var getResponseBody = (response) => {
+  if (response.status !== 204) {
+    return response.data;
+  }
+  return void 0;
+};
+var 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}`
+    );
+  }
+};
+var request = (config, options, axiosClient = axios) => {
+  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 AliasService = 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(OpenAPI, {
+      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(OpenAPI, {
+      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(OpenAPI, {
+      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 ComptesService = 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(OpenAPI, {
+      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(OpenAPI, {
+      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(OpenAPI, {
+      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 = 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(OpenAPI, {
+      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(OpenAPI, {
+      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 = 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(OpenAPI, {
+      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(OpenAPI, {
+      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(OpenAPI, {
+      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(OpenAPI, {
+      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(OpenAPI, {
+      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 = 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(OpenAPI, {
+      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(OpenAPI, {
+      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(OpenAPI, {
+      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 = 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(OpenAPI, {
+      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(OpenAPI, {
+      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(OpenAPI, {
+      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(OpenAPI, {
+      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(OpenAPI, {
+      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 = 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(OpenAPI, {
+      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(OpenAPI, {
+      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(OpenAPI, {
+      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 = 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(OpenAPI, {
+      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(OpenAPI, {
+      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(OpenAPI, {
+      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(OpenAPI, {
+      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(OpenAPI, {
+      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 = 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(OpenAPI, {
+      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`
+      }
+    });
+  }
+};
+
+export {
+  ApiError,
+  CancelError,
+  CancelablePromise,
+  OpenAPI,
+  AnnulationStatut,
+  CompteOperation,
+  CompteSolde,
+  CompteTransfertIntraReponse,
+  DemandePaiementConfirmationAnnulationRaison,
+  DemandePaiementConfirmationReponse,
+  DemandePaiementConsultationReponse,
+  DemandePaiementEnMasseStatutReponse,
+  DemandePaiementListeItem,
+  DemandePaiementReponseRequest,
+  DemandePaiementRequest,
+  DemandePaiementRequestCategorie,
+  DemandePaiementStatut,
+  DemandePaiementStatutRaison,
+  Paiement,
+  PaiementAnnulationMotif,
+  PaiementAnnulationStatutRaison,
+  PaiementEnMasseReponseStatut,
+  PaiementImmediatConfirmationReponse,
+  PaiementImmediatReponse,
+  PaiementStatut,
+  PaiementStatutRaison,
+  RefDocType,
+  RetourStatut,
+  RetourStatutRaison,
+  WebhookEvent,
+  WebhooksEvents,
+  AliasService,
+  ComptesService,
+  DemandeAnnulationService,
+  DemandesDePaiementService,
+  DemandesDePaiementEnMasseService,
+  NotificationService,
+  PaiementEnMasseService,
+  PaiementImmediatService,
+  RetoursdeFondsService
+};