@communecter/cocolight-api-client 1.0.54 → 1.0.56

package/src/api/BaseEntity.js

@@ -1,2828 +0,0 @@
-// BaseEntity.js
-import ObjectID from "bson-objectid";
-// import { fileTypeFromBuffer } from "file-type";
-import EJSON from "ejson";
-import pkg from "file-type";
-
-import { ApiAuthenticationError, ApiError, ApiResponseError, ApiValidationError } from "../error.js";
-import { isReactive, isSignal, reactive } from "../utils/reactive.js";
-const { fromBuffer } = pkg;
-
-/**
- * @typedef {import("../ApiClient.js").default} ApiClient
- * @typedef {import("./EndpointApi.js").default} EndpointApi
- */
-
-/**
- * Classe de base pour toutes les entités métiers : utilisateurs, projets, organisations, etc.
- * Fournit un système de brouillon (draft), transformation, appel API sécurisé,
- * et gestion de données côté client avec support du mode offline.
- * @abstract
- */
-export class BaseEntity {
-  /** @type {Object} Données de brouillon modifiables */
-  _draftData = {};
-
-  /** @type {Object} Snapshot initial des données de brouillon */
-  _initialDraftData = {};
-
-  /** @type {Object|null} Données reçues du serveur */
-  _serverData = null;
-
-  /** @type {boolean} Indique si `save()` est en cours */
-  _calledFromSave = false;
-
-  /** @type {boolean} Indique si le draft est synchronisé avec le serveur */
-  _syncReactiveDraft = false;
-
-  static entityTag = "BaseEntity";
-
-  /**
-   * Constructeur de l'entité.
-   * @param {Object} parent - L'ApiClient ou une entité parente.
-   * @param {Object} parent.apiClient - Instance de l'ApiClient.
-   * @param {Object} [parent.parent] - Instance parente.
-   * @param {Object} [data={}] - Données initiales.
-   * @param {Object} [deps={}] - Dépendances injectées (EndpointApi, autres entités).
-   * @param {Object|function} deps.EndpointApi - Instance de l'API.
-   * @param {function} deps.User - Classe d'entité utilisateur.
-   * @param {function} deps.Organization - Classe d'entité organisation.
-   * @param {function} deps.Project - Classe d'entité projet.
-   * @param {function} deps.Poi - Classe d'entité point d'intérêt.
-   * @param {function} deps.Event - Classe d'entité événement.
-   * @param {function} deps.Badge - Classe d'entité badge.
-   * @param {function} deps.News - Classe d'entité actualité.
-   * @param {string} [config.entityTag] - Tag d'entité (ex: "User", "Organization").
-   * @param {Object} [config={}] - Configuration optionnelle.
-   * @throws {ApiError} Si les dépendances ou parent sont invalides.
-   */
-  constructor(parent, data = {}, deps = {}, config = {}) {
-    this.__entityTag = config.entityTag || this.getEntityTag(this.constructor.entityTag) || "BaseEntity";
-    this.deps = deps;
-
-    if (this.getEntityTag(parent?.__entityTag) === "ApiClient") {
-      /** @type {ApiClient} */
-      this.apiClient = parent;
-      this.parent = null;
-      this.userContext = null;
-    } else if (parent?.apiClient) {
-      /** @type {ApiClient} */
-      this.apiClient = parent.apiClient;
-      this.parent = parent;
-      if (this.getEntityTag(parent?.__entityTag) === "User") {
-        this.userContext = parent;
-      } else if (parent?.userContext) {
-        this.userContext = parent.userContext;
-      }
-    } else {
-      throw new ApiError("Parent invalide ou ApiClient manquant.");
-    }
-
-    // Gérer les deux cas : fonction constructeur ou instance
-    if (typeof deps.EndpointApi === "function") {
-      /** @type {EndpointApi} */
-      this.endpointApi = new deps.EndpointApi(this.apiClient);
-    } else if (typeof deps.EndpointApi === "object") {
-      /** @type {EndpointApi} */
-      this.endpointApi = deps.EndpointApi;
-    } else {
-      throw new ApiError("deps.EndpointApi doit être une classe ou une instance valide.");
-    }
-
-    this._serverData = reactive({});
-
-    const { draft, proxy, initial } = this._buildDraftAndProxy({
-      data: { ...data, ...this.defaultFields },
-      serverData: this._serverData,
-      constant: this.constructor.SCHEMA_CONSTANTS,
-      apiClient: this.apiClient,
-      transforms: this.transforms,
-      removeFields: this.removeFields
-    });
-
-    this._initialDraftData = initial;
-    this._draftData = draft;
-    this.data = proxy;
-  }
-
-  getEntityTag = (__entityTag) => __entityTag?.replace(/^_/, "");
-
-  /** @returns {string|null} Identifiant de l'entité */
-  get id() {
-    return this._draftData.id || null;
-  }
-
-  /** @returns {string|null} Slug de l'entité */
-  get slug() {
-    return this._draftData.slug || null;
-  }
-
-  /** Définit un ID (utilisé en interne) */
-  _id(newId) {
-    this._draftData.id = newId;
-  }
-
-  /** @returns {boolean} Indique si l'utilisateur est connecté */
-  get isConnected() {
-    return this.apiClient.isConnected;
-  }
-
-  /** @returns {string|null} Identifiant utilisateur associé */
-  get userId() {
-    return this.apiClient.userId;
-  }
-
-  /** @returns {Object} Données de brouillon courantes */
-  get draftData() {
-    return this._draftData;
-  }
-
-  /** @returns {Object} Données de brouillon initiales */
-  get initialDraftData() {
-    return this._initialDraftData;
-  }
-
-  /** @returns {Object|null} Données brutes du serveur */
-  get serverData() {
-    return this._serverData;
-  }
-
-  /** @returns {boolean} Indique si cette entité représente l'utilisateur connecté */
-  get isMe() {
-    return this.isConnected && this.userId === this.userContext?.id;
-  }
-
-  /** @returns {string} Type de l'entité (ex: 'citoyens') */
-  getEntityType() {
-    return this.constructor.entityType;
-  }
-
-  /**
-   * Indique si le draft contient des modifications par rapport aux données initiales.
-   * @returns {boolean}
-   */
-  hasChanges() {
-    return this._serialize(this._toRawDeep(this._draftData)) !== this._serialize(this._initialDraftData);
-  }
-
-  /**
-   * Rafraîchit l'entité en rechargeant ses données depuis le serveur.
-   * @returns {Promise<Object>} Données mises à jour
-   */
-  async refresh() {
-    if (!this.id) throw new ApiError("Impossible de rafraîchir sans ID.");
-    return this.get();
-  }
-
-  /**
-   * Sauvegarde les modifications locales vers le serveur (add ou update).
-   * @returns {Promise<Object>} Données serveur mises à jour
-   */
-  async save() {
-    if (!this.isConnected) throw new ApiError("Non connecté.");
-    this._calledFromSave = true;
-    try {
-      const payload = { ...this._draftData };
-
-      if (!this.id && typeof this._add === "function") {
-        await this._add(payload);
-        this._resetInitialDraftData();
-        // on refresh le contexte utilisateur si besoin
-        if(this.userContext) {
-          await this.userContext.refresh();
-        }
-        return await this.refresh();
-      } else if (typeof this._update === "function") {
-        const hasChanged = await this._update(payload);
-        this._resetInitialDraftData();
-        if (hasChanged) return await this.refresh();
-      }
-
-      return this._serverData;
-    } finally {
-      this._calledFromSave = false;
-    }
-  }
-
-  /**
-   * Crée une nouvelle instance d'entité à partir des données du serveur.
-   * 
-   * @param {Object} data - Données du serveur.
-   * @param {BaseEntity} parent - Instance parente.
-   * @param {Object} deps - Dépendances injectées.
-   * @returns {BaseEntity} Nouvelle instance d'entité.
-   */
-  static fromServerData(data, parent, deps) {
-    const instance = new this(parent, {}, deps);
-    instance._setData(data);
-    return instance;
-  }
-
-  /**
-   * Met à jour les données de l'entité avec de nouvelles données.
-   * 
-   * @param {Object} newData - Les nouvelles données à appliquer.
-   * @returns {void}
-   * @private
-   */
-  _setData(newData, { forceInitialDraftReset = false } = {}) {
-    if (this.userContext && this.userContext !== this) {
-      this.apiClient._logger?.info?.(`[${this.__entityTag}] Mise à jour liée à userContext : ${this.userContext.id}`);
-    }
-
-    if (isReactive(this._serverData)) {
-      Object.assign(this._serverData, newData);
-    } else {
-      this._serverData = reactive({ ...newData });
-    }
-
-    const clientDraft = this._draftData ? this._toRawDeep(this._draftData) : {};
-
-    const mergedData = {
-      ...newData,
-      ...this.defaultFields,
-      ...clientDraft
-    };
-
-    const { draft, proxy, initial } = this._buildDraftAndProxy({
-      data: mergedData,
-      serverData: this._serverData,
-      previousDraft: this._draftData,
-      constant: this.constructor.SCHEMA_CONSTANTS,
-      apiClient: this.apiClient,
-      transforms: this.transforms,
-      removeFields: this.removeFields
-    });
-
-    if (forceInitialDraftReset) {
-      this._initialDraftData = structuredClone(this._toRawDeep(draft));
-    } else if (!this._initialDraftData) {
-      this._initialDraftData = initial;
-    }
-
-    if (isReactive(this._draftData)) {
-      this._updateDraftPreservingUserChanges(draft);
-    } else {
-      this._draftData = reactive(draft);
-    }
-
-    if (!this.data) {
-      this.data = proxy;
-    }
-
-  }
-
-  _updateDraftPreservingUserChanges(draft) {
-    for (const key of Object.keys(draft)) {
-      const current = this._draftData?.[key];
-      const initialValue = this._initialDraftData?.[key];
-
-      const isModified =
-      current !== undefined &&
-      initialValue !== undefined &&
-      this._serialize(this._toRawDeep(current)) !== this._serialize(initialValue);
-
-      if (!isModified) {
-        this._draftData[key] = draft[key];
-      }
-    }
-  }
-
-  _resetInitialDraftData() {
-    const raw = this._toRawDeep(this._draftData);
-    this._initialDraftData = structuredClone(raw);
-  }
-
-
-  _toRawDeep(obj) {
-
-    if (!this || typeof this._toRawDeep !== "function") {
-      throw new Error("`this._toRawDeep` is not bound correctly. Use a lambda to preserve context.");
-    }
-  
-    if (isSignal(obj)) {
-      return this._toRawDeep(obj.value);
-    }
-
-    if (Array.isArray(obj)) {
-      return obj.map((item) => this._toRawDeep(item));
-    }
-
-    if (typeof obj === "object" && obj !== null) {
-      const result = {};
-      for (const key of Object.keys(obj)) {
-        result[key] = this._toRawDeep(obj[key]);
-      }
-      return result;
-    }
-
-    return obj; // valeur primitive
-  }
-
-  /**
-   * Champs à ajouter automatiquement à chaque draft (ex: `typeElement`).
-   * Souvent utilisés dans les conditions `if/then` du JSON Schema.
-   * @type {Object<string, any>}
-   */
-  defaultFields = {};
-
-  /**
-   * Champs à exclure explicitement du draft et des payloads.
-   * @type {string[]}
-   */
-  removeFields = [];
-
-  /**
-   * Transformations à appliquer à certains champs lors de la lecture depuis le draft.
-   * Clé = champ, valeur = fonction (val, full) => valeur transformée.
-   * @type {Object<string, function(any, object): any>}
-   */
-  transforms = {};
-
-  /**
-   * ───────────────────────────────
-   * JSON
-   * ───────────────────────────────
-   */
-
-  /**
-   * Convertit l'instance en JSON pour l'envoi au serveur.
-   * 
-   * @returns {Object} Représentation JSON de l'instance.
-   */
-  toJSON() {
-    const parentMeta = {};
-    if (this.parent?.id) parentMeta.id = this.parent.id;
-    if (typeof this.parent?.getEntityType === "function") parentMeta.type = this.parent.getEntityType();
-    if (this.parent?.__entityTag) parentMeta.__entityTag = this.parent.__entityTag;
-    if (this.parent?.slug) parentMeta.slug = this.parent.slug;
-
-    return {
-      __entityTag: this.__entityTag,
-      __isSerializedEntity: true,
-      serverData: this._serialize(this._serverData),
-      parent: Object.keys(parentMeta).length > 0 ? parentMeta : null
-    };
-  }
-
-
-  _serialize(obj) {
-    try {
-      return JSON.parse(EJSON.stringify(this._removeUnserializables(obj)));
-    } catch (e) {
-      this.apiClient?._logger?.error?.("Erreur de sérialisation EJSON", e);
-      return null;
-    }
-  }
-
-  /**
-   * Supprime les propriétés non sérialisables d'un objet.
-   * 
-   * @param {Object} obj - L'objet à nettoyer.
-   * @param {WeakSet} [seen] - Ensemble pour éviter les références circulaires.
-   * @returns {Object} L'objet nettoyé.
-   * @private
-   */
-  _removeUnserializables(obj, seen = new WeakSet()) {
-    if (obj === null || typeof obj !== "object") return obj;
-
-    if (seen.has(obj)) return null;
-    seen.add(obj);
-
-    // Ignore les proxys réactifs
-    if (obj.__isReactive && typeof obj.__raw === "object") {
-      return this._removeUnserializables(obj.__raw, seen);
-    }
-
-    if (Array.isArray(obj)) {
-      return obj.map((el) => this._removeUnserializables(el, seen));
-    }
-
-    const clean = {};
-    for (const key of Object.keys(obj)) {
-      const val = obj[key];
-
-      if (
-        typeof val === "function" ||
-      typeof val === "symbol" ||
-      typeof val === "undefined"
-      ) {
-        continue;
-      }
-
-      try {
-        clean[key] = this._removeUnserializables(val, seen);
-      // eslint-disable-next-line no-unused-vars
-      } catch (e) {
-        clean[key] = null;
-      }
-    }
-
-    return clean;
-  }
-
-  /**
-   * Restaure les données sérialisées en un objet d'origine.
-   *
-   * @param {Object} obj - L'objet à restaurer.
-   * @returns {Object} L'objet restauré.
-   */
-  static _revive(obj) {
-    return EJSON.fromJSONValue(obj);
-  }
-
-  /**
-   * Crée une instance d'entité à partir de données JSON.
-   * 
-   * @param {Object} json - Données JSON à utiliser.
-   * @param {Object} parent - Instance parente.
-   * @param {Object} deps - Dépendances injectées.
-   * @returns {object} Nouvelle instance d'entité.
-   */
-  static fromJSON(json, parent, deps) {
-
-    const { serverData } = json;
-
-    const instance = this.fromServerData(this._revive(serverData), parent, deps);
-
-    return instance;
-  }
-
-  /**
-   * ───────────────────────────────
-   * UtilMixin
-   * ───────────────────────────────
-   */
-
-  /**
-   * Appelle une méthode de l'API.
-   * 
-   * @param {string} constant - Le nom de la méthode à appeler.
-   * @param {object} data - Les données à passer à la méthode.
-   * @returns {Promise<any>} - La promesse de la méthode appelée.
-   * @throws {ApiValidationError} - Si une erreur se produit lors de l'appel de l'API.
-   * @throws {ApiResponseError} - Si une erreur se produit lors de l'appel de l'API.
-   * @throws {ApiClientError} - Si l'utilisateur n'est pas authentifié.
-   */
-  async call(constant, data = {}) {
-    return this.apiClient.safeCall(async () => {
-      const response = await this.apiClient.callEndpoint(constant, data);
-      this.apiClient.checkAndThrowApiResponseError(response);
-      return response.data;
-    });
-  }
-
-  /**
-   * Appelle une méthode de l'API si l'utilisateur n'est pas connecté.
-   * 
-   * @param {string} constant - Le nom de la méthode à appeler.
-   * @param {object} data - Les données à passer à la méthode.
-   * @returns {Promise<any>} - La promesse de la méthode appelée.
-   * @throws {ApiAuthenticationError} - Si l'utilisateur est connecté.
-   * @throws {ApiValidationError} - Si une erreur se produit lors de l'appel de l'API.
-   * @throws {ApiResponseError} - Si une erreur se produit lors de l'appel de l'API.
-   * @throws {ApiClientError} - Si une erreur se produit lors de l'appel de l'API.
-   */
-  async callNoConnected(constant, data = {}) {
-    if(this.isConnected) {
-      throw new ApiAuthenticationError("Vous devez ne devez pas être connecté pour faire cette action.");
-    }
-    return this.call(constant, data);
-  }
-
-  /**
-   * Appelle une méthode de l'API si l'utilisateur est connecté.
-   * 
-   * @param {string|function} param - Le nom de la méthode à appeler ou une fonction de rappel.
-   * @param {object} data - Les données à passer à la méthode.
-   * @returns {Promise<any>} - La promesse de la méthode appelée.
-   * @throws {ApiAuthenticationError} - Si l'utilisateur n'est pas connecté.
-   * @throws {ApiValidationError} - Si une erreur se produit lors de l'appel de l'API.
-   * @throws {ApiResponseError} - Si une erreur se produit lors de l'appel de l'API.
-   * @throws {ApiClientError} - Si une erreur se produit lors de l'appel de l'API.
-   */
-  async callIsConnected(param, data = {}) {
-    if(!this.isConnected) {
-      throw new ApiAuthenticationError("Vous devez être connecté pour faire cette action.");
-    }
-    // Si le premier paramètre est une fonction, on l'exécute en tant que callback
-    if (typeof param === "function") {
-      return await param();
-    }
-    return this.call(param, data);
-  }
-
-  /**
-   * Appelle une méthode de l'API si l'utilisateur est lui-même.
-   * 
-   * @param {string|function} param - Le nom de la méthode à appeler ou une fonction de rappel.
-   * @param {object} data - Les données à passer à la méthode.
-   * @returns {Promise<any>} - La promesse de la méthode appelée.
-   * @throws {ApiAuthenticationError} - Si l'utilisateur n'est pas lui-même.
-   * @throws {ApiValidationError} - Si une erreur se produit lors de l'appel de l'API.
-   * @throws {ApiResponseError} - Si une erreur se produit lors de l'appel de l'API.
-   * @throws {ApiClientError} - Si une erreur se produit lors de l'appel de l'API.
-   */
-  async callIsMe(param, data = {}) {
-    if (!this.isMe) {
-      throw new ApiAuthenticationError("Vous devez être vous-même pour faire cette action.");
-    }
-    // Si le premier paramètre est une fonction, on l'exécute en tant que callback
-    if (typeof param === "function") {
-      return await param();
-    }
-    // Sinon, on considère qu'il s'agit d'un constant et on appelle la méthode par défaut
-    return await this.callIsConnected(param, data);
-  }
-
-  /**
-   * Valide une image d'entrée.
-   * 
-   * @param {File|Blob|Buffer|ReadableStream} imageInput - L'image à valider.
-   * @returns {Promise<File|Buffer|ReadableStream>} - L'image validée.
-   * @private
-   */
-  async _validateImage(imageInput){
-    const image = await this._validateUploadInput(imageInput, {
-      allowedMimeTypes: ["image/jpeg", "image/png", "image/jpg"],
-      expectedType: "image"
-    });
-    return image;
-  }
-
-  /**
-   * Valide un fichier d'entrée.
-   * 
-   * @param {File|Blob|Buffer|ReadableStream} fileInput - Le fichier à valider.
-   * @returns {Promise<File|Buffer|ReadableStream>} - Le fichier validé.
-   * @private
-   */
-  async _validateFile(fileInput){
-    const file = await this._validateUploadInput(fileInput, {
-      allowedMimeTypes: ["application/pdf", "text/plain", "text/csv"],
-      expectedType: "file"
-    });
-    return file;
-  }
-
-  /**
-   * Valide les entrées d'upload de fichiers.
-   * 
-   * @param {File|Blob|Buffer|ReadableStream} input - Le fichier à valider.
-   * @param {Object} options - Options de validation.
-   * @param {Array} options.allowedMimeTypes - Types MIME autorisés.
-   * @param {string} options.expectedType - Type de fichier attendu (ex: "image", "file").
-   * @returns {Promise<File|Buffer|ReadableStream>} - Le fichier validé.
-   * @throws {ApiValidationError} - Si le type de fichier est invalide.
-   * @throws {Error} - Si le type de fichier est inconnu.
-   * @private
-   */
-  async _validateUploadInput(input, { allowedMimeTypes = [], expectedType = "any" }) {
-    if (!input) {
-      throw new ApiValidationError("Le fichier est requis.");
-    }
-  
-    const isNode = typeof window === "undefined" && typeof process !== "undefined";
-    let mimeType = "";
-    let output = input;
-  
-    // Navigateur : File
-    if (typeof File !== "undefined" && input instanceof File) {
-      mimeType = input.type;
-      if (!allowedMimeTypes.includes(mimeType)) {
-        throw new ApiValidationError("Le type du fichier est invalide.");
-      }
-    }
-  
-    // Navigateur : Blob
-    else if (typeof Blob !== "undefined" && input instanceof Blob) {
-      mimeType = input.type;
-      if (!allowedMimeTypes.includes(mimeType)) {
-        throw new ApiValidationError("Le type du fichier est invalide.");
-      }
-  
-      const ext = mimeType.split("/")[1] || "bin";
-      const fileName = `${Date.now()}.${ext}`;
-      output = new File([input], fileName, { type: mimeType });
-    }
-  
-    // Node.js : Buffer
-    else if (isNode && Buffer.isBuffer(input)) {
-      const fileTypeResult = await fromBuffer(input);
-      mimeType = fileTypeResult?.mime;
-  
-      if (!fileTypeResult || !allowedMimeTypes.includes(mimeType)) {
-        throw new ApiValidationError("Le type du fichier est invalide.");
-      }
-  
-      // Pour un fichier image, on transforme en stream
-      if (expectedType === "image") {
-        const ext = fileTypeResult.ext;
-        const filename = `${Date.now()}.${ext}`;
-        output = await this._createReadStreamFromBuffer(input, filename, mimeType);
-      }
-    }
-  
-    // Node.js : ReadableStream
-    else if (isNode && input?.readable && typeof input._read === "function") {
-      const previewChunks = [];
-      const tee = await this._passThrough();
-      const resultStream = await this._passThrough();
-  
-      const MAX_BYTES = 4100;
-      let bytesRead = 0;
-  
-      input.on("data", (chunk) => {
-        if (bytesRead < MAX_BYTES) {
-          previewChunks.push(chunk);
-          bytesRead += chunk.length;
-        }
-      });
-  
-      input.pipe(tee).pipe(resultStream);
-      await new Promise((resolve) => setTimeout(resolve, 10));
-  
-      const previewBuffer = Buffer.concat(previewChunks);
-      const fileTypeResult = await fromBuffer(previewBuffer);
-      mimeType = fileTypeResult?.mime;
-  
-      if (!fileTypeResult || !allowedMimeTypes.includes(mimeType)) {
-        throw new ApiValidationError("Le type du fichier est invalide.");
-      }
-  
-      resultStream.path = `${Date.now()}.${fileTypeResult.ext}`;
-      resultStream.mimeType = mimeType;
-      output = resultStream;
-    }
-  
-    else {
-      throw new ApiValidationError("Type de fichier non reconnu.");
-    }
-  
-    return output;
-  }
-
-  /**
-   * Transforme un Buffer en ReadableStream équivalent à fs.createReadStream
-   * @param {Buffer} buffer - Le buffer contenant les données binaires
-   * @param {string} filename - Nom de fichier (utilisé dans FormData)
-   * @param {string} mimeType - Type MIME (utilisé dans FormData)
-   * @returns {Object} - { stream, filename, mimeType }
-   * @private
-   */
-  async _createReadStreamFromBuffer(buffer, filename = "file.bin", mimeType = "application/octet-stream") {
-    const stream = await this._bufferToReadable(buffer);
-    stream.path = filename; // 👈 hack pour simuler un vrai fichier ReadStream
-    stream.mimeType = mimeType;
-    return stream;
-  }
-
-  /**
-   * Transforme un Buffer en ReadableStream.
-   * 
-   * @param {Buffer} buffer - Le buffer à transformer.
-   * @returns {Promise<stream.Readable>} - Un ReadableStream.
-   * @throws {Error} - Si appelé dans le navigateur.
-   * @private
-   */
-  async _bufferToReadable(buffer) {
-    if (typeof window === "undefined") {
-      const { bufferToReadable } = await import("../utils/stream-utils.node.js");
-      return bufferToReadable(buffer);
-    } else {
-      throw new Error("bufferToReadable ne doit pas être appelé dans le navigateur");
-    }
-  }
-  
-  /**
-   * Crée un PassThrough stream pour le traitement des fichiers.
-   * 
-   * @returns {Promise<stream.PassThrough>} - Un PassThrough stream.
-   * @throws {Error} - Si appelé dans le navigateur.
-   * @private
-   */
-  async _passThrough() {
-    if (typeof window === "undefined") {
-      const { createPassThrough } = await import("../utils/stream-utils.node.js");
-      return createPassThrough();
-    } else {
-      throw new Error("passThrough ne doit pas être appelé dans le navigateur");
-    }
-  }
-
-  // async _bufferToReadable(buffer) {
-  //   if (typeof window === "undefined") {
-  //     const { Readable } = await import("stream");
-  //     return Readable.from(buffer);
-  //   } else {
-  //     throw new Error("bufferToReadable ne doit pas être appelé dans le navigateur");
-  //   }
-  // },
-
-  // async _passThrough() {
-  //   if (typeof window === "undefined") {
-  //     const { PassThrough } = await import("stream");
-  //     return new PassThrough();
-  //   } else {
-  //     throw new Error("passThrough ne doit pas être appelé dans le navigateur");
-  //   }
-  // },
-
-  /**
-   * Supprime les propriétés d'un objet en fonction d'une liste de clés.
-   * 
-   * @param {Object} obj - L'objet source.
-   * @param {Array} propsToRemove - Liste des clés à supprimer
-   * @param {boolean} [deep=false] - Si vrai, supprime les propriétés de manière récursive.
-   * @returns {Object} - Un nouvel objet sans les propriétés supprimées.
-   * @private
-   */
-  _omitProps(obj, propsToRemove) {
-    if (!obj || typeof obj !== "object") return {};
-  
-    const result = { ...obj };
-    for (const prop of propsToRemove) {
-      delete result[prop];
-    }
-    return result;
-  }
-
-  /**
-   * Extrait les propriétés d'un objet en fonction d'une liste de clés.
-   * 
-   * @param {Object} obj - L'objet source.
-   * @param {Array} keys - Liste des clés à extraire.
-   * @param {Object} [transforms={}] - Transformations à appliquer aux valeurs.
-   * @returns {Object} - Un nouvel objet contenant les propriétés extraites.
-   * @private
-   */
-  _pickProps(obj, keys, transforms = {}) {
-    if (!obj || typeof obj !== "object") return {};
-
-    const result = {};
-
-    for (const key of keys) {
-      if (key in obj) {
-        const value = obj[key];
-        if (typeof transforms[key] === "function") {
-          result[key] = transforms[key](value, obj); // (valeur, objet source)
-        } else {
-          result[key] = value;
-        }
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Vérifie si au moins une clé est présente dans l'objet et n'est pas nulle.
-   * 
-   * @param {Object} obj - L'objet à vérifier.
-   * @param {Array} keys - Liste des clés à vérifier.
-   * @returns {boolean} - true si au moins une clé est présente et non nulle, sinon false.
-   * @private
-   */
-  _hasAtLeastOne(obj, keys = []) {
-    return keys.some((key) => key in obj && obj[key] != null);
-  }
-
-  /**
-   * Crée un proxy filtré pour une liste d'entités.
-   * @param {Array} list - Liste d'entités.
-   * @returns {Proxy} Proxy filtré.
-   * @private
-   */
-  _createFilteredProxy(list) {
-    return new Proxy(list, {
-      get(target, prop, receiver) {
-        if (typeof prop === "string" && !isNaN(prop)) {
-          const active = target.filter(n => !n._isDeleted);
-          return active[prop];
-        }
-        if (prop === "length") {
-          return target.filter(n => !n._isDeleted).length;
-        }
-        if (typeof target[prop] === "function") {
-          return (...args) => target.filter(n => !n._isDeleted)[prop](...args);
-        }
-        return Reflect.get(target, prop, receiver);
-      }
-    });
-  }
-  
-  /**
-   * Génère un nouvel identifiant unique.
-   * @returns {string} Un identifiant unique.
-   * @private
-   */
-  _newId() {
-    const newId = new ObjectID();
-    return newId.toString();
-  }
-
-  /**
-   * ───────────────────────────────
-   * DraftStateMixin
-   * ───────────────────────────────
-   */
-
-  /**
-   * Crée un proxy combinant draft + serveur, avec transformations facultatives.
-   * @param {Object} server
-   * @param {Object} draft
-   * @param {Array} allowedFields - champs autorisés dans le draft
-   * @param {Object} [transforms={}] - transformateurs de lecture
-   * @param {Object} [options={}] - options
-   * @returns {Proxy}
-   * @private
-   */
-  _createDraftProxy(apiClient, server = {}, draft = {}, allowedFields = [], transforms = {}, options = {}) {
-    return new Proxy({}, {
-      get: (_, prop) => {
-      // Ne pas tenter d’accéder à des propriétés système
-        if (typeof prop !== "string" && typeof prop !== "symbol") return undefined;
-
-        // Lecture explicite — déclenche signal si draft est réactif
-        if (prop in draft) {
-          const value = draft[prop];
-          const transformer = transforms[prop];
-          return typeof transformer === "function" ? transformer(value) : value;
-        }
-
-        // Fallback vers serverData — aussi potentiellement réactif
-        if (server && typeof server === "object" && prop in server) {
-          const value = server[prop];
-          const transformer = transforms[prop];
-          return typeof transformer === "function" ? transformer(value) : value;
-        }
-
-        return undefined;
-      },
-
-      set: (_, prop, value) => {
-        if (!allowedFields.includes(prop)) {
-          const message = `[DraftProxy] Le champ "${prop}" n'est pas autorisé.`;
-          if (options.throwOnError) {
-            throw new ApiValidationError(message, 400, null, {
-              field: prop,
-              value,
-              allowedFields
-            });
-          }
-          apiClient._logger.warn(message);
-          return false;
-        }
-        const current = draft[prop];
-
-        if (current && typeof current === "object" && current.__isSignal === true) {
-          current.value = value; // ✅ met à jour le signal
-        } else {
-          draft[prop] = value; // fallback classique
-        }
-        return true;
-      },
-
-      deleteProperty: (_, prop) => {
-        if (!allowedFields.includes(prop)) return false;
-        delete draft[prop];
-        return true;
-      },
-
-      has: (_, prop) => prop in draft || prop in server,
-
-      ownKeys: () => [...new Set([
-        ...Object.keys(server || {}),
-        ...Object.keys(draft || {})
-      ])],
-
-      getOwnPropertyDescriptor: () => ({
-        enumerable: true,
-        configurable: true
-      })
-    });
-  }
-
-  /**
-   * Extrait les champs modifiables d'un schéma JSON.
-   * 
-   * @param {Object} schema - Le schéma JSON à analyser.
-   * @param {Object} data - Les données à comparer.
-   * @param {Object} ctx - Contexte d'extraction (pour la récursion).
-   * @param {Object} ctx.defs - Définitions de schéma.
-   * @param {Set} ctx.visited - Ensemble des schémas déjà visités.
-   * @returns {Array} - Liste des champs modifiables.
-   * @private
-   */
-  _extractWritableFields(schema = {}, data = {}, ctx = { defs: {}, visited: new Set() }) {
-    if (!schema || typeof schema !== "object") return [];
-    if (schema.$id && ctx.visited.has(schema.$id)) return [];
-    if (schema.$id) ctx.visited.add(schema.$id);
-    ctx.defs = schema.$defs || schema.definitions || ctx.defs;
-
-    const fields = [];
-
-    if (schema.$ref) {
-      const refKey = schema.$ref.replace(/^#\/?(\$defs|definitions)\//, "");
-      const resolved = ctx.defs?.[refKey];
-      if (resolved) fields.push(...this._extractWritableFields(resolved, data, ctx));
-    }
-
-    if (schema.allOf) {
-      schema.allOf.forEach(s => fields.push(...this._extractWritableFields(s, data, ctx)));
-    }
-
-    if (schema.if && schema.then) {
-      const condition = schema.if?.properties;
-      let matches = true;
-      if (condition) {
-        for (const key in condition) {
-          const expected = condition[key]?.const;
-          if (data[key] !== expected) {
-            matches = false;
-            break;
-          }
-        }
-      }
-      if (matches && schema.then) {
-        fields.push(...this._extractWritableFields(schema.then, data, ctx));
-      } else if (!matches && schema.else) {
-        fields.push(...this._extractWritableFields(schema.else, data, ctx));
-      }
-    }
-
-    if (schema.properties) {
-      fields.push(...Object.entries(schema.properties)
-        // eslint-disable-next-line no-unused-vars
-        .filter(([_, def]) => def.readOnly !== true && def.const === undefined)
-        .map(([key]) => key));
-    }
-
-    return [...new Set(fields)];
-  }
-
-  /**
-   * Construit un brouillon et un proxy à partir des données et du schéma.
-   * 
-   * @param {Object} options - Options de construction.
-   * @param {Object} options.data - Données à utiliser pour le brouillon.
-   * @param {Object} [options.serverData=null] - Données du serveur.
-   * @param {string|Array} options.constant - Nom de la constante ou tableau de constantes.
-   * @param {ApiClient} options.apiClient - Instance de l'API.
-   * @param {Object} [options.transforms={}] - Transformations à appliquer.
-   * @param {boolean} [options.throwOnError=true] - Si vrai, lève une erreur en cas de problème.
-   * @param {Array} [options.removeFields=[]] - Liste des champs à ignorer.
-   * @returns {Object} - Objet contenant le brouillon et le proxy.
-   * @private
-   */
-  _buildDraftAndProxy({ data = {}, serverData = null, previousDraft = null, constant, apiClient, transforms = {}, throwOnError = true, removeFields = [] }) {
-    const constants = Array.isArray(constant) ? constant : [constant];
-    const combinedSchema = {
-      allOf: [],
-      $defs: {}
-    };
-    
-    for (const key of constants) {
-      const sch = apiClient.getRequestSchema(key);
-      if (!sch) throw new ApiError(`Unable to find schema for ${key}.`);
-    
-      // Extraire et fusionner les $defs
-      if (sch.$defs) {
-        for (const [defKey, defVal] of Object.entries(sch.$defs)) {
-          if (combinedSchema.$defs[defKey]) {
-            apiClient._logger.warn(`Duplicate $defs key '${defKey}' from schema '${key}'`);
-          } else {
-            combinedSchema.$defs[defKey] = defVal;
-          }
-        }
-      }
-    
-      combinedSchema.allOf.push(sch);
-    }
-
-    let allowed = this._extractWritableFields(combinedSchema, data);
-
-    if (data.id && allowed.indexOf("id") === -1) {
-      allowed.push("id");
-    }
-    if (data.slug && allowed.indexOf("slug") === -1) {  
-      allowed.push("slug");
-    }
-
-    allowed = allowed.filter(k => !removeFields.includes(k));
-
-    // Transformation des champs autorisés
-    const rawDraft = Object.fromEntries(
-      allowed.map((key) => {
-        const raw = data[key];
-        const transformed = typeof transforms[key] === "function"
-          ? transforms[key](raw, data)
-          : raw;
-        return [key, transformed];
-      // eslint-disable-next-line no-unused-vars
-      }).filter(([_, v]) => v !== undefined)
-    );
-
-    const initial = structuredClone ? structuredClone(rawDraft) : JSON.parse(JSON.stringify(rawDraft));
-
-    const draft = isReactive(previousDraft)
-      ? Object.assign(previousDraft, rawDraft)
-      : reactive(rawDraft);
-
-    // Assure que serverData est réactif si c'est un objet
-    const reactiveServer = isReactive(serverData)
-      ? serverData
-      : (serverData && typeof serverData === "object" ? reactive(serverData) : serverData);
-
-    const proxy = this._createDraftProxy(apiClient, reactiveServer, draft, allowed, transforms, { throwOnError });
-
-    return { draft, proxy, initial};
-  }
-
-  /**
-   * Extrait les champs modifiés du schéma.
-   * 
-   * @param {ApiClient} apiClient - Instance de l'API.
-   * @param {string} constant - Nom de la constante.
-   * @param {Object} data - Données à comparer.
-   * @param {Function} getInitialDraft - Fonction pour obtenir le brouillon initial.
-   * @param {Array} removeFields - Liste des champs à ignorer.
-   * @returns {Object|null} - Champs modifiés ou null.
-   * @private
-   */
-  _extractChangedFieldsFromSchema(apiClient, constant, data = {}, getInitialDraft, removeFields = []) {
-    const schema = apiClient.getRequestSchema(constant);
-    let allowed = this._extractWritableFields(schema, data);
-    const changed = {};
-    const initialDraft = getInitialDraft?.() || {};
-  
-    // on enlève les champs qui ne sont pas dans le draft
-    // ou qui sont dans removeFields
-    allowed = allowed.filter(k => !removeFields.includes(k));
-
-    for (const key of allowed) {
-      // on verifie que le champ existe dans le draft
-      // sinon on ne le prend pas en compte
-
-      if (data[key] === undefined) continue;
-  
-      const current = data[key];
-      const initial = initialDraft[key];
-  
-      const changedValue =
-        JSON.stringify(current) !== JSON.stringify(initial);
-  
-      if (changedValue) {
-        changed[key] = current;
-      }
-    }
-  
-    return Object.keys(changed).length > 0 ? changed : null;
-  }
-
-  /**
-   * Extrait tous les champs valides selon le schéma, et retourne uniquement ceux qui ont changé par rapport au draft initial.
-   * Contrairement à `_extractChangedFieldsFromSchema`, cette méthode retourne l'ensemble des champs valides (`updated`)
-   * uniquement s'il y a au moins un champ modifié (`changed`).
-   *
-   * ⚠️ Les champs sont filtrés en fonction :
-   * - des champs définis comme modifiables dans le schéma (`writeable`)
-   * - des champs non exclus dans `removeFields`
-   * - des champs définis dans `data` (les `undefined` sont ignorés)
-   *
-   * @param {ApiClient} apiClient - L’instance de client API contenant les schémas.
-   * @param {string} constant - Le nom de la constante de schéma (ex: "ADD_EVENT").
-   * @param {Object} data - Les nouvelles données à comparer avec le draft initial.
-   * @param {() => Object} getInitialDraft - Fonction qui retourne le draft initial (souvent `this.initialDraftData`).
-   * @param {string[]} [removeFields=[]] - Champs à ignorer même s’ils sont valides.
-   * @returns {Object|null} - Un objet `updated` avec les champs valides si au moins un champ a changé, sinon `null`.
-   * @private
-   */
-  _extractAllValidFieldsFromSchema(apiClient, constant, data = {}, getInitialDraft, removeFields = []) {
-    const schema = apiClient.getRequestSchema(constant);
-    let allowed = this._extractWritableFields(schema, data);
-    const changed = {};
-    const updated = {};
-    const initialDraft = getInitialDraft?.() || {};
-  
-    // on enlève les champs qui ne sont pas dans le draft
-    // ou qui sont dans removeFields
-    allowed = allowed.filter(k => !removeFields.includes(k));
-
-    for (const key of allowed) {
-      // on verifie que le champ existe dans le draft
-      // sinon on ne le prend pas en compte
-
-      if (data[key] === undefined) continue;
-  
-      const current = data[key];
-      const initial = initialDraft[key];
-  
-      const changedValue =
-        JSON.stringify(current) !== JSON.stringify(initial);
-  
-      if (changedValue) {
-        changed[key] = current;
-      }
-
-      updated[key] = current;
-    }
-  
-    return Object.keys(changed).length > 0 ? updated : null;
-  }
-
-  /**
-   * ───────────────────────────────
-   * MutualEntityMixin
-   * ───────────────────────────────
-   */
-
-  /**
-   * Résout l'identifiant de l'entité si seul le slug est fourni.
-   * @param {string} type - Le type d'entité (ex : "citoyens", "organizations", "projects").
-   * @returns {Promise<string>} L'identifiant résolu.
-   * @private
-   */
-  async _resolveId(type) {
-    if (!this.id && this.slug) {
-      try {
-        const data = await this.endpointApi.getElementsKey({
-          pathParams:{
-            slug: this.slug
-          }
-        });
-        if(data?.contextId && data?.contextType === type) {
-          this._id(data.contextId);
-        } else {
-          throw new ApiResponseError(`Le slug ${this.slug} ne correspond pas à un ${type}`, 200, data);
-        }
-      } catch (error) {
-        if(error instanceof ApiResponseError) {
-          if(error?.responseData?.contextType !== type) {
-            throw error;
-          } else {
-            throw new ApiResponseError(`Impossible de récupérer l'identifiant pour le slug ${this.slug}`, error.status, error.responseData);
-          }
-        } else {
-          throw error;
-        }
-      }
-    }
-    return this.id;
-  }
-  
-  /**
-   * Récupère le profil public de l'entité.
-   * 
-   * @returns {Promise<Object>} - Les données du profil public.
-   * @private
-   */
-  async _getPublicProfile() {
-    await this._resolveId(this.getEntityType());
-    return this.endpointApi.getElementsAbout({ pathParams: { id: this.id, type: this.getEntityType() } });
-  }
-
-  /**
-   * Récupère la classe d'entité et ses dépendances à partir du type d'entité.
-   * 
-   * @param {string} entityType - Le type d'entité.
-   * @return {{ entityClass: Function, deps: Object } | null}
-   * @private
-   */
-  _getEntityMeta(entityType) {
-    const selfClass = this.constructor;
-    const selfTag = this.__entityTag;
-  
-    const commonDeps = {
-      EndpointApi: this.deps.EndpointApi,
-      User: selfTag === "User" ? selfClass : this.deps.User,
-      Organization: selfTag === "Organization" ? selfClass : this.deps.Organization,
-      Project: selfTag === "Project" ? selfClass : this.deps.Project,
-      Event: selfTag === "Event" ? selfClass : this.deps.Event,
-      Poi: selfTag === "Poi" ? selfClass : this.deps.Poi,
-      Badge: selfTag === "Badge" ? selfClass : this.deps.Badge,
-      News: selfTag === "News" ? selfClass : this.deps.News
-    };
-  
-    const map = {
-      citoyens:     { entityClass: commonDeps.User,         deps: commonDeps },
-      organizations:{ entityClass: commonDeps.Organization, deps: commonDeps },
-      projects:      { entityClass: commonDeps.Project,      deps: commonDeps },
-      events:       { entityClass: commonDeps.Event,        deps: { ...commonDeps, Badge: undefined } },
-      poi:          { entityClass: commonDeps.Poi,          deps: { ...commonDeps, Badge: undefined, News: undefined } },
-      news:         { entityClass: commonDeps.News,         deps: { ...commonDeps } },
-      badges:       { entityClass: commonDeps.Badge,        deps: { 
-        EndpointApi: commonDeps.EndpointApi, 
-        User: commonDeps.User, 
-        Organization: commonDeps.Organization, 
-        Project: commonDeps.Project 
-      } }
-    };
-  
-    return map[entityType] || null;
-  }
-
-  /**
-   * Lier des données d'entité à une instance d'entité.
-   * 
-   * @param {string} entityType - Le type d'entité (ex : "citoyens", "organisations", "projets").
-   * @param {Object} entityData - Les données de l'entité à lier.
-   * @return {Object} L'entité liée.
-   * @private
-   */
-  _linkEntity(entityType, entityData) {
-    const meta = this._getEntityMeta(entityType);
-    if (!meta) return entityData;
-    return meta.entityClass.fromServerData(entityData, this, meta.deps);
-  }
-
-  /**
-   * Récupère et lie une entité à partir de son ID.
-   * 
-   * @param {string} entityType - Le type d'entité.
-   * @param {string} entityId - L'identifiant de l'entité.
-   * @param {Object} [options] - Options supplémentaires :
-   * @param {boolean} [options.skipGet] - Si true, ne pas appeler `get()` sur l'entité.
-   * @return {Promise<Object|null>} L'entité liée ou null.
-   * @private
-   */
-  async _linkEntityById(entityType, entityId, options = {}) {
-    const meta = this._getEntityMeta(entityType);
-    if (!meta) return null;
-    const entity = new meta.entityClass(this, { id: entityId }, meta.deps);
-    if(options?.skipGet) return entity;
-    await entity.get();
-    return entity;
-  }
-
-  /**
-   * Lie une liste d'entités à partir de leurs données.
-   * 
-   * @param {Array<Object>} results - Liste de données d'entités.
-   * @return {Array<Object>} Liste d'entités liées.
-   * @private
-   */
-  _linkEntities(results) {
-    return results.flatMap(d => {
-      if (!d?.collection) {
-        this.apiClient._logger?.warn?.(`Objet ignoré car sans 'collection' : ${d?.id}`);
-        return []; // exclu de la liste
-      }
-
-      return [this._linkEntity?.(d.collection, d) ?? d];
-    });
-  }
-
-  /**
-   * Lie des entités présentes dans `this.serverData` à partir de leurs IDs,
-   * en les filtrant dynamiquement et en optionnellement les transformant.
-   *
-   * @param {string} entityType - Le type d'entité (ex : "badges", "citoyens", etc.).
-   * @param {Object} filters - Clés/valeurs de filtres dynamiques. Les valeurs peuvent être :
-   *   - un littéral (comparaison stricte ou intelligente selon le type),
-   *   - une chaîne (utilise `includes` insensible à la casse),
-   *   - une RegExp (appliquée si la valeur est une chaîne),
-   *   - une fonction `(value) => boolean`.
-   * @param {Object} [options] - Options supplémentaires :
-   * @param {string} [options.key] - Le champ de `this.serverData` à utiliser (par défaut = entityType).
-   * @param {Function} [options.mapFn] - Fonction de transformation `(entity) => any` appliquée au résultat.
-   *
-   * @return {Promise<Array<Object>>} Liste des entités liées, filtrées et éventuellement transformées.
-   *
-   * @example
-   * // Tous les badges avec `name` contenant "codev"
-   * const badges = await this.linkEntitiesFromServerData("badges", { name: "codev" });
-   *
-   * @example
-   * // Badges non expirés et visibles
-   * const badges = await this.linkEntitiesFromServerData("badges", {
-   *   expiredOn: false,
-   *   show: "true"
-   * });
-   *
-   * @example
-   * // Badges émis après 2023
-   * const badges = await this.linkEntitiesFromServerData("badges", {
-   *   issuedOn: (v) => new Date(v) >= new Date("2023-01-01")
-   * });
-   *
-   * @example
-   * // Extraire uniquement les noms des badges
-   * const namesOnly = await this.linkEntitiesFromServerData("badges", {}, {
-   *   mapFn: (badge) => badge.meta.name
-   * });
-   */
-  async linkEntitiesFromServerData(entityType, filters = {}, options = {}) {
-    const key = options.key || entityType;
-    const mapFn = typeof options.mapFn === "function" ? options.mapFn : null;
-
-    const isTruthy = (v) => v === true || v === "true";
-    const isFalsy = (v) => v === false || v === "false";
-
-    const data = this.serverData?.[key];
-    const result = [];
-
-    if (data && typeof data === "object" && Object.keys(data).length > 0) {
-      for (const id of Object.keys(data)) {
-        const meta = data[id];
-
-        const matches = Object.entries(filters).every(([key, expected]) => {
-          const actual = meta[key];
-
-          if (typeof expected === "function") {
-            try {
-              return expected(actual);
-            } catch (err) {
-              console.warn(`Erreur dans le filtre personnalisé pour ${key}`, err);
-              return false;
-            }
-          }
-
-          if (expected instanceof RegExp) {
-            return typeof actual === "string" && expected.test(actual);
-          }
-
-          if (typeof expected === "string" && typeof actual === "string") {
-            return actual.toLowerCase().includes(expected.toLowerCase());
-          }
-
-          if (isTruthy(expected)) return isTruthy(actual);
-          if (isFalsy(expected)) return isFalsy(actual);
-
-          if (
-            typeof actual === "string" &&
-            typeof expected === "string" &&
-            !isNaN(Date.parse(actual)) &&
-            !isNaN(Date.parse(expected))
-          ) {
-            return new Date(actual).getTime() === new Date(expected).getTime();
-          }
-
-          return actual === expected;
-        });
-
-        if (!matches) continue;
-
-        try {
-          const entity = await this._linkEntityById(entityType, id);
-          if (entity) {
-            entity.meta = meta;
-            result.push(mapFn ? mapFn(entity) : entity);
-          }
-        } catch (error) {
-          this._logger?.error?.(`Erreur lors de la récupération de l'entité ${entityType} (${id}) :`, error);
-        }
-      }
-    }
-    return result;
-  }
-
-  /**
-   * Crée une instance d'entité à partir des données fournies.
-   * @param {string} entityType - Le type d'entité (ex : "citoyens", "organisations", "projets").
-   * @param {Object} entityData - Les données de l'entité.
-   * @return {Object} L'entité créée.
-   * @private
-   */
-  _entityInstanceData(entityType, entityData) {
-    const meta = this._getEntityMeta(entityType);
-    const selfKey = this.__entityTag; // ex: "User", "Organization", etc.
-    const selfClass = this.constructor;
-
-    // pour citoyens la signature est différentes
-    return new meta.entityClass(this, entityData, {
-      [selfKey]: selfClass,
-      ...meta.deps
-    });
-  }
-
-  /**
-   * Crée une instance d'entité, et déclenche get() si certaines propriétés sont présentes.
-   * @param {string} entityType
-   * @param {Object} entityData
-   * @return {Promise<Object>}
-   */
-  async entity(entityType, entityData = {}) {
-    try {
-      const entity = this._entityInstanceData(entityType, entityData);
-
-      const fetchKeysByEntity = {
-        citoyens: ["id", "slug"],
-        organizations: ["id", "slug"],
-        projects: ["id", "slug"],
-        events: ["id", "slug"],
-        poi: ["id", "slug"],
-        news: ["id"],
-        badges: ["id"],
-      };
-
-      const fetchKeys = fetchKeysByEntity[entityType];
-
-      if (fetchKeys && this._hasAtLeastOne(entityData, fetchKeys)) {
-        await entity.get();
-      }
-
-      return entity;
-    } catch (error) {
-      this.apiClient._logger.error(`[Api.${this.__entityTag}.${entityType}] Erreur lors de la création d'une instance ${entityType} :`, error.message);
-      throw error;
-    }
-  }
-
-  /**
-   * Récupère et lie une entité à partir de son slug.
-   * @param {string} slug - Le slug de l'entité.
-   * @return {Promise<Object|null>} L'entité liée ou null.
-   */
-  async entityBySlug(slug) {
-    if (!slug) {
-      throw new ApiError("Le slug est requis.");
-    }
-    try {
-      const data = await this.endpointApi.getElementsKey({
-        pathParams:{
-          slug: slug
-        }
-      });
-      if(data?.contextId && data?.contextType) {
-        const entity = await this.entity(data.contextType, { id: data.contextId });
-        return entity;
-      } else {
-        throw new ApiResponseError(`Le slug ${slug} n'est pas valide`, 200, data);
-      }
-    } catch (error) {
-      if(error instanceof ApiResponseError) {
-        throw new ApiResponseError(`Impossible de récupérer l'identifiant pour le slug ${slug}`, error.status, error.responseData);
-      } else {
-        throw error;
-      }
-    }
-  }
-
-
-  /**
-   * Construit dynamiquement des filtres sur un lien entre entités
-   *
-   * @param {string} id - L'ID de l'entité cible.
-   * @param {Object} options - Options de filtrage.
-   * @param {"memberOf" | "projects"} [options.linkType] - Le type de lien (ex: "memberOf", "projects", etc.).
-   * @param {boolean} [options.isAdmin] - Si défini, filtre selon l'existence de isAdmin.
-   * @param {boolean} [options.isAdminPending] - Si défini, filtre selon l'existence de isAdminPending.
-   * @param {boolean} [options.isInviting] - Si défini, filtre selon l'existence de isInviting.
-   * @param {boolean} [options.toBeValidated] - Si défini, filtre selon l'existence de toBeValidated.
-   * @param {Array<string>} [options.roles] - Rôles à filtrer.
-   * @returns {Object} - Un objet de filtres à passer à une requête.
-   * @throws {TypeError} - Si les types des paramètres ne sont pas valides.
-   * @private
-   */
-  _buildLinkFilters(id, {
-    linkType,
-    isAdmin,
-    isAdminPending,
-    isInviting,
-    toBeValidated = false,
-    roles = []
-  } = {}) {
-    if (typeof id !== "string") throw new TypeError("id doit être une chaîne.");
-    if (typeof linkType !== "string") throw new TypeError("linkType doit être une chaîne.");
-    if (typeof isAdmin !== "undefined" && typeof isAdmin !== "boolean") {
-      throw new TypeError("isAdmin doit être un booléen.");
-    }
-    if (typeof isAdminPending !== "undefined" && typeof isAdminPending !== "boolean") {
-      throw new TypeError("isAdminPending doit être un booléen.");
-    }
-    if (typeof isInviting !== "undefined" && typeof isInviting !== "boolean") {
-      throw new TypeError("isInviting doit être un booléen.");
-    }
-    if (typeof toBeValidated !== "undefined" && typeof toBeValidated !== "boolean") {
-      throw new TypeError("toBeValidated doit être un booléen.");
-    }
-    if (!Array.isArray(roles)) {
-      throw new TypeError("roles doit être un tableau de chaînes.");
-    }
-
-    const path = `links.${linkType}.${id}`;
-    const filters = {
-      [`${path}`]: { $exists: true }
-    };
-
-    if (typeof toBeValidated === "boolean") {
-      filters[`${path}.toBeValidated`] = { $exists: toBeValidated };
-    }
-
-    if (typeof isInviting === "boolean") {
-      filters[`${path}.isInviting`] = { $exists: isInviting };
-    }
-
-    if (isAdmin === true) {
-      filters[`${path}.isAdmin`] = { $exists: true };
-    }
-
-    if(isAdminPending === true) {
-      filters[`${path}.isAdminPending`] = { $exists: true };
-    }
-
-    if (roles.length > 0) {
-      filters[`${path}.roles`] = { $in: roles };
-    }
-
-    return filters;
-  }
-
-  /**
-   * Retourne les métadonnées de lien pour une entité :
-   * - `linkType` : clé dans `serverData.links`
-   * - `connectTypeConnect` : valeur envoyée pour `connect()`
-   * - `connectTypeDisconnect` : valeur envoyée pour `disconnect()`
-   * @typedef {Object} LinkMeta
-   * @property {string} linkType
-   * @property {string} connectTypeConnect
-   * @property {string} connectTypeDisconnect
-   * @returns {LinkMeta}
-   * @throws {ApiError} - Si le type d'entité est inconnu.
-   * @private
-   */
-  _getLinkMeta() {
-    const map = {
-      organizations: {
-        linkType: "memberOf",
-        connectTypeConnect: "member",
-        connectTypeDisconnect: "members"
-      },
-      projects: {
-        linkType: "projects",
-        connectTypeConnect: "contributor",
-        connectTypeDisconnect: "contributors"
-      },
-      events: {
-        linkType: "events",
-        connectTypeConnect: "attendee",
-        connectTypeDisconnect: "attendees"
-      },
-      citoyens: {
-        linkType: "friends",
-        connectTypeConnect: "friend",
-        connectTypeDisconnect: "friends"
-      }
-    };
-
-    const entityType = this.getEntityType();
-    const meta = map[entityType];
-
-    if (!meta) {
-      throw new ApiError(`Aucune correspondance de lien définie pour le type d'entité "${entityType}"`);
-    }
-
-    return meta;
-  }
-
-  /**
-   * Vérifie si l'entité prend en charge les opérations de lien (`connect`, `disconnect`, etc.).
-   * Utilise `_getLinkMeta()` comme source unique de vérité.
-   *
-   * @throws {ApiError} - Si l'entité ne supporte pas les liens.
-   * @private
-   */
-  _checkLinkableEntity() {
-    try {
-      this._getLinkMeta(); // si l'entité n'est pas supportée, ça throw déjà
-    } catch (error) {
-      if (error instanceof ApiError) {
-        throw new ApiError(`L'entité "${this.getEntityType()}" ne prend pas en charge les actions de lien.`);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Retourne le lien de l'utilisateur connecté avec l'entité cible (dans `parent.serverData.links`)
-   * @private
-   */
-  _getLinkFromConnectedUser() {
-    const { linkType } = this._getLinkMeta();
-    return this?.userContext?.serverData?.links?.[linkType]?.[this.id] || null;
-  }
-
-  /**
-   * Soumet une demande de connexion à une entité (ex : membre, contributeur),
-   * ou valide l'invitation si elle existe déjà.
-   *
-   * @returns {Promise<Object>} - Résultat de l'API
-   * @throws {ApiError} - En cas d'erreur de connexion ou d'invitation.
-   * @private
-   */
-  async _submitLinkRequest() {
-
-    if (!this.id) {
-      throw new ApiError(`${this.constructor.name} non enregistrée.`);
-    }
-
-    const { connectTypeConnect } = this._getLinkMeta();
-
-    const userLink = this._getLinkFromConnectedUser();
-
-    // Cas : aucun lien → on demande à se connecter
-    if (!userLink) {
-      const data = {
-        parentType: this.getEntityType(),
-        parentId: this.id,
-        connectType: connectTypeConnect
-      };
-
-      // TODO : reflechir au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
-      const retour = await this.callIsMe(() => this.endpointApi.connect(data));
-      await this.userContext.refresh();
-      return retour;
-    }
-
-    // Cas : invitation reçue → on valide l'invitation
-    if (userLink.isInviting) {
-      return this._acceptLinkRequest();
-    }
-
-    // Cas : déjà en attente
-    if (userLink.toBeValidated) {
-      throw new ApiError("Vous êtes déjà en attente de validation.");
-    }
-
-    // Cas par défaut : rien à faire
-    throw new ApiError("Vous êtes déjà connecté à cette entité.");
-  }
-
-  /**
-   * Soumet une demande pour devenir administrateur d'une entité.
-   *
-   * @returns {Promise<Object>}
-   * @throws {ApiError}
-   * @private
-   */
-  async _submitLinkRequestAdmin() {
-
-    if (!this.id) {
-      throw new ApiError(`${this.constructor.name} non enregistrée.`);
-    }
-
-    const userLink = this._getLinkFromConnectedUser();
-
-    // Aucun lien existant → envoie une demande avec rôle "admin"
-    if (!userLink) {
-      const data = {
-        parentType: this.getEntityType(),
-        parentId: this.id,
-        connectType: "admin"
-      };
-
-      // TODO : reflechir au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
-      const retour = await this.callIsMe(() => this.endpointApi.connect(data));
-      await this.userContext.refresh();
-      return retour;
-    }
-
-    // Invitation reçue → accepte automatiquement
-    if (userLink.isInviting) {
-      return this._acceptLinkRequest();
-    }
-
-    // Déjà en attente pour admin
-    if (userLink.toBeValidated && userLink.isAdminPending) {
-      throw new ApiError("Vous êtes déjà en attente de validation pour devenir admin.");
-    }
-
-    // Déjà en attente pour un autre rôle
-    if (userLink.toBeValidated) {
-      throw new ApiError("Vous êtes déjà en attente de validation pour rejoindre cette entité.");
-    }
-
-    // Déjà connecté
-    throw new ApiError("Vous êtes déjà connecté à cette entité.");
-  }
-
-  /**
-   * Accepte une demande de lien (ex : invitation à rejoindre un groupe).
-   * 
-   * @returns {Promise<Object>} - Résultat de l'API
-   * @throws {ApiError} - En cas d'erreur de connexion ou d'invitation.
-   * @private
-   */
-  async _acceptLinkRequest() {
-
-    if (!this.id) {
-      throw new ApiError(`${this.constructor.name} non enregistrée.`);
-    }
-
-    const userLink = this._getLinkFromConnectedUser();
-
-    if (userLink.isInviting) {
-      const data = {
-        parentType: this.getEntityType(),
-        parentId: this.id,
-        linkOption: "isInviting"
-      };
-      // TODO : reflechir au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
-      const retour = await this.callIsMe(() => this.endpointApi.linkValidate(data));
-      await this.userContext.refresh();
-      return retour;
-    }
-
-    throw new ApiError("Vous n'avez pas d'invitation à valider.");
-  }
-
-  /**
-   * Annule une demande de lien ou se déconnecte d'une entité.
-   * 
-   * @returns {Promise<Object>} - Résultat de l'API
-   * @throws {ApiError} - En cas d'erreur de connexion ou d'invitation.
-   * @private
-   */
-  async _leaveLinkRequest() {
-
-    if (!this.id) {
-      throw new ApiError(`${this.constructor.name} non enregistrée.`);
-    }
-
-    const { connectTypeDisconnect } = this._getLinkMeta();
-
-    const userLink = this._getLinkFromConnectedUser();
-
-    if (!userLink) {
-      throw new ApiError("Vous n'êtes pas connecté à cette entité.");
-    }
-
-    const data = {
-      parentType: this.getEntityType(),
-      parentId: this.id,
-      // Normalement en auto dans le schema mais je le met quand même
-      connectType: connectTypeDisconnect
-    };
-    
-    // TODO : reflechir au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
-    const retour = await this.callIsMe(() => this.endpointApi.disconnect(data));
-    await this.userContext.refresh();
-    return retour;
-  }
-
-  /**
-   * ───────────────────────────────
-   * EntityMixin
-   * ───────────────────────────────
-   */
-
-  /**
-   * Récupérer le profil public de l'entité
-   * 
-   * @returns {Promise<Object>} - Les données de réponse.
-   */
-  async get() {
-    return this.apiClient.safeCall(async () => {
-      const data = await this._getPublicProfile();
-      this._setData(data, { forceInitialDraftReset: true });
-      return data;
-    });
-  }
-  
-  /**
-   * Mettre à jour les paramètres d'un élément : Mise à jour des paramètres spécifiques d'un élément.
-   * Constant : UPDATE_SETTINGS
-   * @param {Object} data - Les données à envoyer.
-   * @param {string} data.type - data.type
-   * @param {undefined} data.value - data.value
-   * @returns {Promise<Object>} - Les données de réponse.
-   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
-   * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
-   * @throws {Error} - En cas d'erreur inattendue.
-   */
-  async updateSettings(data = {}) {
-    data.idEntity = this.id;
-    data.typeEntity = this.getEntityType();
-    return this.callIsConnected(() => this.endpointApi.updateSettings(data));
-  }
-  
-  /**
-   * Mettre à jour la description d'un élément : Permet de mettre à jour la description courte et complète d'un élément.
-   * Constant : UPDATE_BLOCK_DESCRIPTION
-   * @param {Object} data - Les données à envoyer.
-   * @param {string} data.descMentions - Mentions dans la description (default: "")
-   * @param {string} data.shortDescription - Courte description
-   * @param {string} data.description - Description complète
-   * @returns {Promise<Object>} - Les données de réponse.
-   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
-   * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
-   * @throws {Error} - En cas d'erreur inattendue.
-   */
-  async updateDescription(data = {}) {
-    data.typeElement = this.getEntityType();
-    data.id = this.id;
-    return this.callIsConnected(() => this.endpointApi.updateBlockDescription(data));
-  }
-    
-  /**
-     * Mettre à jour les informations d'un élément : Permet de mettre à jour les informations générales d'un élément (nom, contacts, etc.).
-     * Constant : UPDATE_BLOCK_INFO
-     */
-  async updateInfo(data = {}) {
-    data.typeElement = this.getEntityType();
-    data.id = this.id;
-    return this.callIsConnected(() => this.endpointApi.updateBlockInfo(data));
-  }
-    
-  /**
-   * Mettre à jour les réseaux sociaux d'un élément : Permet de mettre à jour les liens vers les réseaux sociaux d'un élément.
-   * Constant : UPDATE_BLOCK_SOCIAL
-   */
-  async updateSocial(data = {}) {
-    data.typeElement = this.getEntityType();
-    data.id = this.id;
-    return this.callIsConnected(() => this.endpointApi.updateBlockSocial(data));
-  }
-    
-  /**
-   * Mettre à jour les localités d'un élément : Permet de mettre à jour l'adresse et les informations géographiques d'un élément.
-   * Constant : UPDATE_BLOCK_LOCALITY
-   */
-  async updateLocality(data = {}) {
-    data.typeElement = this.getEntityType();
-    data.id = this.id;
-    return this.callIsConnected(() => this.endpointApi.updateBlockLocality(data));
-  }
-    
-  /**
-   * Mettre à jour le slug d'un élément : Permet de mettre à jour le slug pour une URL simplifiée.
-   * Constant : UPDATE_BLOCK_SLUG
-   * @param {Object} data - Les données à envoyer.
-   * @param {string} data.slug - Le nouveau slug à appliquer.
-   * @returns {Promise<Object>} - Les données de réponse.
-   */
-  async updateSlug({ slug }) {
-    try {
-      await this.endpointApi.check({ type: this.getEntityType(), id: this.id, slug });
-    } catch (error) {
-      if(error instanceof ApiResponseError) {
-        throw new ApiResponseError("Erreur lors de la vérification du slug.", error.status, error.data);
-      }
-      throw error;
-    }
-    return this.callIsConnected(() => this.endpointApi.updateBlockSlug({ typeElement: this.getEntityType(), id: this.id, slug }));
-  }
-    
-  /**
-   * Mettre à jour l'image de profil : Permet de mettre à jour l'image de profil d'un utilisateur ou d'une entité.
-   * Constant : PROFIL_IMAGE
-   * @param {Object} data - Les données à envoyer.
-   * @param {string} data.profil_avatar - L'image de profil à mettre à jour.
-   * @returns {Promise<Object>} - Les données de réponse.
-   */
-  async updateImageProfil({ profil_avatar: image  }) {
-    image = await this._validateImage(image);
-    const data = { pathParams: { folder: this.getEntityType(), ownerId: this.id },  profil_avatar: image };
-    return this.callIsConnected(() => this.endpointApi.profilImage(data));
-  }
-
-  /**
-   * Crée une instance d'organisation et récupère son profil si nécessaire.
-   *
-   * @param {Object} organizationData - Les données nécessaires pour initialiser l'organisation.
-   * @returns {Promise<Organization>} Une promesse qui résout l'objet Organisation créé.
-   * @throws {Error} Si une erreur se produit lors de la création de l'organisation.
-   */
-  async organization(organizationData = {}) {
-    if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer une organisation.");
-    }
-    return this.entity("organizations", organizationData);
-  }
-
-  /**
-   * Crée une instance de projet et récupère son profil si nécessaire.
-   *
-   * @param {Object} projectData - Les données nécessaires pour initialiser le projet.
-   * @returns {Promise<Project>} Une promesse qui résout l'objet Projet créé.
-   * @throws {Error} Si une erreur se produit lors de la création du projet.
-   */
-  async project(projectData = {}) {
-    // TODO: Vérifier si l'utilisateur est admin de l'organisation
-    if(!this.isConnected){
-      throw new ApiError("Vous devez être connecté pour créer un projet.");
-    }
-    return this.entity("projects", projectData);
-  }
-
-  /**
-   * Crée une instance de POI et la récupère si nécessaire.
-   * 
-   * @param {Object} poiData - Les données nécessaires pour initialiser le POI.
-   * @returns {Promise<Poi>} Une promesse qui résout l'objet POI créé.
-   * @throws {Error} Si une erreur se produit lors de la création du POI.
-   */
-  async poi(poiData = {}) {
-    // TODO: Vérifier si l'utilisateur est admin de l'organisation
-    if(!this.isConnected){
-      throw new ApiError("Vous devez être connecté pour créer un POI.");
-    }
-    return this.entity("poi", poiData);
-  }
-
-  /**
-   * Crée une instance d'événement et la récupère si nécessaire.
-   * 
-   * @param {Object} eventData - Les données nécessaires pour initialiser l'événement.
-   * @returns {Promise<Event>} Une promesse qui résout l'objet Événement créé.
-   * @throws {Error} Si une erreur se produit lors de la création de l'événement.
-   */
-  async event(eventData = {}) {
-    // TODO: Vérifier si l'utilisateur est admin de l'organisation
-    if(!this.isConnected){
-      throw new ApiError("Vous devez être connecté pour créer un événement.");
-    }
-    return this.entity("events", eventData);
-  }
-
-  /**
-   * Crée une instance de badge et la récupère si nécessaire.
-   * 
-   * @param {Object} badgeData - Les données nécessaires pour initialiser le badge.
-   * @returns {Promise<Badge>} Une promesse qui résout l'objet Badge créé.
-   * @throws {Error} Si une erreur se produit lors de la création du badge.
-   */
-  async badge(badgeData = {}) {
-    // TODO: Vérifier si l'utilisateur est admin de l'organisation
-    if(!this.isConnected){
-      throw new ApiError("Vous devez être connecté pour créer un badge.");
-    }
-    return this.entity("badges", badgeData);
-  }
-
-  /**
-   * Crée une instance de news et la récupère si nécessaire.
-   * 
-   * @param {Object} newsData - Les données nécessaires pour initialiser la news.
-   * @returns {Promise<News>} Une promesse qui résout l'objet News créé.
-   * @throws {Error} Si une erreur se produit lors de la création de la news.
-   */
-  async news(newsData = {}) {
-    if(!this.isConnected){
-      throw new ApiError("Vous devez être connecté.");
-    }
-    return this.entity("news", newsData);
-  }
-
-  /**
-   * Récupérer les organisations d'une entitée : la liste des organisations dont l'entité est membre ou admin valide.
-   * Constant : GET_ORGANIZATIONS_ADMIN | GET_ORGANIZATIONS_NO_ADMIN
-   * @param {Object} data - Les données à envoyer.
-   * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
-   * @returns {Promise<Object>} - Les données de réponse.
-   */
-  async getOrganizations(data = {}) {
-    data.searchType = this._getDefaultFromEndpoint("GET_ORGANIZATIONS_NO_ADMIN", "searchType");
-    // data.searchBy = "ALL";
-
-    const paginator = this._createPaginatorEngine({
-      initialData: data,
-      finalizer: async (finalData) => {
-        if(this.isMe){
-          finalData.pathParams = { type: this.getEntityType(), id: this.id };
-        // NOTE : dans le schema je crois que si pas de finalData.filters alors le default ce fait avec finalData.pathParams
-        // finalData.filters = {
-        //   [`links.members.${this.id}`]: { "$exists": true },
-        //   [`links.members.${this.id}.toBeValidated`]: { "$exists": false },
-        //   [`links.members.${this.id}.isInviting`]: { "$exists": false }
-        // };
-        } else {
-          delete finalData?.pathParams;
-          finalData.filters = {
-            [`links.members.${this.id}`]: { "$exists": true },
-            [`links.members.${this.id}.toBeValidated`]: { "$exists": false },
-            [`links.members.${this.id}.isInviting`]: { "$exists": false }
-          };
-        }
-  
-        const fetchFn = this.isMe
-          ? () => this.callIsMe(() => this.endpointApi.getOrganizationsAdmin(finalData))
-          : () => this.endpointApi.getOrganizationsNoAdmin(finalData);
-
-        return fetchFn();
-      }
-    });
-
-    return paginator.next();
-  }
-
-  /**
-   * Récupérer les projets d'une entitée : liste des projets de l'entité ou elle est "parent" ou "contributeur".
-   * Constant : GET_PROJECTS_ADMIN | GET_PROJECTS_NO_ADMIN
-   * @param {Object} data - Les données à envoyer.
-   * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
-   * @returns {Promise<Object>} - Les données de réponse.
-   */
-  async getProjects(data = {}) {
-    data.searchType = this._getDefaultFromEndpoint("GET_PROJECTS_ADMIN", "searchType");
-    // data.searchBy = "ALL";
-
-    const paginator = this._createPaginatorEngine({
-      initialData: data,
-      finalizer: async (finalData) => {
-        if(this.isMe){
-          finalData.pathParams = { type: this.getEntityType(), id: this.id };
-          // NOTE : dans le schema je crois que si pas de finalData.filters alors le default ce fait avec finalData.pathParams
-          // finalData.filters = {
-          //   "$or": {
-          //     [`links.contributors.${this.id}`]: { "$exists": true },
-          //     [`parent.${this.id}`]: { "$exists": true }
-          //   },
-          //   [`links.contributors.${this.id}`]: { "$exists": true }
-          // };
-        } else {
-          delete finalData?.pathParams;
-          finalData.filters = {
-            "$or": {
-              [`links.contributors.${this.id}`]: { "$exists": true },
-              [`parent.${this.id}`]: { "$exists": true }
-            },
-            [`links.contributors.${this.id}`]: { "$exists": true }
-          };
-        }
-    
-        const fetchFn = this.isMe
-          ? () => this.callIsMe(() => this.endpointApi.getProjectsAdmin(finalData))
-          : () => this.endpointApi.getProjectsNoAdmin(finalData);
-
-        return fetchFn();
-      }
-    });
-
-    return paginator.next();
-  }
-
-  /**
-   * Récupérer les POIs d'une entité : liste des POIs de l'entité ou elle est "parent".
-   * Constant : GET_POIS_NO_ADMIN / GET_POIS_ADMIN
-   * @param {Object} data - Les données à envoyer.
-   * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
-   * @returns {Promise<Object>} - Les données de réponse.
-   */
-  async getPois(data = {}) {
-    data.searchType = this._getDefaultFromEndpoint("GET_POIS_ADMIN", "searchType");
-    // data.searchBy = "ALL";
-
-    const paginator = this._createPaginatorEngine({
-      initialData: data,
-      finalizer: async (finalData) => {
-        if(this.isMe){
-          finalData.pathParams = { type: this.getEntityType(), id: this.id };
-          // NOTE : dans le schema je crois que si pas de finalData.filters alors le default ce fait avec finalData.pathParams
-          // finalData.filters = {
-          //   [`parent.${this.id}`]: { "$exists": true },
-          // };
-        } else {
-          delete finalData?.pathParams;
-          finalData.filters = {
-            [`parent.${this.id}`]: { "$exists": true },
-          };
-        }
-  
-        const fetchFn = this.isMe
-          ? () => this.callIsMe(() => this.endpointApi.getPoisAdmin(finalData))
-          : () => this.endpointApi.getPoisNoAdmin(finalData);
-
-        return fetchFn();
-      }
-    });
-
-    return paginator.next();
-  }
-
-  /**
-   * Récupérer les abonnés d'une entité
-   * Constant : GET_SUBSCRIBERS
-   * @param {Object} data - Les données à envoyer.
-   * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
-   * @returns {Promise<Object>} - Les données de réponse.
-   */
-  async getSubscribers(data = {}) {
-    data.searchType = this._getDefaultFromEndpoint("GET_SUBSCRIBERS", "searchType");
-    // data.searchBy = "ALL";
-
-    const paginator = this._createPaginatorEngine({
-      initialData: data,
-      finalizer: async (finalData) => {
-        delete finalData?.pathParams;
-
-        finalData.filters =  {
-          [`links.follows.${this.id}`]: { "$exists": true },
-          [`links.follows.${this.id}.toBeValidated`]: { "$exists": false },
-          [`links.follows.${this.id}.isInviting`]: { "$exists": false }
-        };
-
-        return this.endpointApi.getSubscribers(finalData);
-      }
-    });
-
-    return paginator.next();
-  }
-
-  /**
-   * Liste des badges créés par l'entité
-   * Constant : GET_BADGES
-   * @param {Object} data - Les données à envoyer.
-   * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
-   * @returns {Promise<Object>} - Les données de réponse. 
-   */
-  async getBadgesIssuer(data = {}) {
-    data.searchType = this._getDefaultFromEndpoint("GET_BADGES", "searchType");
-    // data.searchBy = "ALL";
-
-    const paginator = this._createPaginatorEngine({
-      initialData: data,
-      finalizer: async (finalData) => {
-        delete finalData?.pathParams;
-  
-        finalData.filters = finalData.filters || {};
-        finalData.filters["$or"] = {};
-        finalData.filters["$or"][`issuer.${this.id}`] = { "$exists": true };
-
-        return this.endpointApi.getBadges(finalData);
-      }
-    });
-
-    return paginator.next();
-  }
-
-  /**
-   * Récupérer les actualités : Récupère la liste d’actualités selon plusieurs critères.
-   * Constant : GET_NEWS
-   * @param {Object} data - Les données à envoyer.
-   * @param {number} data.dateLimit - Limite de date timestamp ou 0 (default: 0)
-   * @param {object} data.search - data.search
-   * @param {string} data.search.name - Nom ou terme recherché (default: "")
-   * @param {number} data.indexStep - Nombre de résultats par page (default: 12)
-   * @returns {Promise<Object>} - Les données de réponse.
-   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
-   * @throws {Error} - En cas d'erreur inattendue.
-   */
-  async getNews(data = {}) {
-    data.pathParams = { type: this.getEntityType(), id: this.id };
-    const arrayObjet =  await this.endpointApi.getNews(data);
-    if(!Array.isArray(arrayObjet)){
-      throw new ApiResponseError("Erreur lors de la récupération des actualités.", 500, arrayObjet);
-    }
-
-    const rawList = this._linkEntities(arrayObjet);
-
-    return this._createFilteredProxy(rawList);
-  }
-
-  /**
-   * Récupérer la galerie d'une entité.
-   * Constant : GET_GALLERY
-   * @param {Object} data - Les données à envoyer.
-   * @param {string} data.pathParams.docType - Type de document (default: "image")
-   * @param {string} data.contentKey - Clé de contenu pour la galerie (default: "null")
-   * @param {string} data.folderId - ID du dossier pour la galerie (default: "null")
-   * @returns {Promise<Object>} - Les données de réponse.
-   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
-   * @throws {Error} - En cas d'erreur inattendue.
-   */
-  async getGallery(data = {}) {
-    data.pathParams = { type: this.getEntityType(), id: this.id, docType: data.pathParams?.docType || "image" };
-    const arrayObjet =  await this.endpointApi.getGallery(data);
-
-    return arrayObjet;
-  }
-
-  /**
-   * Soumet une demande pour rejoindre l'entité courante (ex. organisation, projet, événement...).
-   * Si une invitation est en attente, elle est automatiquement acceptée.
-   *
-   * @returns {Promise<Object>} - Résultat de la demande ou de la validation.
-   * @throws {ApiError} - Si l'entité ne supporte pas l'action ou si une demande est déjà en cours.
-   */
-  async requestToJoin(){
-    if (!this.isMe) {
-      throw new ApiError("Vous devez être connecté pour envoyer une demande de participation.");
-    }
-    this._checkLinkableEntity();
-    return this._submitLinkRequest();
-  }
-
-  /**
-   * Soumet une demande pour devenir administrateur de l'entité courante.
-   * Si une invitation est en attente, elle est automatiquement validée.
-   *
-   * @returns {Promise<Object>} - Résultat de la demande ou de la validation.
-   * @throws {ApiError} - Si l'entité ne supporte pas l'action ou si une demande est déjà en cours.
-   */
-  async requestToJoinAdmin(){
-    if (!this.isMe) {
-      throw new ApiError("Vous devez être connecté pour envoyer une demande de participation.");
-    }
-    this._checkLinkableEntity();
-    return this._submitLinkRequestAdmin();
-  }
-
-  /**
-   * Accepte une invitation à rejoindre l'entité courante.
-   * Ne fonctionne que si un lien avec `isInviting` est détecté.
-   *
-   * @returns {Promise<Object>} - Résultat de l'acceptation de l'invitation.
-   * @throws {ApiError} - Si aucune invitation n'est en attente ou si l'entité ne supporte pas cette action.
-   */
-  async acceptInvitation(){
-    if (!this.isMe) {
-      throw new ApiError("Vous devez être connecté pour envoyer une demande de participation.");
-    }
-    this._checkLinkableEntity();
-    return this._acceptLinkRequest();
-  }
-
-  /**
-   * Se désengage de l'entité courante : quitte un rôle (membre, contributeur, etc.).
-   *
-   * @returns {Promise<Object>} - Résultat de la déconnexion.
-   * @throws {ApiError} - Si l'entité ne supporte pas l'action ou si l'utilisateur n'est pas lié à cette entité.
-   */
-  async leave() {
-    if (!this.isMe) {
-      throw new ApiError("Vous devez être connecté pour envoyer une demande de participation.");
-    }
-    this._checkLinkableEntity();
-    return this._leaveLinkRequest();
-  }
-
-  /**
-   * S'abonne à l'entité courante.
-   * 
-   * @returns {Promise<Object>} - Résultat de l'abonnement.
-   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité n'est pas enregistrée.
-   */
-  async follow() {
-    if (!this.isMe) {
-      throw new ApiError("Vous devez être connecté pour suivre cette entité.");
-    }
-
-    if (!this.id) {
-      throw new ApiError(`${this.constructor.name} non enregistrée.`);
-    }
-
-    const userLink = this.userContext?.serverData?.links?.["follows"]?.[this.id] || null;
-
-    if (!userLink) {
-      const data = {
-        parentType: this.getEntityType(),
-        parentId: this.id
-      };
-      const retour = await this.callIsMe(() => this.endpointApi.follow(data));
-      // TODO : reflechir au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
-      await this.userContext.refresh();
-      return retour;
-    }
-
-    throw new ApiError("Vous êtes déjà abonné à cette entité.");
-  }
-
-  /**
-   * Se désabonne de l'entité courante.
-   * 
-   * @returns {Promise<Object>} - Résultat de la désinscription.
-   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité n'est pas enregistrée.
-   */
-  async unfollow() {
-    if (!this.isMe) {
-      throw new ApiError("Vous devez être connecté pour vous désabonner.");
-    }
-
-    if (!this.id) {
-      throw new ApiError(`${this.constructor.name} non enregistrée.`);
-    }
-
-    const userLink = this.userContext?.serverData?.links?.["follows"]?.[this.id] || null;
-
-    if (userLink) {
-      const data = {
-        parentType: this.getEntityType(),
-        parentId: this.id,
-        connectType: "followers"
-      };
-      const retour = await this.callIsMe(() => this.endpointApi.disconnect(data));
-      // TODO : reflechir au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
-      await this.userContext.refresh();
-      return retour;
-    }
-
-    throw new ApiError("Vous n'êtes pas abonné à cette entité.");
-  }
-  
-
-  /**
-   * Vérifie si l'utilisateur est connecté et a accès à l'entité.
-   * 
-   * @param {string} action - Action à effectuer.
-   * @returns {void}
-   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité n'est pas enregistrée.
-   * @private
-   */
-  _checkAccess(action = "effectuer cette action") {
-    if (!this.isMe) {
-      throw new ApiError(`Vous devez être connecté pour ${action}`);
-    }
-    if (!this.id) {
-      throw new ApiError(`${this.constructor.name} non enregistrée.`);
-    }
-  }
-
-  /**
-   * Vérifie si l'utilisateur a un lien valide avec l'entité.
-   * 
-   * @param {Object} userLink - Lien de l'utilisateur avec l'entité.
-   * @param {boolean} userLink.toBeValidated - Indique si le lien est en attente de validation.
-   * @param {boolean} userLink.isInviting - Indique si l'utilisateur a été invité.
-   * @returns {boolean} - `true` si le lien est valide, `false` sinon.
-   * @private
-   */
-  _validateUserLink(userLink) {
-    if (!userLink) return false;
-    const { toBeValidated, isInviting } = userLink;
-    return !toBeValidated && !isInviting;
-  }
-
-  /**
-   * Vérifie si l'entité est d'un type spécifique.
-   * 
-   * @param {...string} types - Types d'entité attendus.
-   * @throws {ApiError} - Si l'entité n'est pas du type attendu.
-   * @private
-   */
-  _assertEntityType(...types) {
-    const expectedTypes = Array.isArray(types[0]) ? types[0] : types;
-    if (!expectedTypes.includes(this.getEntityType())) {
-      throw new ApiError(`L'entité doit être de type : ${expectedTypes.join(", ")}, reçu : ${this.getEntityType()}`);
-    }
-  }
-
-  /**
-   * Vérifie si l'entité est liée à un type de lien spécifique.
-   * 
-   * @param {string} linkType - Type de lien à vérifier.
-   * @returns {boolean} - `true` si l'entité est liée, `false` sinon.
-   * @private
-   */
-  _isLinked(linkType) {
-    return !!this.userContext?.serverData?.links?.[linkType]?.[this.id];
-  }
-
-  /**
-   * Vérifie si l'utilisateur est l'auteur de l'entité.
-   * 
-   * @returns {boolean} - `true` si l'utilisateur est l'auteur, `false` sinon.
-   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si les données du serveur ne sont pas disponibles.
-   */
-  isAuthor() {
-    this._checkAccess("vérifier l'auteur");
-    if (!this.serverData) {
-      throw new ApiError("Aucune donnée serveur disponible.");
-    }
-    return this.userId && this.serverData?.creator === this.userId;
-  }
-
-  /**
-   * Vérifie si l'utilisateur est administrateur de l'entité.
-   * 
-   * @returns {boolean} - `true` si l'utilisateur est administrateur, `false` sinon.
-   * @throws {ApiError}
-   */
-  isAdmin() {
-    this._checkAccess("vérifier l'administrateur.");
-    this._assertEntityType("organizations", "projects", "events");
-    const userLink = this._getLinkFromConnectedUser();
-    return this._validateUserLink(userLink) && userLink?.isAdmin === true && !userLink?.isAdminPending;
-  }
-
-  /**
-   * Vérifie si l'utilisateur est soit l'auteur, soit administrateur de l'entité.
-   * 
-   * @returns {boolean} - `true` si l'utilisateur est l'auteur ou administrateur, `false` sinon.
-   * @throws {ApiError}
-   */
-  isAuthorOrAdmin() {
-    this._checkAccess("vérifier l'auteur ou l'administrateur.");
-    return this.isAuthor() || this.isAdmin();
-  }
-
-  /**
-   * Vérifie si l'utilisateur est membre de l'entité.
-   * 
-   * @returns {boolean} - `true` si l'utilisateur est membre, `false` sinon.
-   * @throws {ApiError}
-   */
-  isMember() {
-    this._checkAccess("vérifier le membre.");
-    this._assertEntityType("organizations");
-    const userLink = this._getLinkFromConnectedUser();
-    return this._validateUserLink(userLink);
-  }
-
-  /**
-   * Vérifie si l'utilisateur est contributeur de l'entité.
-   * 
-   * @returns {boolean} - `true` si l'utilisateur est contributeur, `false` sinon.
-   * @throws {ApiError}
-   */
-  isContributor() {
-    this._checkAccess("vérifier le contributeur.");
-    this._assertEntityType("projects");
-    const userLink = this._getLinkFromConnectedUser();
-    return this._validateUserLink(userLink);
-  }
-
-  /**
-   * Vérifie si l'utilisateur est participant de l'entité.
-   * 
-   * @returns {boolean} - `true` si l'utilisateur est participant, `false` sinon.
-   * @throws {ApiError}
-   */
-  isAttendee() {
-    this._checkAccess("vérifier si vous êtes un participant.");
-    this._assertEntityType("events");
-    const userLink = this._getLinkFromConnectedUser();
-    return this._validateUserLink(userLink);
-  }
-
-  /**
-   * Vérifie si l'utilisateur suit l'entité.
-   * 
-   * @returns {boolean} - `true` si l'utilisateur suit l'entité, `false` sinon.
-   * @throws {ApiError}
-   */
-  isFollower() {
-    this._checkAccess("vérifier si il vous suit.");
-    this._assertEntityType("citoyens","organizations", "projects", "events", "poi");
-    return this._isLinked("followers");
-  }
-
-  /**
-   * Vérifie si l'utilisateur est abonné à l'entité.
-   * 
-   * @returns {boolean} - `true` si l'utilisateur est abonné, `false` sinon.
-   * @throws {ApiError}
-   */
-  isFollowing() {
-    this._checkAccess("vérifier si vous le suivez.");
-    this._assertEntityType("citoyens","organizations", "projects", "events", "poi");
-    return this._isLinked("follows");
-  }
-
-  /**
-   * Récupère le JSON personnalisé de l'entité
-   * 
-   * @returns {Promise<Object>} - Le JSON personnalisé de l'entité.
-   * @throws {ApiError} - Si le slug de l'entité n'est pas défini.
-   */
-  async getCostumJson() {
-    if (!this.serverData.slug) {
-      throw new ApiError("slug de l'entité non défini");
-    }
-    const data = {
-      pathParams: {
-        slug: this.serverData.slug
-      }
-    };
-    return this.endpointApi.getCostumJson(data);
-  }
-
-  /**
-   * Génère des plages d'index pour la pagination.
-   * 
-   * @param {Array<string>} searchType - Types de recherche.
-   * @param {number} indexStep - Pas d'index.
-   * @param {Object} previousRanges - Plages précédentes.
-   * @returns {Object} - Plages d'index générées.
-   * @private
-   */
-  _generateRanges(searchType, indexStep, previousRanges = {}) {
-    const ranges = {};
-    for (const type of searchType) {
-      const previous = previousRanges[type] || { indexMax: 0 };
-      ranges[type] = {
-        indexMin: previous.indexMax || 0,
-        indexMax: previous.indexMax + indexStep
-      };
-    }
-    return ranges;
-  }
-
-  /**
-   * Normalise le compte des résultats.
-   * 
-   * @param {Object} count - Compte des résultats.
-   * @returns {Object} - Compte normalisé.
-   * @private
-   */
-  _normalizeCount(count = {}) {
-    // suppression des indésirables
-    delete count.spam;
-
-    // calcul du total (somme des valeurs numériques)
-    count.total = Object.values(count).reduce((acc, val) => acc + (typeof val === "number" ? val : 0), 0);
-
-    return count;
-  }
-
-  /**
-   * Récupère une valeur par défaut depuis un endpoint donné.
-   *
-   * @param {string} constant - Le nom unique de l’endpoint (ex: "GET_ORGANIZATIONS_NO_ADMIN")
-   * @param {string} path - Le chemin vers la propriété (ex: "searchType")
-   * @returns {*} La valeur par défaut, ou undefined si non trouvée
-   */
-  _getDefaultFromEndpoint(constant, path) {
-    const endpoint = this.apiClient._endpoints.find((ep) => ep.constant === constant);
-    if (!endpoint?.request?.properties?.[path]) return undefined;
-    return endpoint.request.properties[path].default;
-  }
-
-  /**
-   * Coeur de pagination stateless et réutilisable, sans logique métier.
-   *
-   * @param {Object} config
-   * @param {Object} config.initialData - Paramètres de départ
-   * @param {Function} config.finalizer - Fonction async qui retourne { results, count }
-   *
-   * @returns {Object} paginator avec .next() et .prev()
-   */
-  _createPaginatorEngine({ initialData, finalizer }) {
-    const Entity = this;
-
-    const state = {
-      cursor: undefined,
-      count: 0,
-      index: 0,
-      history: [],
-      sizes: []
-    };
-
-    const hasStep = (d) => d?.indexStep && d.indexStep > 0;
-
-    async function getPage(isNext = false) {
-      let data = { ...initialData };
-
-      if (!state.cursor || (!isNext && state.history.length === 0)) {
-        state.count = 0;
-        state.index = 0;
-        state.history = [];
-        state.sizes = [];
-
-        data.countType = data.searchType;
-
-        if (!data?.searchBy && hasStep(data)) {
-          data.ranges = Entity._generateRanges(data.searchType, data.indexStep);
-          data.indexMin = data.indexMin ?? 0;
-          data.indexMax = data.indexMax ?? data.indexStep;
-        } else if (data?.searchBy === "ALL" && hasStep(data)) {
-          data.indexMin = data.indexMin ?? 0;
-          data.indexMax = data.indexMax ?? data.indexStep;
-        }
-
-        state.cursor = { ...data };
-      }
-
-      const cursor = state.cursor;
-
-      if (isNext) {
-        state.history.push({ ...cursor });
-
-        if (!cursor.searchBy && hasStep(cursor)) {
-          cursor.ranges = Entity._generateRanges(cursor.searchType, cursor.indexStep, cursor.ranges);
-          cursor.indexMin = cursor.indexMax ?? 0;
-          cursor.indexMax = (cursor.indexMax ?? 0) + cursor.indexStep;
-        } else if (cursor.searchBy === "ALL" && hasStep(cursor)) {
-          cursor.indexMin = cursor.indexMax ?? 0;
-          cursor.indexMax = (cursor.indexMax ?? 0) + cursor.indexStep;
-        }
-
-        state.cursor = { ...cursor };
-      }
-
-      data = { ...state.cursor };
-
-      if (!isNext && (!data?.searchType || !Array.isArray(data.searchType) || data.searchType.length === 0)) {
-        throw new Error("searchType non défini");
-      }
-
-      const result = await finalizer(data);
-      if (!Array.isArray(result.results)) {
-        throw new Error("Les résultats doivent être un tableau");
-      }
-
-      state.count += result.results.length;
-      state.sizes.push(result.results.length);
-      if (isNext) state.index++;
-
-      const count = Entity._normalizeCount(result.count);
-      const rawList = Entity._linkEntities(result.results);
-
-      const hasNext = hasStep(data) && state.count < count.total;
-      const hasPrev = state.history.length > 0;
-
-      return {
-        count,
-        results: rawList,
-        pageIndex: state.index,
-        pageNumber: state.index + 1,
-        hasNext,
-        hasPrev,
-        next: hasNext ? () => getPage(true) : undefined,
-        prev: hasPrev
-          ? async () => {
-            const previous = state.history.pop();
-            const lastPageSize = state.sizes.pop() ?? 0;
-            state.count -= lastPageSize;
-            state.index = Math.max(0, state.index - 1);
-            state.cursor = { ...previous };
-            return getPage(false);
-          }
-          : undefined
-      };
-    }
-
-    return {
-      next: () => getPage(false)
-    };
-  }
-
-  /**
- * Injection de contexte Communecter dans une requête finalizer.
- *
- * @param {Function} baseFinalizer - fonction async(data) => { results, count }
- * @returns {Function} fonction enrichie
- */
-  _withCostumContext(baseFinalizer) {
-    return async (data) => {
-      const finalData = {
-        ...data,
-        costumSlug: this.serverData.slug,
-        contextId: this.serverData.id,
-        contextType: this.getEntityType(),
-        sourceKey: [...(data.sourceKey || []), this.serverData.slug]
-      };
-      return baseFinalizer(finalData);
-    };
-  }
-
-  /**
-   * ───────────────────────────────
-   *  custom
-   * ───────────────────────────────
-   */
-
-  /**
-   * Recherche liée à l'entité, version stateless.
-   *
-   * @param {Object} data - Données initiales de recherche.
-   * @returns {Object} - Un paginateur avec .next(), .prev(), etc.
-   */
-  async searchCostum(data = {}) {
-
-    const paginator = this._createPaginatorEngine({
-      initialData: data,
-      finalizer: this._withCostumContext((finalData) => this.endpointApi.globalAutocompleteCostum(finalData)),
-    });
-
-    return paginator.next();
-  }
-
-  async costumEventRequestActors(data = {}){
-
-    data = {
-      pathParams: {
-        id: this.id,
-        type: this.getEntityType()
-      },
-      ...data
-    };
-
-    const wrappedFinalizer = this._withCostumContext((finalData) => this.endpointApi.costumEventRequestActors(finalData));
-
-    const actors = await wrappedFinalizer(data);
-
-    // const transformedActors = actors
-    //   .filter(actor => {
-    //     const isValid = !!actor?.type;
-    //     if (!isValid) {
-    //       this.apiClient._logger?.warn?.(`Objet ignoré car sans 'type' : ${actor?.id}`);
-    //     }
-    //     return isValid;
-    //   })
-    //   .map(({ id, name, type, ...meta }) => ({
-    //     id,
-    //     name,
-    //     collection: type,
-    //     meta
-    //   }));
-
-    // const rawList = this._linkEntities(transformedActors);
-
-    return actors;
-  }
-
-  async costumEventRequestSubevents(data = {}){
-
-    data = {
-      pathParams: {
-        id: this.id,
-        type: this.getEntityType()
-      },
-      ...data
-    };
-
-    const wrappedFinalizer = this._withCostumContext((finalData) => this.endpointApi.costumEventRequestSubevents(finalData));
-
-    return wrappedFinalizer(data);
-  }
-
-  async costumEventRequestDates(data = {}){
-    data = {
-      pathParams: {
-        id: this.id,
-        type: this.getEntityType()
-      },
-      ...data
-    };
-
-    const wrappedFinalizer = this._withCostumContext((finalData) => this.endpointApi.costumEventRequestDates(finalData));
-
-    return wrappedFinalizer(data);
-  }
-
-  async costumEventRequestElementEvent(data = {}){
-    data = {
-      pathParams: {
-        id: this.id,
-        type: this.getEntityType()
-      },
-      ...data
-    };
-
-    const wrappedFinalizer = this._withCostumContext((finalData) => this.endpointApi.costumEventRequestElementEvent(finalData));
-
-    return wrappedFinalizer(data);
-  }
-
-  async costumEventRequestCategories(data = {}){
-    data = {
-      pathParams: {
-        id: this.id,
-        type: this.getEntityType()
-      },
-      ...data
-    };
-
-    const wrappedFinalizer = this._withCostumContext((finalData) => this.endpointApi.costumEventRequestCategories(finalData));
-
-    return wrappedFinalizer(data);
-  }
-
-  async costumEventRequestEvent(data = {}){
-    data = {
-      pathParams: {
-        id: this.id,
-        type: this.getEntityType()
-      },
-      ...data
-    };
-
-    const wrappedFinalizer = this._withCostumContext((finalData) => this.endpointApi.costumEventRequestEvent(finalData));
-
-    return wrappedFinalizer(data);
-  }
-
-  async costumEventRequestLinkTlToEvent(data = {}){
-    data = {
-      pathParams: {
-        id: this.id,
-        type: this.getEntityType()
-      },
-      ...data
-    };
-
-    const wrappedFinalizer = this._withCostumContext((finalData) => this.endpointApi.costumEventRequestLinkTlToEvent(finalData));
-
-    return wrappedFinalizer(data);
-  }
-
-  async costumEventRequestLoadContextTag(data = {}){
-    data = {
-      pathParams: {
-        id: this.id,
-        type: this.getEntityType()
-      },
-      ...data
-    };
-
-    const wrappedFinalizer = this._withCostumContext((finalData) => this.endpointApi.costumEventRequestLoadContextTag(finalData));
-
-    return wrappedFinalizer(data);
-  }
-
-
-}
-
-export default BaseEntity;