@communecter/cocolight-api-client 1.0.20 → 1.0.21

package/src/api/EndpointApi.js

@@ -1,11 +1,15 @@
 // Fichier généré automatiquement
-// eslint-disable-next-line no-unused-vars
-import { ApiAuthenticationError, ApiResponseError } from "../error.js";
+// @ts-check
+import { ApiAuthenticationError } from "../error.js";
 
+/**
+ * @typedef {import("../error.js").ApiResponseError} ApiResponseError
+ */
+
+/**
+ * Classe EndpointApi générée automatiquement depuis endpoints-copie.json
+ */
 class EndpointApi {
-  /**
-   * @param {Object} apiClient - Instance du client API.
-   */
   constructor(apiClient) {
     this.apiClient = apiClient;
   }
@@ -17,15 +21,7 @@ class EndpointApi {
   get userId() {
     return this.apiClient.userId;
   }
-  
-  /**
-   * Appelle l'endpoint identifié par la constante et vérifie la réponse.
-   *
-   * @param {string} constant - La constante identifiant l'endpoint.
-   * @param {Object} data - Les données à envoyer.
-   * @returns {Promise<Object>} - Les données de réponse.
-   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
-   */
+
   async call(constant, data = {}) {
     return this.apiClient.safeCall(async () => {
       const response = await this.apiClient.callEndpoint(constant, data);
@@ -33,32 +29,14 @@ class EndpointApi {
       return response.data;
     });
   }
-  
-  /**
-   * Appelle l'endpoint sans être connecté et vérifie la réponse.
-   *
-   * @param {string} constant - La constante identifiant l'endpoint.
-   * @param {Object} data - Les données à envoyer.
-   * @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.
-   */
+
   async callNoConnected(constant, data = {}) {
     if (this.isConnected) {
       throw new ApiAuthenticationError("Vous ne devez pas être connecté pour faire cette action.");
     }
     return this.call(constant, data);
   }
- 
-  /**
-   * Appelle l'endpoint si l'utilisateur est connecté et vérifie la réponse.
-   *
-   * @param {string} constant - La constante identifiant l'endpoint.
-   * @param {Object} data - Les données à envoyer.
-   * @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.
-   */
+
   async callIsConnected(constant, data = {}) {
     if (!this.isConnected) {
       throw new ApiAuthenticationError("Vous devez être connecté pour effectuer cette action.");
@@ -69,1758 +47,1299 @@ class EndpointApi {
   /**
    * Enregistrement d'un utilisateur : Permet d’enregistrer un nouvel utilisateur avec ses informations personnelles.
    * Constant : PERSON_REGISTER
-   * @param {object} data - data
-   * @param {string} data.name - Nom complet de l'utilisateur
-   * @param {string} data.username - Pseudo ou identifiant unique
-   * @param {string} data.email - Adresse email de l'utilisateur
-   * @param {string} data.pwd - Mot de passe
-   * @param {string} data.app - Nom de l'application
-   * @param {string} data.pendingUserId - ID d’un utilisateur en attente (facultatif)
-   * @param {string} data.mode - Mode d’enregistrement
-   * @param {boolean} data.isInvitation - Indique s’il s’agit d’une invitation (facultatif)
+   * @param {import("./EndpointApi.types").PersonRegisterData} data - Données envoyées à l'API
    * @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 personRegister(data = {}) {
+  async personRegister(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callNoConnected("PERSON_REGISTER", data);
   }
 
   /**
    * Authentification : Permet de se connecter en utilisant une adresse email et un mot de passe.
    * Constant : AUTHENTICATE_URL
-   * @param {object} data - data
-   * @param {string} data.email - Adresse email de l'utilisateur
-   * @param {string} data.password - Mot de passe de l'utilisateur
+   * @param {import("./EndpointApi.types").AuthenticateUrlData} data - Données envoyées à l'API
    * @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 authenticateUrl(data = {}) {
+  async authenticateUrl(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callNoConnected("AUTHENTICATE_URL", data);
   }
 
   /**
    * Rafraîchir un token : Permet de rafraîchir un token d'accès expiré en utilisant un token de rafraîchissement.
    * Constant : REFRESH_TOKEN_URL
-   * @param {object} data - Permet de rafraîchir un token d'accès expiré en utilisant un token de rafraîchissement.
-   * @param {string} data.refreshToken - Token de rafraîchissement
+   * @param {import("./EndpointApi.types").RefreshTokenUrlData} data - Données envoyées à l'API
    * @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 refreshTokenUrl(data = {}) {
+  async refreshTokenUrl(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("REFRESH_TOKEN_URL", data);
   }
 
   /**
    * Récupérer les informations utilisateur : Récupère les informations du profil utilisateur pour un token donné.
    * Constant : ME_INFO_URL
+   * @param {Object} [data] - Données envoyées à l'API (optionnel)
    * @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 meInfoUrl(data = {}) {
+  async meInfoUrl(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("ME_INFO_URL", data);
   }
 
   /**
    * Récupération de mot de passe : Envoie un email pour récupérer le mot de passe.
    * Constant : PASSWORD_RECOVERY
-   * @param {object} data - data
-   * @param {string} data.email - Adresse email de l'utilisateur
-   * @param {"password"} data.type - Type d'email envoyé (default: "password")
+   * @param {import("./EndpointApi.types").PasswordRecoveryData} data - Données envoyées à l'API
    * @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 passwordRecovery(data = {}) {
+  async passwordRecovery(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callNoConnected("PASSWORD_RECOVERY", data);
   }
 
   /**
    * Échange de token avec un autre serveur : Permet de se connecter à un autre serveur Communecter en échangeant un token.
    * Constant : SERVER_EXCHANGE_TOKEN
-   * @param {object} data - data
-   * @param {string} data.serverUrl - URL du serveur distant
+   * @param {import("./EndpointApi.types").ServerExchangeTokenData} data - Données envoyées à l'API
    * @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 serverExchangeToken(data = {}) {
+  async serverExchangeToken(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("SERVER_EXCHANGE_TOKEN", data);
   }
 
   /**
    * Changer le mot de passe : Permet de changer le mot de passe d'un utilisateur.
    * Constant : CHANGE_PASSWORD
-   * @param {object} data - data
-   * @param {"changePassword"} data.mode - Mode ou contexte du changement (default: "changePassword")
-   * @param {string} data.userId - Identifiant de l'utilisateur (default: "@userId")
-   * @param {string} data.oldPassword - Ancien mot de passe
-   * @param {string} data.newPassword - Nouveau mot de passe
-   * @param {string} data.newPassword2 - Confirmation du nouveau mot de passe
-   * @param {string} data.scope - Périmètre concerné (default: "")
+   * @param {import("./EndpointApi.types").ChangePasswordData} data - Données envoyées à l'API
    * @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 changePassword(data = {}) {
+  async changePassword(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("CHANGE_PASSWORD", data);
   }
 
   /**
    * Supprimer un compte : Permet de supprimer un compte utilisateur.
    * Constant : DELETE_ACCOUNT
-   * @param {object} data - data
-   * @param {string} data.reason - Raison de la suppression (default: "")
-   * @param {object} data.pathParams - data.pathParams
-   * @param {string} data.pathParams.id - Identifiant de l'utilisateur à supprimer (default: "@userId")
+   * @param {import("./EndpointApi.types").DeleteAccountData} data - Données envoyées à l'API
    * @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 deleteAccount(data = {}) {
+  async deleteAccount(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("DELETE_ACCOUNT", 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 - data
-   * @param {string} data.type - data.type
-   * @param {any} data.value - data.value
-   * @param {"citoyens" | "projects" | "organizations"} data.typeEntity - Type d'élément (citoyens, projects, organizations) (default: "citoyens")
-   * @param {string} data.idEntity - Id de l'élément
+   * @param {import("./EndpointApi.types").UpdateSettingsData} data - Données envoyées à l'API
    * @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 = {}) {
+  async updateSettings(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("UPDATE_SETTINGS", 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 - data
-   * @param {"descriptions"} data.block - Nom du bloc à mettre à jour (doit être 'descriptions') (default: "descriptions")
-   * @param {"citoyens" | "projects" | "organizations" | "poi"} data.typeElement - Type d'élément (citoyens, projects, organizations, poi) (default: "citoyens")
-   * @param {string} data.id - ID de l'élément concerné
-   * @param {string | null} data.scope - Périmètre de mise à jour (default: "")
-   * @param {string} data.descMentions - Mentions dans la description (default: "")
-   * @param {string} data.shortDescription - Courte description
-   * @param {string} data.description - Description complète
+   * @param {import("./EndpointApi.types").UpdateBlockDescriptionData} data - Données envoyées à l'API
    * @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 updateBlockDescription(data = {}) {
+  async updateBlockDescription(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("UPDATE_BLOCK_DESCRIPTION", 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
-   * @param {object} data - data
-   * @param {"info"} data.block - Nom du bloc à mettre à jour (doit être 'info') (default: "info")
-   * @param {"citoyens" | "projects" | "organizations" | "poi"} data.typeElement - Type d'élément (citoyens, projects, organizations, poi) (default: "citoyens")
-   * @param {string} data.id - ID de l'élément concerné
-   * @param {string} data.scope - Périmètre de mise à jour (default: "")
+   * @param {import("./EndpointApi.types").UpdateBlockInfoData} data - Données envoyées à l'API
    * @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 updateBlockInfo(data = {}) {
+  async updateBlockInfo(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("UPDATE_BLOCK_INFO", 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
-   * @param {object} data - data
-   * @param {"network"} data.block - Nom du bloc à mettre à jour (doit être 'network') (default: "network")
-   * @param {"citoyens" | "projects" | "organizations"} data.typeElement - Type d'élément (citoyens, projects, organizations) (default: "citoyens")
-   * @param {string} data.id - ID de l'élément concerné
-   * @param {string} data.scope - Périmètre de mise à jour (default: "")
-   * @param {string} data.gitlab - Compte Gitlab
-   * @param {string} data.github - Compte Github
-   * @param {string} data.twitter - Compte Twitter
-   * @param {string} data.facebook - Compte Facebook
-   * @param {string} data.instagram - Compte Instagram
-   * @param {string} data.diaspora - Compte Diaspora
-   * @param {string} data.mastodon - Compte Mastodon
-   * @param {string} data.telegram - Compte Telegram
-   * @param {string} data.signal - Compte Signal
+   * @param {import("./EndpointApi.types").UpdateBlockSocialData} data - Données envoyées à l'API
    * @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 updateBlockSocial(data = {}) {
+  async updateBlockSocial(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("UPDATE_BLOCK_SOCIAL", 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
-   * @param {object} data - data
-   * @param {"localities"} data.block - Nom du bloc à mettre à jour (doit être 'localities') (default: "localities")
-   * @param {"citoyens" | "projects" | "organizations" | "poi"} data.typeElement - Type d'élément (default: "citoyens")
-   * @param {string} data.id - ID de l'élément concerné
-   * @param {string} data.scope - Périmètre de mise à jour (default: "")
-   * @param {object} data.geo - Coordonnées géographiques
-   * @param {"GeoCoordinates"} data.geo.@type - data.geo.@type
-   * @param {string | number} data.geo.latitude - data.geo.latitude
-   * @param {string | number} data.geo.longitude - data.geo.longitude
-   * @param {object} data.geoPosition - Position géographique GeoJSON
-   * @param {"Point"} data.geoPosition.type - Type GeoJSON (doit être 'Point')
-   * @param {Array<number>} data.geoPosition.coordinates - Tableau contenant [longitude, latitude]
-   * @param {true} data.geoPosition.float - Indicateur pour forcer la conversion en float côté serveur (default: true)
-   * @param {object} data.address - data.address
-   * @param {"PostalAddress"} data.address.@type - data.address.@type
-   * @param {string} data.address.addressCountry - data.address.addressCountry
-   * @param {string} data.address.codeInsee - data.address.codeInsee
-   * @param {string} data.address.addressLocality - data.address.addressLocality
-   * @param {string} data.address.localityId - data.address.localityId
-   * @param {string} data.address.level1 - data.address.level1
-   * @param {string} data.address.level1Name - data.address.level1Name
-   * @param {string} data.address.level3 - ID du département. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.level3Name - Nom du département. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.level4 - ID de la commune. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.level4Name - Nom de la commune. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.postalCode - data.address.postalCode
-   * @param {string} data.address.streetAddress - data.address.streetAddress
+   * @param {import("./EndpointApi.types").UpdateBlockLocalityData} data - Données envoyées à l'API
    * @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 updateBlockLocality(data = {}) {
+  async updateBlockLocality(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("UPDATE_BLOCK_LOCALITY", 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 - data
-   * @param {"info"} data.block - Nom du bloc à mettre à jour (doit être 'info') (default: "info")
-   * @param {"citoyens" | "projects" | "organizations" | "poi"} data.typeElement - Type d'élément (citoyens, projects, organizations, poi) (default: "citoyens")
-   * @param {string} data.id - ID de l'élément concerné
-   * @param {string} data.scope - data.scope (default: "")
-   * @param {string} data.slug - Slug simplifié pour URL
+   * @param {import("./EndpointApi.types").UpdateBlockSlugData} data - Données envoyées à l'API
    * @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 updateBlockSlug(data = {}) {
+  async updateBlockSlug(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("UPDATE_BLOCK_SLUG", data);
   }
 
   /**
    * Vérifier l'état d'une URL : Vérifie si une URL (slug) est valide ou disponible.
    * Constant : CHECK
-   * @param {object} data - data
-   * @param {"info"} data.block - Nom du bloc (default: "info")
-   * @param {string} data.id - ID de l'élément
-   * @param {"citoyens" | "projects" | "organizations"} data.type - Type d'élément (default: "citoyens")
-   * @param {string} data.slug - Slug à vérifier
+   * @param {import("./EndpointApi.types").CheckData} data - Données envoyées à l'API
    * @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 check(data = {}) {
+  async check(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("CHECK", data);
   }
 
   /**
    * 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 - data
-   * @param {any} data.profil_avatar - Fichier image de profil au format binaire
-   * @param {object} data.pathParams - data.pathParams
-   * @param {"citoyens" | "projects" | "organizations" | "events" | "poi"} data.pathParams.folder - Type d'entité (default: "citoyens")
-   * @param {string} data.pathParams.ownerId - ID de l'utilisateur ou de l'entité
+   * @param {import("./EndpointApi.types").ProfilImageData} data - Données envoyées à l'API
    * @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 profilImage(data = {}) {
+  async profilImage(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("PROFIL_IMAGE", data);
   }
 
   /**
    * Obtenir les éléments liés : Récupère les informations détaillées d'un élément et de ses éléments liés.
    * Constant : GET_ELEMENTS_ABOUT
-   * @param {object} data - data
-   * @param {"ficheInfoElement"} data.tpl - Template utilisé (ex: ficheInfoElement) (default: "ficheInfoElement")
-   * @param {object} data.pathParams - data.pathParams
-   * @param {"citoyens" | "projects" | "organizations" | "events" | "poi" | "badges"} data.pathParams.type - Type d'entité (default: "citoyens")
-   * @param {string} data.pathParams.id - ID de l'utilisateur ou de l'entité
+   * @param {import("./EndpointApi.types").GetElementsAboutData} data - Données envoyées à l'API
    * @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 getElementsAbout(data = {}) {
+  async getElementsAbout(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GET_ELEMENTS_ABOUT", data);
   }
 
   /**
    * Gérer des connexions multiples : Permet d’inviter ou de connecter plusieurs utilisateurs en même temps à une entité.
    * Constant : MULTICONNECT
-   * @param {object} data - data
-   * @param {string} data.parentId - ID de l'entité parente
-   * @param {"citoyens" | "projects" | "organizations"} data.parentType - Type de l'entité parente (default: "citoyens")
-   * @param {object} data.listInvite - Liste des citoyens invités
-   * @param {Object.<string, object | any>} data.listInvite - Clés matching "^(citoyens|projects|organizations)$"
+   * @param {import("./EndpointApi.types").MulticonnectData} data - Données envoyées à l'API
    * @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 multiconnect(data = {}) {
+  async multiconnect(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("MULTICONNECT", data);
   }
 
   /**
    * Récupérer les actualités : Récupère la liste d’actualités selon plusieurs critères.
    * Constant : GET_NEWS
-   * @param {object} data - data
-   * @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)
-   * @param {object} data.pathParams - data.pathParams
-   * @param {boolean} data.pathParams.isLive - Indique si l'actualité est en direct (default: true)
-   * @param {"citoyens" | "projects" | "organizations"} data.pathParams.type - Type d'actualité (ex: 'citoyens', 'projects', 'organizations') (default: "citoyens")
-   * @param {string} data.pathParams.id - ID de l'élément (ex: ID d'un utilisateur, d'un projet ou d'une organisation)
+   * @param {import("./EndpointApi.types").GetNewsData} data - Données envoyées à l'API
    * @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 = {}) {
+  async getNews(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GET_NEWS", data);
   }
 
   /**
    * Récupérer des actualités par IDs : Récupère des actualités à partir d’une liste d’identifiants.
    * Constant : GET_NEWS_BY_ID
-   * @param {object} data - data
-   * @param {Array<string>} data.ids - Liste des IDs d’actualités à récupérer
+   * @param {import("./EndpointApi.types").GetNewsByIdData} data - Données envoyées à l'API
    * @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 getNewsById(data = {}) {
+  async getNewsById(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GET_NEWS_BY_ID", data);
   }
 
   /**
    * Ajouter une actualité : Ajoute une nouvelle actualité.
    * Constant : ADD_NEWS
-   * @param {object} data - data
-   * @param {string} data.text - Contenu de l’actualité
-   * @param {"public" | "private" | "restricted"} data.scope - Portée de l'actualité (ex: public, privé...) (default: "public")
-   * @param {boolean} data.markdownActive - Markdown activé (true/false) (default: true)
-   * @param {string} data.parentId - ID de l'entité parente
-   * @param {"citoyens" | "projects" | "organizations"} data.parentType - Type de l'entité parente (default: "citoyens")
-   * @param {"news"} data.type - Type de l'objet, toujours 'news'. (default: "news")
-   * @param {true} data.json - Indique que la réponse est au format JSON. (default: true)
-   * @param {array | string} data.tags - Tags : "" pour effacer tous les tags, ou tableau de mots-clés.
-   * @param {object} data.mediaImg - Optionnel. Informations sur les images associées à la news.
-   * @param {number} data.mediaImg.countImages - Nombre d'images.
-   * @param {Array<string>} data.mediaImg.images - Liste des identifiants ou chemins d'images.
-   * @param {object} data.mediaFile - Optionnel. Informations sur les fichiers associés à la news.
-   * @param {number} data.mediaFile.countFiles - Nombre de fichiers.
-   * @param {Array<string>} data.mediaFile.files - Liste des identifiants ou chemins de fichiers.
-   * @param {Array<object>} data.mentions - Optionnel. Liste des personnes mentionnées.
+   * @param {import("./EndpointApi.types").AddNewsData} data - Données envoyées à l'API
    * @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 addNews(data = {}) {
+  async addNews(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("ADD_NEWS", data);
   }
 
   /**
    * Ajouter une image à une actualité : Ajoute une images à une actualité.
    * Constant : ADD_IMAGE_NEWS
-   * @param {object} data - data
-   * @param {any} data.newsImage - Fichier image à télécharger
-   * @param {object} data.pathParams - data.pathParams
-   * @param {"citoyens" | "projects" | "organizations"} data.pathParams.folder - Type de l'entité parente (ex: 'citoyens', 'projects', 'organizations') (default: "citoyens")
-   * @param {string} data.pathParams.ownerId - ID de l'utilisateur ou de l'entité parente
+   * @param {import("./EndpointApi.types").AddImageNewsData} data - Données envoyées à l'API
    * @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 addImageNews(data = {}) {
+  async addImageNews(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("ADD_IMAGE_NEWS", data);
   }
 
   /**
    * Ajouter un fichier à une actualité : Ajoute un fichier à une actualité.
    * Constant : ADD_FILE_NEWS
-   * @param {object} data - data
-   * @param {any} data.newsFile - Fichier image à télécharger
-   * @param {object} data.pathParams - data.pathParams
-   * @param {"citoyens" | "projects" | "organizations"} data.pathParams.folder - Type de l'entité parente (ex: 'citoyens', 'projects', 'organizations') (default: "citoyens")
-   * @param {string} data.pathParams.ownerId - ID de l'utilisateur ou de l'entité parente
+   * @param {import("./EndpointApi.types").AddFileNewsData} data - Données envoyées à l'API
    * @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 addFileNews(data = {}) {
+  async addFileNews(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("ADD_FILE_NEWS", data);
   }
 
   /**
    * Supprimer une actualité : Supprime une actualité existante.
    * Constant : DELETE_NEWS
-   * @param {object} data - data
-   * @param {boolean} data.isLive - data.isLive (default: false)
-   * @param {object} data.pathParams - data.pathParams
-   * @param {string} data.pathParams.id - ID de l'actualité à supprimer
+   * @param {import("./EndpointApi.types").DeleteNewsData} data - Données envoyées à l'API
    * @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 deleteNews(data = {}) {
+  async deleteNews(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("DELETE_NEWS", data);
   }
 
   /**
    * Mettre à jour une actualité : Met à jour le contenu d’une actualité existante.
    * Constant : UPDATE_NEWS
-   * @param {object} data - data
-   * @param {string} data.idNews - ID de l'actualité à mettre à jour
-   * @param {string} data.text - Contenu de l’actualité
-   * @param {"public" | "private" | "restricted"} data.scope - Portée de l'actualité (ex: public, privé...) (default: "public")
-   * @param {boolean} data.markdownActive - Markdown activé (true/false) (default: true)
-   * @param {string} data.parentId - ID de l'entité parente
-   * @param {"citoyens" | "projects" | "organizations"} data.parentType - Type de l'entité parente (default: "citoyens")
-   * @param {"news"} data.type - Type de l'objet, toujours 'news'. (default: "news")
-   * @param {array | string} data.tags - Tags : "" pour effacer tous les tags, ou tableau de mots-clés.
-   * @param {object} data.mediaImg - Optionnel. Informations sur les images associées à la news.
-   * @param {number} data.mediaImg.countImages - Nombre d'images.
-   * @param {Array<string>} data.mediaImg.images - Liste des identifiants ou chemins d'images.
-   * @param {object} data.mediaFile - Optionnel. Informations sur les fichiers associés à la news.
-   * @param {number} data.mediaFile.countFiles - Nombre de fichiers.
-   * @param {Array<string>} data.mediaFile.files - Liste des identifiants ou chemins de fichiers.
-   * @param {Array<object>} data.mentions - Optionnel. Liste des personnes mentionnées.
+   * @param {import("./EndpointApi.types").UpdateNewsData} data - Données envoyées à l'API
    * @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 updateNews(data = {}) {
+  async updateNews(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("UPDATE_NEWS", data);
   }
 
   /**
    * Partager une actualité : Partage une actualité avec une entité ou un utilisateur.
    * Constant : SHARE_NEWS
-   * @param {object} data - data
-   * @param {string} data.parentId - ID de l'actualité à partager
-   * @param {"news"} data.parentType - Type de l'objet, toujours 'news'. (default: "news")
-   * @param {string} data.childId - ID de l'entité partageante
-   * @param {"citoyens" | "projects" | "organizations"} data.childType - Type de l'entité partageante (default: "citoyens")
-   * @param {"share"} data.connectType - Type de connexion, toujours 'share'. (default: "share")
-   * @param {string} data.comment - Commentaire de partage
+   * @param {import("./EndpointApi.types").ShareNewsData} data - Données envoyées à l'API
    * @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 shareNews(data = {}) {
+  async shareNews(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("SHARE_NEWS", data);
   }
 
   /**
    * Récupérer les commentaires : Récupère les commentaires d’un élément.
    * Constant : GET_COMMENTS
-   * @param {object} data.pathParams - data.pathParams
-   * @param {"news"} data.pathParams.type - Type de l'élément (default: "news")
-   * @param {string} data.pathParams.id - ID de l'élément dont on veut récupérer les commentaires
+   * @param {import("./EndpointApi.types").GetCommentsData} data - Données envoyées à l'API
    * @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 getComments(data = {}) {
+  async getComments(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GET_COMMENTS", data);
   }
 
   /**
    * Ajouter un commentaire : Ajoute un commentaire à une actualité ou autre contexte.
    * Constant : ADD_COMMENTS
-   * @param {object} data - data
-   * @param {string} data.parentCommentId - ID du commentaire parent (optionnel)
-   * @param {string} data.text - Contenu du commentaire
-   * @param {string} data.contextId - ID de l'élément auquel le commentaire est associé
-   * @param {"news"} data.contextType - Type de l'élément auquel le commentaire est associé (default: "news")
-   * @param {string} data.argval - Valeur de l'argument (optionnel) (default: "")
-   * @param {string} data.path - Chemin de l'élément (optionnel) (default: "")
-   * @param {Array<object>} data.mentions - data.mentions
+   * @param {import("./EndpointApi.types").AddCommentsData} data - Données envoyées à l'API
    * @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 addComments(data = {}) {
+  async addComments(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("ADD_COMMENTS", data);
   }
 
   /**
    * Supprimer un commentaire : Supprime un commentaire existant.
    * Constant : DELETE_COMMENTS
-   * @param {object} data.pathParams - data.pathParams
-   * @param {string} data.pathParams.id - ID du commentaire à supprimer
+   * @param {import("./EndpointApi.types").DeleteCommentsData} data - Données envoyées à l'API
    * @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 deleteComments(data = {}) {
+  async deleteComments(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("DELETE_COMMENTS", data);
   }
 
   /**
    * Mettre à jour un commentaire : Met à jour le contenu d’un commentaire.
    * Constant : UPDATE_COMMENTS
-   * @param {object} data - data
-   * @param {string} data.id - ID du commentaire à mettre à jour
-   * @param {object} data.params - data.params
-   * @param {string} data.params.text - Nouveau texte du commentaire
-   * @param {Array<object>} data.params.mentions - data.params.mentions
+   * @param {import("./EndpointApi.types").UpdateCommentsData} data - Données envoyées à l'API
    * @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 updateComments(data = {}) {
+  async updateComments(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("UPDATE_COMMENTS", data);
   }
 
   /**
    * Rechercher des tags : Recherche des tags correspondant à un mot-clé.
    * Constant : SEARCH_TAGS
-   * @param {object} data.pathParams - data.pathParams
-   * @param {string} data.pathParams.q - Mot-clé de recherche
+   * @param {import("./EndpointApi.types").SearchTagsData} data - Données envoyées à l'API
    * @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 searchTags(data = {}) {
+  async searchTags(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("SEARCH_TAGS", data);
   }
 
   /**
    * Afficher les votes d'une actualité : Récupère la liste des votes (like, love, etc.) sur une actualité.
    * Constant : SHOW_VOTE
-   * @param {object} data.pathParams - data.pathParams
-   * @param {"news"} data.pathParams.type - Type de l'élément (default: "news")
-   * @param {string} data.pathParams.id - ID de l'élément dont on veut récupérer les votes
+   * @param {import("./EndpointApi.types").ShowVoteData} data - Données envoyées à l'API
    * @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 showVote(data = {}) {
+  async showVote(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("SHOW_VOTE", data);
   }
 
   /**
    * Recherche globale avec autocomplétion : Effectue une recherche globale avec possibilité d’autocomplétion.
    * Constant : GLOBAL_AUTOCOMPLETE
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou mot-clé de la recherche
-   * @param {object} data.locality - Liste des localités ciblées avec leur identifiant et leur type (city ou level1)
-   * @param {Object.<string, { id: string, type: "cities" | "level1" } | any>} data.locality - Clés matching "^[^\s]+$"
-   * @param {Array<string>} data.searchType - Types d'entités à inclure dans la recherche
-   * @param {Array<string>} data.searchTags - Balises (tags) à utiliser pour filtrer la recherche
-   * @param {object} data.ranges - Configuration des plages de résultats pour chaque type de recherche
-   * @param {Object.<string, { indexMin: number, indexMax: number } | any>} data.ranges - Clés matching "^[^\s]+$"
-   * @param {["NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative","projects","citoyens","poi"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative","projects","citoyens","poi"])
-   * @param {0} data.indexMin - Index de départ global pour la pagination (toujours 0) (default: 0)
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {""} data.filters - Filtres additionnels appliqués à la recherche (actuellement vide) (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
-   * @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 globalAutocomplete(data = {}) {
+   * @param {import("./EndpointApi.types").GlobalAutocompleteData} data - Données envoyées à l'API
+   * @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 globalAutocomplete(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GLOBAL_AUTOCOMPLETE", data);
   }
 
   /**
    * Recherche de villes avec autocomplétion : Recherche des villes en fonction d’un nom, autocomplétion rapide.
    * Constant : CITY_AUTOCOMPLETE
-   * @param {object} data - data
-   * @param {string} data.name - Nom de la ville
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {["cities"]} data.searchType - data.searchType (default: ["cities"])
-   * @param {"ALL"} data.searchBy - Mode de recherche (ex: ALL) (default: "ALL")
-   * @param {number} data.indexMin - Index minimum
-   * @param {number} data.indexMax - Index maximum
+   * @param {import("./EndpointApi.types").CityAutocompleteData} data - Données envoyées à l'API
    * @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 cityAutocomplete(data = {}) {
+  async cityAutocomplete(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("CITY_AUTOCOMPLETE", data);
   }
 
   /**
    * Suggestions d'entrée : Fournit des suggestions basées sur le nom recherché, etc.
    * Constant : SUGGESTION_INPUT
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {Array<string>} data.searchType - Types d'entités à inclure dans la recherche
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {number} data.indexMax - Index maximum pour la pagination (default: 20)
+   * @param {import("./EndpointApi.types").SuggestionInputData} data - Données envoyées à l'API
    * @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 suggestionInput(data = {}) {
+  async suggestionInput(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("SUGGESTION_INPUT", data);
   }
 
   /**
    * Récupérer les projets non administrables : Récupère les projets accessibles sans droits d'administration.
    * Constant : GET_PROJECTS_NO_ADMIN
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {["projects"]} data.searchType - Types d'entités à inclure dans la recherche (default: ["projects"])
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {["projects"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["projects"])
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination) (default: 30)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {object} data.filters - data.filters (default: {"$or":{"links.contributors.@userId":{"$exists":true},"parent.@userId":{"$exists":true}},"links.contributors.@userId":{"$exists":true}})
-   * @param {object} data.filters.$or - data.filters.$or
-   * @param {Object.<string, { $exists: true } | any>} data.filters.$or - Clés matching "^links\.contributors\.(?:[a-f0-9]{24}|@\w+)$", "^parent\.(?:[a-f0-9]{24}|@\w+)$"
-   * @param {Object.<string, { $exists: true } | any>} data.filters - Clés matching "^links\.contributors\.(?:[a-f0-9]{24}|@\w+)$"
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
-   * @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 getProjectsNoAdmin(data = {}) {
+   * @param {import("./EndpointApi.types").GetProjectsNoAdminData} data - Données envoyées à l'API
+   * @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 getProjectsNoAdmin(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GET_PROJECTS_NO_ADMIN", data);
   }
 
   /**
    * Récupérer les projets administrables : Récupère les projets pour lesquels l'utilisateur a des droits d'administration.
    * Constant : GET_PROJECTS_ADMIN
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {["projects"]} data.searchType - Types d'entités à inclure dans la recherche (default: ["projects"])
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {["projects"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["projects"])
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination) (default: 30)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {object} data.filters - data.filters (default: {"$or":{"links.contributors.@{pathParams.id}":{"$exists":true},"parent.@{pathParams.id}":{"$exists":true}},"links.contributors.@{pathParams.id}":{"$exists":true}})
-   * @param {object} data.filters.$or - data.filters.$or
-   * @param {Object.<string, { $exists: true } | any>} data.filters.$or - Clés matching "^links\.contributors\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))$", "^parent\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))$"
-   * @param {Object.<string, { $exists: true } | any>} data.filters - Clés matching "^links\.contributors\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))$"
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
-   * @param {object} data.pathParams - data.pathParams
-   * @param {"citoyens" | "projects" | "organizations"} data.pathParams.type - Type d'entité (default: "citoyens")
-   * @param {string} data.pathParams.id - ID de l'utilisateur ou de l'entité
+   * @param {import("./EndpointApi.types").GetProjectsAdminData} data - Données envoyées à l'API
    * @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 getProjectsAdmin(data = {}) {
+  async getProjectsAdmin(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("GET_PROJECTS_ADMIN", data);
   }
 
   /**
    * Récupérer les POIs non administrables : Récupère la liste des POIs accessibles sans droits d'administration.
    * Constant : GET_POIS_NO_ADMIN
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {["poi"]} data.searchType - Types d'entités à inclure dans la recherche (default: ["poi"])
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {["poi"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["poi"])
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination) (default: 30)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {object} data.filters - data.filters (default: {"parent.@userId":{"$exists":true}})
-   * @param {Object.<string, { $exists: true } | any>} data.filters - Clés matching "^parent\.(?:[a-f0-9]{24}|@\w+)$"
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
+   * @param {import("./EndpointApi.types").GetPoisNoAdminData} data - Données envoyées à l'API
    * @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 getPoisNoAdmin(data = {}) {
+  async getPoisNoAdmin(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GET_POIS_NO_ADMIN", data);
   }
 
   /**
    * Récupérer les POIs administrables : Récupère la liste des POIs administrables par l’utilisateur.
    * Constant : GET_POIS_ADMIN
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {["poi"]} data.searchType - Types d'entités à inclure dans la recherche (default: ["poi"])
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {["poi"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["poi"])
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination) (default: 30)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {object} data.filters - data.filters (default: {"parent.@{pathParams.id}":{"$exists":true}})
-   * @param {Object.<string, { $exists: true } | any>} data.filters - Clés matching "^parent\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))$"
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
-   * @param {object} data.pathParams - data.pathParams
-   * @param {"citoyens" | "projects" | "organizations"} data.pathParams.type - Type d'entité (default: "citoyens")
-   * @param {string} data.pathParams.id - ID de l'utilisateur ou de l'entité
+   * @param {import("./EndpointApi.types").GetPoisAdminData} data - Données envoyées à l'API
    * @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 getPoisAdmin(data = {}) {
+  async getPoisAdmin(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("GET_POIS_ADMIN", data);
   }
 
   /**
    * Récupérer les organisations non administrables : Récupère la liste des organisations auxquelles l’utilisateur appartient sans les administrer.
    * Constant : GET_ORGANIZATIONS_NO_ADMIN
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {["NGO","Cooperative","LocalBusiness","Group","GovernmentOrganization"]} data.searchType - Types d'entités à inclure dans la recherche (default: ["NGO","Cooperative","LocalBusiness","Group","GovernmentOrganization"])
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {["NGO","Cooperative","LocalBusiness","Group","GovernmentOrganization"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["NGO","Cooperative","LocalBusiness","Group","GovernmentOrganization"])
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination) (default: 30)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {object} data.filters - data.filters (default: {"links.members.@userId":{"$exists":true},"links.members.@userId.toBeValidated":{"$exists":false},"links.members.@userId.isInviting":{"$exists":false}})
-   * @param {Object.<string, { $exists: true } | { $exists: false } | any>} data.filters - Clés matching "^links\.members\.(?:[a-f0-9]{24}|@\w+)$", "^links\.members\.(?:[a-f0-9]{24}|@\w+)\.toBeValidated$", "^links\.members\.(?:[a-f0-9]{24}|@\w+)\.isInviting$"
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
+   * @param {import("./EndpointApi.types").GetOrganizationsNoAdminData} data - Données envoyées à l'API
    * @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 getOrganizationsNoAdmin(data = {}) {
+  async getOrganizationsNoAdmin(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GET_ORGANIZATIONS_NO_ADMIN", data);
   }
 
   /**
    * Récupérer les organisations administrables : Récupère les organisations administrées par l’utilisateur.
    * Constant : GET_ORGANIZATIONS_ADMIN
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {["NGO","Cooperative","LocalBusiness","Group","GovernmentOrganization"]} data.searchType - Types d'entités à inclure dans la recherche (default: ["NGO","Cooperative","LocalBusiness","Group","GovernmentOrganization"])
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {["NGO","Cooperative","LocalBusiness","Group","GovernmentOrganization"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["NGO","Cooperative","LocalBusiness","Group","GovernmentOrganization"])
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination) (default: 30)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {object} data.filters - data.filters (default: {"links.members.@{pathParams.id}":{"$exists":true},"links.members.@{pathParams.id}.toBeValidated":{"$exists":false},"links.members.@{pathParams.id}.isInviting":{"$exists":false}})
-   * @param {Object.<string, { $exists: true } | { $exists: false } | any>} data.filters - Clés matching "^links\.members\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))$", "^links\.members\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.toBeValidated$", "^links\.members\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.isInviting$"
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
-   * @param {object} data.pathParams - data.pathParams
-   * @param {"citoyens" | "organizations"} data.pathParams.type - Type d'entité (default: "citoyens")
-   * @param {string} data.pathParams.id - ID de l'utilisateur ou de l'entité
+   * @param {import("./EndpointApi.types").GetOrganizationsAdminData} data - Données envoyées à l'API
    * @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 getOrganizationsAdmin(data = {}) {
+  async getOrganizationsAdmin(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("GET_ORGANIZATIONS_ADMIN", data);
   }
 
   /**
    * Récupérer les membres non administrables : Récupère les membres d’une organisation sans droits d’admin.
    * Constant : GET_MEMBERS_NO_ADMIN
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"]} data.searchType - Types d'entités à inclure dans la recherche (default: ["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"])
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"])
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination) (default: 30)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {object} data.filters - data.filters
-   * @param {Object.<string, { $exists: true } | { $exists: false } | { $exists: boolean } | { $in: Array<string> } | any>} data.filters - Clés matching "^links\.memberOf\.(?:[a-f0-9]{24}|@\w+)$", "^links\.memberOf\.(?:[a-f0-9]{24}|@\w+)\.toBeValidated$", "^links\.memberOf\.(?:[a-f0-9]{24}|@\w+)\.isInviting$", "^links\.memberOf\.(?:[a-f0-9]{24}|@\w+)\.isAdmin$", "^links\.memberOf\.(?:[a-f0-9]{24}|@\w+)\.roles$"
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
+   * @param {import("./EndpointApi.types").GetMembersNoAdminData} data - Données envoyées à l'API
    * @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 getMembersNoAdmin(data = {}) {
+  async getMembersNoAdmin(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GET_MEMBERS_NO_ADMIN", data);
   }
 
   /**
    * Récupérer les membres administrables : Récupère les membres d’une organisation administrée par l’utilisateur.
    * Constant : GET_MEMBERS_ADMIN
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"]} data.searchType - Types d'entités à inclure dans la recherche (default: ["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"])
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"])
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination) (default: 30)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {object} data.filters - data.filters (default: {"links.memberOf.@{pathParams.id}":{"$exists":true},"links.memberOf.@{pathParams.id}.toBeValidated":{"$exists":false},"links.memberOf.@{pathParams.id}.isInviting":{"$exists":false}})
-   * @param {Object.<string, { $exists: true } | { $exists: boolean } | { $in: Array<string> } | any>} data.filters - Clés matching "^links\.memberOf\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))$", "^links\.memberOf\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.toBeValidated$", "^links\.memberOf\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.isInviting$", "^links\.memberOf\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.isAdmin$", "^links\.memberOf\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.roles$"
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
-   * @param {object} data.pathParams - data.pathParams
-   * @param {string} data.pathParams.id - ID de l'organisation
+   * @param {import("./EndpointApi.types").GetMembersAdminData} data - Données envoyées à l'API
    * @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 getMembersAdmin(data = {}) {
+  async getMembersAdmin(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("GET_MEMBERS_ADMIN", data);
   }
 
   /**
    * Récupérer les amis administrables : Récupère les amis administrée par l’utilisateur.
    * Constant : GET_FRIENDS_ADMIN
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {["citoyens"]} data.searchType - Types d'entités à inclure dans la recherche (default: ["citoyens"])
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {["citoyens"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["citoyens"])
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination) (default: 30)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {object} data.filters - data.filters (default: {"links.friends.@{pathParams.id}":{"$exists":true},"links.friends.@{pathParams.id}.toBeValidated":{"$exists":false},"links.friends.@{pathParams.id}.isInviting":{"$exists":false}})
-   * @param {Object.<string, { $exists: true } | { $exists: boolean } | any>} data.filters - Clés matching "^links\.friends\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))$", "^links\.friends\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.toBeValidated$", "^links\.friends\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.isInviting$"
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
-   * @param {object} data.pathParams - data.pathParams
-   * @param {string} data.pathParams.id - ID de l'utilisateur (default: "@userId")
+   * @param {import("./EndpointApi.types").GetFriendsAdminData} data - Données envoyées à l'API
    * @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 getFriendsAdmin(data = {}) {
+  async getFriendsAdmin(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("GET_FRIENDS_ADMIN", data);
   }
 
   /**
    * Récupérer les suivis non administrables : Liste les entités suivies sans droits d’admin.
    * Constant : GET_SUBSCRIPTIONS
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative","projects"]} data.searchType - Types d'entités à inclure dans la recherche (default: ["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative","projects"])
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative","projects"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative","projects"])
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination) (default: 30)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {object} data.filters - data.filters (default: {"links.followers.@userId":{"$exists":true},"links.followers.@{userId}.toBeValidated":{"$exists":false},"links.followers.@{userId}.isInviting":{"$exists":false}})
-   * @param {Object.<string, { $exists: true } | { $exists: false } | any>} data.filters - Clés matching "^links\.followers\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))$", "^links\.followers\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.toBeValidated$", "^links\.followers\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.isInviting$"
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
+   * @param {import("./EndpointApi.types").GetSubscriptionsData} data - Données envoyées à l'API
    * @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 getSubscriptions(data = {}) {
+  async getSubscriptions(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GET_SUBSCRIPTIONS", data);
   }
 
   /**
    * Récupérer les suivis administrables : Liste les entités suivies par l’utilisateur, sur lesquelles il est admin.
    * Constant : GET_SUBSCRIPTIONS_ADMIN
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative","projects"]} data.searchType - Types d'entités à inclure dans la recherche (default: ["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative","projects"])
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative","projects"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative","projects"])
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination) (default: 30)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {object} data.filters - data.filters (default: {"links.followers.@{pathParams.id}":{"$exists":true},"links.followers.@{pathParams.id}.toBeValidated":{"$exists":false},"links.followers.@{pathParams.id}.isInviting":{"$exists":false}})
-   * @param {Object.<string, { $exists: true } | { $exists: false } | any>} data.filters - Clés matching "^links\.followers\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))$", "^links\.followers\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.toBeValidated$", "^links\.followers\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.isInviting$"
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
-   * @param {object} data.pathParams - data.pathParams
-   * @param {string} data.pathParams.id - ID de l'utilisateur (default: "@userId")
+   * @param {import("./EndpointApi.types").GetSubscriptionsAdminData} data - Données envoyées à l'API
    * @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 getSubscriptionsAdmin(data = {}) {
+  async getSubscriptionsAdmin(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("GET_SUBSCRIPTIONS_ADMIN", data);
   }
 
   /**
    * Récupérer les abonnés non administrables : Liste les abonnés sans droits d’admin.
    * Constant : GET_SUBSCRIBERS
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {["citoyens"]} data.searchType - Types d'entités à inclure dans la recherche (default: ["citoyens"])
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {["citoyens"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["citoyens"])
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination) (default: 30)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {object} data.filters - data.filters (default: {"links.follows.@userId":{"$exists":true},"links.follows.@{userId}.toBeValidated":{"$exists":false},"links.follows.@{userId}.isInviting":{"$exists":false}})
-   * @param {Object.<string, { $exists: true } | { $exists: false } | any>} data.filters - Clés matching "^links\.follows\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))$", "^links\.follows\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.toBeValidated$", "^links\.follows\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.isInviting$"
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
+   * @param {import("./EndpointApi.types").GetSubscribersData} data - Données envoyées à l'API
    * @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 getSubscribers(data = {}) {
+  async getSubscribers(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GET_SUBSCRIBERS", data);
   }
 
   /**
    * Récupérer les abonnés administrables : Liste les abonnés d’une entité administrée par l’utilisateur.
    * Constant : GET_SUBSCRIBERS_ADMIN
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {["citoyens"]} data.searchType - Types d'entités à inclure dans la recherche (default: ["citoyens"])
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {["citoyens"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["citoyens"])
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination) (default: 30)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {object} data.filters - data.filters (default: {"links.follows.@{pathParams.id}":{"$exists":true}})
-   * @param {Object.<string, { $exists: true } | any>} data.filters - Clés matching "^links\.follows\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))$"
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
-   * @param {object} data.pathParams - data.pathParams
-   * @param {"citoyens" | "organizations" | "projects"} data.pathParams.type - Type d'entité (default: "citoyens")
-   * @param {string} data.pathParams.id - ID de l'utilisateur ou de l'entité
+   * @param {import("./EndpointApi.types").GetSubscribersAdminData} data - Données envoyées à l'API
    * @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 getSubscribersAdmin(data = {}) {
+  async getSubscribersAdmin(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("GET_SUBSCRIBERS_ADMIN", data);
   }
 
   /**
    * Récupérer les contributeurs non administrables : Récupère les contributeurs sans droits d’admin.
    * Constant : GET_CONTRIBUTORS
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"]} data.searchType - Types d'entités à inclure dans la recherche (default: ["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"])
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"])
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination) (default: 30)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {object} data.filters - data.filters
-   * @param {Object.<string, { $exists: true } | { $exists: false } | { $exists: boolean } | { $in: Array<string> } | any>} data.filters - Clés matching "^links\.projects\.(?:[a-f0-9]{24}|@\w+)$", "^links\.projects\.(?:[a-f0-9]{24}|@\w+)\.toBeValidated$", "^links\.projects\.(?:[a-f0-9]{24}|@\w+)\.isInviting$", "^links\.projects\.(?:[a-f0-9]{24}|@\w+)\.isAdmin$", "^links\.projects\.(?:[a-f0-9]{24}|@\w+)\.roles$"
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
+   * @param {import("./EndpointApi.types").GetContributorsData} data - Données envoyées à l'API
    * @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 getContributors(data = {}) {
+  async getContributors(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GET_CONTRIBUTORS", data);
   }
 
   /**
    * Récupérer les contributeurs administrables : Récupère les contributeurs d’un project l’utilisateur est admin.
    * Constant : GET_CONTRIBUTORS_ADMIN
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"]} data.searchType - Types d'entités à inclure dans la recherche (default: ["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"])
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["citoyens","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"])
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination) (default: 30)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {object} data.filters - data.filters (default: {"links.projects.@{pathParams.id}":{"$exists":true},"links.projects.@{pathParams.id}.toBeValidated":{"$exists":false},"links.projects.@{pathParams.id}.isInviting":{"$exists":false}})
-   * @param {Object.<string, { $exists: true } | { $exists: boolean } | { $in: Array<string> } | any>} data.filters - Clés matching "^links\.projects\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))$", "^links\.projects\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.toBeValidated$", "^links\.projects\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.isInviting$", "^links\.projects\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.isAdmin$", "^links\.projects\.(?:[a-f0-9]{24}|@(?:\{[^}]+\}|[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)?))\.roles$"
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
-   * @param {object} data.pathParams - data.pathParams
-   * @param {string} data.pathParams.id - ID du projet
+   * @param {import("./EndpointApi.types").GetContributorsAdminData} data - Données envoyées à l'API
    * @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 getContributorsAdmin(data = {}) {
+  async getContributorsAdmin(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("GET_CONTRIBUTORS_ADMIN", data);
   }
 
   /**
    * Recherche globale des badges : Recherche des badges publics en fonction de divers critères.
    * Constant : GET_BADGES
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {["badges"]} data.searchType - Types d'entités à inclure dans la recherche (default: ["badges"])
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {["badges"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["badges"])
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination) (default: 30)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {object} data.filters - data.filters
-   * @param {false} data.filters.preferences.private - Indique si le badge est privé ou public (default: false)
-   * @param {boolean} data.filters.isParcours - Indique si le badge est un parcours
-   * @param {object} data.filters.$or - data.filters.$or
-   * @param {Object.<string, { $exists: true } | any>} data.filters.$or - Clés matching "^issuer\.(?:[a-f0-9]{24}|@\w+)$"
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
-   * @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 getBadges(data = {}) {
+   * @param {import("./EndpointApi.types").GetBadgesData} data - Données envoyées à l'API
+   * @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 getBadges(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GET_BADGES", data);
   }
 
   /**
    * Recherche globale des badges : Recherche des badges publics en fonction de divers critères.
    * Constant : GET_BADGES_FILTERS
-   * @param {object} data - data
-   * @param {string} data.name - Nom ou terme recherché
-   * @param {["badges"]} data.fields - data.fields (default: ["badges"])
-   * @param {["citoyens","projects","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"]} data.searchType - Types d'entités à inclure dans la recherche (default: ["citoyens","projects","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"])
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {""} data.initType - Type initial de la recherche, vide par défaut (default: "")
-   * @param {true} data.count - Indique si les types doivent être comptés dans les résultats (default: true)
-   * @param {["citoyens","projects","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"]} data.countType - Liste fixe des types à compter dans les résultats (default: ["citoyens","projects","NGO","LocalBusiness","Group","GovernmentOrganization","Cooperative"])
-   * @param {number} data.indexStep - Nombre d’éléments à récupérer (limite de pagination) (default: 30)
-   * @param {true} data.notSourceKey - Flag pour ne pas filtrer sur une clé de source spécifique (default: true)
-   * @param {object} data.ranges - data.ranges (default: {"citoyens":{"indexMin":0,"indexMax":30},"projects":{"indexMin":0,"indexMax":30},"NGO":{"indexMin":0,"indexMax":30},"LocalBusiness":{"indexMin":0,"indexMax":30},"Group":{"indexMin":0,"indexMax":30},"GovernmentOrganization":{"indexMin":0,"indexMax":30},"Cooperative":{"indexMin":0,"indexMax":30}})
-   * @param {Object.<string, { indexMin: number, indexMax: number } | any>} data.ranges - Clés matching "^[a-zA-Z][a-zA-Z0-9]*$"
-   * @param {object} data.filters - data.filters
-   * @param {""} data.locality - Localité vide ou spécifique (default: "")
-   * @param {false} data.fediverse - Indique si la recherche doit s'étendre au Fediverse (toujours désactivé) (default: false)
-   * @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 getBadgesFilters(data = {}) {
+   * @param {import("./EndpointApi.types").GetBadgesFiltersData} data - Données envoyées à l'API
+   * @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 getBadgesFilters(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GET_BADGES_FILTERS", data);
   }
 
   /**
    * Suivre un élément : Permet à un utilisateur de suivre un élément (projet, organisation...).
    * Constant : CONNECT
-   * @param {object} data - data
-   * @param {string} data.childId - ID de l'élément à suivre (projet, organisation...) (default: "@userId")
-   * @param {"citoyens"} data.childType - Type de l'élément à suivre (default: "citoyens")
-   * @param {"citoyens" | "organizations" | "projects" | "events"} data.parentType - Type de l'élément parent (projet, organisation...)
-   * @param {string} data.parentId - ID de l'élément parent
-   * @param {"admin" | "member" | "contributor" | "attendee" | "friend" | "connect"} data.connectType - Type de connexion
+   * @param {import("./EndpointApi.types").ConnectData} data - Données envoyées à l'API
    * @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 connect(data = {}) {
+  async connect(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("CONNECT", data);
   }
 
   /**
    * Se déconnecter d'un élément : Permet de supprimer le lien entre un utilisateur et un élément.
    * Constant : DISCONNECT
-   * @param {object} data - data
-   * @param {string} data.childId - ID de l'élément à déconnecter (projet, organisation...) (default: "@userId")
-   * @param {"citoyens"} data.childType - Type de l'élément à déconnecter (default: "citoyens")
-   * @param {"citoyens" | "organizations" | "projects" | "events"} data.parentType - Type de l'élément parent (projet, organisation...)
-   * @param {string} data.parentId - ID de l'élément parent
-   * @param {"admin" | "member" | "contributor" | "attendee" | "friend"} data.connectType - Type de connexion
+   * @param {import("./EndpointApi.types").DisconnectData} data - Données envoyées à l'API
    * @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 disconnect(data = {}) {
+  async disconnect(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("DISCONNECT", data);
   }
 
   /**
    * Récuperer l'id et la collection d'un element en fonction du slug : Récuperer l'id et la collection d'un element en fonction du slug
    * Constant : GET_ELEMENTS_KEY
-   * @param {object} data.pathParams - data.pathParams
-   * @param {string} data.pathParams.slug - Slug de l'élément à récupérer
+   * @param {import("./EndpointApi.types").GetElementsKeyData} data - Données envoyées à l'API
    * @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 getElementsKey(data = {}) {
+  async getElementsKey(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GET_ELEMENTS_KEY", data);
   }
 
   /**
    * Récupérer les favoris d'un utilisateur : Récupère la liste des favoris d’un utilisateur.
    * Constant : GET_FAVORIS
-   * @param {object} data.pathParams - data.pathParams
-   * @param {string} data.pathParams.id - ID de l'utilisateur (default: "@userId")
+   * @param {import("./EndpointApi.types").GetFavorisData} data - Données envoyées à l'API
    * @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 getFavoris(data = {}) {
+  async getFavoris(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("GET_FAVORIS", data);
   }
 
   /**
    * Supprimer un favori : Supprime un élément des favoris de l’utilisateur.
    * Constant : DELETE_FAVORIS
-   * @param {object} data - data
-   * @param {"@userId"} data.id - ID de l’utilisateur (default: "@userId")
-   * @param {"citoyens"} data.collection - data.collection (default: "citoyens")
-   * @param {"preferences.search.@{pathParams.index}"} data.path - Chemin à retirer (default: "preferences.search.@{pathParams.index}")
-   * @param {"preferences.search"} data.pull - data.pull
-   * @param {""} data.value - Valeur (default: "")
-   * @param {object} data.pathParams - data.pathParams
-   * @param {number} data.pathParams.index - Index du favoris à supprimer
+   * @param {import("./EndpointApi.types").DeleteFavorisData} data - Données envoyées à l'API
    * @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 deleteFavoris(data = {}) {
+  async deleteFavoris(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("DELETE_FAVORIS", data);
   }
 
   /**
    * Ajouter un favori : Ajoute un élément aux favoris de l’utilisateur.
    * Constant : ADD_FAVORIS
-   * @param {object} data - data
-   * @param {"@userId"} data.id - ID de l’utilisateur (default: "@userId")
-   * @param {"citoyens"} data.collection - data.collection (default: "citoyens")
-   * @param {"preferences.search"} data.path - Chemin à ajouter (default: "preferences.search")
-   * @param {true} data.arrayForm - data.arrayForm
-   * @param {object} data.value - data.value
-   * @param {string} data.value.url - data.value.url
-   * @param {string} data.value.name - data.value.name
-   * @param {string} data.value.description - data.value.description
-   * @param {Array<string>} data.value.tags - data.value.tags
-   * @param {object} data.value.locality - data.value.locality
-   * @param {Object.<string, any>} data.value.locality - Clés matching "^[a-f0-9]{24}$"
+   * @param {import("./EndpointApi.types").AddFavorisData} data - Données envoyées à l'API
    * @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 addFavoris(data = {}) {
+  async addFavoris(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("ADD_FAVORIS", data);
   }
 
   /**
    * Créer une organisation : Crée une nouvelle organisation.
    * Constant : ADD_ORGANIZATION
-   * @param {object} data - data
-   * @param {string} data.id - ID de l’organisation
-   * @param {"organizations"} data.collection - Collection de l’organisation (default: "organizations")
-   * @param {"organization"} data.key - data.key (default: "organization")
-   * @param {string} data.name - Nom de l’organisation
-   * @param {"NGO" | "LocalBusiness" | "Group" | "GovernmentOrganization" | "Cooperative"} data.type - Type d’organisation
-   * @param {"admin" | "member"} data.role - Rôle principal de l’organisation
-   * @param {Array<string>} data.tags - data.tags
-   * @param {string} data.email - Email de l’organisation
-   * @param {string} data.shortDescription - Description courte
-   * @param {string} data.url - Site web
-   * @param {object} data.preferences - data.preferences (default: {"isOpenData":true,"isOpenEdition":true})
-   * @param {boolean} data.preferences.isOpenData - Open data (true/false) (default: true)
-   * @param {boolean} data.preferences.isOpenEdition - Édition ouverte (true/false) (default: true)
-   * @param {object} data.geo - Coordonnées géographiques
-   * @param {"GeoCoordinates"} data.geo.@type - data.geo.@type
-   * @param {string | number} data.geo.latitude - data.geo.latitude
-   * @param {string | number} data.geo.longitude - data.geo.longitude
-   * @param {object} data.geoPosition - Position géographique GeoJSON
-   * @param {"Point"} data.geoPosition.type - Type GeoJSON (doit être 'Point')
-   * @param {Array<number>} data.geoPosition.coordinates - Tableau contenant [longitude, latitude]
-   * @param {true} data.geoPosition.float - Indicateur pour forcer la conversion en float côté serveur (default: true)
-   * @param {object} data.address - data.address
-   * @param {"PostalAddress"} data.address.@type - data.address.@type
-   * @param {string} data.address.addressCountry - data.address.addressCountry
-   * @param {string} data.address.codeInsee - data.address.codeInsee
-   * @param {string} data.address.addressLocality - data.address.addressLocality
-   * @param {string} data.address.localityId - data.address.localityId
-   * @param {string} data.address.level1 - data.address.level1
-   * @param {string} data.address.level1Name - data.address.level1Name
-   * @param {string} data.address.level3 - ID du département. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.level3Name - Nom du département. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.level4 - ID de la commune. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.level4Name - Nom de la commune. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.postalCode - data.address.postalCode
-   * @param {string} data.address.streetAddress - data.address.streetAddress
-   * @param {""} data.scope - data.scope (default: "")
+   * @param {import("./EndpointApi.types").AddOrganizationData} data - Données envoyées à l'API
    * @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 addOrganization(data = {}) {
+  async addOrganization(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("ADD_ORGANIZATION", data);
   }
 
   /**
    * Créer un projet : Crée un nouveau projet avec des informations de base et des options supplémentaires.
    * Constant : ADD_PROJECT
-   * @param {object} data - data
-   * @param {string} data.id - ID
-   * @param {"projects"} data.collection - Collection (default: "projects")
-   * @param {"project"} data.key - data.key (default: "project")
-   * @param {object} data.parent - Objet contenant les entités parentes (clé = ID). null signifie que les parents ne sont pas modifiés. (default: {"@userId":{"type":"citoyens"}})
-   * @param {Object.<string, { type: string, name?: string } | any>} data.parent - Clés matching "^(?:[a-f0-9]{24}|@userId)$"
-   * @param {string} data.name - Nom du projet
-   * @param {boolean} data.public - Visibilité (true/false) (default: true)
-   * @param {Array<string>} data.tags - data.tags
-   * @param {string} data.shortDescription - Description courte
-   * @param {string} data.url - Site web
-   * @param {object} data.preferences - data.preferences (default: {"isOpenData":false,"isOpenEdition":false,"crowdfunding":true})
-   * @param {boolean} data.preferences.isOpenData - Open data (true/false) (default: false)
-   * @param {boolean} data.preferences.isOpenEdition - Édition ouverte (true/false) (default: false)
-   * @param {boolean} data.preferences.crowdfunding - Crowdfunding (true/false) (default: true)
-   * @param {object} data.geo - Coordonnées géographiques
-   * @param {"GeoCoordinates"} data.geo.@type - data.geo.@type
-   * @param {string | number} data.geo.latitude - data.geo.latitude
-   * @param {string | number} data.geo.longitude - data.geo.longitude
-   * @param {object} data.geoPosition - Position géographique GeoJSON
-   * @param {"Point"} data.geoPosition.type - Type GeoJSON (doit être 'Point')
-   * @param {Array<number>} data.geoPosition.coordinates - Tableau contenant [longitude, latitude]
-   * @param {true} data.geoPosition.float - Indicateur pour forcer la conversion en float côté serveur (default: true)
-   * @param {object} data.address - data.address
-   * @param {"PostalAddress"} data.address.@type - data.address.@type
-   * @param {string} data.address.addressCountry - data.address.addressCountry
-   * @param {string} data.address.codeInsee - data.address.codeInsee
-   * @param {string} data.address.addressLocality - data.address.addressLocality
-   * @param {string} data.address.localityId - data.address.localityId
-   * @param {string} data.address.level1 - data.address.level1
-   * @param {string} data.address.level1Name - data.address.level1Name
-   * @param {string} data.address.level3 - ID du département. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.level3Name - Nom du département. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.level4 - ID de la commune. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.level4Name - Nom de la commune. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.postalCode - data.address.postalCode
-   * @param {string} data.address.streetAddress - data.address.streetAddress
-   * @param {""} data.scope - data.scope (default: "")
+   * @param {import("./EndpointApi.types").AddProjectData} data - Données envoyées à l'API
    * @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 addProject(data = {}) {
+  async addProject(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("ADD_PROJECT", data);
   }
 
   /**
    * Créer un POI : Crée un nouveau POI (Point d'Intérêt).
    * Constant : ADD_POI
-   * @param {object} data - data
-   * @param {string} data.id - ID du POI
-   * @param {"poi"} data.collection - Collection du POI (default: "poi")
-   * @param {"poi"} data.key - data.key (default: "poi")
-   * @param {"link" | "tool" | "machine" | "software" | "rh" | "Resource material" | "Financial Ressource" | "ficheBlanche" | "geoJson" | "compostPickup" | "video" | "sharedLibrary" | "recoveryCenter" | "trash" | "history" | "something2See" | "funPlace" | "place" | "artPiece" | "streetArts" | "openScene" | "stand" | "parking" | "other"} data.type - Type de POI
-   * @param {object} data.parent - Objet contenant les entités parentes (clé = ID). null signifie que les parents ne sont pas modifiés. (default: {"@userId":{"type":"citoyens"}})
-   * @param {Object.<string, { type: string, name?: string } | any>} data.parent - Clés matching "^(?:[a-f0-9]{24}|@userId)$"
-   * @param {string} data.name - Nom du poi
-   * @param {string} data.description - Description
-   * @param {Array<string>} data.tags - data.tags
-   * @param {Array<string>} data.urls - URLs externes associées
-   * @param {object} data.geo - Coordonnées géographiques
-   * @param {"GeoCoordinates"} data.geo.@type - data.geo.@type
-   * @param {string | number} data.geo.latitude - data.geo.latitude
-   * @param {string | number} data.geo.longitude - data.geo.longitude
-   * @param {object} data.geoPosition - Position géographique GeoJSON
-   * @param {"Point"} data.geoPosition.type - Type GeoJSON (doit être 'Point')
-   * @param {Array<number>} data.geoPosition.coordinates - Tableau contenant [longitude, latitude]
-   * @param {true} data.geoPosition.float - Indicateur pour forcer la conversion en float côté serveur (default: true)
-   * @param {object} data.address - data.address
-   * @param {"PostalAddress"} data.address.@type - data.address.@type
-   * @param {string} data.address.addressCountry - data.address.addressCountry
-   * @param {string} data.address.codeInsee - data.address.codeInsee
-   * @param {string} data.address.addressLocality - data.address.addressLocality
-   * @param {string} data.address.localityId - data.address.localityId
-   * @param {string} data.address.level1 - data.address.level1
-   * @param {string} data.address.level1Name - data.address.level1Name
-   * @param {string} data.address.level3 - ID du département. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.level3Name - Nom du département. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.level4 - ID de la commune. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.level4Name - Nom de la commune. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.postalCode - data.address.postalCode
-   * @param {string} data.address.streetAddress - data.address.streetAddress
-   * @param {""} data.scope - data.scope (default: "")
+   * @param {import("./EndpointApi.types").AddPoiData} data - Données envoyées à l'API
    * @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 addPoi(data = {}) {
+  async addPoi(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("ADD_POI", data);
   }
 
   /**
    * Créer un événement : Crée un nouvel événement.
    * Constant : ADD_EVENT
-   * @param {object} data - data
-   * @param {string} data.id - ID de l’événement
-   * @param {"events"} data.collection - Collection de l’événement (default: "events")
-   * @param {"event"} data.key - data.key (default: "event")
-   * @param {"workshop" | "competition" | "concert" | "contest" | "conference" | "debate" | "exhibition" | "festival" | "crowdfunding" | "fair" | "course" | "protest" | "market" | "film" | "getTogether" | "meeting" | "spectacle" | "internship" | "stand" | "others"} data.type - Type d’événement
-   * @param {boolean} data.public - Visibilité (true/false) (default: true)
-   * @param {object} data.organizer - Objet contenant les entités parentes (clé = ID). null signifie que les parents ne sont pas modifiés. (default: {"@userId":{"type":"citoyens"}})
-   * @param {Object.<string, { type: string, name?: string } | any>} data.organizer - Clés matching "^(?:[a-f0-9]{24}|@userId)$"
-   * @param {object} data.parent - Objet contenant les entités parentes (clé = ID). null signifie que les parents ne sont pas modifiés.
-   * @param {Object.<string, { type: string, name?: string } | any>} data.parent - Clés matching "^(?:[a-f0-9]{24}|@userId)$"
-   * @param {string} data.name - Nom du poi
-   * @param {string} data.shortDescription - Description courte
-   * @param {Array<string>} data.tags - data.tags
-   * @param {string} data.url - Site web
-   * @param {string} data.email - Email de l’organisation
-   * @param {object} data.preferences - data.preferences (default: {"isOpenData":false,"isOpenEdition":false})
-   * @param {boolean} data.preferences.isOpenData - Open data (true/false) (default: false)
-   * @param {boolean} data.preferences.isOpenEdition - Édition ouverte (true/false) (default: false)
-   * @param {string} data.timeZone - Fuseau horaire IANA
-   * @param {boolean} data.recurrency - Indique si l'événement est récurrent (true/false) (default: false)
-   * @param {string} data.startDate - Date et heure de début (ISO 8601 avec offset)
-   * @param {string} data.endDate - Date et heure de fin (ISO 8601 avec offset)
-   * @param {Array<any>} data.openingHours - Liste ordonnée des jours de la semaine avec leurs horaires d'ouverture ou une chaîne vide pour ignorer le jour (default: ["","","","","","",""])
-   * @param {object} data.geo - Coordonnées géographiques
-   * @param {"GeoCoordinates"} data.geo.@type - data.geo.@type
-   * @param {string | number} data.geo.latitude - data.geo.latitude
-   * @param {string | number} data.geo.longitude - data.geo.longitude
-   * @param {object} data.geoPosition - Position géographique GeoJSON
-   * @param {"Point"} data.geoPosition.type - Type GeoJSON (doit être 'Point')
-   * @param {Array<number>} data.geoPosition.coordinates - Tableau contenant [longitude, latitude]
-   * @param {true} data.geoPosition.float - Indicateur pour forcer la conversion en float côté serveur (default: true)
-   * @param {object} data.address - data.address
-   * @param {"PostalAddress"} data.address.@type - data.address.@type
-   * @param {string} data.address.addressCountry - data.address.addressCountry
-   * @param {string} data.address.codeInsee - data.address.codeInsee
-   * @param {string} data.address.addressLocality - data.address.addressLocality
-   * @param {string} data.address.localityId - data.address.localityId
-   * @param {string} data.address.level1 - data.address.level1
-   * @param {string} data.address.level1Name - data.address.level1Name
-   * @param {string} data.address.level3 - ID du département. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.level3Name - Nom du département. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.level4 - ID de la commune. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.level4Name - Nom de la commune. Peut être vide pour les pays étrangers.
-   * @param {string} data.address.postalCode - data.address.postalCode
-   * @param {string} data.address.streetAddress - data.address.streetAddress
-   * @param {""} data.scope - data.scope (default: "")
+   * @param {import("./EndpointApi.types").AddEventData} data - Données envoyées à l'API
    * @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 addEvent(data = {}) {
+  async addEvent(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("ADD_EVENT", data);
   }
 
   /**
    * Supprimer un POI : Supprime un POI existant.
    * Constant : DELETE_POI
-   * @param {object} data - data
-   * @param {string} data.reason - Raison de la suppression (default: "")
-   * @param {object} data.pathParams - data.pathParams
-   * @param {string} data.pathParams.id - ID de l'élément à supprimer
+   * @param {import("./EndpointApi.types").DeletePoiData} data - Données envoyées à l'API
    * @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 deletePoi(data = {}) {
+  async deletePoi(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("DELETE_POI", data);
   }
 
   /**
    * Supprimer un événement : Supprime un événement spécifique.
    * Constant : DELETE_EVENT
-   * @param {object} data - data
-   * @param {string} data.reason - Raison de la suppression (default: "")
-   * @param {object} data.pathParams - data.pathParams
-   * @param {string} data.pathParams.id - ID de l'élément à supprimer
+   * @param {import("./EndpointApi.types").DeleteEventData} data - Données envoyées à l'API
    * @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 deleteEvent(data = {}) {
+  async deleteEvent(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("DELETE_EVENT", data);
   }
 
   /**
    * Supprimer un élément : Supprime un élément existant.
    * Constant : DELETE_ELEMENT
-   * @param {object} data - data
-   * @param {string} data.reason - Raison de la suppression (default: "")
-   * @param {object} data.pathParams - data.pathParams
-   * @param {string} data.pathParams.type - Type d'élément à supprimer
-   * @param {string} data.pathParams.id - ID de l'élément à supprimer
+   * @param {import("./EndpointApi.types").DeleteElementData} data - Données envoyées à l'API
    * @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 deleteElement(data = {}) {
+  async deleteElement(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("DELETE_ELEMENT", data);
   }
 
   /**
    * Ajouter une image à un élément : Ajoute une image à un élément.
    * Constant : ADD_IMAGE_ELEMENT
-   * @param {object} data - data
-   * @param {string} data.qquuid - ID unique du fichier
-   * @param {string} data.qqfilename - Nom du fichier
-   * @param {number} data.qqtotalfilesize - Taille totale du fichier
-   * @param {any} data.qqfile - Données binaires de l'image
-   * @param {object} data.pathParams - data.pathParams
-   * @param {"badges" | "events"} data.pathParams.folder - Dossier de destination
-   * @param {string} data.pathParams.ownerId - ID du propriétaire de l'image
+   * @param {import("./EndpointApi.types").AddImageElementData} data - Données envoyées à l'API
    * @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 addImageElement(data = {}) {
+  async addImageElement(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("ADD_IMAGE_ELEMENT", data);
   }
 
   /**
    * Valider un lien : Permet de valider un lien (ex: rejoindre un projet, accepter un membre...).
    * Constant : LINK_VALIDATE
-   * @param {object} data - data
-   * @param {string} data.childId - ID de l’enfant (default: "@userId")
-   * @param {"citoyens"} data.childType - Type de l’enfant (default: "citoyens")
-   * @param {"citoyens" | "organizations" | "projects" | "events"} data.parentType - Type du parent
-   * @param {string} data.parentId - ID du parent
-   * @param {"isInviting" | "toBeValidated" | "isAdminPending"} data.linkOption - Type de validation
+   * @param {import("./EndpointApi.types").LinkValidateData} data - Données envoyées à l'API
    * @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 linkValidate(data = {}) {
+  async linkValidate(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("LINK_VALIDATE", data);
   }
 
   /**
    * Recherche avec autocomplétion (membres) : Recherche des membres avec autocomplétion.
    * Constant : SEARCH_MEMBER_AUTOCOMPLETE
-   * @param {object} data - data
-   * @param {string} data.search - Terme recherché
-   * @param {"personOnly" | "organizationOnly" | "mixte"} data.searchMode - Mode de recherche (default: "personOnly")
+   * @param {import("./EndpointApi.types").SearchMemberAutocompleteData} data - Données envoyées à l'API
    * @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 searchMemberAutocomplete(data = {}) {
+  async searchMemberAutocomplete(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("SEARCH_MEMBER_AUTOCOMPLETE", data);
   }
 
   /**
    * Récupérer les notifications : Récupère la liste des notifications pour un utilisateur.
    * Constant : GET_NOTIFICATIONS
-   * @param {object} data - data
-   * @param {number} data.indexMin - Index minimum pour la pagination (default: 0)
-   * @param {object} data.pathParams - data.pathParams
-   * @param {"citoyens"} data.pathParams.type - Type de notification (default: "citoyens")
-   * @param {string} data.pathParams.id - ID de l'utilisateur (default: "@userId")
+   * @param {import("./EndpointApi.types").GetNotificationsData} data - Données envoyées à l'API
    * @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 getNotifications(data = {}) {
+  async getNotifications(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("GET_NOTIFICATIONS", data);
   }
 
   /**
    * Récupérer le nombre de notifications : Récupère le nombre de notifications pour un utilisateur.
    * Constant : GET_NOTIFICATIONS_COUNT
-   * @param {object} data - data
-   * @param {number} data.refreshTimestamp - Timestamp de rafraîchissement
-   * @param {object} data.pathParams - data.pathParams
-   * @param {"citoyens"} data.pathParams.type - Type de notification (default: "citoyens")
-   * @param {string} data.pathParams.id - ID de l'utilisateur (default: "@userId")
+   * @param {import("./EndpointApi.types").GetNotificationsCountData} data - Données envoyées à l'API
    * @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 getNotificationsCount(data = {}) {
+  async getNotificationsCount(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("GET_NOTIFICATIONS_COUNT", data);
   }
 
   /**
    * Mettre à jour toutes les notifications : Marque toutes les notifications comme vues ou lues.
    * Constant : NOTIFICATION_UPDATE
-   * @param {object} data - data
-   * @param {"seen" | "read"} data.action - Action à effectuer
-   * @param {true} data.all - Marquer toutes les notifications comme vues ou lues (default: true)
+   * @param {import("./EndpointApi.types").NotificationUpdateData} data - Données envoyées à l'API
    * @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 notificationUpdate(data = {}) {
+  async notificationUpdate(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("NOTIFICATION_UPDATE", data);
   }
 
   /**
    * Supprimer toutes les notifications : Supprime toutes les notifications de l’utilisateur.
    * Constant : REMOVE_ALL_NOTIFICATIONS
+   * @param {Object} [data] - Données envoyées à l'API (optionnel)
    * @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 removeAllNotifications(data = {}) {
+  async removeAllNotifications(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("REMOVE_ALL_NOTIFICATIONS", data);
   }
 
   /**
    * Marquer une notification comme lue : Marque une notification spécifique comme lue.
    * Constant : MARK_NOTIFICATION_AS_READ
-   * @param {object} data - data
-   * @param {string} data.id - ID de la notification
+   * @param {import("./EndpointApi.types").MarkNotificationAsReadData} data - Données envoyées à l'API
    * @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 markNotificationAsRead(data = {}) {
+  async markNotificationAsRead(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("MARK_NOTIFICATION_AS_READ", data);
   }
 
   /**
    * Recherche ActivityPub : Recherche des éléments ActivityPub selon une adresse ou un terme.
    * Constant : ACTIVITYPUB_SEARCH
-   * @param {object} data.pathParams - data.pathParams
-   * @param {string} data.pathParams.address - Adresse à rechercher
+   * @param {import("./EndpointApi.types").ActivitypubSearchData} data - Données envoyées à l'API
    * @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 activitypubSearch(data = {}) {
+  async activitypubSearch(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("ACTIVITYPUB_SEARCH", data);
   }
 
   /**
    * Mettre à jour une activité (ActivityPub) : Met à jour une activité ActivityPub avec une action et un payload.
    * Constant : ACTIVITYPUB_LINK
-   * @param {object} data - data
-   * @param {"undo_follow" | "accept_invitation" | "reject_invitation" | "undo_accept" | "undo_request_follow" | "follow" | "remove_follow" | "accept_follower" | "reject_follower" | "remove_follower" | "remove_invitation"} data.action - data.action
-   * @param {string} data.payload - data.payload
-   * @param {object} data.actor - data.actor
-   * @param {string} data.actor.id - data.actor.id
-   * @param {"person"} data.actor.type - data.actor.type
-   * @param {string} data.actor.name - data.actor.name
+   * @param {import("./EndpointApi.types").ActivitypubLinkData} data - Données envoyées à l'API
    * @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 activitypubLink(data = {}) {
+  async activitypubLink(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("ACTIVITYPUB_LINK", data);
   }
 
   /**
    * Obtenir la liste ActivityPub : Obtient la liste des communautés ActivityPub pour un utilisateur.
    * Constant : ACTIVITYPUB_GET_COMMUNITY
-   * @param {object} data.pathParams - data.pathParams
-   * @param {string} data.pathParams.userId - ID de l'utilisateur
-   * @param {"follows" | "followers"} data.pathParams.type - Type de communauté
+   * @param {import("./EndpointApi.types").ActivitypubGetCommunityData} data - Données envoyées à l'API
    * @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 activitypubGetCommunity(data = {}) {
+  async activitypubGetCommunity(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("ACTIVITYPUB_GET_COMMUNITY", data);
   }
 
   /**
    * Récupérer les informations d'un badge : Récupère les détails d’un badge par son ID.
    * Constant : GET_BADGE
-   * @param {object} data.pathParams - data.pathParams
-   * @param {string} data.pathParams.id - ID du badge
+   * @param {import("./EndpointApi.types").GetBadgeData} data - Données envoyées à l'API
    * @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 getBadge(data = {}) {
+  async getBadge(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GET_BADGE", data);
   }
 
   /**
    * Obtenir la liste des émetteurs de badges : Récupère la liste des émetteurs pour les badges.
    * Constant : GET_EMETTEUR_BADGES
+   * @param {Object} [data] - Données envoyées à l'API (optionnel)
    * @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 getEmetteurBadges(data = {}) {
+  async getEmetteurBadges(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GET_EMETTEUR_BADGES", data);
   }
 
   /**
    * Créer un badge : Crée un nouveau badge avec des informations détaillées.
    * Constant : ADD_BADGES
-   * @param {object} data - data
-   * @param {string} data.id - ID
-   * @param {"badges"} data.collection - Collection (default: "badges")
-   * @param {"badge"} data.key - data.key (default: "badge")
-   * @param {object} data.parent - Objet contenant les badges parents (clé = ID). null signifie que les parents ne sont pas modifiés.
-   * @param {Object.<string, { type: "badges", name?: string } | any>} data.parent - Clés matching "^[a-f0-9]{24}$"
-   * @param {string} data.name - Nom du badge
-   * @param {boolean} data.public - Visibilité (true/false) (default: true)
-   * @param {Array<string>} data.tags - data.tags
-   * @param {boolean} data.isParcours - Est-ce un parcours (true/false)? (default: false)
-   * @param {string} data.description - Description
-   * @param {object} data.preferences - data.preferences (default: {"isOpenData":true,"isOpenEdition":true})
-   * @param {boolean} data.preferences.isOpenData - Open data (true/false) (default: true)
-   * @param {boolean} data.preferences.isOpenEdition - Édition ouverte (true/false) (default: true)
-   * @param {""} data.scope - data.scope (default: "")
-   * @param {object} data.criteria - data.criteria
-   * @param {string} data.criteria.narrative - Critères d’obtention
-   * @param {object} data.issuer - Objet contenant les émetteurs (clé = ID). null signifie que les émetteurs ne sont pas modifiés.
-   * @param {Object.<string, { type: "citoyens" | "organizations" | "projects", name?: string } | any>} data.issuer - Clés matching "^(?:[a-f0-9]{24}|@userId)$"
+   * @param {import("./EndpointApi.types").AddBadgesData} data - Données envoyées à l'API
    * @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 addBadges(data = {}) {
+  async addBadges(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("ADD_BADGES", data);
   }
 
   /**
    * Attribuer un badge : Attribue un badge à une ou plusieurs personnes ou entités.
    * Constant : ASSIGN_BADGES
-   * @param {object} data - data
-   * @param {"badge"} data.key - data.key (default: "badge")
-   * @param {"badges"} data.collection - data.collection (default: "badges")
-   * @param {string} data.narative - Message/narratif
-   * @param {string} data.badgeId - ID du badge
-   * @param {object} data.award - Objet contenant les cibles (clé = ID). null signifie que les cibles ne sont pas modifiées.
-   * @param {Object.<string, { type: string, name: string } | any>} data.award - Clés matching "^[0-9a-f]{24}$"
-   * @param {Array<object>} data.evidences - Preuves
-   * @param {""} data.scope - data.scope (default: "")
+   * @param {import("./EndpointApi.types").AssignBadgesData} data - Données envoyées à l'API
    * @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 assignBadges(data = {}) {
+  async assignBadges(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("ASSIGN_BADGES", data);
   }
 
   /**
    * Obtenir la liste des événements : Permet de rechercher des événements selon plusieurs critères (dates, nom, type...).
    * Constant : GET_EVENTS
-   * @param {object} data - data
-   * @param {["events"]} data.searchType - data.searchType (default: ["events"])
-   * @param {number} data.indexMin - data.indexMin (default: 0)
-   * @param {number} data.indexStep - data.indexStep (default: 100)
-   * @param {number} data.startDate - Timestamp de début
-   * @param {string} data.startDateUTC - Date de début (UTC)
-   * @param {string} data.endDateUTC - Date de fin (UTC)
-   * @param {string} data.name - Nom ou terme
-   * @param {"workshop" | "competition" | "concert" | "contest" | "conference" | "debate" | "exhibition" | "festival" | "crowdfunding" | "fair" | "course" | "protest" | "market" | "film" | "getTogether" | "meeting" | "spectacle" | "internship" | "stand" | "others"} data.type - Type d’événement
-   * @param {object} data.locality - Liste des localités ciblées
-   * @param {Object.<string, object | any>} data.locality - Clés matching "^[^\s]+$"
-   * @param {boolean} data.count - data.count (default: false)
-   * @param {["events"]} data.countType - data.countType (default: ["events"])
-   * @param {boolean} data.fediverse - data.fediverse (default: false)
+   * @param {import("./EndpointApi.types").GetEventsData} data - Données envoyées à l'API
    * @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 getEvents(data = {}) {
+  async getEvents(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.call("GET_EVENTS", data);
   }
 
   /**
    * Partager un événement : Partage un événement avec d’autres utilisateurs ou entités.
    * Constant : SHARE_EVENTS
-   * @param {object} data - data
-   * @param {string} data.parentId - ID de l’événement à partager
-   * @param {"events"} data.parentType - Type de l’entité parent (events) (default: "events")
-   * @param {string} data.childId - ID de l'entité partageante
-   * @param {"citoyens" | "projects" | "organizations"} data.childType - Type de l'entité partageante (default: "citoyens")
-   * @param {"share"} data.connectType - Type de connexion (share) (default: "share")
-   * @param {string} data.comment - Commentaire de partage
+   * @param {import("./EndpointApi.types").ShareEventsData} data - Données envoyées à l'API
    * @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 shareEvents(data = {}) {
+  async shareEvents(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("SHARE_EVENTS", data);
   }
 
   /**
    * Inviter des participants à un événement : Invite plusieurs utilisateurs ou entités à participer à un événement.
    * Constant : INVITE_EVENT
-   * @param {object} data - data
-   * @param {string} data.parentId - ID de l'entité parente
-   * @param {"citoyens" | "projects" | "organizations"} data.parentType - Type de l'entité parente (default: "citoyens")
-   * @param {object} data.listInvite - Liste des citoyens invités
-   * @param {object} data.listInvite.citoyens - data.listInvite.citoyens
-   * @param {Object.<string, { name: string, isAdmin?: "" | "admin", roles?: Array<string> } | any>} data.listInvite.citoyens - Clés matching "^[0-9a-f]{24}$"
-   * @param {object} data.listInvite.projects - data.listInvite.projects
-   * @param {Object.<string, { name: string, isAdmin?: "" | "admin", roles?: Array<string> } | any>} data.listInvite.projects - Clés matching "^[0-9a-f]{24}$"
-   * @param {object} data.listInvite.organizations - data.listInvite.organizations
-   * @param {Object.<string, { name: string, isAdmin?: "" | "admin", roles?: Array<string> } | any>} data.listInvite.organizations - Clés matching "^[0-9a-f]{24}$"
-   * @param {object} data.listInvite.invites - data.listInvite.invites
-   * @param {Object.<string, { name: string, email: string, msg?: string, isAdmin?: "" | "admin", roles?: Array<string> } | any>} data.listInvite.invites - Clés matching "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
+   * @param {import("./EndpointApi.types").InviteEventData} data - Données envoyées à l'API
    * @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 inviteEvent(data = {}) {
+  async inviteEvent(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
     return this.callIsConnected("INVITE_EVENT", data);
   }