@communecter/cocolight-api-client 1.0.54 → 1.0.56

package/src/api/{User.js → User.ts}

@@ -1,15 +1,34 @@
 import { ApiError } from "../error.js";
-import BaseEntity from "./BaseEntity.js";
+import { BaseEntity } from "./BaseEntity.js";
 import { UserMixin } from "../mixin/UserMixin.js";
 
-// User.js
-export class User extends BaseEntity {
-
-  static entityType = "citoyens";
-
-  static entityTag = "User";
-
-  static SCHEMA_CONSTANTS = [
+import type { Badge } from "./Badge.js";
+import type { PaginatorPage } from "./BaseEntity.js";
+import type {
+  ConnectData,
+  DisconnectData,
+  LinkValidateData,
+  FollowData,
+  ChangePasswordData,
+  DeleteAccountData,
+  GetSubscriptionsAdminData,
+  GetSubscriptionsData,
+  GetOrganizationsNoAdminData,
+  GetOrganizationsAdminData,
+  GetFriendsAdminData
+} from "./EndpointApi.types.js";
+import type { Organization } from "./Organization.js";
+
+type ApiClient = import("../ApiClient.js").default;
+type UserItemNormalized = import("./serverDataType/User.js").UserItemNormalized;
+
+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",
@@ -25,70 +44,92 @@ export class User extends BaseEntity {
     ["UPDATE_BLOCK_INFO", "updateInfo"],
     ["UPDATE_BLOCK_SLUG", "updateSlug"],
     ["PROFIL_IMAGE", "updateImageProfil"]
-  ]);
+  ] as const);
 
