@communecter/cocolight-api-client 1.0.81 → 1.0.83

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@communecter/cocolight-api-client",
-    "version": "1.0.81",
+    "version": "1.0.83",
     "description": "Client Axios simplifié pour l'API cocolight",
     "repository": {
         "type": "git",

package/src/api/BaseEntity.ts

@@ -3209,6 +3209,63 @@ export class BaseEntity<TServerData = any> {
     return arrayObjet as Record<string, any>;
   }
 
+
+  /**
+   * Recherche des membres (utilisateurs ou organisations) liés à l'entité courante.
+   *
+   * Cette méthode effectue une recherche par autocomplétion parmi les membres de l'entité
+   * (organisation, projet, événement). Les résultats sont filtrés selon le mode de recherche
+   * et retournés sous forme d'entités User ou Organization liées à l'entité parente.
+   *
+   * @param {SearchMemberAutocompleteData} data - Paramètres de recherche
+   * @param {string} data.search - Terme recherché (nom, slug, etc.)
+   * @param {"personOnly" | "organizationOnly" | "mixte"} data.searchMode - Mode de recherche :
+   *   - `"personOnly"` : recherche uniquement parmi les utilisateurs
+   *   - `"organizationOnly"` : recherche uniquement parmi les organisations
+   *   - `"mixte"` : recherche parmi les utilisateurs et organisations
+   * @returns {Promise<(User | Organization)[]>} Liste des entités correspondantes, liées à l'entité parente
+   * @throws {ApiError} Si le type d'entité n'est pas supporté (badges, news, poi, comments)
+   *
+   * @example
+   * ```typescript
+   * // Rechercher des utilisateurs dans une organisation
+   * const org = await me.organization({ slug: "myOrg" });
+   * const users = await org.searchMembers({ search: "jean", searchMode: "personOnly" });
+   * users.forEach(user => console.log(user.data.name));
+   *
+   * // Rechercher des organisations membres d'un projet
+   * const project = await me.project({ slug: "myProject" });
+   * const orgs = await project.searchMembers({ search: "asso", searchMode: "organizationOnly" });
+   * ```
+   *
+   * @remarks
+   * Les entités retournées sont automatiquement liées à l'entité parente via `_linkEntities`,
+   * ce qui permet d'utiliser les méthodes comme `sendRequestToJoinParent()`, `isAdminPending()`, etc.
+   */
+  async searchMembers(data: SearchMemberAutocompleteData): Promise<(User | Organization)[]> {
+    // TODO: j'ai l'impression que searchMode : "organizationOnly" ne renvois pas que des organisations
+    const result = await this.endpointApi.searchMemberAutocomplete(data);
+    if (!result || !Array.isArray(result)) {
+      return [];
+    }
+
+    const t = this.getEntityType();
+    if (t === "badges" || t === "news" || t === "poi" || t === "comments") {
+      throw new ApiError(`Le type d'entité "${t}" n'est pas supporté par searchMemberAutocomplete.`, 400);
+    }
+
+    result.forEach(item => {
+      for (const key of Object.keys(item)) {
+        if (!["id", "name", "slug", "profilThumbImageUrl", "profilMarkerImageUrl", "type", "collection"].includes(key)) {
+          delete item[key];
+        }
+      }
+    });
+
+    const rawList = this._linkEntities(result);
+    return rawList;
+  }
+  
   /**
    * Soumet une demande pour rejoindre l'entité courante (ex. organisation, projet, événement...).
    * Si une invitation est en attente, elle est automatiquement acceptée.
@@ -4088,30 +4145,6 @@ export class BaseEntity<TServerData = any> {
     return paginator.next() as Promise<PaginatorPage<any>>;
   }
 
-  async searchMembers(data: SearchMemberAutocompleteData) {
-    // TODO: j'ai l'impression que searchMode : "organizationOnly" ne renvois pas que des organisations
-    const result = await this.endpointApi.searchMemberAutocomplete(data);
-    if (!result || !Array.isArray(result)) {
-      return [];
-    }
-
-    const t = this.getEntityType();
-    if (t === "badges" || t === "news" || t === "poi" || t === "comments") {
-      throw new ApiError(`Le type d'entité "${t}" n'est pas supporté par searchMemberAutocomplete.`, 400);
-    }
-
-    result.forEach(item => {
-      for (const key of Object.keys(item)) {
-        if (!["id", "name", "slug", "profilThumbImageUrl", "profilMarkerImageUrl", "type", "collection"].includes(key)) {
-          delete item[key];
-        }
-      }
-    });
-
-    const rawList = this._linkEntities(result);
-    return rawList;
-  }
-
 }
 
 export default BaseEntity;

package/src/api/User.ts

@@ -24,6 +24,18 @@ import type { EntityTypes } from "@/types/entities.js";
 type ApiClient = import("../ApiClient.js").default;
 type UserItemNormalized = import("./serverDataType/User.js").UserItemNormalized;
 
+/**
+ * Interface représentant le lien entre un utilisateur et une entité parente.
+ * Utilisée pour typer les données de relation (membre, admin, invitations, etc.)
+ */
+interface ParentLink {
+  isAdmin?: boolean;
+  isAdminPending?: boolean;
+  isInviting?: boolean;
+  isAdminInviting?: boolean;
+  toBeValidated?: boolean;
+}
+
 export class User extends BaseEntity<UserItemNormalized> {
 
   static override entityType = "citoyens" as const;
@@ -890,37 +902,88 @@ export class User extends BaseEntity<UserItemNormalized> {
     return super.entityBySlug(slug);
   }
 
+  // ────────────────────────────────
+  //  Actions sur l'utilisateur par rapport à l'entité parente
+  // ────────────────────────────────
+
   /**
-   * Valide les préconditions communes pour les méthodes de vérification de rôle.
+   * Valide les préconditions pour les méthodes nécessitant d'être membre.
    * @private
    * @param methodName - Nom de la méthode appelante (pour les messages d'erreur).
    * @param expectedTypes - Types d'entité parent autorisés.
    * @throws {ApiError} 401 - Si l'utilisateur n'est pas connecté.
-   * @throws {ApiError} 401 - Si l'utilisateur connecté n'est pas administrateur de l'entité parente.
    * @throws {ApiError} 404 - Si l'utilisateur n'est pas enregistré.
    * @throws {ApiError} 404 - Si l'entité parente n'est pas enregistrée.
+   * @throws {ApiError} 401 - Si l'utilisateur connecté n'est pas membre de l'entité parente.
    * @throws {ApiError} 400 - Si le type d'entité parent n'est pas valide.
    */
-  private _validateRoleCheckPreconditions(methodName: string, expectedTypes: string[]): void {
+  private _validateMemberPreconditions(methodName: string, expectedTypes: string[]): void {
     if (!this.userId) {
       throw new ApiError(`Vous devez être connecté pour ${methodName}.`, 401);
     }
 
-    if(!this.parent?.isAdmin()){
-      throw new ApiError("Vous devez être administrateur pour effectuer cette action.", 401);
-    }
-
     if (!this.id) {
       throw new ApiError(`${this.constructor.name} non enregistrée.`, 404);
     }
 
-    if(!this.parent?.id){
+    if (!this.parent?.id) {
       throw new ApiError("L'entité parente n'est pas enregistrée.", 404);
     }
 
     if (!expectedTypes.includes(this.parent.getEntityType())) {
       throw new ApiError(`L'entité doit être de type : ${expectedTypes.join(", ")}, reçu : ${this.parent.getEntityType()}`, 400);
     }
+
+    // Vérifier que l'utilisateur connecté a le bon rôle selon le type d'entité
+    // Pour les events, tout utilisateur connecté peut agir (pas besoin d'être participant)
+    const parentType = this.parent.getEntityType();
+
+    if (parentType === "events") {
+      // Pour les événements, être connecté suffit (déjà vérifié ci-dessus)
+      return;
+    }
+
+    let hasRole = false;
+
+    switch (parentType) {
+    case "organizations":
+      hasRole = this.parent.isMember();
+      break;
+    case "projects":
+      hasRole = this.parent.isContributor();
+      break;
+    default:
+      hasRole = false;
+    }
+
+    if (!hasRole) {
+      const roleNames: Record<string, string> = {
+        organizations: "membre",
+        projects: "contributeur"
+      };
+      const roleName = roleNames[parentType] || "membre";
+      throw new ApiError(`Vous devez être ${roleName} pour effectuer cette action.`, 401);
+    }
+  }
+
+  /**
+   * Valide les préconditions pour les méthodes nécessitant d'être administrateur.
+   * @private
+   * @param methodName - Nom de la méthode appelante (pour les messages d'erreur).
+   * @param expectedTypes - Types d'entité parent autorisés.
+   * @throws {ApiError} 401 - Si l'utilisateur n'est pas connecté.
+   * @throws {ApiError} 404 - Si l'utilisateur n'est pas enregistré.
+   * @throws {ApiError} 404 - Si l'entité parente n'est pas enregistrée.
+   * @throws {ApiError} 401 - Si l'utilisateur connecté n'est pas membre de l'entité parente.
+   * @throws {ApiError} 401 - Si l'utilisateur connecté n'est pas administrateur de l'entité parente.
+   * @throws {ApiError} 400 - Si le type d'entité parent n'est pas valide.
+   */
+  private _validateAdminPreconditions(methodName: string, expectedTypes: string[]): void {
+    this._validateMemberPreconditions(methodName, expectedTypes);
+
+    if (!this.parent?.isAdmin()) {
+      throw new ApiError("Vous devez être administrateur pour effectuer cette action.", 401);
+    }
   }
 
 
@@ -930,13 +993,24 @@ export class User extends BaseEntity<UserItemNormalized> {
    * @returns Le lien parent de l'utilisateur ou `null` s'il n'existe pas.
    * @private
    */
-  private _getParentLinkForUser(): any {
+  private _getParentLinkForUser(): ParentLink | null {
     const { connectTypeDisconnect } = this.parent!._getLinkMeta();
     const userId = this!.id;
     if (!userId) return null;
     return this.parent?.serverData?.links?.[connectTypeDisconnect]?.[userId] || null;
   }
 
+  /**
+   * Rafraîchit l'utilisateur et l'entité parente après une action.
+   * @private
+   */
+  private async _refreshWithParent(): Promise<void> {
+    await this.refresh();
+    if (this.parent) {
+      await this.parent.refresh();
+    }
+  }
+
   /**
    * Vérifie si l'utilisateur est administrateur de l'entité parente.
    *
@@ -978,7 +1052,7 @@ export class User extends BaseEntity<UserItemNormalized> {
    * }
    */
   override isAdmin(): boolean {
-    this._validateRoleCheckPreconditions("isAdmin", ["organizations", "projects"]);
+    this._validateMemberPreconditions("isAdmin", ["organizations", "projects"]);
     const parentLink = this._getParentLinkForUser();
     return this._validateUserLink(parentLink) && parentLink?.isAdmin === true;
   }
@@ -1009,7 +1083,7 @@ export class User extends BaseEntity<UserItemNormalized> {
    * }
    */
   override isMember(): boolean {
-    this._validateRoleCheckPreconditions("isMember", ["organizations"]);
+    this._validateMemberPreconditions("isMember", ["organizations"]);
     const parentLink = this._getParentLinkForUser();
     return this._validateUserLink(parentLink);
   }
@@ -1040,7 +1114,7 @@ export class User extends BaseEntity<UserItemNormalized> {
    * }
    */
   override isContributor(): boolean {
-    this._validateRoleCheckPreconditions("isContributor", ["projects"]);
+    this._validateMemberPreconditions("isContributor", ["projects"]);
     const parentLink = this._getParentLinkForUser();
     return this._validateUserLink(parentLink);
   }
@@ -1071,7 +1145,7 @@ export class User extends BaseEntity<UserItemNormalized> {
    * }
    */
   override isAttendee(): boolean {
-    this._validateRoleCheckPreconditions("isAttendee", ["events"]);
+    this._validateMemberPreconditions("isAttendee", ["events"]);
     const parentLink = this._getParentLinkForUser();
     return this._validateUserLink(parentLink);
   }
@@ -1094,7 +1168,7 @@ export class User extends BaseEntity<UserItemNormalized> {
    * ```
    */
   isInviting(): boolean {
-    this._validateRoleCheckPreconditions("isInviting", ["organizations", "projects", "events"]);
+    this._validateMemberPreconditions("isInviting", ["organizations", "projects", "events"]);
     const parentLink = this._getParentLinkForUser();
     if (!parentLink) return false;
     return parentLink?.isInviting === true;
@@ -1118,10 +1192,10 @@ export class User extends BaseEntity<UserItemNormalized> {
    * ```
    */
   isInvitingAdmin(): boolean {
-    this._validateRoleCheckPreconditions("isInvitingAdmin", ["organizations", "projects"]);
+    this._validateMemberPreconditions("isInvitingAdmin", ["organizations", "projects"]);
     const parentLink = this._getParentLinkForUser();
     if (!parentLink) return false;
-    return parentLink?.isAdminInviting === true && parentLink?.isAdmin === true;
+    return (parentLink?.isAdminInviting === true || parentLink?.isInviting === true) && parentLink?.isAdmin === true;
   }
 
   /**
@@ -1144,7 +1218,7 @@ export class User extends BaseEntity<UserItemNormalized> {
    * ```
    */
   isAdminPending(): boolean {
-    this._validateRoleCheckPreconditions("isAdminPending", ["organizations", "projects"]);
+    this._validateMemberPreconditions("isAdminPending", ["organizations", "projects"]);
     const parentLink = this._getParentLinkForUser();
     return parentLink?.isAdmin === true && parentLink?.isAdminPending === true;
   }
@@ -1169,16 +1243,11 @@ export class User extends BaseEntity<UserItemNormalized> {
    * ```
    */
   isToBeValidated(): boolean {
-    this._validateRoleCheckPreconditions("isToBeValidated", ["organizations", "projects", "events"]);
+    this._validateMemberPreconditions("isToBeValidated", ["organizations", "projects", "events"]);
     const parentLink = this._getParentLinkForUser();
     return parentLink?.toBeValidated === true;
   }
 
-
-  // ────────────────────────────────
-  //  Actions d'admin sur l'utilisateur par rapport à l'entité parente
-  // ────────────────────────────────
-
   /**
    * Envoie une demande pour rejoindre l'entité parente.
    *
@@ -1186,6 +1255,8 @@ export class User extends BaseEntity<UserItemNormalized> {
    * vers l'organisation ou le projet parent. Si l'utilisateur n'a pas encore de lien,
    * une demande de connexion est créée.
    *
+   * @param {Object} [options] - Options de la méthode
+   * @param {boolean} [options.admin=false] - Si true, utilise "admin" comme connectType au lieu du type par défaut (connectTypeConnect)
    * @returns {Promise<unknown>} La réponse de l'API après création de la demande
    * @throws {ApiError} Si l'utilisateur n'est pas connecté, pas admin, ou si le parent n'est pas défini
    * @throws {ApiError} Si l'utilisateur est déjà en attente de validation
@@ -1193,15 +1264,25 @@ export class User extends BaseEntity<UserItemNormalized> {
    *
    * @example
    * ```typescript
-   * // Un admin récupère les membres et envoie une invitation
+   * // Un admin récupère les membres et envoie une invitation (type par défaut)
    * const org = await me.organization({ slug: "myOrg" });
    * const users = await org.getMembers();
    * const user = users.results[0];
    * await user.sendRequestToJoinParent();
+   *
+   * // Avec le type admin explicite
+   * await user.sendRequestToJoinParent({ admin: true });
    * ```
    */
-  async sendRequestToJoinParent(): Promise<unknown> {
-    this._validateRoleCheckPreconditions("sendRequestToJoinParent", ["organizations", "projects"]);
+  async sendRequestToJoinParent({ admin }: { admin: boolean } = { admin: false }): Promise<unknown> {
+    // Validation selon le type d'invitation : admin requis pour inviter en tant qu'admin
+    if (admin) {
+      // Invitation admin : uniquement orga/project, seul un admin peut le faire
+      this._validateAdminPreconditions("sendRequestToJoinParent", ["organizations", "projects"]);
+    } else {
+      // Invitation simple : orga/project/event, membre/contributeur/connecté peut le faire
+      this._validateMemberPreconditions("sendRequestToJoinParent", ["organizations", "projects", "events"]);
+    }
 
     const { connectTypeConnect } = this.parent!._getLinkMeta();
 
@@ -1212,7 +1293,7 @@ export class User extends BaseEntity<UserItemNormalized> {
 
       const t = this.parent!.getEntityType();
 
-      // 2) Narrow de type pour TypeScript
+      // Narrow de type pour TypeScript
       const parentType = t as ConnectData["parentType"];
 
       const data: ConnectData = {
@@ -1220,21 +1301,17 @@ export class User extends BaseEntity<UserItemNormalized> {
         childType: "citoyens",
         parentType,
         parentId: this.parent!.id!,
-        connectType: connectTypeConnect
+        connectType: admin ? "admin" : connectTypeConnect
       };
 
       const retour = await this.callIsConnected(() => this.endpointApi.connect(data));
-      // Refresh l'utilisateur membre et l'entité parente
-      await this.refresh();
-      if (this.parent) {
-        await this.parent.refresh();
-      }
+      await this._refreshWithParent();
       return retour;
     }
 
-    // Cas : déjà en attente
-    if (parentLink.toBeValidated) {
-      throw new ApiError("Vous êtes déjà en attente de validation.", 400);
+    // Cas : déjà en attente d'acceptation
+    if (parentLink.isInviting || parentLink?.isAdminInviting) {
+      throw new ApiError("Une invitation est déjà en attente d'acceptation.", 400);
     }
 
     // Cas par défaut : rien à faire
@@ -1262,7 +1339,7 @@ export class User extends BaseEntity<UserItemNormalized> {
    * ```
    */
   async validateMemberRequest(): Promise<unknown> {
-    this._validateRoleCheckPreconditions("validateMemberRequest", ["organizations", "projects"]);
+    this._validateAdminPreconditions("validateMemberRequest", ["organizations", "projects"]);
 
     const parentLink = this._getParentLinkForUser();
 
@@ -1283,64 +1360,10 @@ export class User extends BaseEntity<UserItemNormalized> {
     };
 
     const retour = await this.callIsConnected(() => this.endpointApi.linkValidate(data));
-    // Refresh l'utilisateur membre et l'entité parente
-    await this.refresh();
-    if (this.parent) {
-      await this.parent.refresh();
-    }
+    await this._refreshWithParent();
     return retour;
   }
 
-  /**
-   * Valide une invitation en attente d'acceptation.
-   *
-   * Cette méthode permet à un admin de valider une invitation envoyée à un utilisateur
-   * qui est en attente (`isInviting: true`). Après validation, l'utilisateur devient
-   * membre actif de l'entité parente.
-   *
-   * @returns {Promise<unknown>} La réponse de l'API après validation
-   * @throws {ApiError} Si l'utilisateur n'est pas connecté, pas admin, ou si le parent n'est pas défini
-   * @throws {ApiError} Si l'utilisateur n'a pas d'invitation en attente
-   *
-   * @example
-   * ```typescript
-   * // Un admin valide une invitation en attente
-   * const org = await me.organization({ slug: "myOrg" });
-   * const members = await org.getMembers();
-   * const invitedUser = members.results.find(u => u.serverData.links?.memberOf?.[org.id]?.isInviting);
-   * await invitedUser.validateInvitation();
-   * ```
-   */
-  // async validateInvitation(): Promise<unknown> {
-  //   this._validateRoleCheckPreconditions("validateInvitation", ["organizations", "projects"]);
-
-  //   const parentLink = this._getParentLinkForUser();
-
-  //   if (!parentLink?.isInviting) {
-  //     throw new ApiError("Cet utilisateur n'a pas d'invitation en attente.", 400);
-  //   }
-
-  //   const t = this.parent!.getEntityType();
-
-  //   const parentType = t as LinkValidateData["parentType"];
-
-  //   const data: LinkValidateData = {
-  //     childId: this.id!,
-  //     childType: "citoyens",
-  //     parentType,
-  //     parentId: this.parent!.id!,
-  //     linkOption: "isInviting"
-  //   };
-
-  //   const retour = await this.callIsConnected(() => this.endpointApi.linkValidate(data));
-  //   // Refresh l'utilisateur membre et l'entité parente
-  //   await this.refresh();
-  //   if (this.parent) {
-  //     await this.parent.refresh();
-  //   }
-  //   return retour;
-  // }
-
   /**
    * Valide une demande d'admin en attente.
    *
@@ -1362,7 +1385,7 @@ export class User extends BaseEntity<UserItemNormalized> {
    * ```
    */
   async validateAdminRequest(): Promise<unknown> {
-    this._validateRoleCheckPreconditions("validateAdminRequest", ["organizations", "projects"]);
+    this._validateAdminPreconditions("validateAdminRequest", ["organizations", "projects"]);
 
     const parentLink = this._getParentLinkForUser();
 
@@ -1383,11 +1406,7 @@ export class User extends BaseEntity<UserItemNormalized> {
     };
 
     const retour = await this.callIsConnected(() => this.endpointApi.linkValidate(data));
-    // Refresh l'utilisateur membre et l'entité parente
-    await this.refresh();
-    if (this.parent) {
-      await this.parent.refresh();
-    }
+    await this._refreshWithParent();
     return retour;
   }
 
@@ -1411,7 +1430,7 @@ export class User extends BaseEntity<UserItemNormalized> {
    * ```
    */
   async removeFromParent(): Promise<unknown> {
-    this._validateRoleCheckPreconditions("removeFromParent", ["organizations", "projects"]);
+    this._validateAdminPreconditions("removeFromParent", ["organizations", "projects"]);
 
     const parentLink = this._getParentLinkForUser();
 
@@ -1434,11 +1453,7 @@ export class User extends BaseEntity<UserItemNormalized> {
     };
 
     const retour = await this.callIsConnected(() => this.endpointApi.disconnect(data));
-    // Refresh l'utilisateur membre et l'entité parente
-    await this.refresh();
-    if (this.parent) {
-      await this.parent.refresh();
-    }
+    await this._refreshWithParent();
     return retour;
   }
 
@@ -1463,7 +1478,7 @@ export class User extends BaseEntity<UserItemNormalized> {
    * ```
    */
   async promoteToAdmin(): Promise<unknown> {
-    this._validateRoleCheckPreconditions("promoteToAdmin", ["organizations", "projects"]);
+    this._validateAdminPreconditions("promoteToAdmin", ["organizations", "projects"]);
 
     const parentLink = this._getParentLinkForUser();
 
@@ -1471,7 +1486,11 @@ export class User extends BaseEntity<UserItemNormalized> {
       throw new ApiError("Cet utilisateur n'est pas membre de cette entité.", 400);
     }
 
-    if (parentLink.isAdmin && !parentLink.isAdminPending) {
+    if (parentLink?.isAdmin && (parentLink?.isInviting || parentLink?.isAdminInviting)) {
+      throw new ApiError("Cet utilisateur est déjà en cours d'invitation en tant qu'admin.", 400);
+    }
+
+    if (parentLink?.isAdmin && !parentLink?.isInviting && !parentLink?.isAdminInviting) {
       throw new ApiError("Cet utilisateur est déjà admin.", 400);
     }
 
@@ -1488,11 +1507,7 @@ export class User extends BaseEntity<UserItemNormalized> {
     };
 
     const retour = await this.callIsConnected(() => this.endpointApi.connect(data));
-    // Refresh l'utilisateur membre et l'entité parente
-    await this.refresh();
-    if (this.parent) {
-      await this.parent.refresh();
-    }
+    await this._refreshWithParent();
     return retour;
   }
 
@@ -1517,7 +1532,7 @@ export class User extends BaseEntity<UserItemNormalized> {
    * ```
    */
   async demoteFromAdmin(): Promise<unknown> {
-    this._validateRoleCheckPreconditions("demoteFromAdmin", ["organizations", "projects"]);
+    this._validateAdminPreconditions("demoteFromAdmin", ["organizations", "projects"]);
 
     const parentLink = this._getParentLinkForUser();
 
@@ -1543,11 +1558,7 @@ export class User extends BaseEntity<UserItemNormalized> {
     };
 
     const retour = await this.callIsConnected(() => this.endpointApi.demoteAdmin(data));
-    // Refresh l'utilisateur membre et l'entité parente
-    await this.refresh();
-    if (this.parent) {
-      await this.parent.refresh();
-    }
+    await this._refreshWithParent();
     return retour;
   }
 

package/types/api/BaseEntity.d.ts

@@ -1081,6 +1081,39 @@ export declare class BaseEntity<TServerData = any> {
             docType?: "image" | "file";
         };
     }): Promise<Record<string, any>>;
+    /**
+     * Recherche des membres (utilisateurs ou organisations) liés à l'entité courante.
+     *
+     * Cette méthode effectue une recherche par autocomplétion parmi les membres de l'entité
+     * (organisation, projet, événement). Les résultats sont filtrés selon le mode de recherche
+     * et retournés sous forme d'entités User ou Organization liées à l'entité parente.
+     *
+     * @param {SearchMemberAutocompleteData} data - Paramètres de recherche
+     * @param {string} data.search - Terme recherché (nom, slug, etc.)
+     * @param {"personOnly" | "organizationOnly" | "mixte"} data.searchMode - Mode de recherche :
+     *   - `"personOnly"` : recherche uniquement parmi les utilisateurs
+     *   - `"organizationOnly"` : recherche uniquement parmi les organisations
+     *   - `"mixte"` : recherche parmi les utilisateurs et organisations
+     * @returns {Promise<(User | Organization)[]>} Liste des entités correspondantes, liées à l'entité parente
+     * @throws {ApiError} Si le type d'entité n'est pas supporté (badges, news, poi, comments)
+     *
+     * @example
+     * ```typescript
+     * // Rechercher des utilisateurs dans une organisation
+     * const org = await me.organization({ slug: "myOrg" });
+     * const users = await org.searchMembers({ search: "jean", searchMode: "personOnly" });
+     * users.forEach(user => console.log(user.data.name));
+     *
+     * // Rechercher des organisations membres d'un projet
+     * const project = await me.project({ slug: "myProject" });
+     * const orgs = await project.searchMembers({ search: "asso", searchMode: "organizationOnly" });
+     * ```
+     *
+     * @remarks
+     * Les entités retournées sont automatiquement liées à l'entité parente via `_linkEntities`,
+     * ce qui permet d'utiliser les méthodes comme `sendRequestToJoinParent()`, `isAdminPending()`, etc.
+     */
+    searchMembers(data: SearchMemberAutocompleteData): Promise<(User | Organization)[]>;
     /**
      * Soumet une demande pour rejoindre l'entité courante (ex. organisation, projet, événement...).
      * Si une invitation est en attente, elle est automatiquement acceptée.
@@ -1381,6 +1414,5 @@ export declare class BaseEntity<TServerData = any> {
      */
     costumEventRequestLoadContextTag(data?: Partial<Omit<CostumEventRequestLoadContextTagData, "pathParams">>): Promise<unknown>;
     coformAnswersSearch(data?: Partial<CoformAnswersSearchData>): Promise<PaginatorPage<any>>;
-    searchMembers(data: SearchMemberAutocompleteData): Promise<any[]>;
 }
 export default BaseEntity;