@communecter/cocolight-api-client 1.0.154 → 1.0.156

package/src/api/User.ts

@@ -1,1889 +0,0 @@
-import { ApiError } from "../error.js";
-import { BaseEntity } from "./BaseEntity.js";
-import { Notifications } from "./Notifications.js";
-import { resolveCostumScope, costumScopeFromEntity, type CostumScope } from "../costum/runtime.js";
-import { UserMixin } from "../mixin/UserMixin.js";
-import { createSocialTransform } from "../types/transforms.js";
-
-
-import type { Badge } from "./Badge.js";
-import type { PaginatorPage, PaginatorState } from "./BaseEntity.js";
-import type {
-  ConnectData,
-  DisconnectData,
-  LinkValidateData,
-  FollowData,
-  ChangePasswordData,
-  DeleteAccountData,
-  GetSubscriptionsAdminData,
-  GetSubscriptionsData,
-  GetOrganizationsNoAdminData,
-  GetOrganizationsAdminData,
-  GetUserEligiblePlacesData,
-  GetFriendsAdminData,
-  DemoteAdminData,
-  GetNotificationsData,
-  GetNotificationsCountData,
-  NotificationUpdateData,
-  MarkNotificationAsReadData
-} from "./EndpointApi.types.js";
-import type { Organization } from "./Organization.js";
-import type { KnownCostumSlug } from "../costum/types.js";
-import type { NotificationItemData } from "./serverDataType/Notification.js";
-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;
-
-  static override entityTag = "User";
-
-  static override SCHEMA_CONSTANTS: string[] = [
-    "UPDATE_BLOCK_DESCRIPTION",
-    "UPDATE_BLOCK_INFO",
-    "UPDATE_BLOCK_SOCIAL",
-    "UPDATE_BLOCK_LOCALITY",
-    "UPDATE_BLOCK_SLUG",
-    "PROFIL_IMAGE"
-  ];
-
-  static UPDATE_BLOCKS = new Map([
-    ["UPDATE_BLOCK_DESCRIPTION", "updateDescription"],
-    ["UPDATE_BLOCK_SOCIAL", "updateSocial"],
-    ["UPDATE_BLOCK_LOCALITY", "updateLocality"],
-    ["UPDATE_BLOCK_INFO", "updateInfo"],
-    ["UPDATE_BLOCK_SLUG", "updateSlug"],
-    ["PROFIL_IMAGE", "updateImageProfil"]
-  ] as const);
-
-  override defaultFields: Record<string, any> = {
-    typeElement: this.getEntityType(),
-  };
-
-  override removeFields: string[] = [
-    "typeElement",
-  ];
-
-  override transforms: Record<string, (val: any, full: any) => any> = {
-    github: createSocialTransform("github"),
-    gitlab: createSocialTransform("gitlab"),
-    facebook: createSocialTransform("facebook"),
-    twitter: createSocialTransform("twitter"),
-    instagram: createSocialTransform("instagram"),
-    diaspora: createSocialTransform("diaspora"),
-    mastodon: createSocialTransform("mastodon"),
-    telegram: createSocialTransform("telegram"),
-    signal: createSocialTransform("signal")
-  };
-      
-  /**
-   * Crée une instance de `User`.
-   *
-   * @param parent
-   *        L'ApiClient, une entité parente, ou tout objet exposant `apiClient`.
-   * @param {{ id?: string, slug?: string }} data  Données initiales (il faut au moins `id` OU `slug`).
-   * @param {{
-   *   EndpointApi: EndpointApiDep,
-   *   Organization: typeof import("./Organization.js").Organization,
-   *   Project: typeof import("./Project.js").Project,
-   *   Event: typeof import("./Event.js").Event,
-   *   Poi: typeof import("./Poi.js").Poi,
-   *   Badge: typeof import("./Badge.js").Badge,
-   *   News: typeof import("./News.js").News
-   * }} deps
-   * @throws {ApiError} Si `EndpointApi` n'est pas injecté, ou si `id`/`slug` manquent,
-   *                    ou si une des classes dépendantes n'est pas injectée.
-   */
-  constructor(
-    parent: ApiClient | any,
-    data: { id?: string; slug?: string },
-    deps: {
-      EndpointApi: any;
-      Organization: typeof import("./Organization.js").Organization;
-      Project: typeof import("./Project.js").Project;
-      Event: typeof import("./Event.js").Event;
-      Poi: typeof import("./Poi.js").Poi;
-      Badge: typeof import("./Badge.js").Badge;
-      News: typeof import("./News.js").News;
-      Comment: typeof import("./Comment.js").Comment;
-      Answer: typeof import("./Answer.js").Answer;
-      Form?: typeof import("./Form.js").Form;
-      Classified?: typeof import("./Classified.js").Classified;
-      Action?: typeof import("./Action.js").Action;
-    }
-  ) {
-    if(!deps.EndpointApi){
-      throw new ApiError("EndpointApi class must be injected to avoid circular dependency.", 500);
-    }
-    if (!data?.id && !data?.slug) {
-      throw new ApiError("Vous devez fournir un id ou un slug pour créer un User.", 400);
-    }
-
-    if (!deps.Organization) throw new ApiError("Organization class must be injected.", 500);
-    if (!deps.Project) throw new ApiError("Project class must be injected.", 500);
-    if (!deps.Event) throw new ApiError("Event class must be injected.", 500);
-    if (!deps.Poi) throw new ApiError("Poi class must be injected.", 500);
-    if (!deps.Badge) throw new ApiError("Badge class must be injected.", 500);
-    if (!deps.News) throw new ApiError("News class must be injected.", 500);
-    if (!deps.Answer) throw new ApiError("Answer class must be injected.", 500);
-
-    super(parent, data, deps);
-  }
-
-  override get slug() {
-    return this._draftData.slug || null;
-  }
-
-  override get isMe() {
-    return this.isConnected && this.userId === this.id;
-  }
-
-  get parentIsMe() {
-    return super.isMe;
-  }
-
-  get isActingUser() {
-    return this.parentIsMe && !this.isMe;
-  }
-
-  /** @returns {"citoyens"} */
-  override getEntityType(): "citoyens" { return "citoyens"; }
-
-  /**
-     * Récupère le profil complet de l'utilisateur.
-     * Si l'utilisateur est connecté, on appelle le endpoint ME_INFO_URL,
-     * sinon, on peut imaginer appeler un endpoint public.
-     *
-     * @returns Le profil complet.
-     */
-  override async get(): Promise<Record<string, any>> {
-    // Tombstone : `meInfoUrl()` est basé sur le token (ignore `this.id`), donc cette
-    // lecture ne lèverait pas via le garde `!this.id` après un delete — on garde ici.
-    this._checkNotDeleted();
-    return this.apiClient.safeCall(async () => {
-      if (this.isMe) {
-        const data = await this.endpointApi.meInfoUrl();
-        this._setData(data as UserItemNormalized, { forceInitialDraftReset: true });
-        return data;
-      } else {
-        const data = await this._getPublicProfile();
-        this._setData(data as UserItemNormalized, { forceInitialDraftReset: true });
-        return data;
-      }
-    });
-  }
-
-  /**
-   * Changer le mot de passe : Permet de changer le mot de passe d'un utilisateur.
-   * Constant : CHANGE_PASSWORD
-   * @param data - Données envoyées à l'API
-   * @returns - 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: ChangePasswordData): Promise<unknown> {
-    return this.callIsMe(() => this.endpointApi.changePassword(data));
-  }
-
-  /**
-   * Supprimer un compte : Permet de supprimer un compte utilisateur.
-   * Constant : DELETE_ACCOUNT
-   * @param data - Données envoyées à l'API
-   * @returns - 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 delete(data: DeleteAccountData): Promise<unknown> {
-    const result = await this.callIsMe(() => this.endpointApi.deleteAccount(data));
-
-    // Vider les objets réactifs sans casser la réactivité (cf. Action/Answer/News/Comment.delete)
-    Object.keys(this._draftData).forEach(key => delete this._draftData[key]);
-    Object.keys(this._serverData).forEach(key => delete (this._serverData as any)[key]);
-
-    // Marquer comme supprimé → toute opération ultérieure lève le tombstone.
-    this._isDeleted = true;
-    return result;
-  }
-  
-  /**
-   * Sauvegarde les modifications de l'utilisateur en appelant les endpoints correspondants.
-   * Seul l'utilisateur connecté peut se modifier lui-même.
-   *
-   * @returns - Données serveur mises à jour si applicable.
-   * @throws {ApiError} - Si l'utilisateur n'est pas autorisé.
-   */
-  override async save(): Promise<Record<string, any>> {
-    if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour sauvegarder.", 401);
-    }
-    return await super.save();
-  }
-
-  override _add = async () => {
-    throw new ApiError("Vous ne pouvez pas ajouter un utilisateur par ce moyen.", 403);
-  };
-
-  /**
-   * Met à jour les blocs modifiés de l'utilisateur via les constantes de schéma définies.
-   *
-   * @param payload - Données courantes à comparer et envoyer.
-   * @returns - Indique s'il y a eu une modification réelle.
-   * @throws {ApiError} - Si l'utilisateur n'est pas autorisé à effectuer cette action.
-   */
-  override _update = async (payload: Record<string, any>): Promise<boolean> => {
-    if (!this._calledFromSave) {
-      throw new ApiError("utilisation invalide de _update, utilisez save", 400);
-    }
-
-    if (payload.id) {
-      delete payload.id;
-    }
-
-    let hasChanged = false;
-
-    // Sinon, on fait les updates en blocs
-    for (const [constant, methodName] of Array.from(User.UPDATE_BLOCKS)) {
-      const blockData = this._extractChangedFieldsFromSchema(
-        this.apiClient,
-        constant,
-        { ...payload, ...this.defaultFields},
-        () => this.initialDraftData,
-        this.removeFields
-      );
-      if (blockData && Object.keys(blockData).length > 0) {
-        await this._invokeBlockMethod(User.UPDATE_BLOCKS, methodName, blockData);
-        hasChanged = true;
-      }
-    }
-  
-    return hasChanged;
-  };
-
-  static override fromServerData(data: any, parent: any, deps: any): User {
-    const Ctor = this as any;
-    const instance = new Ctor(parent, data, deps);
-    if (data && typeof data === "object" && Object.keys(data).length > 0 && typeof instance._setData === "function") {
-      // Voir BaseEntity.fromServerData : on réconcilie le baseline de diff avec l'état serveur
-      // pour qu'une entité fraîchement revifiée ne se croie pas « entièrement modifiée ».
-      instance._setData(data as UserItemNormalized, { forceInitialDraftReset: true });
-    }
-    return instance;
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#updateSettings}
-   *
-   * Mettre à jour les paramètres utilisateur : Mise à jour des paramètres spécifiques d'un utilisateur.
-   */
-  override async updateSettings(data: Parameters<BaseEntity<UserItemNormalized>["updateSettings"]>[0]) {
-    if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour les paramètres.", 401);
-    }
-    const result = await super.updateSettings(data);
-    await this.refresh();
-    return result;
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#updateDescription}
-   *
-   * Mettre à jour la description d'un élément : Permet de mettre à jour la description courte et complète d'un élément.
-   */
-  override async updateDescription(data: Parameters<BaseEntity<UserItemNormalized>["updateDescription"]>[0]) {
-    if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour la description.", 401);
-    }
-    return super.updateDescription(data);
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#updateInfo}
-   *
-   * Mettre à jour les informations d'un élément : Permet de mettre à jour les informations générales d'un élément (nom, contacts, etc.).
-   */
-  override async updateInfo(data: Parameters<BaseEntity<UserItemNormalized>["updateInfo"]>[0]) {
-    if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour les informations.", 401);
-    }
-    return super.updateInfo(data);
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#updateSocial}
-   *
-   * 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.
-   */
-  override async updateSocial(data: Parameters<BaseEntity<UserItemNormalized>["updateSocial"]>[0]) {
-    if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour les réseaux sociaux.", 401);
-    }
-    return super.updateSocial(data);
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#updateLocality}
-   *
-   * Mettre à jour les localités d'un élément : Permet de mettre à jour l'adresse et les informations géographiques d'un élément.
-   */
-  override async updateLocality(data: Parameters<BaseEntity<UserItemNormalized>["updateLocality"]>[0]) {
-    if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour la localité.", 401);
-    }
-    return super.updateLocality(data);
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#updateSlug}
-   *
-   * Mettre à jour le slug d'un élément : Permet de mettre à jour le slug pour une URL simplifiée.
-   */
-  override async updateSlug(data: Parameters<BaseEntity<UserItemNormalized>["updateSlug"]>[0]) {
-    if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour le slug.", 401);
-    }
-    return super.updateSlug(data);
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#updateImageProfil}
-   *
-   * Mettre à jour l'image de profil : Permet de mettre à jour l'image de profil d'un utilisateur ou d'une entité.
-   */
-  override async updateImageProfil(data: Parameters<BaseEntity<UserItemNormalized>["updateImageProfil"]>[0]) {
-    if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour l'image de profil.", 401);
-    }
-    return super.updateImageProfil(data);
-  }
-
-
-  /**
-   * {@inheritDoc BaseEntity#updateImageBanner}
-   *
-   * Mettre à jour l'image de bannière : Permet de mettre à jour l'image de bannière d'un utilisateur ou d'une entité.
-   */
-  override async updateImageBanner(data: Parameters<BaseEntity<UserItemNormalized>["updateImageBanner"]>[0]) {
-    if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour l'image de bannière.", 401);
-    }
-    return super.updateImageBanner(data);
-  }
-  
-
-  /**
-   * {@inheritDoc BaseEntity#getOrganizations}
-   * @param [data]
-   * 
-   * Récupérer les organisations d'un utilisateur : Récupère la liste des organisations auxquelles l'utilisateur appartient.
-   * Constant : GET_ORGANIZATIONS_ADMIN | GET_ORGANIZATIONS_NO_ADMIN
-   */
-  override async getOrganizations(
-    data: Partial<GetOrganizationsAdminData | GetOrganizationsNoAdminData> = {},
-    options?: { restoredState?: PaginatorState }
-  ) {
-    data.searchType = this._getDefaultFromEndpoint("GET_ORGANIZATIONS_NO_ADMIN", "searchType") as GetOrganizationsNoAdminData["searchType"];
-    // data.searchBy = "ALL";
-
-    const paginator = this._createPaginatorEngine({
-      initialData: data,
-      methodName: "getOrganizations",
-      restoredState: options?.restoredState,
-      finalizer: async (finalData) => {
-        delete finalData?.pathParams;
-
-        const fetchFn = this.isMe
-          ? () => this.callIsMe(() => this.endpointApi.getOrganizationsAdmin(finalData))
-          : () => this.endpointApi.getOrganizationsNoAdmin(finalData);
-
-        if (!this.isMe && !finalData.filters) {
-          finalData.filters = {
-            [`links.members.${this.id}`]: { "$exists": true },
-            [`links.members.${this.id}.toBeValidated`]: { "$exists": false },
-            [`links.members.${this.id}.isInviting`]: { "$exists": false }
-          };
-        }
-
-        return fetchFn();
-      }
-    });
-
-    return paginator.next() as Promise<PaginatorPage<Organization>>;
-  }
-
-  /**
-   * Récupère les lieux (organizations) memberOf de l'utilisateur, filtrés
-   * côté serveur par des filters arbitraires (tags, source.key, etc.) et
-   * un flag `notSourceKey` configurables.
-   *
-   * Mirroir de `getOrganizations` mais permet de passer dynamiquement les
-   * filtres du finder du formulaire (vue collaborative coform/place), pour
-   * que la pagination soit correcte (filtrage côté serveur, pas côté client).
-   *
-   * Constant : GET_USER_ELIGIBLE_PLACES
-   */
-  async getEligiblePlaces(
-    data: Partial<GetUserEligiblePlacesData> = {},
-    options?: { restoredState?: PaginatorState }
-  ) {
-    // Force le default `searchType` ([NGO, Cooperative, ...]) — le PHP ne
-    // retourne rien si le tableau est vide / absent. Pattern aligné avec
-    // `getOrganizations`.
-    data.searchType = this._getDefaultFromEndpoint(
-      "GET_USER_ELIGIBLE_PLACES",
-      "searchType"
-    ) as GetUserEligiblePlacesData["searchType"];
-
-    const paginator = this._createPaginatorEngine({
-      initialData: data,
-      methodName: "getEligiblePlaces",
-      restoredState: options?.restoredState,
-      finalizer: async (finalData) => {
-        delete finalData?.pathParams;
-
-        // Auto-merge du filtre memberOf par défaut si l'appelant n'en pousse
-        // que des filters "métier" (tags, etc.). On garde la sémantique
-        // "uniquement les orgs où l'user est membre validé".
-        const userFilters = finalData.filters ?? {};
-        const memberOfDefaults: Record<string, unknown> = {
-          [`links.members.${this.id}`]: { "$exists": true },
-          [`links.members.${this.id}.toBeValidated`]: { "$exists": false },
-          [`links.members.${this.id}.isInviting`]: { "$exists": false },
-        };
-        finalData.filters = { ...memberOfDefaults, ...userFilters };
-
-        // Cast nécessaire : callIsMe est typé Promise<unknown>, mais l'endpoint
-        // retourne bien la shape `{ results, count }` attendue par le finalizer.
-        // Pattern aligné avec getOrganizations (cf. la branche ternaire au-dessus).
-        return this.callIsMe(() => this.endpointApi.getUserEligiblePlaces(finalData)) as ReturnType<
-          typeof this.endpointApi.getUserEligiblePlaces
-        >;
-      },
-    });
-
-    return paginator.next() as Promise<PaginatorPage<Organization>>;
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#getProjects}
-   * 
-   * Récupérer les projets d'un utilisateur : Récupère la liste des projets auxquels l'utilisateur contribue.
-   */
-  override async getProjects(data: Parameters<BaseEntity<UserItemNormalized>["getProjects"]>[0] = {}) {
-    return super.getProjects(data);
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#getEvents}
-   *
-   * Récupère les événements d'un utilisateur.
-   */
-  override async getEvents(data: Parameters<BaseEntity<UserItemNormalized>["getEvents"]>[0] = {}) {
-    return super.getEvents(data);
-  }
-    
-  /**
-   * {@inheritDoc BaseEntity#getPois}
-   * 
-   * Récupérer les POIs
-   */
-  override async getPois(data: Parameters<BaseEntity<UserItemNormalized>["getPois"]>[0] = {}) {
-    return super.getPois(data);
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#getNews}
-   * 
-   * Récupérer les actualités : Récupère la liste des actualités liées à l'utilisateur.
-   */
-  override async getNews(data: Parameters<BaseEntity<UserItemNormalized>["getNews"]>[0] = {}) {
-    return super.getNews(data);
-  }
-
-  /**
-   * Récupérer les amis administrables : Récupère les amis administrée par l’utilisateur.
-   * Constant : GET_FRIENDS_ADMIN
-   * question : qui peut voir la liste d'amis, seulement l'utilisateur connecté ? ou tous les utilisateurs connectés ?
-   * actuellement, c'est tous les utilisateurs connectés
-   */
-  async getFriends(
-    data: Partial<GetFriendsAdminData> = {},
-    options?: { restoredState?: PaginatorState }
-  ): Promise<PaginatorPage<User>> {
-    data.searchType = this._getDefaultFromEndpoint("GET_FRIENDS_ADMIN", "searchType") as GetFriendsAdminData["searchType"];
-    // data.searchBy = "ALL";
-
-    const paginator = this._createPaginatorEngine({
-      initialData: data,
-      methodName: "getFriends",
-      restoredState: options?.restoredState,
-      finalizer: async (finalData) => {
-
-        delete finalData?.pathParams;
-
-        if (!this.isMe && this.id){
-          // is not me add id
-          finalData.pathParams = { id: this.id };
-        }
-
-        return this.endpointApi.getFriendsAdmin(finalData);
-      }
-    });
-
-    return paginator.next() as Promise<PaginatorPage<User>>;
-  }
-
-  /**
-   * Récupérer les suivis
-   * Constant : GET_SUBSCRIPTIONS / GET_SUBSCRIPTIONS_ADMIN
-   */
-  async getSubscriptions(
-    data: Partial<GetSubscriptionsAdminData | GetSubscriptionsData> = {},
-    options?: { restoredState?: PaginatorState }
-  ): Promise<PaginatorPage<BaseEntity<any>>> {
-    data.searchType = this._getDefaultFromEndpoint("GET_SUBSCRIPTIONS", "searchType") as GetSubscriptionsAdminData["searchType"];
-    // data.searchBy = "ALL";
-
-    const paginator = this._createPaginatorEngine({
-      initialData: data,
-      methodName: "getSubscriptions",
-      restoredState: options?.restoredState,
-      finalizer: async (finalData) => {
-
-        delete finalData?.pathParams;
-
-        const fetchFn = this.isMe
-          ? () => this.callIsMe(() => this.endpointApi.getSubscriptionsAdmin(finalData))
-          : () => this.endpointApi.getSubscriptions(finalData);
-
-        if (!this.isMe && !finalData.filters) {
-          finalData.filters = {
-            [`links.followers.${this.id}`]: { "$exists": true },
-          };
-        }
-
-        return fetchFn();
-      }
-    });
-
-    return paginator.next() as Promise<PaginatorPage<BaseEntity<any>>>;
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#getSubscribers}
-   * 
-   * Récupérer les abonnés
-   */
-  override async getSubscribers(data: Parameters<BaseEntity<UserItemNormalized>["getSubscribers"]>[0] = {}) {
-    return super.getSubscribers(data);
-  }
-
-  /**
-   * Obtenir la liste des événements
-   * Constant : GET_EVENTS
-   * TODO : il n'est pas fait encore pour GET_EVENTS_ADMIN / GET_EVENTS_NO_ADMIN comme les autres dans endpointApi
-   */
-
-  /**
-   * {@inheritDoc BaseEntity#getBadgesIssuer}
-   * 
-   * Liste des badges créés par l'utilisateur
-   */
-  override async getBadgesIssuer(data: Parameters<BaseEntity<UserItemNormalized>["getBadgesIssuer"]>[0] = {}) {
-    return super.getBadgesIssuer(data);
-  }
-
-  /**
-   * Liste des badges associés à l'utilisateur
-   * 
-   * TODO : documenté le fonctionnement et sont utilisation avec un exemple
-   */
-  async getBadges(filter: Record<string, any> = {}): Promise<Badge[]> {
-    /*
-      "badges": {
-            "627df5663a0fae60e57f4a31": {
-                "attenteRecepteur": true,
-                "expiredOn": false,
-                "isParcours": "false",
-                "issuedOn": "2023-10-02T14:00:00.000Z",
-                "name": "CODEV",
-                "show": "true",
-            },
-        },
-    */
-
-    const filteredBadges = await this.linkEntitiesFromServerData("badges", filter);
-    // voir si je les met dans objet { count, results }
-    return filteredBadges;
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#getGallery}
-   * 
-   * Récupérer la galerie de l'utilisateur
-   */
-  override async getGallery(data: Parameters<BaseEntity<UserItemNormalized>["getGallery"]>[0] = {}) {
-    return super.getGallery(data);
-  }
-
-  async user(userData: { id?: string, slug?: string }): Promise<User> {
-    if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur", 401);
-    }
-    if (!userData.id && !userData.slug) {
-      throw new ApiError("Vous devez fournir un id ou un slug pour créer un User.", 400);
-    }
-    const requiredDeps = this.deps as any;
-    const user = new User(this, userData, requiredDeps as any);
-    await user.get();
-    return user;
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#organization}
-   * 
-   * Crée une instance d'organisation et récupère son profil si nécessaire.
-   */
-  override async organization(organizationData: Parameters<BaseEntity<UserItemNormalized>["organization"]>[0] = {}) {
-    if(!("id" in organizationData) && !("slug" in organizationData) && !this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer une organisation.", 401);
-    }
-    return super.organization(organizationData);
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#project}
-   * 
-   * Crée une instance de projet et récupère son profil si nécessaire.
-   */
-  override async project(projectData: Parameters<BaseEntity<UserItemNormalized>["project"]>[0] = {}) {
-    if(!("id" in projectData) && !("slug" in projectData) && !this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un projet.", 401);
-    }
-    return super.project(projectData);
-  }
-
-  /**
-   * Bloqué sur User : un Form nécessite un costumContext (slug d'Organization/Project)
-   * que User n'a pas. Utilisez `user.organization({slug}).then(o => o.form({id}))`
-   * ou `user.project({slug}).then(p => p.form({id}))` pour la chaîne propagée.
-   */
-  override async form(): Promise<never> {
-    throw new ApiError(`form n'existe pas dans ${this.constructor.name}`, 501);
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#news}
-   * 
-   * Crée une instance de news et la récupère si nécessaire.
-   */
-  override async news(newsData: Parameters<BaseEntity<UserItemNormalized>["news"]>[0] = {}) {
-    if(!("id" in newsData) && !this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer une actualité.", 401);
-    }
-    return super.news(newsData);
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#poi}
-   * 
-   * Crée une instance de POI et la récupère si nécessaire.
-   */
-  override async poi(poiData: Parameters<BaseEntity<UserItemNormalized>["poi"]>[0] = {}) {
-    if(!("id" in poiData) && !("slug" in poiData) && !this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un POI.", 401);
-    }
-    return super.poi(poiData);
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#event}
-   *
-   * Crée une instance d'événement et la récupère si nécessaire.
-   */
-  override async event(eventData: Parameters<BaseEntity<UserItemNormalized>["event"]>[0] = {}) {
-    if(!("id" in eventData) && !("slug" in eventData) && !this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un événement.", 401);
-    }
-    return super.event(eventData);
-  }
-
-  /**
-   * Ouvre un *scope costum* : les entités créées via le scope (`poi`/`organization`/`project`/`event`)
-   * portent le contexte costum (costumSlug + champs costum validés par le binding du costum à `element/save`).
-   *
-   * @example
-   * const tl = await me.costum("reseauTierslieux");
-   * const org = await tl.organization({ name: "Mon TL", manageModel: "Association", buildingSurfaceArea: "120" });
-   * await org.save();
-   *
-   * Deux formes :
-   *  - `me.costum(slug)` : slug d'un costum du registry (autocomplété) OU n'importe quel slug (`string`) —
-   *    le backend reste l'autorité de validité (`found`). Slug hors registry sans champ → inc1b (résolution live).
-   *  - `me.costum(entity)` : ouvre un scope FIELDLESS depuis une entité DÉJÀ CHARGÉE (org/projet/event qui porte
-   *    un costum), zéro fetch — `source.key` = slug de l'entité. Cas « créer sous ce site nu ».
-   *
-   * @param arg - slug (`KnownCostumSlug | string`) OU une entité chargée porteuse d'un costum.
-   */
-  async costum(slug: KnownCostumSlug | (string & {})): Promise<CostumScope>;
-  async costum(entity: BaseEntity): Promise<CostumScope>;
-  async costum(arg: KnownCostumSlug | (string & {}) | BaseEntity): Promise<CostumScope> {
-    if (typeof arg === "string") return resolveCostumScope(this, arg);
-    return costumScopeFromEntity(this, arg);
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#badge}
-   * 
-   * Crée une instance de badge et la récupère si nécessaire.
-   */
-  override async badge(badgeData: Parameters<BaseEntity<UserItemNormalized>["badge"]>[0] = {}) {
-    if(!("id" in badgeData) && !this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un badge.", 401);
-    }
-    return super.badge(badgeData);
-  }
-
-  /**
-   * ───────────────────────────────
-   *  Lien utilisateur ↔ utilisateur (ami)
-   *  (demander, valider, se retirer)
-   * ───────────────────────────────
-   */
-
-  /**
-   * Envoie une demande d'amitié à cet utilisateur.
-   * L'utilisateur ciblé devra valider la demande pour établir la relation.
-   *
-   * @returns - Résultat de la requête.
-   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'action est interdite.
-   */
-  async sendFriendRequest(): Promise<unknown> {
-    if (!this.isActingUser || !this.userId) {
-      throw new ApiError("Vous devez être connecté pour envoyer une demande d'amis.", 401);
-    }
-
-    this._checkLinkableEntity();
-    if (!this.id) {
-      throw new ApiError(`${this.constructor.name} non enregistrée.`, 404);
-    }
-
-    const { connectTypeConnect } = this._getLinkMeta();
-    const userLink = this._getLinkFromConnectedUser();
-
-    if (!userLink) {
-      const data: ConnectData = {
-        childId: this.userId,
-        childType: "citoyens",
-        parentType: this.getEntityType(),
-        parentId: this.id,
-        connectType: connectTypeConnect
-      };
-      const retour = await this.endpointApi.connect(data);
-      // TODO : reflechier au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
-      await this.userContext?.refresh();
-      return retour;
-    }
-
-    if (userLink.isInviting && userLink.invitorId === this.id) {
-      return this.acceptFriendRequest();
-    }
-
-    if (userLink.isInviting && userLink.invitorId === this.userId) {
-      throw new ApiError("Vous avez déjà envoyé une demande d'amis à cet utilisateur.", 403);
-    }
-
-    throw new ApiError("Vous êtes déjà connecté à cette entité.", 409);
-  }
-
-  /**
-   * Accepte une demande d'amitié envoyée par cet utilisateur.
-   * Cette action établit un lien entre les deux utilisateurs.
-   *
-   * @returns - Résultat de la validation du lien.
-   * @throws {ApiError} - Si aucune invitation n'est en attente ou si l'action est interdite.
-   */
-  async acceptFriendRequest(): Promise<unknown> {
-    if (!this.isActingUser || !this.userId) {
-      throw new ApiError("Vous devez être connecté pour accepter une demande d'amitié.", 401);
-    }
-
-    this._checkLinkableEntity();
-    if (!this.id) {
-      throw new ApiError(`${this.constructor.name} non enregistrée.`, 404);
-    }
-
-    const userLink = this._getLinkFromConnectedUser();
-
-    if (userLink?.isInviting && userLink.invitorId === this.id) {
-      const data: LinkValidateData = {
-        childId: this.userId,
-        childType: "citoyens",
-        parentType: this.getEntityType(),
-        parentId: this.id,
-        linkOption: "isInviting"
-      };
-      const retour = await this.endpointApi.linkValidate(data);
-      // TODO : reflechier au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
-      await this.userContext?.refresh();
-      return retour;
-    }
-
-    throw new ApiError("Vous n'avez pas d'invitation à valider.", 404);
-  }
-
-  /**
-   * Supprime la relation d'amitié avec cet utilisateur.
-   * Cette action annule tout lien existant entre les deux profils.
-   *
-   * @returns - Résultat de la suppression.
-   * @throws {ApiError} - Si aucune relation n'existe.
-   */
-  async removeFriend(): Promise<unknown> {
-    if (!this.isActingUser || !this.userId) {
-      throw new ApiError("Vous devez être connecté pour supprimer un ami.", 401);
-    }
-
-    this._checkLinkableEntity();
-    if (!this.id) {
-      throw new ApiError(`${this.constructor.name} non enregistrée.`, 404);
-    }
-
-    const { connectTypeDisconnect } = this._getLinkMeta();
-    const userLink = this._getLinkFromConnectedUser();
-
-    if (!userLink) {
-      throw new ApiError("Vous n'êtes pas connecté à cette entité.", 404);
-    }
-    const data: DisconnectData = {
-      childId: this.userId,
-      childType: "citoyens",
-      parentType: this.getEntityType(),
-      parentId: this.id,
-      connectType: connectTypeDisconnect
-    };
-    const retour = await this.endpointApi.disconnect(data);
-    // TODO : reflechier au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
-    await this.userContext?.refresh();
-    return retour;
-  }
-    
-
-  override async requestToJoin(): Promise<never> {
-    throw new ApiError("l'utilisation de requestToJoin n'est pas autorisée sur un utilisateur.", 403);
-  }
-
-  override async requestToJoinAdmin(): Promise<never> {
-    throw new ApiError("l'utilisation de requestToJoinAdmin n'est pas autorisée sur un utilisateur.", 403);
-  }
-
-  override async acceptInvitation(): Promise<never> {
-    throw new ApiError("l'utilisation de acceptInvitation n'est pas autorisée sur un utilisateur.", 403);
-  }
-
-  override async leave(): Promise<never> {
-    throw new ApiError("l'utilisation de leave n'est pas autorisée sur un utilisateur.", 403);
-  }
-
-  /**
-   * Suivre un utilisateur
-   * Cette action permet à l'utilisateur connecté de suivre un autre utilisateur.
-   * Elle nécessite que l'utilisateur soit connecté.
-   *
-   * @returns - Résultat de la requête.
-   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'action est interdite.
-   */
-  override async follow(): Promise<unknown> {
-    if (!this.isActingUser || !this.userId) {
-      throw new ApiError("Vous devez être connecté pour suivre un utilisateur.", 401);
-    }
-    if (!this.id) {
-      throw new ApiError(`${this.constructor.name} non enregistrée.`, 404);
-    }
-
-    const userLink = this.userContext?.serverData?.links?.["follows"]?.[this.id] || null;
-
-    if (!userLink) {
-      const data: FollowData = {
-        childId: this.userId,
-        childType: "citoyens",
-        parentType: this.getEntityType(),
-        parentId: this.id
-      };
-      const retour = await this.endpointApi.follow(data);
-      // TODO : reflechier au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
-      await this.userContext?.refresh();
-      return retour;
-    }
-
-    throw new ApiError("Vous êtes déjà abonné à cet utilisateur.", 409);
-  }
-
-  /**
-   * Se désabonner d'un utilisateur
-   * Cette action permet à l'utilisateur connecté de se désabonner d'un autre utilisateur.
-   * Elle nécessite que l'utilisateur soit connecté.
-   *
-   * @returns - Résultat de la requête.
-   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'action est interdite.
-   */
-  override async unfollow(): Promise<unknown> {
-    if (!this.isActingUser || !this.userId) {
-      throw new ApiError("Vous devez être connecté pour vous désabonner d'un utilisateur.", 401);
-    }
-    if (!this.id) {
-      throw new ApiError(`${this.constructor.name} non enregistrée.`, 404);
-    }
-
-    const userLink = this.userContext?.serverData?.links?.["follows"]?.[this.id] || null;
-
-    if (userLink) {
-      const data: DisconnectData = {
-        childId: this.userId,
-        childType: "citoyens",
-        parentType: this.getEntityType(),
-        parentId: this.id,
-        connectType: "followers"
-      };
-      const retour = await this.endpointApi.disconnect(data);
-      // TODO : reflechir au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
-      await this.userContext?.refresh();
-      return retour;
-    }
-
-    throw new ApiError("Vous n'êtes pas abonné à cet utilisateur.", 404);
-  }
-
-  /**
-   * Vérifie si l'utilisateur connecté est ami avec cet utilisateur.
-   * @param options - Options de vérification.
-   * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
-   * @returns - True si l'utilisateur connecté est ami, sinon false.
-   * @throws {ApiError} - Si l'utilisateur n'est pas connecté.
-   */
-  isFriend(options?: { silent?: boolean }): boolean {
-    const silent = options?.silent ?? true;
-    try {
-      if (!this.isActingUser) {
-        throw new ApiError("Vous devez être connecté pour vérifier si vous êtes ami.", 401);
-      }
-    } catch (e) {
-      if (silent) return false;
-      throw e;
-    }
-    this._assertEntityType("citoyens");
-    const userLink = this._getLinkFromConnectedUser();
-    if(!userLink) return false;
-    return this._validateUserLink(userLink);
-  }
-
-  /**
-   * Vérifie si l'utilisateur suit l'entité.
-   * @param options - Options de vérification.
-   * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
-   * @returns - `true` si l'utilisateur suit l'entité, `false` sinon.
-   * @throws {ApiError}
-   */
-  override isFollower(options?: { silent?: boolean }): boolean {
-    const silent = options?.silent ?? true;
-    try {
-      if (!this.isActingUser) {
-        throw new ApiError("Vous devez être connecté pour vérifier si il vous suit.", 401);
-      }
-      if (!this.id) {
-        throw new ApiError(`${this.constructor.name} non enregistrée.`, 404);
-      }
-    } catch (e) {
-      if (silent) return false;
-      throw e;
-    }
-    this._assertEntityType("citoyens");
-    return this._isLinked("followers");
-  }
-
-  /**
-   * Vérifie si l'utilisateur est abonné à l'entité.
-   * @param options - Options de vérification.
-   * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
-   * @returns - `true` si l'utilisateur est abonné, `false` sinon.
-   * @throws {ApiError}
-   */
-  override isFollowing(options?: { silent?: boolean }): boolean {
-    const silent = options?.silent ?? true;
-    try {
-      if (!this.isActingUser) {
-        throw new ApiError("Vous devez être connecté pour vérifier si vous le suivez.", 401);
-      }
-      if (!this.id) {
-        throw new ApiError(`${this.constructor.name} non enregistrée.`, 404);
-      }
-    } catch (e) {
-      if (silent) return false;
-      throw e;
-    }
-    this._assertEntityType("citoyens");
-    return this._isLinked("follows");
-  }
-
-  /**
-   * Retourne une entité à partir d'un slug.
-   * @param slug - Le slug de l'entité à récupérer.
-   * @returns L'entité correspondante au slug.
-   */
-  override async entityBySlug(slug: string): Promise<EntityTypes> {
-    if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer cet entité.", 401);
-    }
-    return super.entityBySlug(slug);
-  }
-
-  // ────────────────────────────────
-  //  Actions sur l'utilisateur par rapport à l'entité parente
-  // ────────────────────────────────
-
-  /**
-   * Valide les préconditions de base (connexion, entité, parent, type).
-   * @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} 400 - Si le type d'entité parent n'est pas valide.
-   */
-  private _validateBasePreconditions(methodName: string, expectedTypes: string[]): void {
-    if (!this.userId) {
-      throw new ApiError(`Vous devez être connecté pour ${methodName}.`, 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);
-    }
-  }
-
-  /**
-   * 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} 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 _validateMemberPreconditions(methodName: string, expectedTypes: string[]): void {
-    this._validateBasePreconditions(methodName, expectedTypes);
-
-    if (!this.parent?.id) {
-      throw new ApiError("L'entité parente n'est pas enregistrée.", 404);
-    }
-
-    // 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);
-    }
-  }
-
-
-  /**
-   * 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(): ParentLink | null {
-    const { connectTypeDisconnect } = this.parent!._getLinkMeta();
-    const userId = this!.id;
-    if (!userId) return null;
-    return this.parent?.serverData?.links?.[connectTypeDisconnect]?.[userId] || null;
-  }
-
-  /**
-   * Valide les préconditions et retourne le lien parent.
-   *
-   * @param methodName - Nom de la méthode appelante (pour les messages d'erreur).
-   * @param expectedTypes - Types d'entité parent autorisés.
-   * @param options - Options de validation.
-   * @param options.silent - Si `true`, retourne `null` au lieu de lever une exception. Par défaut `true`.
-   * @returns - Le lien parent de l'utilisateur, ou `null` si validation échoue.
-   * @throws {ApiError} - Si `silent` est `false` et que les préconditions ne sont pas remplies.
-   * @private
-   */
-  private _getValidatedParentLink(
-    methodName: string,
-    expectedTypes: string[],
-    options?: { silent?: boolean }
-  ): ParentLink | null {
-    const silent = options?.silent ?? true;
-    try {
-      this._validateBasePreconditions(methodName, expectedTypes);
-    } catch (e) {
-      if (silent) return null;
-      throw e;
-    }
-    return this._getParentLinkForUser();
-  }
-
-  /**
-   * 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.
-   *
-   * 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(options?: { silent?: boolean }): boolean {
-    const parentLink = this._getValidatedParentLink(
-      "isAdmin",
-      ["organizations", "projects"],
-      { silent: options?.silent }
-    );
-    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(options?: { silent?: boolean }): boolean {
-    const parentLink = this._getValidatedParentLink(
-      "isMember",
-      ["organizations"],
-      { silent: options?.silent }
-    );
-    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(options?: { silent?: boolean }): boolean {
-    const parentLink = this._getValidatedParentLink(
-      "isContributor",
-      ["projects"],
-      { silent: options?.silent }
-    );
-    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(options?: { silent?: boolean }): boolean {
-    const parentLink = this._getValidatedParentLink(
-      "isAttendee",
-      ["events"],
-      { silent: options?.silent }
-    );
-    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);
-   * ```
-   */
-  override isInviting(options?: { silent?: boolean }): boolean {
-    const parentLink = this._getValidatedParentLink(
-      "isInviting",
-      ["citoyens", "organizations", "projects", "events"],
-      { silent: options?.silent }
-    );
-    if (!parentLink) return false;
-    return parentLink.isInviting === true;
-  }
-
-  /**
-   * Vérifie si l'utilisateur connecté a envoyé une invitation d'ami à cet utilisateur.
-   *
-   * @param options - Options de vérification.
-   * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
-   * @returns - `true` si une invitation d'ami est en attente, `false` sinon.
-   */
-  isInvitingFriend(options?: { silent?: boolean }): boolean {
-    const userLink = this._getValidatedUserLink(
-      "isInvitingFriend",
-      ["citoyens", "organizations", "projects", "events"],
-      { silent: options?.silent }
-    );
-    if (!userLink) return false;
-    return userLink.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);
-   * ```
-   */
-  override isInvitingAdmin(options?: { silent?: boolean }): boolean {
-    const parentLink = this._getValidatedParentLink(
-      "isInvitingAdmin",
-      ["organizations", "projects"],
-      { silent: options?.silent }
-    );
-    if (!parentLink) return false;
-    return (parentLink.isAdminInviting === true || parentLink.isInviting === 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();
-   * }
-   * ```
-   */
-  override isAdminPending(options?: { silent?: boolean }): boolean {
-    const parentLink = this._getValidatedParentLink(
-      "isAdminPending",
-      ["organizations", "projects"],
-      { silent: options?.silent }
-    );
-    if (!parentLink) return false;
-    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();
-   * }
-   * ```
-   */
-  override isToBeValidated(options?: { silent?: boolean }): boolean {
-    const parentLink = this._getValidatedParentLink(
-      "isToBeValidated",
-      ["citoyens", "organizations", "projects", "events"],
-      { silent: options?.silent }
-    );
-    if (!parentLink) return false;
-    return parentLink.toBeValidated === true;
-  }
-
-  /**
-   * Vérifie si cet utilisateur a envoyé une demande d'ami en attente de validation.
-   *
-   * @param options - Options de vérification.
-   * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
-   * @returns - `true` si une demande d'ami est en attente de validation, `false` sinon.
-   */
-  isToBeValidatedFriend(options?: { silent?: boolean }): boolean {
-    const userLink = this._getValidatedUserLink(
-      "isToBeValidatedFriend",
-      ["citoyens", "organizations", "projects", "events"],
-      { silent: options?.silent }
-    );
-    if (!userLink) return false;
-    return userLink.toBeValidated === true;
-  }
-
-  /**
-   * 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.
-   *
-   * @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
-   * @throws {ApiError} Si l'utilisateur est déjà connecté à l'entité
-   *
-   * @example
-   * ```typescript
-   * // 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({ 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();
-
-    const parentLink = this._getParentLinkForUser();
-
-    // Cas : aucun lien → on demande à se connecter
-    if (!parentLink) {
-
-      const t = this.parent!.getEntityType();
-
-      // 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: admin ? "admin" : connectTypeConnect
-      };
-
-      const retour = await this.callIsConnected(() => this.endpointApi.connect(data));
-      await this._refreshWithParent();
-      return retour;
-    }
-
-    // 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
-    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._validateAdminPreconditions("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));
-    await this._refreshWithParent();
-    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._validateAdminPreconditions("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));
-    await this._refreshWithParent();
-    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._validateAdminPreconditions("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));
-    await this._refreshWithParent();
-    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._validateAdminPreconditions("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?.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);
-    }
-
-    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));
-    await this._refreshWithParent();
-    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._validateAdminPreconditions("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));
-    await this._refreshWithParent();
-    return retour;
-  }
-
-  // ===========================================================================
-  // Notifications (sous-ressource de l'utilisateur connecté)
-  // ===========================================================================
-
-  /** Gestionnaire de notifications, créé paresseusement et mis en cache. */
-  private _notifications?: Notifications;
-
-  /**
-   * Point d'entrée `me.notifications` (composition, PAS une entité BaseEntity).
-   * Sûr : endpointApi/apiClient sont initialisés dans le constructeur avant tout accès getter.
-   */
-  get notifications(): Notifications {
-    return (this._notifications ??= new Notifications(this));
-  }
-
-  /**
-   * Récupère les notifications (mode liste). STATELESS + plat (`NotificationItemData[]`),
-   * idéal comme `queryFn` React Query / prefetch SSR — ne touche PAS le manager réactif
-   * (`me.notifications`). `ApiClient._transformData` garantit `notif` = tableau (map -> array
-   * + `id` injecté), donc on fait confiance à la normalisation amont.
-   * pathParams.id est OBLIGATOIRE : le défaut "@userId" ne matche pas le pattern de l'endpoint.
-   */
-  async fetchNotifications({ indexMin }: { indexMin?: number } = {}): Promise<NotificationItemData[]> {
-    const res = (await this.callIsMe(() => {
-      const data: GetNotificationsData = {
-        pathParams: { type: "citoyens", id: this.userId! },
-        ...(indexMin != null ? { indexMin } : {})
-      };
-      return this.endpointApi.getNotifications(data);
-    })) as { notif?: NotificationItemData[] };
-    return Array.isArray(res?.notif) ? res.notif : [];
-  }
-
-  /**
-   * Compte les notifications NON VUES (badge). STATELESS. refreshTimestamp = maintenant ->
-   * le serveur renvoie `countNotif` (total non-vus) + une liste vide.
-   */
-  async fetchNotificationsCount(): Promise<number> {
-    const res = (await this.callIsMe(() => {
-      const data: GetNotificationsCountData = {
-        pathParams: { type: "citoyens", id: this.userId! },
-        refreshTimestamp: Math.floor(Date.now() / 1000)
-      };
-      return this.endpointApi.getNotificationsCount(data);
-    })) as { countNotif?: number };
-    return typeof res?.countNotif === "number" ? res.countNotif : 0;
-  }
-
-  /** Marque une notification comme lue (MARK_NOTIFICATION_AS_READ). */
-  async markNotificationAsRead(id: string): Promise<unknown> {
-    const data: MarkNotificationAsReadData = { id };
-    return this.callIsMe(() => this.endpointApi.markNotificationAsRead(data));
-  }
-
-  /** Marque toutes les notifications comme vues/lues (NOTIFICATION_UPDATE). */
-  async markAllNotifications(action: "seen" | "read"): Promise<unknown> {
-    const data: NotificationUpdateData = { action, all: true };
-    return this.callIsMe(() => this.endpointApi.notificationUpdate(data));
-  }
-
-  /** Supprime toutes les notifications de l'utilisateur (REMOVE_ALL_NOTIFICATIONS). */
-  async removeAllNotifications(): Promise<unknown> {
-    return this.callIsMe(() => this.endpointApi.removeAllNotifications());
-  }
-
-}
-
-// Incorporation des mixins dans User
-Object.assign(User.prototype, UserMixin);
-