-  defaultFields = {
-    typeElement: this.getEntityType(), 
+  override defaultFields: Record<string, any> = {
+    typeElement: this.getEntityType(),
   };
-    
-  removeFields = [
+
+  override removeFields: string[] = [
     "typeElement",
   ];
-      
-  transforms = {
-    github: (val, full) => full?.socialNetwork?.github,
-    gitlab: (val, full) => full?.socialNetwork?.gitlab,
-    facebook: (val, full) => full?.socialNetwork?.facebook,
-    twitter: (val, full) => full?.socialNetwork?.twitter,
-    instagram: (val, full) => full?.socialNetwork?.instagram,
-    diaspora: (val, full) => full?.socialNetwork?.diaspora,
-    mastodon: (val, full) => full?.socialNetwork?.mastodon,
-    telegram: (val, full) => full?.socialNetwork?.telegram,
-    signal: (val, full) => full?.socialNetwork?.signal
-  };
+
+  override transforms: {
+    github: (val: any, full: any) => any;
+    gitlab: (val: any, full: any) => any;
+    facebook: (val: any, full: any) => any;
+    twitter: (val: any, full: any) => any;
+    instagram: (val: any, full: any) => any;
+    diaspora: (val: any, full: any) => any;
+    mastodon: (val: any, full: any) => any;
+    telegram: (val: any, full: any) => any;
+    signal: (val: any, full: any) => any;
+  } = {
+      github: (val, full) => full?.socialNetwork?.github,
+      gitlab: (val, full) => full?.socialNetwork?.gitlab,
+      facebook: (val, full) => full?.socialNetwork?.facebook,
+      twitter: (val, full) => full?.socialNetwork?.twitter,
+      instagram: (val, full) => full?.socialNetwork?.instagram,
+      diaspora: (val, full) => full?.socialNetwork?.diaspora,
+      mastodon: (val, full) => full?.socialNetwork?.mastodon,
+      telegram: (val, full) => full?.socialNetwork?.telegram,
+      signal: (val, full) => full?.socialNetwork?.signal
+    };
       
   /**
-   * Crée une instance de User.
+   * Crée une instance de `User`.
    *
-   * @param {ApiClient} apiClient - Le client API connecté.
-   * @param {Object} data - Données initiales (peuvent inclure `id`, `slug`, etc.).
-   * @param {string} [data.id] - ID de l'utilisateur.
-   * @param {string} [data.slug] - Slug de l'utilisateur.
-   * @param {Object} deps - Dépendances injectées.
-   * @param {function|object} deps.EndpointApi - Classe ou instance de EndpointApi.
-   * @param {function} deps.Organization - Classe Organization.
-   * @param {function} deps.Project - Classe Project.
-   * @param {function} deps.Event - Classe Events.
-   * @param {function} deps.Poi - Classe Poi.
-   * @param {function} deps.Badge - Classe Badge.
-   * @param {function} deps.News - Classe News.
-   *
-   * @throws {ApiError} - Si des dépendances nécessaires sont manquantes ou invalides.
-   */
-
-  constructor(parent, data = {}, deps = {}) {
+   * @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;
+    }
+  ) {
     if(!deps.EndpointApi){
-      throw new ApiError("EndpointApi class must be injected to avoid circular dependency.");
+      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.");
+      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.");
-    if (!deps.Project) throw new ApiError("Project class must be injected.");
-    if (!deps.Event) throw new ApiError("Event class must be injected.");
-    if (!deps.Poi) throw new ApiError("Poi class must be injected.");
-    if (!deps.Badge) throw new ApiError("Badge class must be injected.");
-    if (!deps.News) throw new ApiError("News class must be injected.");
-      
+    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);
+
     super(parent, data, deps);
   }
 
-  get slug() {
+  override get slug() {
     return this._draftData.slug || null;
   }
-  
-  get isMe() {
+
+  override get isMe() {
     return this.isConnected && this.userId === this.id;
   }
 
@@ -100,22 +141,25 @@ export class User extends BaseEntity {
     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 {Promise<Object>} Le profil complet.
+     * @returns Le profil complet.
      */
-  async get() {
+  override async get(): Promise<Record<string, any>> {
     return this.apiClient.safeCall(async () => {
       if (this.isMe) {
         const data = await this.endpointApi.meInfoUrl();
-        this._setData(data);
+        this._setData(data as UserItemNormalized, { forceInitialDraftReset: true });
         return data;
       } else {
         const data = await this._getPublicProfile();
-        this._setData(data);
+        this._setData(data as UserItemNormalized, { forceInitialDraftReset: true });
         return data;
       }
     });
@@ -124,16 +168,26 @@ export class User extends BaseEntity {
   /**
    * 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 = {}) {
+  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 = {}) {
+  async delete(data: DeleteAccountData): Promise<unknown> {
     return this.callIsMe(() => this.endpointApi.deleteAccount(data));
   }
   
@@ -141,39 +195,40 @@ export class User extends BaseEntity {
    * Sauvegarde les modifications de l'utilisateur en appelant les endpoints correspondants.
    * Seul l'utilisateur connecté peut se modifier lui-même.
    *
-   * @returns {Promise<Object>} - Données serveur mises à jour si applicable.
+   * @returns - Données serveur mises à jour si applicable.
    * @throws {ApiError} - Si l'utilisateur n'est pas autorisé.
    */
-  async save() {
+  override async save(): Promise<Record<string, any>> {
     if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour sauvegarder.");
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour sauvegarder.", 401);
     }
-    await super.save();
+    return await super.save();
   }
 
-  async _add() {
-    throw new ApiError("Vous ne pouvez pas ajouter un utilisateur par ce moyen.");
-  }
+  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 {Object} payload - Données courantes à comparer et envoyer.
-   * @returns {Promise<boolean>} - Indique s'il y a eu une modification réelle.
+   * @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.
    */
-  async _update(payload){
+  override _update = async (payload: Record<string, any>): Promise<boolean> => {
     if (!this._calledFromSave) {
-      throw new Error("utilisation invalide de _update, utilisez save");
+      throw new ApiError("utilisation invalide de _update, utilisez save", 400);
     }
 
-    if(payload.id){
+    if (payload.id) {
       delete payload.id;
     }
 
     let hasChanged = false;
 
     // Sinon, on fait les updates en blocs
-    for (const [constant, methodName] of User.UPDATE_BLOCKS) {
+    for (const [constant, methodName] of Array.from(User.UPDATE_BLOCKS)) {
       const blockData = this._extractChangedFieldsFromSchema(
         this.apiClient,
         constant,
@@ -182,110 +237,118 @@ export class User extends BaseEntity {
         this.removeFields
       );
       if (blockData && Object.keys(blockData).length > 0) {
-        await this[methodName](blockData);
+        await this._invokeBlockMethod(User.UPDATE_BLOCKS, methodName, blockData);
         hasChanged = true;
       }
     }
   
     return hasChanged;
-  }
+  };
 
-  static fromServerData(data, parent, deps) {
-    const instance = new User(parent.apiClient, data, deps);
-    if (typeof data === "object" || Object.keys(data).length > 0) {
-      instance._setData(data);
+  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") {
+      instance._setData(data as UserItemNormalized);
     }
     return instance;
   }
 
   /**
+   * {@inheritDoc BaseEntity#updateSettings}
+   *
    * Mettre à jour les paramètres utilisateur : Mise à jour des paramètres spécifiques d'un utilisateur.
-   * Constant : UPDATE_SETTINGS
-   * @param {Object} data - Données à mettre à jour.
-   * @param {"birthDate"|"email"|"locality"|"phone"|"directory"} data.type - Type de paramètre à mettre à jour.
-   * @param {"private"|"public"|"mask"} data.value - Nouvelle valeur du paramètre.
-   * @returns {Promise<void>} - Résultat de la mise à jour.
    */
-  async updateSettings(data = {}) {
+  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.");
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour les paramètres.", 401);
     }
-    await super.updateSettings(data);
+    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.
-   * Constant : UPDATE_BLOCK_DESCRIPTION
    */
-  async updateDescription(data = {}) {
+  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.");
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour la description.", 401);
     }
     return super.updateDescription(data);
   }
-  
+
   /**
-     * Mettre à jour les informations d'un élément : Permet de mettre à jour les informations générales d'un élément (nom, contacts, etc.).
-     * Constant : UPDATE_BLOCK_INFO
-     */
-  async updateInfo(data = {}) {
+   * {@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.");
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour les informations.", 401);
     }
     return super.updateInfo(data);
   }
-  
+
   /**
-     * Mettre à jour les réseaux sociaux d'un élément : Permet de mettre à jour les liens vers les réseaux sociaux d'un élément.
-     * Constant : UPDATE_BLOCK_SOCIAL
-     */
-  async updateSocial(data = {}) {
+   * {@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.");
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour les réseaux sociaux.", 401);
     }
     return super.updateSocial(data);
   }
-  
+
   /**
-     * Mettre à jour les localités d'un élément : Permet de mettre à jour l'adresse et les informations géographiques d'un élément.
-     * Constant : UPDATE_BLOCK_LOCALITY
-     */
-  async updateLocality(data = {}) {
+   * {@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é.");
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour la localité.", 401);
     }
     return super.updateLocality(data);
   }
-  
+
   /**
-     * Mettre à jour le slug d'un élément : Permet de mettre à jour le slug pour une URL simplifiée.
-     * Constant : UPDATE_BLOCK_SLUG
-     */
-  async updateSlug({ slug }) {
+   * {@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.");
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour le slug.", 401);
     }
-    return super.updateSlug({ slug });
+    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é.
-   * Constant : PROFIL_IMAGE
    */
-  async updateImageProfil({ profil_avatar: image  }) {
+  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.");
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour mettre à jour l'image de profil.", 401);
     }
-    return super.updateImageProfil({ profil_avatar: image });
+    return super.updateImageProfil(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
    */
-  async getOrganizations(data = {}) {
-    data.searchType = this._getDefaultFromEndpoint("GET_ORGANIZATIONS_NO_ADMIN", "searchType");
+  override async getOrganizations(data: Partial<GetOrganizationsAdminData | GetOrganizationsNoAdminData> = {}) {
+    data.searchType = this._getDefaultFromEndpoint("GET_ORGANIZATIONS_NO_ADMIN", "searchType") as GetOrganizationsNoAdminData["searchType"];
     // data.searchBy = "ALL";
 
     const paginator = this._createPaginatorEngine({
@@ -296,7 +359,7 @@ export class User extends BaseEntity {
         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 },
@@ -309,30 +372,33 @@ export class User extends BaseEntity {
       }
     });
 
-    return paginator.next();
+    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.
-   * Constant : GET_PROJECTS_ADMIN | GET_PROJECTS_NO_ADMIN
    */
-  async getProjects(data = {}) {
+  override async getProjects(data: Parameters<BaseEntity<UserItemNormalized>["getProjects"]>[0] = {}) {
     return super.getProjects(data);
   }
 
   /**
+   * {@inheritDoc BaseEntity#getPois}
+   * 
    * Récupérer les POIs
-   * Constant : GET_POIS_NO_ADMIN / GET_POIS_ADMIN
    */
-  async getPois(data = {}) {
+  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.
-   * Constant : GET_NEWS
    */
-  async getNews(data = {}) {
+  override async getNews(data: Parameters<BaseEntity<UserItemNormalized>["getNews"]>[0] = {}) {
     return super.getNews(data);
   }
 
@@ -342,8 +408,8 @@ export class User extends BaseEntity {
    * 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 = {}) {
-    data.searchType = this._getDefaultFromEndpoint("GET_FRIENDS_ADMIN", "searchType");
+  async getFriends(data: Partial<GetFriendsAdminData> = {}): Promise<PaginatorPage<User>> {
+    data.searchType = this._getDefaultFromEndpoint("GET_FRIENDS_ADMIN", "searchType") as GetFriendsAdminData["searchType"];
     // data.searchBy = "ALL";
 
     const paginator = this._createPaginatorEngine({
@@ -351,25 +417,25 @@ export class User extends BaseEntity {
       finalizer: async (finalData) => {
 
         delete finalData?.pathParams;
-  
-        if (!this.isMe){
+
+        if (!this.isMe && this.id){
           // is not me add id
           finalData.pathParams = { id: this.id };
         }
 
-        return this.endpointApi.getFriendsAdmin(finalData);;
+        return this.endpointApi.getFriendsAdmin(finalData);
       }
     });
 
-    return paginator.next();
+    return paginator.next() as Promise<PaginatorPage<User>>;
   }
 
   /**
    * Récupérer les suivis
    * Constant : GET_SUBSCRIPTIONS / GET_SUBSCRIPTIONS_ADMIN
    */
-  async getSubscriptions(data = {}) {
-    data.searchType = this._getDefaultFromEndpoint("GET_SUBSCRIPTIONS", "searchType");
+  async getSubscriptions(data: Partial<GetSubscriptionsAdminData | GetSubscriptionsData> = {}): Promise<PaginatorPage<BaseEntity<any>>> {
+    data.searchType = this._getDefaultFromEndpoint("GET_SUBSCRIPTIONS", "searchType") as GetSubscriptionsAdminData["searchType"];
     // data.searchBy = "ALL";
 
     const paginator = this._createPaginatorEngine({
@@ -377,11 +443,11 @@ export class User extends BaseEntity {
       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 },
@@ -392,14 +458,15 @@ export class User extends BaseEntity {
       }
     });
 
-    return paginator.next();
+    return paginator.next() as Promise<PaginatorPage<BaseEntity<any>>>;
   }
 
   /**
+   * {@inheritDoc BaseEntity#getSubscribers}
+   * 
    * Récupérer les abonnés
-   * Constant : GET_SUBSCRIBERS
    */
-  async getSubscribers(data = {}) {
+  override async getSubscribers(data: Parameters<BaseEntity<UserItemNormalized>["getSubscribers"]>[0] = {}) {
     return super.getSubscribers(data);
   }
 
@@ -410,10 +477,11 @@ export class User extends BaseEntity {
    */
 
   /**
+   * {@inheritDoc BaseEntity#getBadgesIssuer}
+   * 
    * Liste des badges créés par l'utilisateur
-   * Constant : GET_BADGES
    */
-  async getBadgesIssuer(data = {}) {
+  override async getBadgesIssuer(data: Parameters<BaseEntity<UserItemNormalized>["getBadgesIssuer"]>[0] = {}) {
     return super.getBadgesIssuer(data);
   }
 
@@ -422,7 +490,7 @@ export class User extends BaseEntity {
    * 
    * TODO : documenté le fonctionnement et sont utilisation avec un exemple
    */
-  async getBadges(filter = {}) {
+  async getBadges(filter: Record<string, any> = {}): Promise<Badge[]> {
     /*
       "badges": {
             "627df5663a0fae60e57f4a31": {
@@ -442,105 +510,95 @@ export class User extends BaseEntity {
   }
 
   /**
+   * {@inheritDoc BaseEntity#getGallery}
+   * 
    * Récupérer la galerie de l'utilisateur
-   * Constant : GET_GALLERY
    */
-  async getGallery(data = {}) {
+  override async getGallery(data: Parameters<BaseEntity<UserItemNormalized>["getGallery"]>[0] = {}) {
     return super.getGallery(data);
   }
 
-  async user(userData) {
+  async user(userData: { id?: string, slug?: string }): Promise<User> {
     if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur");
+      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.");
+      throw new ApiError("Vous devez fournir un id ou un slug pour créer un User.", 400);
     }
-    const user = new User(this, userData, this.deps);
+    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.
-   *
-   * @param {Object} organizationData - Les données nécessaires pour initialiser l'organisation.
-   * @returns {Promise<Organization>} Une promesse qui résout l'objet Organisation créé.
-   * @throws {Error} Si une erreur se produit lors de la création de l'organisation.
    */
-  async organization(organizationData = {}) {
+  override async organization(organizationData: Parameters<BaseEntity<UserItemNormalized>["organization"]>[0] = {}) {
     if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer une organisation.");
+      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.
-   *
-   * @param {Object} projectData - Les données nécessaires pour initialiser le projet.
-   * @returns {Promise<Project>} Une promesse qui résout l'objet Projet créé.
-   * @throws {Error} Si une erreur se produit lors de la création du projet.
    */
-  async project(projectData = {}) {
+  override async project(projectData: Parameters<BaseEntity<UserItemNormalized>["project"]>[0] = {}) {
     if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un projet.");
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un projet.", 401);
     }
     return super.project(projectData);
   }
 
   /**
-   * Crée une instance de news et la récupère si nécessaire.
+   * {@inheritDoc BaseEntity#news}
    * 
-   * @param {Object} newsData - Les données nécessaires pour initialiser la news.
-   * @returns {Promise<News>} Une promesse qui résout l'objet News créé.
-   * @throws {Error} Si une erreur se produit lors de la création de la news.
+   * Crée une instance de news et la récupère si nécessaire.
    */
-  async news(newsData = {}) {
+  override async news(newsData: Parameters<BaseEntity<UserItemNormalized>["news"]>[0] = {}) {
     if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer une actualité.");
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer une actualité.", 401);
     }
     return super.news(newsData);
   }
 
   /**
-   * Crée une instance de POI et la récupère si nécessaire.
+   * {@inheritDoc BaseEntity#poi}
    * 
-   * @param {Object} poiData - Les données nécessaires pour initialiser le POI.
-   * @returns {Promise<Poi>} Une promesse qui résout l'objet POI créé.
-   * @throws {Error} Si une erreur se produit lors de la création du POI.
+   * Crée une instance de POI et la récupère si nécessaire.
    */
-  async poi(poiData = {}) {
+  override async poi(poiData: Parameters<BaseEntity<UserItemNormalized>["poi"]>[0] = {}) {
     if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un POI.");
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un POI.", 401);
     }
     return super.poi(poiData);
   }
 
   /**
-   * Crée une instance d'événement et la récupère si nécessaire.
+   * {@inheritDoc BaseEntity#event}
    * 
-   * @param {Object} eventData - Les données nécessaires pour initialiser l'événement.
-   * @returns {Promise<Event>} Une promesse qui résout l'objet Événement créé.
-   * @throws {Error} Si une erreur se produit lors de la création de l'événement.
+   * Crée une instance d'événement et la récupère si nécessaire.
    */
-  async event(eventData = {}) {
+  override async event(eventData: Parameters<BaseEntity<UserItemNormalized>["event"]>[0] = {}) {
     if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un événement.");
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un événement.", 401);
     }
     return super.event(eventData);
   }
 
   /**
-   * Crée une instance de badge et la récupère si nécessaire.
+   * {@inheritDoc BaseEntity#badge}
    * 
-   * @param {Object} badgeData - Les données nécessaires pour initialiser le badge.
-   * @returns {Promise<Badge>} Une promesse qui résout l'objet Badge créé.
-   * @throws {Error} Si une erreur se produit lors de la création du badge.
+   * Crée une instance de badge et la récupère si nécessaire.
    */
-  async badge(badgeData = {}) {
+  override async badge(badgeData: Parameters<BaseEntity<UserItemNormalized>["badge"]>[0] = {}) {
     if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un badge.");
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un badge.", 401);
     }
     return super.badge(badgeData);
   }
@@ -556,31 +614,33 @@ export class User extends BaseEntity {
    * Envoie une demande d'amitié à cet utilisateur.
    * L'utilisateur ciblé devra valider la demande pour établir la relation.
    *
-   * @returns {Promise<Object>} - Résultat de la requête.
+   * @returns - Résultat de la requête.
    * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'action est interdite.
    */
-  async sendFriendRequest() {
-    if (!this.isActingUser) {
-      throw new ApiError("Vous devez être connecté pour envoyer une demande d'amis.");
+  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.`);
+      throw new ApiError(`${this.constructor.name} non enregistrée.`, 404);
     }
 
     const { connectTypeConnect } = this._getLinkMeta();
     const userLink = this._getLinkFromConnectedUser();
 
     if (!userLink) {
-      const data = {
+      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();
+      await this.userContext?.refresh();
       return retour;
     }
 
@@ -589,172 +649,179 @@ export class User extends BaseEntity {
     }
 
     if (userLink.isInviting && userLink.invitorId === this.userId) {
-      throw new ApiError("Vous avez déjà envoyé une demande d'amis à cet utilisateur.");
+      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é.");
+    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 {Promise<Object>} - Résultat de la validation du lien.
+   * @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() {
-    if (!this.isActingUser) {
-      throw new ApiError("Vous devez être connecté pour accepter une demande d'amitié.");
+  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.`);
+      throw new ApiError(`${this.constructor.name} non enregistrée.`, 404);
     }
 
     const userLink = this._getLinkFromConnectedUser();
 
     if (userLink?.isInviting && userLink.invitorId === this.id) {
-      const data = {
+      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();
+      await this.userContext?.refresh();
       return retour;
     }
 
-    throw new ApiError("Vous n'avez pas d'invitation à valider.");
+    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 {Promise<Object>} - Résultat de la suppression.
+   * @returns - Résultat de la suppression.
    * @throws {ApiError} - Si aucune relation n'existe.
    */
-  async removeFriend() {
-    if (!this.isActingUser) {
-      throw new ApiError("Vous devez être connecté pour supprimer un ami.");
+  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.`);
+      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é.");
+      throw new ApiError("Vous n'êtes pas connecté à cette entité.", 404);
     }
-
-    const data = {
+    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();
+    await this.userContext?.refresh();
     return retour;
   }
     
 
-  requestToJoin() {
-    throw new ApiError("l'utilisation de requestToJoin n'est pas autorisée sur un utilisateur.");
+  override async requestToJoin(): Promise<never> {
+    throw new ApiError("l'utilisation de requestToJoin n'est pas autorisée sur un utilisateur.", 403);
   }
 
-  requestToJoinAdmin() {
-    throw new ApiError("l'utilisation de requestToJoinAdmin n'est pas autorisée sur un utilisateur.");
+  override async requestToJoinAdmin(): Promise<never> {
+    throw new ApiError("l'utilisation de requestToJoinAdmin n'est pas autorisée sur un utilisateur.", 403);
   }
 
-  acceptInvitation() {
-    throw new ApiError("l'utilisation de acceptInvitation n'est pas autorisée sur un utilisateur.");
+  override async acceptInvitation(): Promise<never> {
+    throw new ApiError("l'utilisation de acceptInvitation n'est pas autorisée sur un utilisateur.", 403);
   }
 
-  leave() {
-    throw new ApiError("l'utilisation de leave n'est pas autorisée sur un utilisateur.");
+  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 {Promise<Object>} - Résultat de la requête.
+   *
+   * @returns - Résultat de la requête.
    * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'action est interdite.
    */
-  async follow() {
-    if (!this.isActingUser) {
-      throw new ApiError("Vous devez être connecté pour suivre un utilisateur.");
+  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.`);
+      throw new ApiError(`${this.constructor.name} non enregistrée.`, 404);
     }
 
     const userLink = this.userContext?.serverData?.links?.["follows"]?.[this.id] || null;
 
     if (!userLink) {
-      const data = {
+      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();
+      await this.userContext?.refresh();
       return retour;
     }
 
-    throw new ApiError("Vous êtes déjà abonné à cet utilisateur.");
+    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 {Promise<Object>} - Résultat de la requête.
+   *
+   * @returns - Résultat de la requête.
    * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'action est interdite.
    */
-  async unfollow() {
-    if (!this.isActingUser) {
-      throw new ApiError("Vous devez être connecté pour vous désabonner d'un utilisateur.");
+  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.`);
+      throw new ApiError(`${this.constructor.name} non enregistrée.`, 404);
     }
 
     const userLink = this.userContext?.serverData?.links?.["follows"]?.[this.id] || null;
 
     if (userLink) {
-      const data = {
+      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();
+      await this.userContext?.refresh();
       return retour;
     }
 
-    throw new ApiError("Vous n'êtes pas abonné à cet utilisateur.");
+    throw new ApiError("Vous n'êtes pas abonné à cet utilisateur.", 404);
   }
 
   /**
    * Vérifie si l'utilisateur connecté est ami avec cet utilisateur.
    * 
-   * @returns {boolean} - True si l'utilisateur connecté est ami, sinon false.
+   * @returns - True si l'utilisateur connecté est ami, sinon false.
    * @throws {ApiError} - Si l'utilisateur n'est pas connecté.
    */
-  isFriend() {
+  isFriend(): boolean {
     if (!this.isActingUser) {
-      throw new ApiError("Vous devez être connecté pour vérifier si vous êtes ami.");
+      throw new ApiError("Vous devez être connecté pour vérifier si vous êtes ami.", 401);
     }
     this._assertEntityType("citoyens");
     const userLink = this._getLinkFromConnectedUser();
@@ -763,16 +830,16 @@ export class User extends BaseEntity {
 
   /**
    * Vérifie si l'utilisateur suit l'entité.
-   * 
-   * @returns {boolean} - `true` si l'utilisateur suit l'entité, `false` sinon.
+   *
+   * @returns - `true` si l'utilisateur suit l'entité, `false` sinon.
    * @throws {ApiError}
    */
-  isFollower() {
+  override isFollower(): boolean {
     if (!this.isActingUser) {
-      throw new ApiError("Vous devez être connecté pour vérifier si il vous suit.");
+      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.`);
+      throw new ApiError(`${this.constructor.name} non enregistrée.`, 404);
     }
     this._assertEntityType("citoyens");
     return this._isLinked("followers");
@@ -780,22 +847,20 @@ export class User extends BaseEntity {
 
   /**
    * Vérifie si l'utilisateur est abonné à l'entité.
-   * 
-   * @returns {boolean} - `true` si l'utilisateur est abonné, `false` sinon.
+   *
+   * @returns - `true` si l'utilisateur est abonné, `false` sinon.
    * @throws {ApiError}
    */
-  isFollowing() {
+  override isFollowing(): boolean {
     if (!this.isActingUser) {
-      throw new ApiError("Vous devez être connecté pour vérifier si vous le suivez.");
+      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.`);
+      throw new ApiError(`${this.constructor.name} non enregistrée.`, 404);
     }
     this._assertEntityType("citoyens");
     return this._isLinked("follows");
   }
-
-
 }
 
 // Incorporation des mixins dans User