@communecter/cocolight-api-client 1.0.154 → 1.0.156

package/src/ApiClient.ts

@@ -1,1994 +0,0 @@
-import { EventEmitter } from "events";
-
-import { AggregateAjvError } from "@segment/ajv-human-errors";
-import axios from "axios";
-import axiosRetryImport from "axios-retry";
-import { jwtDecode } from "jwt-decode";
-
-
-import { COSTUM_NUMBER_FIELDS, COSTUM_DATE_FIELDS } from "./costum/normalize.js";
-import { COSTUM_REQUEST_ENVELOPE, type CostumRequestEnvelope } from "./costum/symbol.js";
-import MongoID from "./EJSONType.js";
-import endpointsJson from "./endpoints.module.js";
-import { ApiClientError, ApiResponseError, ApiValidationError, CircuitBreakerError } from "./error.js";
-import { getErrorMessage, getErrorStatusCode, hasResponse } from "./types/error-guards.js";
-import { Ajv, addFormats, pino, EJSON } from "./utils/compat.js";
-import { MultiServerTokenStorageStrategy } from "./utils/MultiServerTokenStorageStrategy.js";
-import { MemoryStorageStrategy, type TokenStorageStrategy } from "./utils/TokenStorage.js";
-
-import type { ApiErrorDetails } from "./types/api-responses.js";
-import type OfflineClientManager from "./utils/OfflineClientManager.js";
-import type { ValidateFunction } from "ajv";
-import type { AxiosInstance } from "axios";
-import type { JwtPayload } from "jwt-decode";
-
-// Fix pour le typage de axios-retry avec les modules CommonJS
-interface AxiosRetryType {
-  (axiosInstance: AxiosInstance, config?: any): void;
-  exponentialDelay: (retryNumber?: number, error?: Error, delayFactor?: number) => number;
-  isNetworkError: (error: Error) => boolean;
-  isRetryableError: (error: Error) => boolean;
-}
-const axiosRetry = axiosRetryImport as unknown as AxiosRetryType;
-
-/**
- * Résultat retourné quand une requête est **mise en file** (offline ou breaker).
- * Permet de typer précisément les chemins « non-réseau » de `callEndpoint`.
- */
-export interface ApiClientOfflineEnqueueResult {
-  data: null;
-  offline?: true;  // Présent si l'enqueue est dû au mode offline.
-  breaker?: true;  // Présent si l'enqueue est dû au circuit breaker.
-}
-
-/**
- * Options de configuration pour ApiClient
- */
-export interface ApiClientOptions {
-  baseURL: string;
-  accessToken?: string | null;
-  refreshToken?: string | null;
-  refreshUrl?: string;
-  endpoints?: any[];
-  timeout?: number;
-  debug?: boolean;
-  maxRetries?: number;
-  circuitBreakerThreshold?: number;
-  circuitBreakerResetTime?: number;
-  fromJSONValue?: boolean;
-  /**
-   * Mode de dialogue avec le backend cocolight-backend :
-   *  - `legacy` (défaut) : réponses byte-compatibles PHP ; la lib applique TOUTES ses
-   *    normalisations côté client (_transformData/_normalizeJsonData) + validation AJV.
-   *  - `clean` : envoie `X-Coco-Mode: clean` ; le SERVEUR applique les normalisations et
-   *    répond {success, data|error}. La lib unwrap l'enveloppe, lève ApiResponseError sur
-   *    success:false, SAUTE _transformData et la validation AJV (schémas legacy), et revive
-   *    (dates ISO -> Date, id -> _id ObjectID) pour rendre à l'app le MÊME shape qu'avant.
-   *  NB : l'intercepteur refresh-token reste en legacy (appel interne sans le header).
-   */
-  mode?: "legacy" | "clean";
-  tokenStorageStrategy?: TokenStorageStrategy | null;
-}
-
-/**
- * Structure des données pour les appels d'endpoint
- */
-export interface CallEndpointData {
-  pathParams?: Record<string, any>;
-  [key: string]: any;
-}
-
-/**
- * Résultat d'un appel d'endpoint réussi
- */
-export interface CallEndpointResult<T = any> {
-  data: T;
-  offline?: never;
-  breaker?: never;
-}
-
-/**
- * Union type pour tous les résultats possibles de callEndpoint
- */
-export type CallEndpointResponse<T = any> = CallEndpointResult<T> | ApiClientOfflineEnqueueResult;
-
-EJSON.addType("oid", (value: any) => {
-  if (typeof value === "string") {
-    return new MongoID.ObjectID(value);
-  }
-  if (typeof value === "undefined") {
-    return new MongoID.ObjectID();
-  }
-  throw new Error("Expected string value for ObjectID");
-});
-
-
-/**
- * Client générique pour consommer une API REST avec validation AJV, gestion des tokens,
- * circuit breaker, retry automatique, et support offline.
- *
- * @fires ApiClient#retryAttempt
- * @fires ApiClient#queuedOffline
- * @fires ApiClient#circuitBreakerOpen
- * @fires ApiClient#circuitBreakerReset
- * @fires ApiClient#refreshSuccess
- * @fires ApiClient#refreshFailed
- * @fires ApiClient#sessionReset
- * @fires ApiClient#validationError
- * @fires ApiClient#offlineModeChanged
- * @fires ApiClient#userLoggedIn
- */
-export default class ApiClient extends EventEmitter {
-  // Public properties
-  public readonly __entityTag: string = "ApiClient";
-  public readonly userId: string | null = null;
-
-  // Private properties
-  private readonly _baseURL: string;
-  private readonly _refreshUrl: string;
-  private readonly _endpoints: any[];
-  private readonly _debug: boolean;
-  private readonly _fromJSONValue: boolean;
-  private readonly _tokenStorage: TokenStorageStrategy;
-
-  private _offlineClientManager: OfflineClientManager | null = null;
-  private _ajv: any;
-  private _ajvNoDefaults: any;
-  public _logger: any;
-  private _client: AxiosInstance;
-
-  // Circuit breaker properties
-  private readonly _breakerThreshold: number;
-  private readonly _breakerResetTime: number;
-  private _breakerErrorCount: number = 0;
-  private _breakerOpen: boolean = false;
-  private _lastBreakerOpenTime: number | null = null;
-
-  // Token properties
-  private _accessToken: string | null = null;
-  private _refreshToken: string | null = null;
-
-  // Internal userId setter
-  private _setUserId: (id: string | null) => void;
-  private _mode: "legacy" | "clean" = "legacy";
-  constructor({
-    baseURL,
-    accessToken,
-    refreshToken,
-    refreshUrl = "/api/cocolight/refreshtoken",
-    endpoints = endpointsJson.endpoints,
-    timeout = 30000,
-    debug = false,
-    maxRetries = 0,
-    circuitBreakerThreshold = 5,
-    circuitBreakerResetTime = 60000,
-    fromJSONValue = true,
-    mode = "legacy",
-    tokenStorageStrategy = null
-  }: ApiClientOptions) {
-    super(); // EventEmitter
-
-    if (!baseURL) {
-      throw new ApiClientError("Le paramètre \"baseURL\" est obligatoire.", 500);
-    }
-
-    this._baseURL = baseURL;
-    this._refreshUrl = refreshUrl;
-    this._endpoints = endpoints || endpointsJson.endpoints;
-    this._debug = debug;
-    this._fromJSONValue = fromJSONValue;
-    this._mode = mode === "clean" ? "clean" : "legacy";
-    this._breakerThreshold = circuitBreakerThreshold;
-    this._breakerResetTime = circuitBreakerResetTime;
-
-    // Setup userId with getter/setter pattern
-    let _userId: string | null = null;
-
-    Object.defineProperty(this, "userId", {
-      get: () => _userId,
-      set: () => {
-        throw new Error("Modification directe de userId non autorisée.");
-      },
-      enumerable: true
-    });
-
-    this._setUserId = (id: string | null) => {
-      _userId = id;
-      this._logger?.debug(`[ApiClient] userId set: ${id}`);
-    };
-
-    // AJV
-    this._ajv = new Ajv({ strict: false, useDefaults: true, allErrors: true, verbose: true });
-    // Variante SANS injection de défauts : utilisée pour l'UPDATE costum via `element/save`
-    // (enveloppe.isUpdate) — on n'envoie que les champs modifiés, jamais les défauts de création.
-    this._ajvNoDefaults = new Ajv({ strict: false, useDefaults: false, allErrors: true, verbose: true });
-    for (const ajv of [this._ajv, this._ajvNoDefaults]) {
-      addFormats(ajv);
-      ajv.addFormat("textarea", true);
-      ajv.addKeyword({
-        keyword: "startBeforeEnd",
-        type: "object",
-        errors: true,
-        validate: this._startBeforeEndValidate
-      });
-    }
-
-    // Pino logger
-    this._logger = pino({
-      transport: {
-        target: "pino-pretty",
-        options: { colorize: true }
-      },
-      level: debug ? "debug" : "info"
-    });
-
-    // Création instance Axios
-    this._client = axios.create({
-      baseURL,
-      timeout
-    });
-    // axios-retry : pour retenter en cas de soucis réseau ou code 5xx
-    if (maxRetries > 0) {
-      axiosRetry(this._client, {
-        retries: maxRetries,
-        retryDelay: axiosRetry.exponentialDelay,
-        retryCondition: (error: any) => {
-          // Retry sur erreurs 5xx ou erreurs réseau
-          return axiosRetry.isNetworkError(error) || axiosRetry.isRetryableError(error);
-        },
-        onRetry: (retryCount: number, error: any, requestConfig: any) => {
-          this._logger.warn(`[Retry] Tentative #${retryCount} pour ${requestConfig?.url}`);
-          this.emit("retryAttempt", { retryCount, url: requestConfig?.url });
-        }
-      });
-      this._logger.info(`[ApiClient] Retry activé : ${maxRetries} max`);
-    }
-
-    if (tokenStorageStrategy instanceof MultiServerTokenStorageStrategy) {
-      tokenStorageStrategy.use(this._baseURL);
-    }
-
-    this._tokenStorage = tokenStorageStrategy || new MemoryStorageStrategy();
-
-    if (
-      typeof this._tokenStorage?.getAccessToken !== "function" ||
-      typeof this._tokenStorage?.setAccessToken !== "function" ||
-      typeof this._tokenStorage?.getRefreshToken !== "function" ||
-      typeof this._tokenStorage?.setRefreshToken !== "function" ||
-      typeof this._tokenStorage?.clear !== "function"
-    ) {
-      throw new Error("[ApiClient] La stratégie de stockage des tokens n’est pas valide. Elle doit implémenter les méthodes requises.");
-    }
-    
-    // Applique un token initial s'il est fourni
-    if (refreshToken) {
-      this.setRefreshToken(refreshToken);
-    }
-
-    if (accessToken) {
-      this.setToken(accessToken);
-    }
-
-    const initialAccessToken = this._tokenStorage.getAccessToken();
-    if (initialAccessToken) {
-      this.setToken(initialAccessToken);
-    }
-
-    const initialRefreshToken = this._tokenStorage.getRefreshToken();
-    if (initialRefreshToken) {
-      this.setRefreshToken(initialRefreshToken);
-    }
-    
-
-    // Intercepteur 401 -> refresh
-    this._client.interceptors.response.use(
-      response => response,
-      async error => {
-        const originalRequest = error.config;
-
-        // Si la requête est déjà réessayée, abandonne
-        if (originalRequest._retry) {
-          this._logger.error("[ApiClient] Requête déjà retentée, échec définitif.");
-          throw error;
-        }
-
-        if (error.response && error.response.status === 401 && this._refreshToken) {
-          originalRequest._retry = true;
-
-          try {
-            this._logger.info("[ApiClient] Tentative de refresh du token...");
-            const refreshed = await this._refreshAccessToken();
-
-            if (refreshed) {
-              this._logger.info("[ApiClient] Token rafraîchi avec succès.");
-
-              // 🔑 Mise à jour EXPLICITE du header Authorization dans la requête originale
-              originalRequest.headers = originalRequest.headers ?? {};
-              originalRequest.headers["Authorization"] = "Bearer " + this.getToken();
-
-              this._logger.info("[ApiClient] Retente la requête originale avec le nouveau token.");
-              return this._client.request(originalRequest);
-            } else {
-              this.resetSession();
-              throw new ApiClientError("Impossible de rafraîchir le token.", 401);
-            }
-          } catch (err) {
-            this.resetSession();
-            const errorDetails: ApiErrorDetails = {
-              code: getErrorStatusCode(err) || 401,
-              message: getErrorMessage(err)
-            };
-            throw new ApiClientError("Erreur lors du rafraîchissement du token.", 401, errorDetails);
-          }
-        }
-
-        throw error;
-      }
-    );
-
-  }
-
-  /**
-   * Sets the access token for the API client and updates the authorization header.
-   */
-  setToken(token: string | null): void {
-    this._accessToken = token;
-    this._tokenStorage.setAccessToken(token ?? "");
-    if (token) {
-      this._client.defaults.headers.common["Authorization"] = "Bearer " + token;
-    } else {
-      delete this._client.defaults.headers.common["Authorization"];
-    }
-    // Extrait l'id depuis le token et le stocke si disponible
-    const userId = this._getIdFromToken(token);
-    if (userId) {
-      this._setUserId(userId);
-      this._logger.debug(`[ApiClient] userId extrait et défini : ${userId}`);
-    }
-    this._logger.debug(`[ApiClient] setToken: ${token}`);
-  }
-
-  /**
-   * Retrieves the current access token.
-   */
-  getToken(): string | null {
-    return this._accessToken;
-  }
-
-  /**
-   * Sets the refresh token for the API client.
-   */
-  setRefreshToken(token: string | null): void {
-    this._refreshToken = token;
-    this._tokenStorage.setRefreshToken(token ?? "");
-    if(this.userId === null){
-    // Extrait l'id depuis le token et le stocke si disponible
-      const userId = this._getIdFromToken(token);
-      if (userId) {
-        this._setUserId(userId);
-        this._logger.debug(`[ApiClient] userId extrait depuis refreshToken : ${userId}`);
-      }
-    }
-    this._logger.debug(`[ApiClient] setRefreshToken: ${token}`);
-  }
-
-  /**
-   * Retrieves the current refresh token.
-   */
-  getRefreshToken(): string | null {
-    return this._refreshToken;
-  }
-
-  /**
-   * Indique si le client est connecté.
-   * On considère que le client est connecté si un token d'accès (_accessToken) est défini.
-   */
-  get isConnected(): boolean {
-    return !!this._accessToken;
-  }
-
-  /**
-   * Extrait l'identifiant depuis un JWT.
-   */
-  private _getIdFromToken(token: string | null): string | null {
-    if (!token) return null;
-    try {
-      // Décodage du token grâce à jwt-decode
-      const payload = jwtDecode<JwtPayload & { id?: string; userId?: string }>(token);
-      // L'identifiant peut être dans "id" ou "userId"
-      this._logger.debug("[ApiClient] Payload décodé :", payload);
-      return payload.id || payload.userId || null;
-    } catch (err) {
-      this._logger.error("[ApiClient] Erreur lors du décodage du token :", err);
-      return null;
-    }
-  }
-
-  /**
-   * Méthode simplifiée de refresh (en JSON).
-   * Emet un event refreshSuccess si ça marche
-   */
-  private async _refreshAccessToken(): Promise<boolean> {
-    if (!this._refreshToken) return false;
-
-    const refreshClient = axios.create({
-      baseURL: this._baseURL,
-      timeout: 10000, // ajuster si nécessaire
-      headers: { "Content-Type": "application/json" }
-    });
-
-    try {
-      const response = await refreshClient.post(this._refreshUrl, {
-        refreshToken: this._refreshToken
-      });
-      if (response.data && response.data.token) {
-        this.setToken(response.data.token);
-        if (response.data.refreshToken) {
-          this.setRefreshToken(response.data.refreshToken);
-        }
-        this.emit("refreshSuccess", response.data);
-        return true;
-      }
-      return false;
-    } catch (err) {
-      // Si on a une erreur, on reset la session
-      this.emit("refreshFailed", { error: getErrorMessage(err) });
-      this.resetSession();
-      this._logger.error(`[ApiClient] Refresh Error : ${getErrorMessage(err)}`);
-      return false;
-    }
-  }
-
-  /**
-   * checkCircuitBreaker : vérifie si on peut appeler l'API ou non
-   * si le breaker est "open", on regarde si on peut "reset"
-   */
-  private _checkCircuitBreaker(): boolean {
-    if (!this._breakerOpen) return true;
-    const now = Date.now();
-    if (this._lastBreakerOpenTime != null && (now - this._lastBreakerOpenTime) > this._breakerResetTime) {
-      this._breakerOpen = false;
-      this._breakerErrorCount = 0;
-      this._logger.warn("[ApiClient] Circuit breaker réinitialisé");
-      this.emit("circuitBreakerReset");
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * updateCircuitBreaker : incremente le compteur d'erreurs
-   * si on dépasse le threshold, on "open" le breaker.
-   */
-  private _updateCircuitBreakerError(): void {
-    this._breakerErrorCount += 1;
-    this._logger.warn(`[ApiClient] Erreur #${this._breakerErrorCount} sur ${this._breakerThreshold}`);
-    if (this._breakerErrorCount >= this._breakerThreshold) {
-      this._breakerOpen = true;
-      this._lastBreakerOpenTime = Date.now();
-      this._logger.error("[ApiClient] Circuit breaker ACTIVÉ - L'API est considérée indisponible");
-      this.emit("circuitBreakerOpen", { timestamp: this._lastBreakerOpenTime });
-    }
-  }
-
-  /**
-   * resetCircuitBreaker : en cas de succès on reset le compteur
-   */
-  private _resetCircuitBreakerSuccess(): void {
-    this._breakerErrorCount = 0;
-    if (this._breakerOpen) {
-      this._breakerOpen = false;
-      this._logger.warn("[ApiClient] Circuit breaker refermé suite à un succès");
-    }
-  }
-
-  static stripNullsInPlace(obj: any): any {
-    // Si l'objet semble être un "fichier uploadé", c'est-à-dire qu'il possède une propriété "value" qui est un stream, on le laisse intact.
-    if (obj && typeof obj === "object" && obj.value && typeof obj.value.pipe === "function") {
-      return obj;
-    }
-    
-    if (Array.isArray(obj)) {
-      for (let i = obj.length - 1; i >= 0; i--) {
-        if (obj[i] === null || obj[i] === undefined) {
-          obj.splice(i, 1);
-        } else if (typeof obj[i] === "object") {
-          ApiClient.stripNullsInPlace(obj[i]);
-        }
-      }
-    } else if (obj && typeof obj === "object") {
-      for (const key in obj) {
-        if (Object.prototype.hasOwnProperty.call(obj, key)) {
-          if (obj[key] === null || obj[key] === undefined) {
-            delete obj[key];
-          } else if (typeof obj[key] === "object") {
-            ApiClient.stripNullsInPlace(obj[key]);
-          }
-        }
-      }
-    }
-    return obj;
-  }
-
-  private _resolveSpecialValuesInPlace(obj: any, pathParams: any = {}) {
-    const aliasMap: any = {
-      userId: () => this.userId,
-      accessToken: () => this._accessToken,
-      refreshToken: () => this._refreshToken,
-      baseURL: () => this._baseURL,
-      pathParams: (subPath: any) => {
-        // Si la valeur existe dans pathParams, on la retourne
-        const value = this._getValueByPath(pathParams, subPath);
-        return value !== undefined && value !== null ? value : undefined;
-      }
-    };
-  
-    // Expression régulière qui capture les alias sous forme délimitée @{...} ou simple @...
-    const regex = /@(?:\{([^}]+)\}|([\w.]+))/g;
-
-    const resolveString = (str: any) => {
-      if (typeof str !== "string") return str;
-      return str.replace(regex, (_, delimitedAlias, plainAlias) => {
-      // Si alias délimité, on traite toute la chaîne à l'intérieur des accolades.
-        if (delimitedAlias) {
-        // On s'attend à une forme comme "pathParams.id.autre"
-          if (delimitedAlias.startsWith("pathParams.")) {
-            const subPath = delimitedAlias.substring("pathParams.".length);
-            const value = aliasMap.pathParams(subPath);
-            return value !== undefined && value !== null ? value : `@{${delimitedAlias}}`;
-          } else {
-          // Pour d'autres alias délimités, on cherche directement dans aliasMap
-            const fn = aliasMap[delimitedAlias];
-            if (typeof fn === "function") {
-              const value = fn();
-              return value !== undefined && value !== null ? value : `@{${delimitedAlias}}`;
-            }
-            return `@{${delimitedAlias}}`;
-          }
-        } else if (plainAlias) {
-        // Traitement de l'alias simple, potentiellement avec des segments
-        // Vérifier s'il commence par "pathParams."
-          if (plainAlias.startsWith("pathParams.")) {
-          // Extrait la partie après "pathParams." et sépare le premier segment et le reste.
-            const match = plainAlias.match(/^pathParams\.([^.]+)(.*)$/);
-            if (match) {
-              const subKey = match[1];   // ex: "id"
-              const remainder = match[2];  // ex: "" ou ".autrechose"
-              // Si le reste est vide, ou s'il ne doit pas être remplacé (on remplace toujours le premier segment uniquement)
-              const value = aliasMap.pathParams(subKey);
-              return value !== undefined && value !== null ? value + remainder : `@${plainAlias}`;
-            }
-            return `@${plainAlias}`;
-          } else {
-          // Pour tout autre alias simple sans point ou autre
-            const fn = aliasMap[plainAlias];
-            if (typeof fn === "function") {
-              const value = fn();
-              return value !== undefined && value !== null ? value : `@${plainAlias}`;
-            }
-            return `@${plainAlias}`;
-          }
-        }
-        return str;
-      });
-    };
-
-  
-    // Vérifie si l'objet est un binaire (par exemple un flux ou un Buffer)
-    const isBinary = (input: any) => {
-      return input && typeof input === "object" &&
-             (typeof input.pipe === "function" || (typeof Buffer !== "undefined" && input instanceof Buffer));
-    };
-
-    // Vérifie si l'objet est un "plain object"
-    const isPlainObject = (input: any) => {
-      return Object.prototype.toString.call(input) === "[object Object]";
-    };
-
-    const internal = (input: any): any => {
-      // Si c'est un binaire, ne rien modifier
-      if (isBinary(input)) {
-        return input;
-      }
-      // Si c'est un tableau, on traite chaque élément
-      if (Array.isArray(input)) {
-        return input.map(internal);
-      }
-      // Si c'est un plain object, on crée un nouvel objet avec remplacement dans les clés et valeurs
-      if (isPlainObject(input)) {
-        const result: any = {};
-        for (const [key, value] of Object.entries(input)) {
-          const resolvedKey = resolveString(key);
-          result[resolvedKey] = internal(value);
-        }
-        return result;
-      }
-      // Si c'est une string, on applique le remplacement
-      if (typeof input === "string") {
-        return resolveString(input);
-      }
-      // Sinon (nombre, booléen, etc.), on retourne la valeur telle quelle
-      return input;
-    };
-  
-    return internal(obj);
-  }
-  
-
-  private _cleanSchemaLeftoverAlias(obj: any): any {
-    // Expression régulière qui détecte n'importe quel alias du type "@quelqueChose"
-    const aliasRegex = /@\w+/;
-    
-    if (Array.isArray(obj)) {
-      return obj.map((item: any) => this._cleanSchemaLeftoverAlias(item));
-    } else if (obj && typeof obj === "object") {
-      const newObj: any = {};
-      for (const key of Object.keys(obj)) {
-        const val = obj[key];
-
-        // Si le nom de la clé contient un alias (exemple : "@userId", "@anything"), on ne la copie pas
-        if (aliasRegex.test(key)) {
-          continue;
-        }
-
-        // Si la propriété s'appelle "default"
-        if (key === "default") {
-          // Si la valeur est une chaîne et qu'elle contient un alias, on ne la copie pas
-          if (typeof val === "string" && aliasRegex.test(val)) {
-            continue;
-          }
-          // Si la valeur est un objet, on le nettoie récursivement
-          if (val && typeof val === "object") {
-            const cleanedDefault = this._cleanSchemaLeftoverAlias(val);
-            // On ajoute seulement si l'objet nettoyé n'est pas vide
-            if (Object.keys(cleanedDefault).length > 0) {
-              newObj[key] = cleanedDefault;
-            }
-            continue;
-          }
-        }
-
-        // Si la valeur est une chaîne contenant un alias, on ne la copie pas
-        if (typeof val === "string" && aliasRegex.test(val)) {
-          continue;
-        }
-
-        // Sinon, on nettoie récursivement la valeur
-        newObj[key] = this._cleanSchemaLeftoverAlias(val);
-      }
-      return newObj;
-    }
-    return obj;
-  }
-  
-  /**
-   * Safely calls an asynchronous function and handles any errors that occur.
-   * Logs the error message using the instance's logger before re-throwing the error.
-   *
-   * @param fn - The asynchronous function to be called.
-   * @param args - The arguments to pass to the function.
-   * @returns The result of the asynchronous function.
-   * @throws {Error} Re-throws any error that occurs during the function execution.
-   */
-  async safeCall(fn: (...args: any[]) => Promise<any>, ...args: any[]) {
-    try {
-      return await fn(...args);
-    } catch (error) {
-      this._logger.error(`[ApiClient.safeCall] Erreur: ${getErrorMessage(error)}`);
-      throw error;
-    }
-  }
-
-  /**
-   * Appelle un endpoint avec validations AJV, auth et circuit breaker.
-   * En cas d’indisponibilité (offline ou breaker), **met en file** l’action via
-   * `_offlineClientManager` si présent.
-   *
-   * @param constant - The constant representing the endpoint to call.
-   * @param data - Données envoyées (incluant éventuellement `pathParams`).
-   * @param transformResponseData - `true` (transforme via `_transformData`), `false`, ou une fonction `(data) => any`.
-   * @param validateResponseSchema - Whether to validate the response schema.
-   * @returns The response from the endpoint call, or an enqueue result if offline or breaker is active.
-   * @throws {CircuitBreakerError} If the circuit breaker is activated.
-   * @throws {ApiClientError} If the endpoint is not found, token is required but not provided, or validation fails.
-   */
-  async callEndpoint<T = any>(
-    constant: string,
-    data: CallEndpointData = {},
-    transformResponseData: boolean | ((data: any) => any) = true,
-    validateResponseSchema: boolean = true
-  ): Promise<CallEndpointResponse<T>> {
-
-    const endpoint = this._endpoints.find((ep) => ep.constant === constant);
-    if (!endpoint) {
-      throw new ApiClientError(`Endpoint introuvable : ${constant}`, 404);
-    }
-  
-    const {
-      path,
-      method,
-      contentType,
-      auth,
-      pathParams: pathSchema,
-      request: requestSchema,
-      responses
-    } = endpoint;
-  
-    const lowerMethod = (method || "GET").toLowerCase();
-    const realContentType = contentType || "application/json";
-    const headers: Record<string, string> = { "Content-Type": realContentType };
-    if (this._mode === "clean") {
-      headers["X-Coco-Mode"] = "clean";
-    }
-
-    // Auth headers
-    if (this._accessToken) {
-      if (auth === "bearer") {
-        headers["Authorization"] = `Bearer ${this._accessToken}`;
-      } else if (!auth || auth === "none") {
-        if (!headers["Authorization"]) {
-          headers["Authorization"] = `Bearer ${this._accessToken}`;
-        }
-      }
-    } else if (auth === "bearer") {
-      throw new ApiClientError(`Token requis pour l'endpoint sécurisé : ${constant}`, 401);
-    }
-  
-    // === 1. PathParams ===
-    let resolvedPath = path;
-    let resolvedParams = {};
-    if (pathSchema) {
-
-      // Si auth est "none" et que userId n'est pas défini, on nettoie le schéma
-      let schemaToCompile = pathSchema;
-      if (auth === "none" && this.userId === null) {
-        schemaToCompile = this._cleanSchemaLeftoverAlias(pathSchema);
-      }
-
-      const pathParams = data.pathParams || {};
-      const validatePathParams: ValidateFunction = this._ajv.compile(schemaToCompile);
-      const valid = validatePathParams(pathParams);
-  
-      if (!valid) {
-        const errorMessages = this._ajvErrorHuman(validatePathParams.errors ?? []);
-        this.emit("validationError", { stage: "pathParams", errors: validatePathParams.errors });
-        throw new ApiValidationError(`callEndpoint: ${constant} -  Path parameter validation failed.`, 400, errorMessages, validatePathParams.errors);
-      }
-  
-      resolvedParams = this._resolveSpecialValuesInPlace(pathParams);
-
-      resolvedPath = resolvedPath.replace(/\{(\w+)\}/g, (_: any, key: string) => {
-        const val = (resolvedParams as any)[key];
-        if (val !== undefined) return encodeURIComponent(val);
-        throw new ApiClientError(`Path param manquant ou non résolu : {${key}}`, 400);
-      });
-    }
-
-    // === 2. Validation données (request schema) ===
-    if (requestSchema) {
-      // Si auth est "none" et que userId n'est pas défini, on nettoie le schéma
-      let schemaToCompile = requestSchema;
-      if (auth === "none" && this.userId === null) {
-        schemaToCompile = this._cleanSchemaLeftoverAlias(requestSchema);
-      }
-
-      // Enveloppe costum (canal Symbol, cf. CostumScope) — injection UNIFIÉE données + contexte :
-      //  - `properties` : champs DATA costum (per-costum) fusionnés dans le schéma racine compilé
-      //    (`additionalProperties:false` ne voit que les properties du même objet schema, pas les allOf) ;
-      //  - `context` : costumSlug/costumId/costumType acceptés par l'AJV (props) PUIS injectés dans le payload
-      //    plus bas → le contrat n'a plus à déclarer le contexte costum.
-      const costumEnv = (data as Record<symbol, unknown>)[COSTUM_REQUEST_ENVELOPE] as CostumRequestEnvelope | undefined;
-      if (costumEnv) {
-        const ctxProps = Object.fromEntries(Object.keys(costumEnv.context ?? {}).map((k) => [k, { type: "string" }]));
-        if (costumEnv.isUpdate) {
-          // UPDATE costum via `element/save` (pendant de l'ADD) : on n'envoie que les champs MODIFIÉS
-          // (standard + costum, schémas portés dans `properties`). On compile un schéma PERMISSIF — pas
-          // les `required`/`default` du schéma de création (sinon échec sur `name`/`type`/… non envoyés et
-          // réinjection de `parent` par défaut). $defs conservés pour les éventuels $ref des properties.
-          schemaToCompile = {
-            type: "object",
-            $defs: { ...((schemaToCompile as { $defs?: Record<string, unknown> }).$defs ?? {}), ...(costumEnv.defs ?? {}) },
-            properties: { ...(costumEnv.properties ?? {}), ...ctxProps, id: { type: "string" }, collection: { type: "string" } },
-            additionalProperties: false,
-          };
-        } else {
-          schemaToCompile = {
-            ...schemaToCompile,
-            properties: { ...(schemaToCompile.properties ?? {}), ...(costumEnv.properties ?? {}), ...ctxProps },
-          };
-        }
-      }
-
-      let dataForValidation = { ...data };
-      delete dataForValidation.pathParams;
-      delete (dataForValidation as Record<symbol, unknown>)[COSTUM_REQUEST_ENVELOPE];
-      // contexte costum injecté dans le payload (auto) → lu par resolveActiveCostum côté backend.
-      if (costumEnv?.context) Object.assign(dataForValidation, costumEnv.context);
-
-      // Normalize Dates to ISO strings for x-www-form-urlencoded BEFORE validation
-      if (realContentType === "application/x-www-form-urlencoded") {
-        dataForValidation = ApiClient.normalizeDatesForValidation(dataForValidation);
-        // For fields with format:"date", extract only YYYY-MM-DD
-        dataForValidation = ApiClient.normalizeSchemaDateFields(dataForValidation, schemaToCompile);
-      }
-
-      const cleanedData = ApiClient.stripNullsInPlace(dataForValidation);
-
-      // UPDATE costum (enveloppe.isUpdate) : AJV SANS useDefaults — ne réinjecte aucun défaut de création.
-      const requestAjv = costumEnv?.isUpdate ? this._ajvNoDefaults : this._ajv;
-      const validateRequest: ValidateFunction = requestAjv.compile(schemaToCompile);
-      const valid = validateRequest(cleanedData);
-      if (!valid) {
-        const errorMessages = validateRequest.errors ? this._ajvErrorHuman(validateRequest.errors) : [];
-        this.emit("validationError", { stage: "request", errors: validateRequest.errors });
-        throw new ApiValidationError(`callEndpoint: ${constant} - Request validation failed.`, 400, errorMessages , validateRequest.errors);
-      }
-
-      data = this._resolveSpecialValuesInPlace(cleanedData, resolvedParams);
-    }
-  
-    // === 3. ENQUEUE SI OFFLINE (après validations, avant le breaker)
-    if (this._offlineClientManager?.isOffline()) {
-      if (typeof this._offlineClientManager._enqueueOfflineAction === "function") {
-        this._logger.warn(`[ApiClient] Mode dégradé : mise en file de ${constant}`);
-        await this._offlineClientManager._enqueueOfflineAction({
-          constant,
-          data,
-          options: { transformResponseData, validateResponseSchema }
-        });
-
-        this._logger.info(`[ApiClient] Requête ${constant} mise en file (offline mode)`);
-
-        this.emit("queuedOffline", {
-          constant,
-          reason: "offlineMode",
-          data
-        });
-
-        const enqueued = { data: null, offline: true as const };
-        return enqueued;
-      } else {
-        this._logger.warn("[ApiClient] Mode dégradé actif mais offlineManager non initialisé correctement");
-        throw new ApiClientError("Mode hors-ligne actif, mais gestionnaire offline non disponible.", 503);
-      }
-    }
-
-    // === 4. Circuit Breaker
-    if (!this._checkCircuitBreaker()) {
-      if (
-        this._offlineClientManager?.isOffline?.() === false && // pas déjà en mode offline
-        typeof this._offlineClientManager._enqueueOfflineAction === "function"
-      ) {
-        this._logger.warn(`[ApiClient] Circuit breaker actif → mise en file de ${constant}`);
-        await this._offlineClientManager._enqueueOfflineAction({
-          constant,
-          data,
-          options: { transformResponseData, validateResponseSchema }
-        });
-
-        this._logger.info(`[ApiClient] Requête ${constant} mise en file (circuit breaker)`);
-
-        this.emit("queuedOffline", {
-          constant,
-          reason: "circuitBreaker",
-          data
-        });
-
-        const enqueued = { data: null, breaker: true as const };
-        return enqueued;
-      }
-
-      throw new CircuitBreakerError("Le circuit breaker est activé, impossible d'appeler l'API");
-    }
-
-    // === 5. Payload ===
-    let payload;
-    if (realContentType === "application/json" || realContentType === "multipart/form-data") {
-      payload = data;
-    } else if (realContentType === "application/x-www-form-urlencoded") {
-      payload = ApiClient.toURLSearchParams(data);
-    }
-  
-    this._logger.debug(`[ApiClient] callEndpoint: ${constant} -> ${resolvedPath}, method=${lowerMethod}`);
-
-    try {
-      const response = await this._client.request({
-        url: resolvedPath,
-        method: lowerMethod,
-        headers,
-        [lowerMethod === "get" ? "params" : "data"]: payload
-      });
-      
-      if (this._mode === "clean") {
-        // Enveloppe serveur {success, data|error} : unwrap + erreur typée. Les normalisations
-        // sont faites PAR LE SERVEUR (serializeClean) — pas de _transformData ni d'AJV legacy ici.
-        const body = response.data;
-        if (body && typeof body === "object" && !Array.isArray(body) && typeof body.success === "boolean") {
-          if (body.success === false) {
-            throw new ApiResponseError(body?.error?.message ?? "Erreur inconnue", response.status, body);
-          }
-          response.data = body.data;
-        }
-        if (this._fromJSONValue) {
-          response.data = this._reviveClean(response.data);
-        }
-      } else if (validateResponseSchema) {
-        const statusStr = String(response.status);
-        const schema = responses?.[statusStr];
-        
-        if (schema) {
-          const validateResponse: ValidateFunction = this._ajv.compile(schema);
-          const valid = validateResponse(response.data);
-          if (!valid) {
-            const errorMessages = this._ajvErrorHuman(validateResponse.errors ?? []);
-            this.emit("validationError", { stage: "response", errors: validateResponse.errors });
-            throw new ApiValidationError("Response validation failed.", response.status, errorMessages, validateResponse.errors);
-          }
-        }
-      }
-  
-      this._resetCircuitBreakerSuccess();
-  
-      if (typeof transformResponseData === "function") {
-        response.data = transformResponseData(response.data);
-      } else if (transformResponseData === true && this._mode !== "clean") {
-        response.data = this._transformData(response.data);
-      }
-  
-      // postActions éventuelles
-      if (Array.isArray(endpoint.postActions)) {
-        endpoint.postActions.forEach((action: any) => {
-          const value = action.path ? this._getValueByPath(response.data, action.path) : null;
-      
-          switch (action.type) {
-          case "setToken":
-            this.setToken(value);
-            break;
-      
-          case "setRefreshToken":
-            this.setRefreshToken(value);
-            break;
-      
-            // case "setUserId":
-            //   this._setUserId(value);
-            //   break;
-            
-          case "resetSession":
-            this.resetSession();
-            break;
-      
-          case "emitEvent":
-            if (action.event) {
-              this.emit(action.event, value);
-              this._logger.debug(`[ApiClient] Event émis : ${action.event}`, value);
-            }
-            break;
-      
-          case "callMethod":
-            if (typeof (this as any)[action.method] === "function") {
-              (this as any)[action.method]();
-              this._logger.debug(`[ApiClient] Méthode appelée : ${action.method}`);
-            } else {
-              this._logger.warn(`[ApiClient] Méthode inconnue : ${action.method}`);
-            }
-            break;
-      
-          default:
-            this._logger.warn(`[ApiClient] Action inconnue : ${action.type}`);
-          }
-        });
-      }
-      
-  
-      return response;
-    } catch (error) {
-      if (error instanceof ApiResponseError) {
-        // Erreur MÉTIER (enveloppe du mode clean success:false) : même sémantique que le
-        // checkAndThrowApiResponseError legacy -> re-throw tel quel, et SANS compter dans le
-        // circuit breaker (en legacy ces erreurs arrivent en HTTP 200 et ne l'incrémentent pas).
-        throw error;
-      }
-      this._updateCircuitBreakerError();
-      this._logger.error(`[ApiClient] Erreur lors de l'appel de ${constant}: ${getErrorMessage(error)}`);
-      if(error instanceof ApiValidationError) {
-        throw error;
-      } else {
-        const statusCode = hasResponse(error) ? error.response.status : 500;
-        const responseData = hasResponse(error) ? error.response.data : null;
-        throw new ApiClientError(
-          `Erreur lors de l'appel de l'API : ${getErrorMessage(error)}`,
-          statusCode,
-          responseData
-        );
-      }
-
-    }
-  }
-  
-  /**
-   * Converts AJV (Another JSON Schema Validator) errors into human-readable messages.
-   *
-   * @param errors - An array of AJV validation error objects.
-   * @returns An array of human-readable error messages extracted from the AJV errors.
-   */
-  private _ajvErrorHuman(errors: any[]){
-    try {
-      const errorsMessages = new AggregateAjvError(errors);
-      // @ts-expect-error - champ non typé public dans les defs
-      const messages = errorsMessages.errors.map(({ message }: any) => message);
-      return messages;
-    } catch (e) {
-      this._logger.error("[ApiClient] _ajvErrorHuman", e);
-      return errors.map(({ message }: any) => message);
-    }
-  }
-
-  /**
-   * Checks the API response for errors and throws an `ApiResponseError` if any are found.
-   *
-   * This method examines the `response.data` object to determine if it contains
-   * error information. It handles both standard and nested error cases:
-   * 
-   * - Standard case: If `data.result` is a boolean and is `false`, an error is thrown.
-   * - Nested case: If `data.resultErrors` exists and contains a `result` property
-   *   that is a boolean and is `false`, an error is thrown.
-   *
-   * If no errors are found, the original `response` is returned.
-   *
-   * @param {import("axios").AxiosResponse | { data: any } } response
-   * @returns {import("axios").AxiosResponse | { data: any }}
-   * @throws {ApiResponseError} If an error is detected in the response data.
-   */
-  checkAndThrowApiResponseError(response: any) {
-    if (!("status" in response)) {
-      return response;
-    }
-
-    const data = response.data;
-    if (!data || typeof data !== "object") {
-      return response;
-    }
-  
-    // Cas standard : vérifie si data.result vaut false
-    if (typeof data.result === "boolean" && data.result === false) {
-      throw new ApiResponseError(
-        data.msg || "Erreur inconnue",
-        response.status,
-        data
-      );
-    }
-  
-    // Cas imbriqué : vérifie si data.resultErrors existe et contient une erreur
-    if (data.resultErrors && typeof data.resultErrors === "object") {
-      if (typeof data.resultErrors.result === "boolean" && data.resultErrors.result === false) {
-        throw new ApiResponseError(
-          data.resultErrors.msg || "Erreur inconnue",
-          response.status,
-          data
-        );
-      }
-    }
-  
-    return response;
-  }
-    
-  /**
- * Réinitialise complètement la session de l'utilisateur :
- * - Token d'accès
- * - Token de rafraîchissement
- * - userId
- * - En-têtes Axios
- */
-  resetSession(): void {
-    this.setToken(null);
-    this.setRefreshToken(null);
-    this._setUserId(null);
-    this._tokenStorage.clear();
-
-    // Suppression des en-têtes
-    delete this._client.defaults.headers.common["Authorization"];
-
-    this._logger.info("[ApiClient] Session utilisateur réinitialisée.");
-    this.emit("sessionReset");
-  }
-
-  /**
-   * Retrieves the value from an object based on a dot-separated path.
-   */
-  private _getValueByPath(obj: any, path: string): any {
-    if (!path) return undefined;
-    const keys = path.split(".");
-    return keys.reduce((acc, key) => acc && acc[key], obj);
-  }
-  
-  // Conversions
-
-  /**
-   * Normalizes Date objects to ISO strings for AJV validation.
-   * This preserves the object structure while converting only Dates.
-   * Handles reactive Proxies by unwrapping them first.
-   *
-   * @param obj - The object to normalize
-   * @returns The normalized object with Dates as ISO strings
-   */
-  static normalizeDatesForValidation(obj: any): any {
-    if (obj === null || obj === undefined) return obj;
-
-    // Unwrap reactive Proxies BEFORE checking for Date
-    if (obj && typeof obj === "object" && obj.__isReactive && obj.__raw) {
-      return ApiClient.normalizeDatesForValidation(obj.__raw);
-    }
-
-    if (obj instanceof Date) {
-      return obj.toISOString().replace(/\.\d{3}Z$/, "+0000");
-    }
-
-    if (Array.isArray(obj)) {
-      return obj.map((item: any) => ApiClient.normalizeDatesForValidation(item));
-    }
-
-    if (typeof obj === "object") {
-      const normalized: any = {};
-      for (const key of Object.keys(obj)) {
-        normalized[key] = ApiClient.normalizeDatesForValidation(obj[key]);
-      }
-      return normalized;
-    }
-
-    return obj;
-  }
-
-  /**
-   * Normalizes fields with format:"date" in schema to YYYY-MM-DD format.
-   * Extracts only the date part from ISO datetime strings.
-   *
-   * @param data - The data object to normalize
-   * @param schema - The JSON schema containing field definitions
-   * @returns The normalized data with date-only strings for format:"date" fields
-   */
-  static normalizeSchemaDateFields(data: any, schema: any) {
-    if (!data || !schema || typeof data !== "object") return data;
-
-    const normalized = { ...data };
-
-    // Récupérer les propriétés du schéma (gérer allOf, then, properties, etc.)
-    let properties = schema.properties || {};
-
-    // Si le schéma utilise allOf, parcourir tous les éléments
-    if (schema.allOf && Array.isArray(schema.allOf)) {
-      for (const allOfItem of schema.allOf) {
-        // Chercher dans properties directes
-        if (allOfItem.properties) {
-          properties = { ...properties, ...allOfItem.properties };
-        }
-        // Chercher dans if/then/properties
-        if (allOfItem.then && allOfItem.then.properties) {
-          properties = { ...properties, ...allOfItem.then.properties };
-        }
-      }
-    }
-
-    // Aussi vérifier schema.then.properties si présent
-    if (schema.then && schema.then.properties) {
-      properties = { ...properties, ...schema.then.properties };
-    }
-
-    // Pour chaque propriété ayant format:"date"
-    for (const [key, propDef] of Object.entries(properties)) {
-      const typedPropDef = propDef as any;
-      if (typedPropDef?.format === "date" && normalized[key]) {
-        const value = normalized[key];
-
-        // Si c'est une string ISO datetime, extraire YYYY-MM-DD
-        if (typeof value === "string" && value.includes("T")) {
-          normalized[key] = value.split("T")[0];
-        }
-      }
-    }
-
-    return normalized;
-  }
-
-  /**
-   * Converts an object to URL search parameters.
-   *
-   * @param obj - The object to be converted to URL search parameters.
-   * @param [options={}] - Optional settings for the conversion.
-   * @returns The URL search parameters generated from the object.
-   */
-  static toURLSearchParams(obj: any, options: any = {}) {
-    return this._buildParams(obj, new URLSearchParams(), options) as URLSearchParams;
-  }
-
-  /**
-   * Builds parameters for an API request from a given object.
-   */
-  static _buildParams(
-    obj: any,
-    paramsInstance: FormData | URLSearchParams,
-    options: {
-      dots?: boolean;
-      indexes?: boolean;
-      metaTokens?: boolean;
-    } = {}
-  ): FormData | URLSearchParams {
-    if (typeof obj !== "object" || obj === null) {
-      throw new TypeError("La donnée doit être un objet non nul.");
-    }
-
-    const { dots = false, indexes = false, metaTokens = true } = options;
-    const stack: any[] = [];
-
-    function isVisitable(thing: any) {
-      return Object.prototype.toString.call(thing) === "[object Object]" || Array.isArray(thing);
-    }
-
-    function removeBrackets(key: any) {
-      return key.endsWith("[]") ? key.slice(0, -2) : key;
-    }
-
-    function renderKey(path: any, key: any, useDots = false) {
-      if (!path) return key;
-      return path.concat(key).map((token: any, i: any) => {
-        token = removeBrackets(token);
-        return !useDots && i ? `[${token}]` : token;
-      }).join(useDots ? "." : "");
-    }
-
-    function convertValue(value: any) {
-      if (value === null || value === undefined) return "";
-      if (value instanceof Date) return value.toISOString();
-      if (
-        value instanceof Blob ||
-        value instanceof File ||
-        value instanceof ArrayBuffer ||
-        ArrayBuffer.isView(value)
-      ) {
-        return value;
-      }
-      return value;
-    }
-
-    function defaultVisitor(value: any, key: any, path: any) {
-      if (value && typeof value === "object") {
-        if (key.endsWith("{}")) {
-          key = metaTokens ? key : key.slice(0, -2);
-          paramsInstance.append(renderKey(path, key, dots), JSON.stringify(value));
-          return false;
-        }
-
-        if ((Array.isArray(value) && !value.some(isVisitable)) || key.endsWith("[]")) {
-          key = removeBrackets(key);
-          value.forEach((el: any, index: any) => {
-            if (el !== undefined && el !== null) {
-              // const fieldKey = indexes ? renderKey([key], index, dots) : `${key}[]`;
-              const fieldKey = indexes
-                ? renderKey(path.concat(key), index, dots)
-                : `${renderKey(path, key, dots)}[]`;
-              paramsInstance.append(fieldKey, convertValue(el));
-            }
-          });
-          return false;
-        }
-      }
-
-      if (isVisitable(value)) return true;
-      paramsInstance.append(renderKey(path, key, dots), convertValue(value));
-      return false;
-    }
-
-    function build(value: any, path: any = []) {
-      if (value === undefined || value === null || (stack as any).includes(value)) return;
-      (stack as any).push(value);
-
-      Object.entries(value).forEach(([k, el]) => {
-        if (el !== undefined && defaultVisitor(el, k.trim(), path)) {
-          build(el, path.concat(removeBrackets(k)));
-        }
-      });
-
-      stack.pop();
-    }
-
-    build(obj);
-    return paramsInstance;
-  }
-
-
-  /**
-     * Transforms the given data based on its structure.
-     * 
-     * This method normalizes various structures of data into a consistent format.
-     * It handles different types of data including objects, arrays, and specific
-     * nested structures like `resultGoods`, `resultErrors`, `results`, `news`, 
-     * `notif`, `citoyens`, `organizations`, `cities`, `newComment`, `map`, and `object`.
-     * 
-     * @param data - The data to be transformed.
-     * @returns - The transformed data.
-     * 
-     * @private
-     */
-  /**
-   * Reviver du mode clean : redonne à l'app le shape exact qu'elle recevait après les
-   * normalisations legacy de la lib — dates ISO (champs _dateFields) -> instances Date,
-   * `id` oid-hex -> `_id` instance ObjectID (créée via EJSON.fromJSONValue, MÊME chemin
-   * que le mode legacy). Le serveur clean a déjà fait tout le reste.
-   */
-  private _reviveClean(data: any): any {
-    if (Array.isArray(data)) {
-      return data.map((item) => this._reviveClean(item));
-    }
-    if (data !== null && typeof data === "object") {
-      const out: any = {};
-      Object.keys(data).forEach((key) => {
-        let value = this._reviveClean(data[key]);
-        if (this._dateFields.includes(key) && typeof value === "string" && /^\d{4}-\d{2}-\d{2}T/.test(value)) {
-          const d = new Date(value);
-          if (!Number.isNaN(d.getTime())) value = d;
-        }
-        out[key] = value;
-      });
-      if (typeof out.id === "string" && /^[0-9a-fA-F]{24}$/.test(out.id) && out._id === undefined) {
-        out._id = EJSON.fromJSONValue({ $type: "oid", $value: out.id });
-      }
-      return out;
-    }
-    return data;
-  }
-
-  private _transformData(data: any): any {
-    if (data && typeof data === "object") {
-      if (data.resultGoods?.msg) {
-        data = this._normalizeJsonData({ msg: data.resultGoods.msg, ...data });
-      } else if (data.resultErrors?.msg) {
-        data = this._normalizeJsonData({ msg: data.resultErrors.msg, ...data });
-      } else if (data.results && typeof data.results === "object" && !Array.isArray(data.results)) {
-        data.results = Object.keys(data.results).map((key) => {
-          return this._normalizeJsonData({ id: key, ...data.results[key] });
-        });
-      } else if (Array.isArray(data.results) && data.results.length > 0) {
-        data.results = data.results.map((item: any) => this._normalizeJsonData(item));
-      } else if (data.news && Array.isArray(data.news) && data.news.length === 0) {
-        data = data.news;
-      } else if (data.news && typeof data.news === "object" && !Array.isArray(data.news)) {
-        data = Object.keys(data.news).map((key) => {
-          return this._normalizeJsonData({ id: key, ...data.news[key] });
-        });
-      } else if (data.notif && typeof data.notif === "object" && !Array.isArray(data.notif)) {
-        data.notif = Object.keys(data.notif).map((key) => {
-          return this._normalizeJsonData({ id: key, ...data.notif[key] });
-        });
-      } else if (
-        data.citoyens && typeof data.citoyens === "object" && !Array.isArray(data.citoyens) &&
-          data.organizations && typeof data.organizations === "object" && !Array.isArray(data.organizations)
-      ) {
-        data = [
-          ...Object.keys(data.citoyens).map(key => this._normalizeJsonData({ id: key, ...data.citoyens[key] })),
-          ...Object.keys(data.organizations).map(key => this._normalizeJsonData({ id: key, ...data.organizations[key] }))
-        ];
-      } else if (
-        data.citoyens && typeof data.citoyens === "object" && !Array.isArray(data.citoyens)
-      ) {
-        data = Object.keys(data.citoyens).map(key => this._normalizeJsonData({ id: key, ...data.citoyens[key] }));
-      } else if (data.cities && typeof data.cities === "object" && !Array.isArray(data.cities)) {
-        data = Object.keys(data.cities).map(key => this._normalizeJsonData({ id: key, ...data.cities[key] }));
-      } else if (data.cities && Array.isArray(data.cities) && data.cities.length === 0) {
-        data = data.cities;
-      } else if (data.newComment && typeof data.newComment === "object") {
-        data.newComment = this._normalizeJsonData({ ...data.newComment });
-      } else if (Array.isArray(data)) {
-        data = data.map((item) => this._normalizeJsonData(item));
-      } else if (data.map && typeof data.map === "object") {
-        data.map = this._normalizeJsonData(data.map);
-      } else if (data.object && typeof data.object === "object") {
-        data.object = this._normalizeJsonData(data.object);
-      } else if (typeof data === "object" && Object.keys(data).length > 0) {
-        // Vérifie si toutes les clés sont des IDs mongo
-        const allMongoIds = Object.keys(data).every((key) => /^[0-9a-fA-F]{24}$/.test(key));
-        if (allMongoIds) {
-          data = Object.keys(data).map((key) => ({
-            id: key,
-            ...this._normalizeJsonData(data[key])
-          }));
-        } else {
-          data = this._normalizeJsonData(data);
-        }
-      }
-    }
-    return data;
-  }
-  
-
-  /**
-     * Normalizes JSON data by transforming specific fields and ensuring URLs are complete.
-     *
-     * @param item - The JSON object to be normalized.
-     * @returns - The normalized JSON object.
-     *
-     * The function performs the following transformations:
-     * - Normalizes the ID field if it matches a specific pattern.
-     * - Converts date fields from seconds to milliseconds.
-     * - Ensures URLs in specific fields are complete.
-     * - Filters and normalizes nested objects and arrays.
-     * - Removes the `timeAgo` field if it exists.
-     * - Converts the object to EJSON format if necessary.
-     */
-  private _normalizeJsonData(item: any) {
-    if (!item || typeof item !== "object") {
-      return item;
-    }
-  
-    // Application des normalisations récursives
-    item = this._normalizeRecursively(item);
-
-    // item = this._normalizeIdRecursively(item);
-    // item = this._normalizeDatesRecursively(item);
-    // item = this._normalizeImagesRecursively(item);
-
-    // if(item?.preferences){
-    //   item.preferences = this._normalizeBooleansRecursively(item.preferences);
-    // }
-
-    if (item?.mediaImg?.images && Array.isArray(item.mediaImg.images) && item.mediaImg.images.length > 0) {
-      item.mediaImg.countImages = item.mediaImg.images.length;
-    }
-  
-    if (item?.mediaFile?.files && Array.isArray(item.mediaFile.files) && item.mediaFile.files.length > 0) {
-      item.mediaFile.countFiles = item.mediaFile.files.length;
-    }
-
-    if (
-      item?.src?.changes &&
-        typeof item.src.changes === "object" &&
-        Object.keys(item.src.changes).length > 0
-    ) {
-      Object.keys(item.src.changes).forEach((key) => {
-        if (item.src.changes[key]) {
-          item.src.changes[key] = this._ensureFullURL(item.src.changes[key]);
-        }
-      });
-    }
-  
-    if (item?.openingHours && Array.isArray(item.openingHours) && item.openingHours.length > 0) {
-      item.openingHours = item.openingHours.filter(
-        (day: any) => day.dayOfWeek && day.hours && day.hours[0] && day.hours[0].opens
-      );
-    }
-  
-    if (item.replies && typeof item.replies === "object" && Object.keys(item.replies).length > 0) {
-      item.replies = Object.keys(item.replies).map((key) => {
-        return this._normalizeJsonData({ id: key, ...item.replies[key] });
-      });
-    }
-  
-    if (
-      item?.author &&
-      typeof item.author === "object" &&
-      Object.keys(item.author).length > 0
-    ) {
-      // Si author contient déjà une propriété attendue (ici "profilThumbImageUrl"),
-      // on considère qu'il est déjà aplatit.
-      if (!("profilThumbImageUrl" in item.author)) {
-        // Sinon, on considère que author est un mapping et on prend le premier sous-objet.
-        const firstKey = Object.keys(item.author)[0];
-        // On remplace author par le contenu du sous-objet
-        item.author = { ...item.author[firstKey] };
-      }
-    }
-  
-    // Supprime timeAgo
-    if (item?.timeAgo) {
-      delete item.timeAgo;
-    }
-
-    if(item?.author?.typeSig === "people"){
-      item.author.type = "citoyens";
-    }
-
-    if(item?.typeSig === "people"){
-      item.collection = "citoyens";
-    }
-    if(item?.typeSig === "organizations"){
-      item.collection = "organizations";
-    }
-  
-    // Convertit en EJSON si besoin
-    return this._fromJSONValue ? EJSON.fromJSONValue(item) : item;
-  }
-  
-
-  /**
-     * Ensures that the given image path is a full URL. If the image path is already a full URL
-     * (i.e., it starts with "http://" or "https://"), it is returned as is. Otherwise, the image path
-     * is concatenated with the base URL of the ApiClient instance.
-     *
-     * @param imagePath - The image path to ensure as a full URL.
-     * @returns - The full URL of the image path.
-     */
-  private _ensureFullURL(imagePath: any) {
-    if (!imagePath) return imagePath;
-    imagePath = imagePath.trim();
-    if (!imagePath || /^https?:\/\//i.test(imagePath)) {
-      return imagePath;
-    }
-  
-    let separator = "/";
-    if (this._baseURL.endsWith("/") && imagePath.startsWith("/")) {
-      separator = "";
-    } else if (!this._baseURL.endsWith("/") && !imagePath.startsWith("/")) {
-      separator = "/";
-    } else {
-      separator = "";
-    }
-  
-    return `${this._baseURL}${separator}${imagePath}`;
-  }
-
-  /**
- * Parcourt récursivement un objet pour normaliser les champs de date.
- * Pour chaque clé présente dans dateFields, si la valeur est un nombre ou un objet
- * contenant une propriété sec (nombre), la transforme en { $date: valeurEnMs }.
- *
- * @param obj - L’objet à normaliser.
- * @returns L’objet normalisé.
- */
-  // _normalizeDatesRecursively(obj) {
-  //   if (obj === null || typeof obj !== "object") return obj;
-
-  //   // Si c'est un tableau, on traite chaque élément récursivement.
-  //   if (Array.isArray(obj)) {
-  //     return obj.map(item => this._normalizeDatesRecursively(item));
-  //   }
-
-  //   Object.keys(obj).forEach((key) => {
-  //     if (this._dateFields.includes(key)) {
-  //       if (obj[key] && typeof obj[key] === "object" && obj[key].sec && typeof obj[key].sec === "number") {
-  //         obj[key] = { $date: obj[key].sec * 1000 };
-  //       } else if (typeof obj[key] === "number") {
-  //         obj[key] = { $date: obj[key] * 1000 };
-  //       }
-  //     }
-  //     if (obj[key] && typeof obj[key] === "object") {
-  //       this._normalizeDatesRecursively(obj[key]);
-  //     }
-  //   });
-  //   return obj;
-  // }
-
-  /**
- * Parcourt récursivement un objet pour normaliser les chemins d'images.
- * Pour chaque propriété correspondant à un champ d'image (dans imageFields),
- * vérifie et convertit le chemin en URL complète à l’aide de _ensureFullURL.
- * Les cas particuliers (comme mediaImg.images ou mediaFile.files) sont également gérés.
- *
- * @param obj - L’objet à normaliser.
- * @returns L’objet normalisé.
- */
-  // _normalizeImagesRecursively(obj) {
-  //   if (obj === null || typeof obj !== "object") return obj;
-
-  //   // Si c'est un tableau, on traite chaque élément récursivement.
-  //   if (Array.isArray(obj)) {
-  //     return obj.map(item => this._normalizeImagesRecursively(item));
-  //   }
-
-  //   Object.keys(obj).forEach((key) => {
-  //     if (this._imageFields.includes(key) && typeof obj[key] === "string" && obj[key].trim() !== "") {
-  //       obj[key] = this._ensureFullURL(obj[key]);
-  //     }
-
-  //     // Cas particulier pour content.image
-  //     if (key === "content" && obj[key]?.image) {
-  //       obj[key].image = this._ensureFullURL(obj[key].image);
-  //     }
-
-  //     if (obj[key] && typeof obj[key] === "object") {
-  //       this._normalizeImagesRecursively(obj[key]);
-  //     }
-  //   });
-  //   return obj;
-  // }
-
-  /**
- * Parcourt récursivement un objet ou un tableau pour normaliser les identifiants (ID).
- * Si un objet possède une propriété "_id" ou "id" contenant un sous-objet "$id" valide,
- * l'ID est normalisé et la propriété _id est convertie au format EJSON attendu.
- *
- * @param obj - L'objet ou le tableau à normaliser.
- * @returns L'objet ou le tableau normalisé.
- */
-  // _normalizeIdRecursively(obj) {
-  //   if (obj === null || typeof obj !== "object") return obj;
-
-  //   // Si c'est un tableau, on traite chaque élément récursivement.
-  //   if (Array.isArray(obj)) {
-  //     return obj.map(item => this._normalizeIdRecursively(item));
-  //   }
-
-  //   // Vérifier et normaliser l'ID dans l'objet
-  //   if (obj._id && obj._id.$id && /^[0-9a-fA-F]{24}$/.test(obj._id.$id)) {
-  //     obj.id = obj._id.$id;
-  //     obj._id = { $type: "oid", $value: obj._id.$id };
-  //   }
-  //   if (obj.id && obj.id.$id && /^[0-9a-fA-F]{24}$/.test(obj.id.$id)) {
-  //     obj._id = { $type: "oid", $value: obj.id.$id };
-  //     obj.id = obj.id.$id;
-  //   }
-
-  //   // Appel récursif pour chaque propriété de l'objet
-  //   Object.keys(obj).forEach(key => {
-  //     if (obj[key] && typeof obj[key] === "object") {
-  //       obj[key] = this._normalizeIdRecursively(obj[key]);
-  //     }
-  //   });
-
-  //   return obj;
-  // }
-
-  /**
- * Normalise récursivement les valeurs booléennes.
- * Si une valeur est une chaîne "true" ou "false", elle est convertie en booléen.
- *
- * @param data - L'objet, le tableau ou la valeur à normaliser.
- * @returns La donnée normalisée.
- */
-  // _normalizeBooleansRecursively(data) {
-  //   if (typeof data === "string") {
-  //     if (data === "true") return true;
-  //     if (data === "false") return false;
-  //     return data;
-  //   }
-  //   if (Array.isArray(data)) {
-  //     return data.map(item => this._normalizeBooleansRecursively(item));
-  //   }
-  //   if (data !== null && typeof data === "object") {
-  //     Object.keys(data).forEach(key => {
-  //       data[key] = this._normalizeBooleansRecursively(data[key]);
-  //     });
-  //   }
-  //   return data;
-  // }
-
-  /**
- * Transforme une chaîne "true" ou "false" en booléen.
- *
- * @param str - La chaîne à normaliser.
- * @returns La valeur booléenne ou la chaîne originale.
- */
-  private _normalizeString(str: any) {
-    if (str === "true") return true;
-    if (str === "false") return false;
-    return str;
-  }
-
-  /**
- * Normalise les identifiants dans un objet.
- * Si l'objet possède une propriété "_id" ou "id" contenant un sous-objet "$id" valide,
- * il met à jour l'objet en assignant la valeur de l'ID et en formattant _id en EJSON.
- *
- * @param obj - L'objet à normaliser.
- * @returns L'objet avec l'ID normalisé.
- */
-  private _normalizeId(obj: any) {
-    if (obj._id && obj._id.$id && /^[0-9a-fA-F]{24}$/.test(obj._id.$id)) {
-      obj.id = obj._id.$id;
-      obj._id = { $type: "oid", $value: obj._id.$id };
-    }
-    if (obj.id && obj.id.$id && /^[0-9a-fA-F]{24}$/.test(obj.id.$id)) {
-      obj._id = { $type: "oid", $value: obj.id.$id };
-      obj.id = obj.id.$id;
-    }
-    return obj;
-  }
-
-  /**
- * Normalise une valeur de date.
- * Si la valeur est un objet contenant "sec" (nombre) ou un nombre,
- * elle est convertie en { $date: valeurEnMs }.
- *
- * @param value - La valeur à normaliser.
- * @returns La valeur normalisée.
- */
-  private _normalizeDate(value: any) {
-    if (value && typeof value === "object" && typeof value.sec === "number") {
-      return { $date: value.sec * 1000 };
-    } else if (typeof value === "number") {
-      return { $date: value * 1000 };
-    } else if (typeof value === "string" && value.trim() !== "") {
-      const date = new Date(value);
-      // Vérifier que la date est valide (pas NaN)
-      if (!isNaN(date.getTime())) {
-        return EJSON.toJSONValue(date);
-      }
-    }
-    return value;
-  }
-
-  /**
- * Normalise une URL d'image.
- * Si la valeur est une chaîne non vide, retourne l'URL complète via _ensureFullURL.
- *
- * @param value - La valeur à normaliser.
- * @returns La valeur normalisée.
- */
-  private _normalizeImage(value: any) {
-    if (typeof value === "string" && value.trim() !== "") {
-      return this._ensureFullURL(value);
-    }
-    return value;
-  }
-
-  /**
- * Normalise les valeurs numériques renvoyées en string par le backend
- * (cas typique : content-type application/x-www-form-urlencoded qui
- * sérialise tout en string, et le backend stocke tel quel).
- *
- * @param value - La valeur à normaliser.
- * @returns Number si conversion possible, sinon la valeur d'origine.
- */
-  private _normalizeNumber(value: any) {
-    if (typeof value !== "string") return value;
-    const trimmed = value.trim();
-    if (trimmed === "") return value;
-    const n = Number(trimmed);
-    return Number.isFinite(n) ? n : value;
-  }
-
-  /**
- * Liste des champs d'image à normaliser.
- */
-  private _imageFields = [
-    "profilImageUrl",
-    "profilThumbImageUrl",
-    "profilMediumImageUrl",
-    "profilMarkerImageUrl",
-    "profilBannerUrl",
-    "profilRealBannerUrl",
-    "imagePath",
-    "imageThumbPath",
-    "docPath",
-    "imageThumb",
-    "imageMediumPath",
-    "logo",
-    "logoMin",
-    // `image` : chemin relatif renvoyé par Document::getDocumentPath (ex: valeurs
-    // thématiques de COSTUM_FILTER_COFORM_BY_PATH). _normalizeImage ne touche que les
-    // strings non vides → "" et non-strings restent inchangés (pas d'effet de bord).
-    "image"
-  ];
-
-  /**
- * Liste des champs de date à normaliser.
- */
-  // champs d'ENTITÉ génériques + champs costum (auto-générés depuis l'artefact via normalize.ts, coercés par NOM
-  // sans dépendre de source.key ; les champs au type divergent entre costums — phone/rate — en sont exclus).
-  private _dateFields = ["modified", "created", "updated", "birthDate", "lastLoginDate", "startDate", "endDate", "date", "issuedOn", ...COSTUM_DATE_FIELDS];
-
-  /**
- * Liste des champs numériques à normaliser (le backend les renvoie en string
- * via x-www-form-urlencoded ; sans cette coercion, JSON.stringify diff
- * produit des faux positifs dans `hasChanges()`).
- */
-  private _numberFields = ["credits", "min", "max", "timeSpent", ...COSTUM_NUMBER_FIELDS];
-
-  /**
- * Normalise récursivement un objet, un tableau ou une valeur simple.
- * Cette fonction réalise en une seule passe les opérations suivantes :
- * - Conversion des chaînes "true"/"false" en booléens.
- * - Normalisation des dates (pour les champs spécifiés).
- * - Normalisation des images (pour les champs spécifiés).
- * - Transformation récursive des objets et tableaux.
- * - Normalisation des identifiants.
- *
- * @param data - La donnée à normaliser.
- * @returns La donnée normalisée.
- */
-  private _normalizeRecursively(data: any): any {
-  // Cas de base pour les chaînes
-    if (typeof data === "string") {
-      return this._normalizeString(data);
-    }
-
-    // Traitement des tableaux
-    if (Array.isArray(data)) {
-      return data.map((item: any) => this._normalizeRecursively(item));
-    }
-
-    // Traitement des objets non nuls
-    if (data !== null && typeof data === "object") {
-    // On crée une copie de l'objet pour éviter les effets de bord.
-      const normalizedData: any = {};
-
-      Object.keys(data).forEach(key => {
-      // Appliquer récursivement la normalisation sur la valeur.
-        let value = this._normalizeRecursively(data[key]);
-
-        // Si la clé correspond à un champ de date, on applique la normalisation de date.
-        if (this._dateFields.includes(key)) {
-          value = this._normalizeDate(value);
-        }
-
-        // Si la clé correspond à un champ d'image, on applique la normalisation d'image.
-        if (this._imageFields.includes(key)) {
-          value = this._normalizeImage(value);
-        }
-
-        // Si la clé correspond à un champ numérique, on coerce la string en number.
-        if (this._numberFields.includes(key)) {
-          value = this._normalizeNumber(value);
-        }
-
-        // Cas particulier : si la clé est "content" et qu'elle possède une propriété "image".
-        if (key === "content" && value && typeof value === "object" && value.image) {
-          value.image = this._normalizeImage(value.image);
-        }
-
-        normalizedData[key] = value;
-      });
-
-      // Normalisation des identifiants après traitement de l'objet.
-      return this._normalizeId(normalizedData);
-    }
-
-    // Pour les autres types (nombres, booléens déjà, etc.), on renvoie la donnée inchangée.
-    return data;
-  }
-
-  private _startBeforeEndValidate = (schema: any, data: any) => {
-    if (!data.startDate || !data.endDate) return true;
-  
-    const isValid = new Date(data.startDate) < new Date(data.endDate);
-    if (!isValid) {
-      // @ts-expect-error - on sait que ValidateFunction expose .errors au runtime
-      this._startBeforeEndValidate.errors = [
-        {
-          instancePath: "/startDate", // ou "." si tu veux le chemin actuel
-          schemaPath: "#/startBeforeEnd",
-          keyword: "startBeforeEnd",
-          params: {},
-          message: "startDate must be before endDate"
-        }
-      ];
-    }
-    return isValid;
-  };
-  
-
-  /**
-   * Récupère le schéma de requête pour un endpoint donné.
-   * @param constant - Le nom de l'endpoint.
-   * @returns Le schéma de requête ou null si non trouvé.
-   */
-  getRequestSchema(constant: string) {
-    const endpoint = this._endpoints.find(e => e.constant === constant);
-    return endpoint?.request || null;
-  }
-
-  /**
-   * Récupère le schéma de chemin pour un endpoint donné.
-   * @param constant - Le nom de l'endpoint.
-   * @returns Le schéma de chemin ou null si non trouvé.
-   */
-  getPathSchema(constant: string) {
-    return this._endpoints.find(e => e.constant === constant)?.pathParams || null;
-  }
-
-  /**
-   * Permet d'écouter facilement un ensemble d'événements importants émis par l'ApiClient.
-   *
-   * @param handlers - Un objet avec des fonctions à appeler selon l'événement.
-   * @param [handlers.retryAttempt] - Lors d'une tentative de retry axios.
-   * @param [handlers.queuedOffline] - Lorsqu'une requête est mise en file.
-   * @param [handlers.circuitBreakerOpen] - Quand le breaker s'ouvre.
-   * @param [handlers.circuitBreakerReset] - Quand le breaker se referme.
-   * @param [handlers.refreshSuccess] - Quand le token est rafraîchi.
-   * @param [handlers.refreshFailed] - Quand le refresh échoue.
-   * @param [handlers.sessionReset] - Quand la session est réinitialisée.
-   * @param [handlers.validationError] - Quand une validation échoue.
-   * @param [handlers.offlineModeChanged] - Quand le mode offline change.
-   * @param [handlers.userLoggedIn] - Quand un utilisateur se connecte.
-   */
-  onEvent(handlers: Record<string, (...args: any[]) => void> = {}) {
-    const availableEvents = [
-      "retryAttempt",
-      "queuedOffline",
-      "circuitBreakerOpen",
-      "circuitBreakerReset",
-      "refreshSuccess",
-      "refreshFailed",
-      "sessionReset",
-      "validationError",
-      "offlineModeChanged",
-      "userLoggedIn"
-    ];
-
-    for (const eventName of availableEvents) {
-      if (typeof handlers[eventName] === "function") {
-        this.on(eventName, handlers[eventName] as (...args: any[]) => void);
-      }
-    }
-  }
-
-  /**
-   * Retourne la liste des noms d'événements personnalisés déclarés dans les endpoints.
-   * Utile pour introspection ou documentation.
-   *
-   * @returns Liste des événements émis dynamiquement via postActions.
-   */
-  getDeclaredEvents() {
-    const events = new Set();
-    for (const endpoint of this._endpoints) {
-      if (Array.isArray(endpoint.postActions)) {
-        for (const action of endpoint.postActions) {
-          if (action.type === "emitEvent" && action.event) {
-            events.add(action.event);
-          }
-        }
-      }
-    }
-    return Array.from(events);
-  }
-
-}
-
-/**
- * @event ApiClient#retryAttempt
- * @type {Object}
- * @property {number} retryCount - Le numéro de tentative.
- * @property {string} url - L'URL de la requête ayant échoué.
- */
-
-/**
- * @event ApiClient#queuedOffline
- * @type {Object}
- * @property {string} constant - Le nom de l'endpoint.
- * @property {Object} data - Les données envoyées.
- * @property {"offlineMode"|"circuitBreaker"} reason - La raison de la mise en file.
- */
-
-/**
- * @event ApiClient#circuitBreakerOpen
- * @type {Object}
- * @property {number} timestamp - Date (ms) à laquelle le breaker s'est ouvert.
- */
-
-/**
- * @event ApiClient#circuitBreakerReset
- * @type {void}
- */
-
-/**
- * @event ApiClient#refreshSuccess
- * @type {Object}
- * @property {string} token - Le nouveau token d'accès.
- * @property {string} [refreshToken] - Le nouveau refreshToken (optionnel).
- */
-
-/**
- * @event ApiClient#refreshFailed
- * @type {Object}
- * @property {string} error - Le message d’erreur de refresh.
- */
-
-/**
- * @event ApiClient#sessionReset
- * @type {void}
- */
-
-/**
- * @event ApiClient#validationError
- * @type {Object}
- * @property {"pathParams"|"request"|"response"} stage - Étape de validation échouée.
- * @property {Array<Object>} errors - Erreurs AJV brutes.
- */
-
-/**
- * @event ApiClient#offlineModeChanged
- * @type {boolean} - true si le client est offline, false sinon.
- */
-
-/**
- * @event ApiClient#userLoggedIn
- * @param user - Les données utilisateur extraites de la réponse.
- */
-