@tricoteuses/assemblee 1.10.5 → 2.0.2

package/lib/cleaners.js

@@ -0,0 +1,1138 @@
+import assert from "node:assert";
+import { c as cleanXmlArtefacts, a as cleanBooleanAttribute, b as cleanIntegerAttribute } from "./amendements-CN7bRFdP.js";
+import { d } from "./amendements-CN7bRFdP.js";
+function cleanActeur(acteur) {
+  cleanXmlArtefacts(acteur);
+  assert.strictEqual(acteur.uid["@xsi:type"], "IdActeur_type");
+  acteur.uid = acteur.uid["#text"];
+  assert(acteur.uid);
+  const etatCivil = acteur.etatCivil;
+  {
+    cleanXmlArtefacts(etatCivil);
+    const ident = etatCivil.ident;
+    {
+      cleanXmlArtefacts(ident);
+      const infoNaissance = etatCivil.infoNaissance;
+      {
+        cleanXmlArtefacts(infoNaissance);
+      }
+    }
+  }
+  const profession = acteur.profession;
+  if (profession !== void 0) {
+    cleanXmlArtefacts(profession);
+    const socProcInsee = profession.socProcINSEE;
+    assert(socProcInsee);
+    cleanXmlArtefacts(socProcInsee);
+    delete profession.socProcINSEE;
+    profession.socProcInsee = socProcInsee;
+  }
+  const uriHatvp = acteur.uri_hatvp;
+  if (uriHatvp !== void 0) {
+    acteur.uriHatvp = uriHatvp;
+    delete acteur.uri_hatvp;
+  }
+  let adresses = acteur.adresses;
+  if (adresses !== void 0) {
+    adresses = adresses.adresse;
+    if (adresses === void 0) {
+      delete acteur.adresses;
+      adresses = void 0;
+    } else if (Array.isArray(adresses)) {
+      acteur.adresses = adresses;
+    } else {
+      assert.notStrictEqual(adresses, null);
+      assert.strictEqual(typeof adresses, "object");
+      acteur.adresses = adresses = [adresses];
+    }
+    if (adresses !== void 0) {
+      for (const adresse of adresses) {
+        cleanXmlArtefacts(adresse);
+        const xsiType = adresse["@xsi:type"];
+        assert([
+          "AdresseMail_Type",
+          "AdressePostale_Type",
+          "AdresseSiteWeb_Type",
+          "AdresseTelephonique_Type"
+        ].includes(xsiType), `Unexpected "@xsi:type": ${xsiType}`);
+        adresse.xsiType = xsiType;
+        delete adresse["@xsi:type"];
+        assert.notStrictEqual(adresse.uid, void 0);
+        assert.notStrictEqual(adresse.type, void 0);
+        assert.notStrictEqual(adresse.typeLibelle, void 0);
+        if (xsiType === "AdressePostale_Type") {
+          assert.strictEqual(adresse.adresseDeRattachement, void 0);
+        }
+      }
+    }
+  }
+  let mandats = acteur.mandats;
+  if (mandats !== void 0) {
+    let mandat = mandats.mandat;
+    if (Array.isArray(mandat)) {
+      mandats = acteur.mandats = mandat;
+    } else if (typeof mandat === "object") {
+      mandats = acteur.mandats = [mandat];
+    }
+    for (const mandat2 of mandats) {
+      cleanXmlArtefacts(mandat2);
+      const xsiType = mandat2["@xsi:type"];
+      if (xsiType !== void 0) {
+        mandat2.xsiType = xsiType;
+        delete mandat2["@xsi:type"];
+      }
+      const infosQualite = mandat2.infosQualite;
+      {
+        cleanXmlArtefacts(infosQualite);
+      }
+      const organes = mandat2.organes;
+      delete mandat2.organes;
+      let organesRefs = organes.organeRef;
+      assert(organesRefs);
+      if (!Array.isArray(organesRefs)) {
+        organesRefs = [organesRefs];
+      }
+      mandat2.organesRefs = organesRefs;
+      let suppleant = mandat2.suppleants;
+      delete mandat2.suppleants;
+      if (suppleant) {
+        suppleant = suppleant.suppleant;
+        assert(suppleant);
+        mandat2.suppleant = suppleant;
+        cleanXmlArtefacts(suppleant);
+      }
+      const election = mandat2.election;
+      if (election !== void 0) {
+        cleanXmlArtefacts(election);
+        const lieu = election.lieu;
+        cleanXmlArtefacts(lieu);
+      }
+      const mandature = mandat2.mandature;
+      if (mandature !== void 0) {
+        cleanXmlArtefacts(mandature);
+      }
+      assert.strictEqual(mandat2.chambre, void 0);
+      let collaborateurs = mandat2.collaborateurs;
+      if (collaborateurs !== void 0) {
+        const collaborateursArray = Array.isArray(collaborateurs) ? collaborateurs.filter((collaborateur) => collaborateur !== null) : [collaborateurs];
+        collaborateurs = [];
+        collaborateursArray.map(({ collaborateur }) => {
+          if (Array.isArray(collaborateur)) {
+            for (const collaborateurItem of collaborateur) {
+              if (collaborateurItem !== null) {
+                collaborateurs.push(collaborateurItem);
+              }
+            }
+          } else if (collaborateur) {
+            collaborateurs.push(collaborateur);
+          }
+        });
+        if (collaborateurs.length === 0) {
+          delete mandat2.collaborateurs;
+          collaborateurs = void 0;
+        } else {
+          mandat2.collaborateurs = collaborateurs;
+        }
+        for (const collaborateur of collaborateurs || []) {
+          cleanXmlArtefacts(collaborateur);
+          assert.strictEqual(collaborateur.dateDebut, void 0);
+          assert.strictEqual(collaborateur.dateFin, void 0);
+        }
+      }
+      const infosHorsSian = mandat2.InfosHorsSIAN;
+      if (infosHorsSian !== void 0) {
+        cleanXmlArtefacts(infosHorsSian);
+        assert.strictEqual(infosHorsSian.HATVP_URI, void 0);
+        assert.strictEqual(Object.keys(infosHorsSian).length, 0);
+        delete mandat2.InfosHorsSIAN;
+      }
+    }
+    mandats.sort((a, b) => a.uid.length === b.uid.length ? a.uid.localeCompare(b.uid) : a.uid.length - b.uid.length);
+  }
+  let deports = acteur.deports;
+  if (deports !== void 0) {
+    let deport = deports.deport;
+    if (Array.isArray(deport)) {
+      deports = acteur.deports = deport;
+    } else if (typeof deport === "object") {
+      deports = acteur.deports = [deport];
+    }
+    for (const deport2 of deports) {
+      cleanXmlArtefacts(deport2);
+      const cible = deport2.cible;
+      {
+        cleanXmlArtefacts(cible);
+        assert.strictEqual(cible.references, void 0);
+      }
+    }
+    deports.sort((a, b) => a.uid.length === b.uid.length ? a.uid.localeCompare(b.uid) : a.uid.length - b.uid.length);
+  }
+}
+function cleanRapporteur(rapporteur) {
+  const etudePlfRef = rapporteur.etudePLFRef;
+  if (rapporteur.etudePLFRef !== void 0) {
+    delete rapporteur.etudePLFRef;
+    rapporteur.etudePlfRef = etudePlfRef;
+  }
+}
+function cleanDocumentOrDivision(d2) {
+  cleanXmlArtefacts(d2);
+  if (d2.metadatas?.dateSuppression !== void 0) {
+    for (const key of Object.getOwnPropertyNames(d2)) {
+      delete d2[key];
+    }
+    return;
+  }
+  const xsiType = d2["@xsi:type"];
+  if (xsiType !== void 0) {
+    d2.xsiType = xsiType;
+    delete d2["@xsi:type"];
+  }
+  const cycleDeVie = d2.cycleDeVie;
+  assert(cycleDeVie);
+  {
+    const chrono = cycleDeVie.chrono;
+    assert(chrono);
+    cleanXmlArtefacts(chrono);
+  }
+  let divisions = d2.divisions;
+  if (divisions !== void 0) {
+    divisions = divisions.division;
+    if (!Array.isArray(divisions)) {
+      assert(divisions);
+      divisions = [divisions];
+    }
+    d2.divisions = divisions;
+    for (const division of divisions) {
+      cleanDocumentOrDivision(division);
+    }
+  }
+  assert.strictEqual(d2.redacteur, void 0);
+  const classification = d2.classification;
+  assert(classification);
+  cleanXmlArtefacts(classification);
+  let auteurs = d2.auteurs;
+  if (auteurs !== void 0) {
+    auteurs = auteurs.auteur;
+    if (!Array.isArray(auteurs)) {
+      assert(auteurs);
+      auteurs = [auteurs];
+    }
+    d2.auteurs = auteurs;
+    for (const auteur of auteurs) {
+      let organeRef = auteur.organe;
+      if (organeRef !== void 0) {
+        auteur.organeRef = organeRef.organeRef;
+        delete auteur.organe;
+      }
+    }
+  }
+  const notice = d2.notice;
+  {
+    cleanBooleanAttribute(notice, "adoptionConforme");
+  }
+  let coSignataires = d2.coSignataires;
+  if (coSignataires !== void 0) {
+    coSignataires = coSignataires.coSignataire;
+    if (!Array.isArray(coSignataires)) {
+      assert(coSignataires);
+      coSignataires = [coSignataires];
+    }
+    d2.coSignataires = coSignataires;
+    for (const coSignataire of coSignataires) {
+      cleanXmlArtefacts(coSignataire);
+      cleanBooleanAttribute(coSignataire, "edite");
+      let acteurRef = coSignataire.acteur;
+      if (acteurRef !== void 0) {
+        acteurRef = acteurRef.acteurRef;
+        assert(acteurRef);
+        delete coSignataire.acteur;
+        coSignataire.acteurRef = acteurRef;
+      }
+      const organe = coSignataire.organe;
+      if (organe !== void 0) {
+        cleanBooleanAttribute(organe, "etApparentes");
+      }
+    }
+  }
+  const depotAmendements = d2.depotAmendements;
+  if (depotAmendements !== void 0) {
+    cleanXmlArtefacts(depotAmendements);
+    const amendementsSeance = depotAmendements.amendementsSeance;
+    {
+      cleanXmlArtefacts(amendementsSeance);
+      cleanBooleanAttribute(amendementsSeance, "amendable");
+    }
+    let amendementsCommission = depotAmendements.amendementsCommission;
+    if (amendementsCommission !== void 0) {
+      amendementsCommission = amendementsCommission.commission;
+      if (!Array.isArray(amendementsCommission)) {
+        assert(amendementsCommission);
+        amendementsCommission = [amendementsCommission];
+      }
+      depotAmendements.amendementsCommission = amendementsCommission;
+      for (const commision of amendementsCommission) {
+        cleanXmlArtefacts(commision);
+        cleanBooleanAttribute(commision, "amendable");
+        assert.strictEqual(commision.dateLimiteDepot, void 0);
+      }
+    }
+  }
+  const imprimerie = d2.imprimerie;
+  if (imprimerie !== void 0) {
+    cleanXmlArtefacts(imprimerie);
+    const dian = imprimerie.DIAN;
+    if (dian !== void 0) {
+      delete imprimerie.DIAN;
+      imprimerie.dian = dian;
+    }
+    const isbn = imprimerie.ISBN;
+    if (isbn !== void 0) {
+      delete imprimerie.ISBN;
+      imprimerie.isbn = isbn;
+    }
+    assert.strictEqual(imprimerie.ISSN, void 0);
+  }
+  cleanBooleanAttribute(d2, "rapportPublie");
+  let organesReferents = d2.organesReferents;
+  if (organesReferents !== void 0) {
+    organesReferents = organesReferents.organeRef;
+    if (!Array.isArray(organesReferents)) {
+      assert(organesReferents);
+      organesReferents = [organesReferents];
+    }
+    d2.organesReferents = organesReferents;
+  }
+}
+function cleanActeLegislatif(acteLegislatif) {
+  cleanXmlArtefacts(acteLegislatif);
+  const xsiType = acteLegislatif["@xsi:type"];
+  if (xsiType !== void 0) {
+    acteLegislatif.xsiType = xsiType;
+    delete acteLegislatif["@xsi:type"];
+  }
+  let auteursRefs = acteLegislatif.auteurs;
+  if (auteursRefs !== void 0) {
+    auteursRefs = auteursRefs.acteurRef;
+    if (!Array.isArray(auteursRefs)) {
+      assert(auteursRefs);
+      auteursRefs = [auteursRefs];
+    }
+    acteLegislatif.auteursRefs = auteursRefs;
+    delete acteLegislatif.auteurs;
+  }
+  const casSaisine = acteLegislatif.casSaisine;
+  if (casSaisine !== void 0) {
+    cleanTypeDeclaration(casSaisine);
+  }
+  const contributionInternaute = acteLegislatif.contributionInternaute;
+  if (contributionInternaute !== void 0) {
+    cleanXmlArtefacts(contributionInternaute);
+  }
+  assert.strictEqual(acteLegislatif.dateRetrait, void 0);
+  const decision = acteLegislatif.decision;
+  if (decision !== void 0) {
+    cleanTypeDeclaration(decision);
+  }
+  const infoJo = acteLegislatif.infoJO;
+  if (infoJo !== void 0) {
+    cleanInfoJo(infoJo);
+    acteLegislatif.infoJo = infoJo;
+    delete acteLegislatif.infoJO;
+  }
+  const infoJoce = acteLegislatif.infoJOCE;
+  if (infoJoce !== void 0) {
+    acteLegislatif.infoJoce = infoJoce;
+    delete acteLegislatif.infoJOCE;
+    const refJoce = infoJoce.refJOCE;
+    if (refJoce !== void 0) {
+      infoJoce.refJoce = refJoce;
+      delete infoJoce.refJOCE;
+    }
+    const dateJoce = infoJoce.dateJOCE;
+    if (dateJoce !== void 0) {
+      infoJoce.dateJoce = dateJoce;
+      delete infoJoce.dateJOCE;
+    }
+  }
+  let infoJoRect = acteLegislatif.infoJORect;
+  if (infoJoRect !== void 0) {
+    if (!Array.isArray(infoJoRect)) {
+      infoJoRect = [infoJoRect];
+    }
+    acteLegislatif.infoJoRect = infoJoRect;
+    delete acteLegislatif.infoJORect;
+    for (const infoJoRectItem of infoJoRect) {
+      cleanInfoJo(infoJoRectItem);
+    }
+  }
+  cleanActeOuDossierInitiateur(acteLegislatif);
+  let initiateur = acteLegislatif.initiateurs;
+  if (initiateur !== void 0) {
+    assert.strictEqual(acteLegislatif.initiateur, void 0);
+    if (initiateur.acteurRef === void 0) {
+      assert.notStrictEqual(initiateur.organeRef, void 0);
+    } else {
+      if (!Array.isArray(initiateur)) {
+        assert(initiateur);
+        initiateur = [initiateur];
+      }
+      initiateur = {
+        acteurs: initiateur
+      };
+    }
+    acteLegislatif.initiateur = initiateur;
+    delete acteLegislatif.initiateurs;
+  }
+  assert.strictEqual(acteLegislatif.odSeancejRef, void 0);
+  const provenanceRef = acteLegislatif.provenance;
+  if (provenanceRef !== void 0) {
+    delete acteLegislatif.provenance;
+    acteLegislatif.provenanceRef = provenanceRef;
+  }
+  let rapporteurs = acteLegislatif.rapporteurs;
+  if (rapporteurs !== void 0) {
+    rapporteurs = rapporteurs.rapporteur;
+    if (!Array.isArray(rapporteurs)) {
+      assert(rapporteurs);
+      rapporteurs = [rapporteurs];
+    }
+    acteLegislatif.rapporteurs = rapporteurs;
+    for (const rapporteur of rapporteurs) {
+      cleanRapporteur(rapporteur);
+    }
+  }
+  const referenceNor = acteLegislatif.referenceNOR;
+  if (referenceNor !== void 0) {
+    acteLegislatif.referenceNor = referenceNor;
+    delete acteLegislatif.referenceNOR;
+  }
+  assert.strictEqual(acteLegislatif.reunion, void 0);
+  const statutAdoption = acteLegislatif.statutAdoption;
+  if (statutAdoption !== void 0) {
+    cleanTypeDeclaration(statutAdoption);
+  }
+  const statutConclusion = acteLegislatif.statutConclusion;
+  if (statutConclusion !== void 0) {
+    cleanTypeDeclaration(statutConclusion);
+    if (statutConclusion.famCode === "TSORTFnull") {
+      delete acteLegislatif.statutConclusion;
+    }
+  }
+  const texteAdopteRef = acteLegislatif.texteAdopte;
+  if (texteAdopteRef !== void 0) {
+    delete acteLegislatif.texteAdopte;
+    acteLegislatif.texteAdopteRef = texteAdopteRef;
+  }
+  const texteAssocieRef = acteLegislatif.texteAssocie;
+  if (texteAssocieRef !== void 0) {
+    delete acteLegislatif.texteAssocie;
+    acteLegislatif.texteAssocieRef = texteAssocieRef;
+  }
+  let textesAssocies = acteLegislatif.textesAssocies;
+  if (textesAssocies !== void 0) {
+    textesAssocies = textesAssocies.texteAssocie;
+    if (!Array.isArray(textesAssocies)) {
+      assert(textesAssocies);
+      textesAssocies = [textesAssocies];
+    }
+    acteLegislatif.textesAssocies = textesAssocies;
+    for (const texteAssocie of textesAssocies) {
+      const texteAssocieRef2 = texteAssocie.refTexteAssocie;
+      if (texteAssocieRef2 !== void 0) {
+        delete texteAssocie.refTexteAssocie;
+        texteAssocie.texteAssocieRef = texteAssocieRef2;
+      }
+    }
+  }
+  const typeDeclaration = acteLegislatif.typeDeclaration;
+  if (typeDeclaration !== void 0) {
+    cleanTypeDeclaration(typeDeclaration);
+  }
+  const typeMotion = acteLegislatif.typeMotion;
+  if (typeMotion !== void 0) {
+    cleanTypeDeclaration(typeMotion);
+  }
+  const typeMotionCensure = acteLegislatif.typeMotionCensure;
+  if (typeMotionCensure !== void 0) {
+    cleanTypeDeclaration(typeMotionCensure);
+  }
+  let voteRefs = acteLegislatif.voteRefs;
+  if (voteRefs !== void 0) {
+    voteRefs = voteRefs.voteRef;
+    if (!Array.isArray(voteRefs)) {
+      assert(voteRefs);
+      voteRefs = [voteRefs];
+    }
+    acteLegislatif.voteRefs = voteRefs;
+  }
+  let actesLegislatifs = acteLegislatif.actesLegislatifs;
+  if (actesLegislatifs !== void 0) {
+    actesLegislatifs = actesLegislatifs.acteLegislatif;
+    if (!Array.isArray(actesLegislatifs)) {
+      assert(actesLegislatifs);
+      actesLegislatifs = [actesLegislatifs];
+    }
+    acteLegislatif.actesLegislatifs = actesLegislatifs;
+    for (const acteLegislatif2 of actesLegislatifs) {
+      cleanActeLegislatif(acteLegislatif2);
+    }
+  }
+}
+function cleanActeOuDossierInitiateur(acteOuDossier) {
+  const initiateur = acteOuDossier.initiateur;
+  if (initiateur !== void 0) {
+    let acteurs = initiateur.acteurs;
+    if (acteurs !== void 0) {
+      acteurs = acteurs.acteur;
+      if (!Array.isArray(acteurs)) {
+        assert(acteurs);
+        acteurs = [acteurs];
+      }
+      if (acteurs.length > 0) {
+        initiateur.acteurs = acteurs;
+      } else {
+        delete initiateur.acteurs;
+      }
+    }
+    let organeRef = initiateur.organes;
+    if (organeRef !== void 0) {
+      organeRef = organeRef.organe.organeRef.uid;
+      assert.notStrictEqual(organeRef, void 0);
+      initiateur.organeRef = organeRef;
+      delete initiateur.organes;
+    }
+    if (initiateur.acteurs === void 0 && initiateur.organeRef === void 0) {
+      delete acteOuDossier.initiateur;
+    }
+  }
+}
+function cleanInfoJo(infoJo) {
+  cleanXmlArtefacts(infoJo);
+  const typeJo = infoJo.typeJO;
+  if (typeJo !== void 0) {
+    infoJo.typeJo = typeJo;
+    delete infoJo.typeJO;
+  }
+  const dateJo = infoJo.dateJO;
+  if (dateJo !== void 0) {
+    infoJo.dateJo = dateJo;
+    delete infoJo.dateJO;
+  }
+  assert.strictEqual(infoJo.pageJO, void 0);
+  const numJo = infoJo.numJO;
+  if (numJo !== void 0) {
+    infoJo.numJo = numJo;
+    delete infoJo.numJO;
+  }
+  const referenceNor = infoJo.referenceNOR;
+  if (referenceNor !== void 0) {
+    infoJo.referenceNor = referenceNor;
+    delete infoJo.referenceNOR;
+  }
+}
+function cleanTypeDeclaration(typeDeclaration) {
+  typeDeclaration.famCode = typeDeclaration.fam_code;
+  delete typeDeclaration.fam_code;
+  assert(typeDeclaration.famCode);
+  if (!typeDeclaration.libelle) {
+    typeDeclaration.libelle = typeDeclaration.famCode;
+  }
+}
+function cleanDossierParlementaire(dossierParlementaire) {
+  cleanXmlArtefacts(dossierParlementaire);
+  const xsiType = dossierParlementaire["@xsi:type"];
+  if (xsiType !== void 0) {
+    dossierParlementaire.xsiType = xsiType;
+    delete dossierParlementaire["@xsi:type"];
+  }
+  const titreDossier = dossierParlementaire.titreDossier;
+  cleanXmlArtefacts(titreDossier);
+  cleanActeOuDossierInitiateur(dossierParlementaire);
+  let actesLegislatifs = dossierParlementaire.actesLegislatifs;
+  if (actesLegislatifs !== void 0) {
+    actesLegislatifs = actesLegislatifs.acteLegislatif;
+    if (!Array.isArray(actesLegislatifs)) {
+      assert(actesLegislatifs);
+      actesLegislatifs = [actesLegislatifs];
+    }
+    dossierParlementaire.actesLegislatifs = actesLegislatifs;
+    for (const acteLegislatif of actesLegislatifs) {
+      cleanActeLegislatif(acteLegislatif);
+    }
+  }
+  let plf = dossierParlementaire.PLF;
+  if (plf !== void 0) {
+    plf = plf.EtudePLF;
+    assert(Array.isArray(plf));
+    delete dossierParlementaire.PLF;
+    dossierParlementaire.plf = plf;
+    for (const etudePlf of plf) {
+      let rapporteurs = etudePlf.rapporteur;
+      if (rapporteurs !== void 0) {
+        if (!Array.isArray(rapporteurs)) {
+          assert(rapporteurs);
+          rapporteurs = [rapporteurs];
+        }
+        delete etudePlf.rapporteur;
+        etudePlf.rapporteurs = rapporteurs;
+        for (const rapporteur of rapporteurs) {
+          cleanRapporteur(rapporteur);
+        }
+      }
+      let missionMinefi = etudePlf.missionMinefi;
+      if (missionMinefi !== void 0) {
+        cleanMission(missionMinefi);
+      }
+      etudePlf.ordreDiqs = etudePlf.ordreDIQS;
+      delete etudePlf.ordreDIQS;
+      assert(etudePlf.ordreDiqs);
+    }
+  }
+}
+function cleanMission(mission) {
+  let missions = mission.missions;
+  if (missions !== void 0) {
+    missions = missions.mission;
+    if (!Array.isArray(missions)) {
+      assert(missions);
+      missions = [missions];
+    }
+    mission.missions = missions;
+    for (const missionItem of missions) {
+      cleanMission(missionItem);
+    }
+  }
+}
+function cleanOrgane(organe) {
+  cleanXmlArtefacts(organe);
+  const xsiType = organe["@xsi:type"];
+  if (xsiType !== void 0) {
+    organe.xsiType = xsiType;
+    delete organe["@xsi:type"];
+  }
+  const viMoDe = organe.viMoDe;
+  cleanXmlArtefacts(viMoDe);
+  const organeParentRef = organe.organeParent;
+  if (organeParentRef !== void 0) {
+    delete organe.organeParent;
+    organe.organeParentRef = organeParentRef;
+  }
+  assert.strictEqual(organe.chambre, void 0);
+  const secretariat = organe.secretariat;
+  if (secretariat !== void 0) {
+    cleanXmlArtefacts(secretariat);
+  }
+  const lieu = organe.lieu;
+  if (lieu !== void 0) {
+    cleanXmlArtefacts(lieu);
+    const region = lieu.region;
+    if (region !== void 0) {
+      cleanXmlArtefacts(region);
+    }
+    const departement = lieu.departement;
+    if (departement !== void 0) {
+      cleanXmlArtefacts(departement);
+    }
+  }
+  const couleurAssociee = organe.couleurAssociee;
+  if (couleurAssociee === null) {
+    delete organe.couleurAssociee;
+  }
+  let listePays = organe.listePays;
+  if (listePays !== void 0) {
+    listePays = listePays.paysRef;
+    if (!Array.isArray(listePays)) {
+      assert.strictEqual(typeof listePays, "string");
+      listePays = [listePays];
+    }
+    organe.listePays = listePays;
+  }
+}
+function cleanCycleDeVie(cycleDeVie) {
+  cleanXmlArtefacts(cycleDeVie);
+  const chrono = cycleDeVie.chrono;
+  assert(chrono);
+  {
+    cleanXmlArtefacts(chrono);
+    let creation = chrono.creation;
+    assert.strictEqual(typeof creation, "string");
+    creation = new Date(creation);
+    chrono.creation = creation;
+    let cloture = chrono.cloture;
+    if (cloture !== void 0) {
+      assert.strictEqual(typeof cloture, "string");
+      cloture = new Date(cloture);
+      chrono.cloture = cloture;
+    }
+  }
+}
+function cleanReunion(reunion) {
+  cleanXmlArtefacts(reunion);
+  cleanBooleanAttribute(reunion, "captationVideo");
+  cleanBooleanAttribute(reunion, "comiteSecret");
+  cleanBooleanAttribute(reunion, "ouverturePresse");
+  const xsiType = reunion["@xsi:type"];
+  if (xsiType !== void 0) {
+    reunion.xsiType = xsiType;
+    delete reunion["@xsi:type"];
+  }
+  const timestampDebut = reunion.timeStampDebut;
+  assert.notStrictEqual(timestampDebut, void 0);
+  reunion.timestampDebut = timestampDebut;
+  delete reunion.timeStampDebut;
+  let timestampFin = reunion.timeStampFin;
+  if (timestampFin !== void 0) {
+    assert.strictEqual(typeof timestampFin, "string");
+    timestampFin = new Date(timestampFin);
+    reunion.timestampFin = timestampFin;
+    delete reunion.timeStampFin;
+  }
+  const lieu = reunion.lieu;
+  if (lieu !== void 0) {
+    cleanXmlArtefacts(lieu);
+  }
+  const cycleDeVie = reunion.cycleDeVie;
+  assert.notStrictEqual(cycleDeVie, void 0);
+  cleanCycleDeVie(cycleDeVie);
+  const demandeurs = reunion.demandeurs;
+  if (demandeurs !== void 0) {
+    let acteurs = demandeurs.acteur;
+    if (acteurs !== void 0) {
+      if (!Array.isArray(acteurs)) {
+        assert.notStrictEqual(acteurs, null);
+        assert.strictEqual(typeof acteurs, "object");
+        acteurs = [acteurs];
+      }
+      demandeurs.acteurs = acteurs;
+      delete demandeurs.acteur;
+      for (const acteur of acteurs) {
+        cleanXmlArtefacts(acteur);
+      }
+    }
+    const organe = demandeurs.organe;
+    if (organe !== void 0) {
+      cleanXmlArtefacts(organe);
+    }
+  }
+  const demandeur = reunion.demandeur;
+  if (demandeur !== void 0) {
+    assert.strictEqual(reunion.demandeurs, void 0);
+    delete reunion.demandeur;
+    let acteur = demandeur.acteur;
+    if (acteur !== void 0) {
+      assert.notStrictEqual(acteur, null);
+      assert.strictEqual(typeof acteur, "object");
+      const acteurs = [acteur];
+      demandeur.acteurs = acteurs;
+      delete demandeur.acteur;
+      reunion.demandeurs = demandeur;
+      for (const acteur2 of acteurs) {
+        cleanXmlArtefacts(acteur2);
+      }
+    }
+    const organe = demandeur.organe;
+    if (organe !== void 0) {
+      cleanXmlArtefacts(organe);
+    }
+  }
+  const participants = reunion.participants;
+  if (participants !== void 0) {
+    cleanXmlArtefacts(participants);
+    let participantsInternes = participants.participantsInternes;
+    if (participantsInternes !== void 0) {
+      participantsInternes = participantsInternes.participantInterne;
+      if (!Array.isArray(participantsInternes)) {
+        assert.notStrictEqual(participantsInternes, null);
+        assert.strictEqual(typeof participantsInternes, "object");
+        participantsInternes = [participantsInternes];
+      }
+      participants.participantsInternes = participantsInternes;
+    }
+    let personnesAuditionnees = participants.personnesAuditionnees;
+    if (personnesAuditionnees !== void 0) {
+      personnesAuditionnees = personnesAuditionnees.personneAuditionnee;
+      if (personnesAuditionnees === null) {
+        delete participants.personnesAuditionnees;
+      } else {
+        if (!Array.isArray(personnesAuditionnees)) {
+          assert.strictEqual(typeof personnesAuditionnees, "object");
+          personnesAuditionnees = [personnesAuditionnees];
+        }
+        personnesAuditionnees = personnesAuditionnees.filter((personneAudionnee) => personneAudionnee !== null);
+        if (personnesAuditionnees.length > 0) {
+          participants.personnesAuditionnees = personnesAuditionnees;
+        } else {
+          delete participants.personnesAuditionnees;
+        }
+        for (const personneAudionnee of personnesAuditionnees) {
+          const xsiType2 = personneAudionnee.uid["@xsi:type"];
+          assert(xsiType2);
+          personneAudionnee.xsiType = xsiType2;
+          const uid = personneAudionnee.uid["#text"];
+          assert(uid);
+          personneAudionnee.uid = uid;
+          const ident = personneAudionnee.ident;
+          assert(ident);
+          {
+            cleanXmlArtefacts(ident);
+          }
+        }
+      }
+    }
+  }
+  if (reunion.ODJ !== void 0) {
+    const odj = reunion.ODJ;
+    reunion.odj = odj;
+    delete reunion.ODJ;
+    {
+      cleanXmlArtefacts(odj);
+      let convocationOdj = odj.convocationODJ;
+      if (convocationOdj !== void 0) {
+        if (Array.isArray(convocationOdj.item)) {
+          convocationOdj = convocationOdj.item;
+        } else {
+          assert(convocationOdj.item);
+          convocationOdj = [convocationOdj.item];
+        }
+        odj.convocationOdj = convocationOdj;
+        delete odj.convocationODJ;
+      }
+      let resumeOdj = odj.resumeODJ;
+      if (resumeOdj !== void 0) {
+        if (Array.isArray(resumeOdj.item)) {
+          resumeOdj = resumeOdj.item;
+        } else {
+          assert(resumeOdj.item);
+          resumeOdj = [resumeOdj.item];
+        }
+        odj.resumeOdj = resumeOdj;
+        delete odj.resumeODJ;
+      }
+      let pointsOdj = odj.pointsODJ;
+      if (pointsOdj !== void 0) {
+        let pointOdj = pointsOdj.pointODJ;
+        if (Array.isArray(pointOdj)) {
+          pointsOdj = pointOdj;
+        } else {
+          assert(pointOdj);
+          pointsOdj = [pointOdj];
+        }
+        odj.pointsOdj = pointsOdj;
+        for (const pointOdj2 of pointsOdj) {
+          cleanXmlArtefacts(pointOdj2);
+          cleanBooleanAttribute(pointOdj2, "comiteSecret");
+          const xsiType2 = pointOdj2["@xsi:type"];
+          if (xsiType2 !== void 0) {
+            pointOdj2.xsiType = xsiType2;
+            delete pointOdj2["@xsi:type"];
+          }
+          const cycleDeVie2 = pointOdj2.cycleDeVie;
+          assert.notStrictEqual(cycleDeVie2, void 0);
+          cleanCycleDeVie(cycleDeVie2);
+          assert.strictEqual(pointOdj2.demandeurPoint, void 0);
+          let dossiersLegislatifsRefs = pointOdj2.dossiersLegislatifsRefs;
+          if (dossiersLegislatifsRefs !== void 0) {
+            if (Array.isArray(dossiersLegislatifsRefs.dossierRef)) {
+              dossiersLegislatifsRefs = dossiersLegislatifsRefs.dossierRef;
+            } else {
+              assert(dossiersLegislatifsRefs.dossierRef);
+              dossiersLegislatifsRefs = [dossiersLegislatifsRefs.dossierRef];
+            }
+            pointOdj2.dossiersLegislatifsRefs = dossiersLegislatifsRefs;
+          }
+          pointOdj2.typePointOdj = pointOdj2.typePointODJ;
+          delete pointOdj2.typePointODJ;
+          assert.strictEqual(pointOdj2.textesAssocies, void 0);
+          pointOdj2.natureTravauxOdj = pointOdj2.natureTravauxODJ;
+          delete pointOdj2.natureTravauxODJ;
+          let dateConfPres = pointOdj2.dateConfPres;
+          if (dateConfPres !== void 0) {
+            assert.strictEqual(typeof dateConfPres, "string");
+            assert(/^\d{4}-\d{2}-\d{2}\+\d{2}:00$/.test(dateConfPres));
+            dateConfPres = new Date(dateConfPres.split("+")[0]);
+            pointOdj2.dateConfPres = dateConfPres;
+          }
+          let dateLettreMinistre = pointOdj2.dateLettreMinistre;
+          if (dateLettreMinistre !== void 0) {
+            assert.strictEqual(typeof dateLettreMinistre, "string");
+            assert(/^\d{4}-\d{2}-\d{2}\+\d{2}:00$/.test(dateLettreMinistre));
+            dateLettreMinistre = new Date(dateLettreMinistre.split("+")[0]);
+            pointOdj2.dateLettreMinistre = dateLettreMinistre;
+          }
+        }
+        delete odj.pointsODJ;
+      }
+    }
+  }
+  const identifiants = reunion.identifiants;
+  if (identifiants !== void 0) {
+    cleanXmlArtefacts(identifiants);
+    const numSeanceJo = identifiants.numSeanceJO;
+    if (numSeanceJo !== void 0) {
+      identifiants.numSeanceJo = numSeanceJo;
+      delete identifiants.numSeanceJO;
+    }
+    const idJo = identifiants.idJO;
+    if (idJo !== void 0) {
+      identifiants.idJo = idJo;
+      delete identifiants.idJO;
+    }
+    let dateSeance = identifiants.DateSeance;
+    assert.strictEqual(typeof dateSeance, "string");
+    assert(/^\d{4}-\d{2}-\d{2}\+\d{2}:00$/.test(dateSeance));
+    dateSeance = new Date(dateSeance.split("+")[0]);
+    identifiants.dateSeance = dateSeance;
+    delete identifiants.DateSeance;
+  }
+  const infosReunionsInternationale = reunion.infosReunionsInternationale;
+  if (infosReunionsInternationale !== void 0) {
+    cleanXmlArtefacts(infosReunionsInternationale);
+    cleanBooleanAttribute(infosReunionsInternationale, "estReunionInternationale");
+    let listePays = infosReunionsInternationale.listePays;
+    if (listePays !== void 0) {
+      listePays = listePays.paysRef;
+      if (!Array.isArray(listePays)) {
+        assert.strictEqual(typeof listePays, "string");
+        listePays = [listePays];
+      }
+      infosReunionsInternationale.listePays = listePays;
+    }
+  }
+}
+function cleanDecompteNominatif(decompteNominatif) {
+  cleanXmlArtefacts(decompteNominatif);
+  let nonVotants = decompteNominatif.nonVotants;
+  if (nonVotants === void 0) {
+    nonVotants = decompteNominatif.nonVotant;
+    delete decompteNominatif.nonVotant;
+  } else {
+    assert.strictEqual(decompteNominatif.nonVotant, void 0);
+  }
+  if (nonVotants !== void 0) {
+    if (typeof nonVotants === "string") {
+      assert.strictEqual(nonVotants, "0");
+      nonVotants = [];
+    } else if (!Array.isArray(nonVotants)) {
+      assert(nonVotants);
+      nonVotants = [nonVotants];
+    }
+    const nonVotantsArray = nonVotants;
+    nonVotants = [];
+    for (let nonVotant of nonVotantsArray) {
+      if (nonVotant === null) {
+        continue;
+      }
+      nonVotant = nonVotant.votant;
+      if (Array.isArray(nonVotant)) {
+        nonVotants.push(...nonVotant);
+      } else {
+        assert(nonVotant);
+        nonVotants.push(nonVotant);
+      }
+    }
+    if (nonVotants.length === 0) {
+      delete decompteNominatif.nonVotants;
+    } else {
+      decompteNominatif.nonVotants = nonVotants;
+      for (const votant of nonVotants) {
+        cleanVotant(votant);
+      }
+    }
+  }
+  let pour = decompteNominatif.pour;
+  if (pour === void 0) {
+    pour = decompteNominatif.pours;
+    delete decompteNominatif.pours;
+  } else {
+    assert.strictEqual(decompteNominatif.pours, void 0);
+  }
+  if (pour !== void 0) {
+    pour = pour.votant;
+    if (!Array.isArray(pour)) {
+      assert(pour);
+      pour = [pour];
+    }
+    if (pour.length === 0) {
+      delete decompteNominatif.pour;
+    } else {
+      decompteNominatif.pour = pour;
+      for (const votant of pour) {
+        cleanVotant(votant);
+      }
+    }
+  }
+  let contre = decompteNominatif.contre;
+  if (contre === void 0) {
+    contre = decompteNominatif.contres;
+    delete decompteNominatif.contres;
+  } else {
+    assert.strictEqual(decompteNominatif.contres, void 0);
+  }
+  if (contre !== void 0) {
+    contre = contre.votant;
+    if (!Array.isArray(contre)) {
+      assert(contre);
+      contre = [contre];
+    }
+    if (contre.length === 0) {
+      delete decompteNominatif.contre;
+    } else {
+      decompteNominatif.contre = contre;
+      for (const votant of contre) {
+        cleanVotant(votant);
+      }
+    }
+  }
+  let abstentions = decompteNominatif.abstentions;
+  if (abstentions === void 0) {
+    abstentions = decompteNominatif.abstention;
+    delete decompteNominatif.abstention;
+  } else {
+    assert.strictEqual(decompteNominatif.abstention, void 0);
+  }
+  if (abstentions !== void 0) {
+    if (!Array.isArray(abstentions)) {
+      assert(abstentions);
+      abstentions = [abstentions];
+    }
+    const abstentionsArray = abstentions;
+    abstentions = [];
+    for (let absentionsItem of abstentionsArray) {
+      if (absentionsItem === null) {
+        continue;
+      }
+      absentionsItem = absentionsItem.votant;
+      if (Array.isArray(absentionsItem)) {
+        abstentions.push(...absentionsItem);
+      } else {
+        assert(absentionsItem);
+        abstentions.push(absentionsItem);
+      }
+    }
+    if (abstentions.length === 0) {
+      delete decompteNominatif.abstentions;
+    } else {
+      decompteNominatif.abstentions = abstentions;
+      for (const votant of abstentions) {
+        cleanVotant(votant);
+      }
+    }
+  }
+  let nonVotantsVolontaires = decompteNominatif.nonVotantsVolontaires;
+  if (nonVotantsVolontaires !== void 0) {
+    if (!Array.isArray(nonVotantsVolontaires)) {
+      nonVotantsVolontaires = [nonVotantsVolontaires];
+    }
+    const nonVotantsVolontairesArray = nonVotantsVolontaires;
+    nonVotantsVolontaires = [];
+    for (let absentionsItem of nonVotantsVolontairesArray) {
+      if (absentionsItem === null) {
+        continue;
+      }
+      absentionsItem = absentionsItem.votant;
+      if (Array.isArray(absentionsItem)) {
+        nonVotantsVolontaires.push(...absentionsItem);
+      } else {
+        assert(absentionsItem);
+        nonVotantsVolontaires.push(absentionsItem);
+      }
+    }
+    if (nonVotantsVolontaires.length === 0) {
+      delete decompteNominatif.nonVotantsVolontaires;
+    } else {
+      decompteNominatif.nonVotantsVolontaires = nonVotantsVolontaires;
+      for (const votant of nonVotantsVolontaires) {
+        cleanVotant(votant);
+      }
+    }
+  }
+}
+function cleanScrutin(scrutin) {
+  cleanXmlArtefacts(scrutin);
+  const demandeur = scrutin.demandeur;
+  assert(demandeur);
+  {
+    cleanXmlArtefacts(demandeur);
+    assert.strictEqual(demandeur.referenceLegislative, void 0);
+  }
+  const objet = scrutin.objet;
+  assert(objet);
+  {
+    cleanXmlArtefacts(objet);
+    assert.strictEqual(objet.referenceLegislative, void 0);
+  }
+  let ventilationVotes = scrutin.ventilationVotes;
+  assert(ventilationVotes);
+  {
+    ventilationVotes = ventilationVotes.organe;
+    assert(ventilationVotes);
+    let groupes = ventilationVotes.groupes;
+    assert(groupes);
+    {
+      groupes = groupes.groupe;
+      assert(Array.isArray(groupes));
+      for (const groupe of groupes) {
+        const vote = groupe.vote;
+        assert(vote);
+        {
+          const decompteVoix = vote.decompteVoix;
+          assert(decompteVoix);
+          {
+            if (decompteVoix.abstention !== void 0) {
+              assert.strictEqual(decompteVoix.abstentions, void 0);
+              decompteVoix.abstentions = decompteVoix.abstention;
+              delete decompteVoix.abstention;
+            }
+            if (decompteVoix.nonVotant !== void 0) {
+              assert.strictEqual(decompteVoix.nonVotants, void 0);
+              decompteVoix.nonVotants = decompteVoix.nonVotant;
+              delete decompteVoix.nonVotant;
+            }
+          }
+          const decompteNominatif = vote.decompteNominatif;
+          assert(decompteNominatif);
+          cleanDecompteNominatif(decompteNominatif);
+        }
+      }
+      ventilationVotes.groupes = groupes;
+    }
+    scrutin.ventilationVotes = ventilationVotes;
+  }
+  const miseAuPoint = scrutin.miseAuPoint;
+  if (miseAuPoint !== void 0) {
+    cleanDecompteNominatif(miseAuPoint);
+    let dysfonctionnement = miseAuPoint.dysfonctionnement;
+    if (dysfonctionnement !== void 0) {
+      cleanDecompteNominatif(dysfonctionnement);
+      if (Object.values(dysfonctionnement).filter((value) => value !== void 0).length === 0) {
+        delete miseAuPoint.dysfonctionnement;
+      }
+    }
+    if (Object.values(miseAuPoint).filter((value) => value !== void 0).length === 0) {
+      delete scrutin.miseAuPoint;
+    }
+  }
+}
+function cleanVotant(votant) {
+  cleanBooleanAttribute(votant, "parDelegation");
+  cleanIntegerAttribute(votant, "numPlace");
+}
+function cleanQuestion(question) {
+  cleanXmlArtefacts(question);
+}
+function cleanCompteRendu(compteRendu) {
+  cleanXmlArtefacts(compteRendu);
+}
+export {
+  cleanActeur,
+  d as cleanAmendement,
+  cleanCompteRendu,
+  cleanDocumentOrDivision,
+  cleanDossierParlementaire,
+  cleanOrgane,
+  cleanQuestion,
+  cleanReunion,
+  cleanScrutin
+};
+//# sourceMappingURL=cleaners.js.map