@communecter/cocolight-api-client 1.0.77 → 1.0.79

package/src/api/User.ts

@@ -15,7 +15,8 @@ import type {
   GetSubscriptionsData,
   GetOrganizationsNoAdminData,
   GetOrganizationsAdminData,
-  GetFriendsAdminData
+  GetFriendsAdminData,
+  DemoteAdminData
 } from "./EndpointApi.types.js";
 import type { Organization } from "./Organization.js";
 import type { EntityTypes } from "@/types/entities.js";
@@ -888,6 +889,668 @@ export class User extends BaseEntity<UserItemNormalized> {
     }
     return super.entityBySlug(slug);
   }
+
+  /**
+   * Valide les préconditions communes pour les méthodes de vérification de rôle.
+   * @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} 400 - Si le type d'entité parent n'est pas valide.
+   */
+  private _validateRoleCheckPreconditions(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){
+      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);
+    }
+  }
+
+
+  /**
+   * Récupère le lien parent pour l'utilisateur actuel.
+   *
+   * @returns Le lien parent de l'utilisateur ou `null` s'il n'existe pas.
+   * @private
+   */
+  private _getParentLinkForUser(): any {
+    const { connectTypeDisconnect } = this.parent!._getLinkMeta();
+    const userId = this!.id;
+    if (!userId) return null;
+    return this.parent?.serverData?.links?.[connectTypeDisconnect]?.[userId] || null;
+  }
+
+  /**
+   * Vérifie si l'utilisateur est administrateur de l'entité parente.
+   *
+   * Cette méthode permet de vérifier si un utilisateur possède les droits d'administration
+   * sur l'organisation ou le projet parent. Elle est particulièrement utile après avoir
+   * récupéré des membres via `getMembers()` pour déterminer leur niveau de permissions.
+   *
+   * @returns `true` si l'utilisateur est administrateur de l'entité parente, `false` sinon.
+   *
+   * @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é (pas d'ID).
+   * @throws {ApiError} 404 - Si l'entité parente n'est pas enregistrée (pas d'ID).
+   * @throws {ApiError} 400 - Si l'entité parente n'est pas de type "organizations" ou "projects".
+   *
+   * @example
+   * // Vérifier les admins d'une organisation
+   * const org = await me.organization({ slug: "openAtlas" });
+   * const members = await org.getMembers();
+   *
+   * for (const member of members.results) {
+   *   if (member.getEntityType() === "citoyens") {
+   *     if (member.isAdmin()) {
+   *       console.log(`${member.data.name} est administrateur`);
+   *     }
+   *   }
+   * }
+   *
+   * @example
+   * // Récupérer uniquement les membres admins
+   * const org = await me.organization({ slug: "myOrg" });
+   * const adminMembers = await org.getMembers({}, { isAdmin: true });
+   *
+   * // Vérifier chaque admin
+   * for (const admin of adminMembers.results) {
+   *   if (admin.getEntityType() === "citoyens" && admin.isAdmin()) {
+   *     console.log(`${admin.data.name} a les droits admin`);
+   *   }
+   * }
+   */
+  override isAdmin(): boolean {
+    this._validateRoleCheckPreconditions("isAdmin", ["organizations", "projects"]);
+    const parentLink = this._getParentLinkForUser();
+    return this._validateUserLink(parentLink) && parentLink?.isAdmin === true;
+  }
+
+  /**
+   * Vérifie si l'utilisateur est membre de l'organisation parente.
+   *
+   * Cette méthode permet de vérifier si un utilisateur est membre actif d'une organisation.
+   * Elle est utile pour déterminer si un utilisateur a accès aux ressources de l'organisation.
+   *
+   * @returns `true` si l'utilisateur est membre validé de l'organisation parente, `false` sinon.
+   *
+   * @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é (pas d'ID).
+   * @throws {ApiError} 404 - Si l'entité parente n'est pas enregistrée (pas d'ID).
+   * @throws {ApiError} 400 - Si l'entité parente n'est pas de type "organizations".
+   *
+   * @example
+   * // Vérifier les membres d'une organisation
+   * const org = await me.organization({ slug: "myOrg" });
+   * const members = await org.getMembers();
+   *
+   * for (const member of members.results) {
+   *   if (member.getEntityType() === "citoyens" && member.isMember()) {
+   *     console.log(`${member.data.name} est membre de l'organisation`);
+   *   }
+   * }
+   */
+  override isMember(): boolean {
+    this._validateRoleCheckPreconditions("isMember", ["organizations"]);
+    const parentLink = this._getParentLinkForUser();
+    return this._validateUserLink(parentLink);
+  }
+
+  /**
+   * Vérifie si l'utilisateur est contributeur du projet parent.
+   *
+   * Cette méthode permet de vérifier si un utilisateur est contributeur actif d'un projet.
+   * Elle est utile pour déterminer si un utilisateur peut participer aux activités du projet.
+   *
+   * @returns `true` si l'utilisateur est contributeur validé du projet parent, `false` sinon.
+   *
+   * @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é (pas d'ID).
+   * @throws {ApiError} 404 - Si l'entité parente n'est pas enregistrée (pas d'ID).
+   * @throws {ApiError} 400 - Si l'entité parente n'est pas de type "projects".
+   *
+   * @example
+   * // Vérifier les contributeurs d'un projet
+   * const project = await me.project({ slug: "myProject" });
+   * const contributors = await project.getContributors();
+   *
+   * for (const contributor of contributors.results) {
+   *   if (contributor.getEntityType() === "citoyens" && contributor.isContributor()) {
+   *     console.log(`${contributor.data.name} est contributeur du projet`);
+   *   }
+   * }
+   */
+  override isContributor(): boolean {
+    this._validateRoleCheckPreconditions("isContributor", ["projects"]);
+    const parentLink = this._getParentLinkForUser();
+    return this._validateUserLink(parentLink);
+  }
+
+  /**
+   * Vérifie si l'utilisateur est participant de l'événement parent.
+   *
+   * Cette méthode permet de vérifier si un utilisateur est inscrit comme participant à un événement.
+   * Elle est utile pour déterminer si un utilisateur a confirmé sa participation à l'événement.
+   *
+   * @returns `true` si l'utilisateur est participant validé de l'événement parent, `false` sinon.
+   *
+   * @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é (pas d'ID).
+   * @throws {ApiError} 404 - Si l'entité parente n'est pas enregistrée (pas d'ID).
+   * @throws {ApiError} 400 - Si l'entité parente n'est pas de type "events".
+   *
+   * @example
+   * // Vérifier les participants d'un événement
+   * const event = await me.event({ slug: "myEvent" });
+   * const attendees = await event.getAttendees();
+   *
+   * for (const attendee of attendees.results) {
+   *   if (attendee.getEntityType() === "citoyens" && attendee.isAttendee()) {
+   *     console.log(`${attendee.data.name} participe à l'événement`);
+   *   }
+   * }
+   */
+  override isAttendee(): boolean {
+    this._validateRoleCheckPreconditions("isAttendee", ["events"]);
+    const parentLink = this._getParentLinkForUser();
+    return this._validateUserLink(parentLink);
+  }
+
+  /**
+   * Vérifie si l'utilisateur a une invitation en attente d'acceptation pour l'entité parente.
+   *
+   * Cette méthode vérifie si l'utilisateur a été invité à rejoindre l'organisation, le projet
+   * ou l'événement parent, mais n'a pas encore accepté l'invitation (`isInviting: true`).
+   *
+   * @returns {boolean} `true` si l'utilisateur a une invitation en attente, `false` sinon
+   * @throws {ApiError} Si l'utilisateur n'est pas connecté, pas admin du parent, ou si le parent n'est pas défini
+   *
+   * @example
+   * ```typescript
+   * const org = await me.organization({ slug: "myOrg" });
+   * const members = await org.getMembers();
+   * const invitedUser = members.results.find(m => m.isInviting());
+   * console.log("Invitation en attente:", invitedUser?.data.name);
+   * ```
+   */
+  isInviting(): boolean {
+    this._validateRoleCheckPreconditions("isInviting", ["organizations", "projects", "events"]);
+    const parentLink = this._getParentLinkForUser();
+    if (!parentLink) return false;
+    return parentLink?.isInviting === true;
+  }
+
+  /**
+   * Vérifie si l'utilisateur a une invitation en attente avec des droits d'admin.
+   *
+   * Cette méthode vérifie si l'utilisateur a été invité à rejoindre l'organisation ou le projet
+   * parent en tant qu'administrateur, mais n'a pas encore accepté (`isInviting: true` et `isAdmin: true`).
+   *
+   * @returns {boolean} `true` si l'utilisateur a une invitation admin en attente, `false` sinon
+   * @throws {ApiError} Si l'utilisateur n'est pas connecté, pas admin du parent, ou si le parent n'est pas défini
+   *
+   * @example
+   * ```typescript
+   * const org = await me.organization({ slug: "myOrg" });
+   * const members = await org.getMembers();
+   * const invitedAdmin = members.results.find(m => m.isInvitingAdmin());
+   * console.log("Invitation admin en attente:", invitedAdmin?.data.name);
+   * ```
+   */
+  isInvitingAdmin(): boolean {
+    this._validateRoleCheckPreconditions("isInvitingAdmin", ["organizations", "projects"]);
+    const parentLink = this._getParentLinkForUser();
+    if (!parentLink) return false;
+    return parentLink?.isAdminInviting === true && parentLink?.isAdmin === true;
+  }
+
+  /**
+   * Vérifie si l'utilisateur a une demande de promotion admin en attente de validation.
+   *
+   * Cette méthode vérifie si l'utilisateur a demandé ou a été proposé pour devenir administrateur
+   * de l'organisation ou du projet parent, mais la demande n'a pas encore été validée (`isAdminPending: true`).
+   *
+   * @returns {boolean} `true` si l'utilisateur a une demande admin en attente, `false` sinon
+   * @throws {ApiError} Si l'utilisateur n'est pas connecté, pas admin du parent, ou si le parent n'est pas défini
+   *
+   * @example
+   * ```typescript
+   * const org = await me.organization({ slug: "myOrg" });
+   * const members = await org.getMembers();
+   * const pendingAdmin = members.results.find(m => m.isAdminPending());
+   * if (pendingAdmin) {
+   *   await pendingAdmin.validateAdminRequest();
+   * }
+   * ```
+   */
+  isAdminPending(): boolean {
+    this._validateRoleCheckPreconditions("isAdminPending", ["organizations", "projects"]);
+    const parentLink = this._getParentLinkForUser();
+    return parentLink?.isAdmin === true && parentLink?.isAdminPending === true;
+  }
+
+  /**
+   * Vérifie si l'utilisateur a une demande d'adhésion en attente de validation.
+   *
+   * Cette méthode vérifie si l'utilisateur a demandé à rejoindre l'organisation, le projet
+   * ou l'événement parent, mais la demande n'a pas encore été validée par un administrateur (`toBeValidated: true`).
+   *
+   * @returns {boolean} `true` si l'utilisateur a une demande en attente, `false` sinon
+   * @throws {ApiError} Si l'utilisateur n'est pas connecté, pas admin du parent, ou si le parent n'est pas défini
+   *
+   * @example
+   * ```typescript
+   * const org = await me.organization({ slug: "myOrg" });
+   * const members = await org.getMembers();
+   * const pendingUser = members.results.find(m => m.isToBeValidated());
+   * if (pendingUser) {
+   *   await pendingUser.validateMemberRequest();
+   * }
+   * ```
+   */
+  isToBeValidated(): boolean {
+    this._validateRoleCheckPreconditions("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.
+   *
+   * Cette méthode permet à un admin de créer une demande de connexion pour un utilisateur
+   * vers l'organisation ou le projet parent. Si l'utilisateur n'a pas encore de lien,
+   * une demande de connexion est créée.
+   *
+   * @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
+   * @throws {ApiError} Si l'utilisateur est déjà connecté à l'entité
+   *
+   * @example
+   * ```typescript
+   * // Un admin récupère les membres et envoie une invitation
+   * const org = await me.organization({ slug: "myOrg" });
+   * const users = await org.getMembers();
+   * const user = users.results[0];
+   * await user.sendRequestToJoinParent();
+   * ```
+   */
+  async sendRequestToJoinParent(): Promise<unknown> {
+    this._validateRoleCheckPreconditions("sendRequestToJoinParent", ["organizations", "projects"]);
+
+    const { connectTypeConnect } = this.parent!._getLinkMeta();
+
+    const parentLink = this._getParentLinkForUser();
+
+    // Cas : aucun lien → on demande à se connecter
+    if (!parentLink) {
+
+      const t = this.parent!.getEntityType();
+
+      // 2) Narrow de type pour TypeScript
+      const parentType = t as ConnectData["parentType"];
+
+      const data: ConnectData = {
+        childId: this.id!,
+        childType: "citoyens",
+        parentType,
+        parentId: this.parent!.id!,
+        connectType: 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();
+      }
+      return retour;
+    }
+
+    // Cas : déjà en attente
+    if (parentLink.toBeValidated) {
+      throw new ApiError("Vous êtes déjà en attente de validation.", 400);
+    }
+
+    // Cas par défaut : rien à faire
+    throw new ApiError("Vous êtes déjà connecté à cette entité.", 400);
+  }
+
+  /**
+   * Valide une demande de membre en attente de validation.
+   *
+   * Cette méthode permet à un admin de valider une demande d'adhésion d'un utilisateur
+   * qui est en attente (`toBeValidated: 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 de demande en attente
+   *
+   * @example
+   * ```typescript
+   * // Un admin valide une demande en attente
+   * const org = await me.organization({ slug: "myOrg" });
+   * const members = await org.getMembers();
+   * const pendingUser = members.results.find(u => u.serverData.links?.memberOf?.[org.id]?.toBeValidated);
+   * await pendingUser.validateMemberRequest();
+   * ```
+   */
+  async validateMemberRequest(): Promise<unknown> {
+    this._validateRoleCheckPreconditions("validateMemberRequest", ["organizations", "projects"]);
+
+    const parentLink = this._getParentLinkForUser();
+
+    if (!parentLink?.toBeValidated) {
+      throw new ApiError("Cet utilisateur n'a pas de demande en attente de validation.", 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: "toBeValidated"
+    };
+
+    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 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.
+   *
+   * Cette méthode permet à un admin de valider une demande de promotion au statut d'admin
+   * pour un utilisateur qui est en attente (`isAdminPending: true`). Après validation,
+   * l'utilisateur devient admin 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 de demande d'admin en attente
+   *
+   * @example
+   * ```typescript
+   * // Un admin valide une demande de promotion à admin
+   * const org = await me.organization({ slug: "myOrg" });
+   * const members = await org.getMembers();
+   * const pendingAdmin = members.results.find(u => u.serverData.links?.memberOf?.[org.id]?.isAdminPending);
+   * await pendingAdmin.validateAdminRequest();
+   * ```
+   */
+  async validateAdminRequest(): Promise<unknown> {
+    this._validateRoleCheckPreconditions("validateAdminRequest", ["organizations", "projects"]);
+
+    const parentLink = this._getParentLinkForUser();
+
+    if (!parentLink?.isAdminPending) {
+      throw new ApiError("Cet utilisateur n'a pas de demande d'admin 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: "isAdminPending"
+    };
+
+    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;
+  }
+
+  /**
+   * Retire un utilisateur de l'entité parente.
+   *
+   * Cette méthode permet à un admin de déconnecter un membre de l'organisation ou du projet parent.
+   * L'utilisateur perd tous ses liens avec l'entité (membre, admin, etc.).
+   *
+   * @returns {Promise<unknown>} La réponse de l'API après déconnexion
+   * @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'est pas membre de l'entité
+   *
+   * @example
+   * ```typescript
+   * // Un admin retire un membre
+   * const org = await me.organization({ slug: "myOrg" });
+   * const members = await org.getMembers();
+   * const userToRemove = members.results[0];
+   * await userToRemove.removeFromParent();
+   * ```
+   */
+  async removeFromParent(): Promise<unknown> {
+    this._validateRoleCheckPreconditions("removeFromParent", ["organizations", "projects"]);
+
+    const parentLink = this._getParentLinkForUser();
+
+    if (!parentLink) {
+      throw new ApiError("Cet utilisateur n'est pas connecté à cette entité.", 400);
+    }
+
+    const t = this.parent!.getEntityType();
+
+    const parentType = t as DisconnectData["parentType"];
+
+    const { connectTypeDisconnect } = this.parent!._getLinkMeta();
+
+    const data: DisconnectData = {
+      childId: this.id!,
+      childType: "citoyens",
+      parentType,
+      parentId: this.parent!.id!,
+      connectType: connectTypeDisconnect
+    };
+
+    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();
+    }
+    return retour;
+  }
+
+  /**
+   * Promeut un utilisateur au statut d'admin de l'entité parente.
+   *
+   * Cette méthode permet à un admin de promouvoir un membre ordinaire au statut d'admin
+   * de l'organisation ou du projet parent.
+   *
+   * @returns {Promise<unknown>} La réponse de l'API après promotion
+   * @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'est pas membre de l'entité
+   * @throws {ApiError} Si l'utilisateur est déjà admin
+   *
+   * @example
+   * ```typescript
+   * // Un admin promeut un membre au statut d'admin
+   * const org = await me.organization({ slug: "myOrg" });
+   * const members = await org.getMembers();
+   * const userToPromote = members.results.find(u => !u.isAdmin());
+   * await userToPromote.promoteToAdmin();
+   * ```
+   */
+  async promoteToAdmin(): Promise<unknown> {
+    this._validateRoleCheckPreconditions("promoteToAdmin", ["organizations", "projects"]);
+
+    const parentLink = this._getParentLinkForUser();
+
+    if (!parentLink) {
+      throw new ApiError("Cet utilisateur n'est pas membre de cette entité.", 400);
+    }
+
+    if (parentLink.isAdmin && !parentLink.isAdminPending) {
+      throw new ApiError("Cet utilisateur est déjà admin.", 400);
+    }
+
+    const t = this.parent!.getEntityType();
+
+    const parentType = t as ConnectData["parentType"];
+
+    const data: ConnectData = {
+      childId: this.id!,
+      childType: "citoyens",
+      parentType,
+      parentId: this.parent!.id!,
+      connectType: "admin"
+    };
+
+    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();
+    }
+    return retour;
+  }
+
+  /**
+   * Rétrograde un admin au statut de membre ordinaire.
+   *
+   * Cette méthode permet à un admin de rétrograder un autre admin au statut de membre
+   * ordinaire de l'organisation ou du projet parent. L'utilisateur perd ses privilèges d'admin
+   * mais reste membre de l'entité.
+   *
+   * @returns {Promise<unknown>} La réponse de l'API après rétrogradation
+   * @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'est pas admin de l'entité
+   *
+   * @example
+   * ```typescript
+   * // Un admin rétrograde un autre admin
+   * const org = await me.organization({ slug: "myOrg" });
+   * const admins = await org.getMembers({}, { isAdmin: true });
+   * const adminToDemote = admins.results.find(u => u.isAdmin());
+   * await adminToDemote.demoteFromAdmin();
+   * ```
+   */
+  async demoteFromAdmin(): Promise<unknown> {
+    this._validateRoleCheckPreconditions("demoteFromAdmin", ["organizations", "projects"]);
+
+    const parentLink = this._getParentLinkForUser();
+
+    if (!parentLink?.isAdmin || parentLink.isAdminPending) {
+      throw new ApiError("Cet utilisateur n'est pas admin de cette entité.", 400);
+    }
+
+    const t = this.parent!.getEntityType();
+
+    const { connectTypeDisconnect } = this.parent!._getLinkMeta();
+
+    const parentType = t as DemoteAdminData["parentType"];
+
+    // Pour rétrograder un admin, on déconnecte le lien "admin"
+    // L'utilisateur garde son lien "member"
+    const data: DemoteAdminData = {
+      childId: this.id!,
+      childType: "citoyens",
+      parentType,
+      parentId: this.parent!.id!,
+      connect: connectTypeDisconnect as DemoteAdminData["connect"],
+      isAdmin: false
+    };
+
+    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();
+    }
+    return retour;
+  }
+
 }
 
 // Incorporation des mixins dans User

package/src/api/serverDataType/common.ts

@@ -18,6 +18,7 @@ export interface LinkRef<TType extends string = string> {
   isAdmin?: boolean;
   isAdminPending?: boolean;
   isInviting?: boolean;
+  isAdminInviting?: boolean;
   invitorId?: string;
   invitorName?: string;
   toBeValidated?: boolean;