@communecter/cocolight-api-client 1.0.155 → 1.0.157

package/src/api/EntityRegistry.ts

@@ -1,324 +0,0 @@
-// TypeScript native types
-import type { CollectionType } from "../types/entities.js";
-
-export type EntityTag = "User" | "Organization" | "Project" | "Event" | "Poi" | "Badge" | "News" | "Comment" | "Answer" | "Form" | "Classified" | "Action";
-export type CollectionKey = CollectionType; // Alias pour compatibilité
-type BaseEntity = import("./BaseEntity.js").BaseEntity<any>;
-type ApiClient = import("../ApiClient.js").default;
-
-type EndpointApiClass = typeof import("./EndpointApi.js").default;
-type EntityConstructor = new (...args: any[]) => BaseEntity;
-type EntityClass = EntityConstructor & {
-  fromJSON?: (json: unknown, parent?: ApiClient | BaseEntity | null, deps?: EntityDeps) => BaseEntity;
-};
-type EntityDeps = Partial<Record<EntityTag | "EndpointApi", EntityClass | EndpointApiClass | undefined>>;
-
-/**
- * Métadonnées de construction d'entité.
- */
-type EntityMeta = {
-  entityClass: EntityClass;
-  deps: EntityDeps;
-};
-
-/**
- * Types minimaux pour le JSON d'entité
- */
-type MinimalEntityJSON = {
-  __entityTag: EntityTag;
-  serverData?: {
-    collection?: CollectionKey;
-  };
-};
-
-export const EntityRegistry: Map<EntityTag | "EndpointApi", EntityClass | EndpointApiClass> = new Map();
-
-// Overloads for registerEntity
-export function registerEntity(tag: "EndpointApi", EntityClass: EndpointApiClass): void;
-export function registerEntity(tag: EntityTag, EntityClass: EntityClass): void;
-export function registerEntity(tag: EntityTag | "EndpointApi", EntityClass: EntityClass | EndpointApiClass): void {
-  EntityRegistry.set(tag, EntityClass);
-}
-
-
-/**
- * Type guard: vérifie si la valeur ressemble à un JSON d'entité.
- */
-function isEntityJSON(v: unknown): v is MinimalEntityJSON {
-  return !!v && typeof v === "object"
-    && "__entityTag" in (v as any);
-}
-
-/**
- * Récupère une instance depuis un JSON générique.
- * Si la collection ou la métadonnée d'entité est absente, renvoie l'objet d'origine.
- */
-export function fromEntityJSON(json: unknown, parent: ApiClient | BaseEntity | null = null): BaseEntity | unknown | null {
-  // On gère null / non-objet / pas une entité → on renvoie tel quel (ou null si tu préfères)
-  if (!isEntityJSON(json)) return json;
-
-  // Vérifier si l'entité a son propre parent sérialisé
-  let actualParent = parent;
-  const entityJson = json as any;
-  if (entityJson.parent && typeof entityJson.parent === "object") {
-    // Vérifier si le parent passé correspond déjà au parent sérialisé
-    const serializedParent = entityJson.parent;
-    const parentId = serializedParent.serverData?.id || serializedParent.id;
-
-    if (parent && "id" in parent && parent.id === parentId) {
-      // Le parent passé est déjà le bon, on l'utilise directement
-      actualParent = parent as BaseEntity;
-    } else {
-      // Reconstruire le parent depuis les données sérialisées en transmettant le parent original
-      const reconstructedParent = fromEntityJSON(entityJson.parent, parent);
-      // Vérifier que c'est bien une BaseEntity avant de l'utiliser
-      if (reconstructedParent && typeof reconstructedParent === "object" && "id" in reconstructedParent) {
-        actualParent = reconstructedParent as BaseEntity;
-      }
-    }
-  }
-
-  // Récupérer la collection depuis serverData, ou la dériver depuis __entityTag
-  let collection: CollectionKey | null | undefined = json.serverData?.collection;
-
-  // Si collection est absente, essayer de la dériver depuis __entityTag
-  if (!collection) {
-    collection = _getCollectionFromTag(json.__entityTag);
-  }
-
-  // Si on n'a toujours pas de collection, on ne peut pas désérialiser
-  if (!collection) return json;
-
-  const meta = _getEntityMeta(collection, json.__entityTag);
-  if (!meta) return json;
-
-  if (!meta.entityClass?.fromJSON) {
-    throw new Error(`Classe inconnue ou fromJSON manquant pour ${json.__entityTag}`);
-  }
-  return meta.entityClass.fromJSON(json, actualParent, meta.deps);
-}
-
-/**
- * Walker récursif : parcourt un objet/tableau et ressuscite toutes les entités
- * sérialisées (marqueurs `__isSerializedEntity` / `__entityTag`) rencontrées.
- *
- * Pensé pour les wrappers non-entité retournés par certains endpoints (ex: `fundingEnvelope`)
- * ou pour réhydrater un état côté client après un transfert JSON (SSR, cache restore).
- *
- * Dates, RegExp et primitives sont préservées. Pour les entités, la chaîne de parents
- * est reconstruite automatiquement depuis les méta embarquées par `toJSON()`.
- *
- * @param obj - L'objet à parcourir (wrapper, array, primitive…)
- * @param parent - Parent racine (typiquement l'ApiClient côté client)
- * @returns L'objet avec toutes les entités revived
- *
- * @example
- * // Côté client SSR : revive l'état dehydraté
- * const apiClient = new ApiClient({ baseURL });
- * const envelope = reviveEntities(window.__INIT__.envelope, apiClient);
- * envelope.projects[0].serverData.actions[0]; // Action instance
- */
-export function reviveEntities<T = unknown>(
-  obj: unknown,
-  parent: ApiClient | BaseEntity | null = null
-): T {
-  if (obj === null || obj === undefined) return obj as T;
-  if (typeof obj !== "object") return obj as T;
-  if (obj instanceof Date || obj instanceof RegExp) return obj as T;
-
-  if (isEntityJSON(obj)) {
-    return fromEntityJSON(obj, parent) as T;
-  }
-
-  if (Array.isArray(obj)) {
-    return obj.map(item => reviveEntities(item, parent)) as T;
-  }
-
-  const result: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(obj as object)) {
-    result[key] = reviveEntities(value, parent);
-  }
-  return result as T;
-}
-
-/**
- * Mappe un EntityTag vers son CollectionKey correspondant.
- */
-function _getCollectionFromTag(tag: EntityTag): CollectionKey | null {
-  const map: Record<EntityTag, CollectionKey> = {
-    "User": "citoyens",
-    "Organization": "organizations",
-    "Project": "projects",
-    "Event": "events",
-    "Poi": "poi",
-    "News": "news",
-    "Badge": "badges",
-    "Comment": "comments",
-    "Answer": "answers",
-    "Form": "forms",
-    "Classified": "classifieds",
-    "Action": "actions"
-  };
-  return map[tag] || null;
-}
-
-/**
- * Récupère la classe d'entité et ses dépendances à partir du type d'entité.
- */
-function _getEntityMeta(entityType: CollectionKey, __entityTag: EntityTag): EntityMeta | null {
-  const selfClass = EntityRegistry.get(__entityTag);
-  const selfTag = __entityTag;
-
-  const commonDeps: EntityDeps = {
-    EndpointApi: EntityRegistry.get("EndpointApi"),
-    User: selfTag === "User" ? selfClass : EntityRegistry.get("User"),
-    Organization: selfTag === "Organization" ? selfClass : EntityRegistry.get("Organization"),
-    Project: selfTag === "Project" ? selfClass : EntityRegistry.get("Project"),
-    Event: selfTag === "Event" ? selfClass : EntityRegistry.get("Event"),
-    Poi: selfTag === "Poi" ? selfClass : EntityRegistry.get("Poi"),
-    Badge: selfTag === "Badge" ? selfClass : EntityRegistry.get("Badge"),
-    News: selfTag === "News" ? selfClass : EntityRegistry.get("News"),
-    Comment: selfTag === "Comment" ? selfClass : EntityRegistry.get("Comment"),
-    Answer: selfTag === "Answer" ? selfClass : EntityRegistry.get("Answer"),
-    Form: selfTag === "Form" ? selfClass : EntityRegistry.get("Form"),
-    Classified: selfTag === "Classified" ? selfClass : EntityRegistry.get("Classified"),
-    Action: selfTag === "Action" ? selfClass : EntityRegistry.get("Action"),
-  };
-
-  const map: Record<CollectionKey, EntityMeta> = {
-    citoyens:     { entityClass: commonDeps.User as EntityClass,         deps: commonDeps },
-    organizations:{ entityClass: commonDeps.Organization as EntityClass, deps: commonDeps },
-    projects:     { entityClass: commonDeps.Project as EntityClass,      deps: commonDeps },
-    events:       { entityClass: commonDeps.Event as EntityClass,        deps: { ...commonDeps, Badge: undefined } },
-    poi:          { entityClass: commonDeps.Poi as EntityClass,          deps: { ...commonDeps, Badge: undefined, News: undefined, Comment: undefined } },
-    news:         { entityClass: commonDeps.News as EntityClass,         deps: { ...commonDeps } },
-    badges:       { entityClass: commonDeps.Badge as EntityClass,        deps: {
-      EndpointApi: commonDeps.EndpointApi,
-      User: commonDeps.User,
-      Organization: commonDeps.Organization,
-      Project: commonDeps.Project
-    } },
-    comments:     { entityClass: commonDeps.Comment as EntityClass,      deps: { ...commonDeps } },
-    answers:      { entityClass: commonDeps.Answer as EntityClass,       deps: { ...commonDeps } },
-    forms:        { entityClass: commonDeps.Form as EntityClass,         deps: { ...commonDeps } },
-    classifieds:  { entityClass: commonDeps.Classified as EntityClass,   deps: { ...commonDeps, Badge: undefined, News: undefined } },
-    actions:      { entityClass: commonDeps.Action as EntityClass,       deps: { ...commonDeps } },
-  };
-  
-  return map[entityType] || null;
-}
-
-type CollectionMapEntry = {
-  entityTag: EntityTag;
-  meta: (tag: EntityTag) => EntityMeta;
-};
-
-/**
- * Crée une instance d'entité basée sur le seul nom de la collection.
- */
-export function createFromCollection(collection: CollectionKey, parent: ApiClient | BaseEntity | null = null, data: object = {}): BaseEntity | null {
-  const _collectionMap: Record<CollectionKey, CollectionMapEntry> = {
-    citoyens: {
-      entityTag: "User",
-      meta: tag => _buildMeta(tag, { remove: [] })
-    },
-    organizations: {
-      entityTag: "Organization",
-      meta: tag => _buildMeta(tag, { remove: [] })
-    },
-    projects: {
-      entityTag: "Project",
-      meta: tag => _buildMeta(tag, { remove: [] })
-    },
-    events: {
-      entityTag: "Event",
-      meta: tag => _buildMeta(tag, { remove: ["Badge"] })
-    },
-    poi: {
-      entityTag: "Poi",
-      meta: tag => _buildMeta(tag, { remove: ["Badge","News","Comments"] })
-    },
-    news: {
-      entityTag: "News",
-      meta: tag => _buildMeta(tag, { remove: [] })
-    },
-    badges: {
-      entityTag: "Badge",
-      meta: () => _buildCustomMeta("Badge")
-    },
-    comments: {
-      entityTag: "Comment",
-      meta: tag => _buildMeta(tag, { remove: [] })
-    },
-    answers: {
-      entityTag: "Answer",
-      meta: tag => _buildMeta(tag, { remove: [] })
-    },
-    forms: {
-      entityTag: "Form",
-      meta: tag => _buildMeta(tag, { remove: [] })
-    },
-    classifieds: {
-      entityTag: "Classified",
-      meta: tag => _buildMeta(tag, { remove: ["Badge","News"] })
-    },
-    actions: {
-      entityTag: "Action",
-      meta: tag => _buildMeta(tag, { remove: [] })
-    }
-  };
-  const entry = _collectionMap[collection];
-  if (!entry) {
-    console.warn(`Collection inconnue : '${collection}'`);
-    return null;
-  }
-  const { entityTag, meta } = entry;
-  const { entityClass, deps } = meta(entityTag);
-  if (!entityClass) {
-    throw new Error(`EntityClass introuvable pour ${entityTag}`);
-  }
-  const Ctor = entityClass as EntityConstructor;
-  return new Ctor(parent, data, deps);
-}
-
-/**
- * Construit entityClass et deps pour une collection standard.
- */
-function _buildMeta(tag: EntityTag, options: { remove: string[] }): EntityMeta {
-  const EntityClass = EntityRegistry.get(tag) as EntityClass;
-  const allDeps: EntityDeps = {
-    EndpointApi: EntityRegistry.get("EndpointApi"),
-    User: EntityRegistry.get("User"),
-    Organization: EntityRegistry.get("Organization"),
-    Project: EntityRegistry.get("Project"),
-    Event: EntityRegistry.get("Event"),
-    Poi: EntityRegistry.get("Poi"),
-    Badge: EntityRegistry.get("Badge"),
-    News: EntityRegistry.get("News"),
-    Comment: EntityRegistry.get("Comment"),
-    Answer: EntityRegistry.get("Answer"),
-    Form: EntityRegistry.get("Form"),
-    Classified: EntityRegistry.get("Classified"),
-    Action: EntityRegistry.get("Action")
-  };
-  // inject self
-  (allDeps as any)[tag] = EntityClass;
-  // remove undesired
-  options.remove.forEach(dep => delete (allDeps as any)[dep]);
-  return { entityClass: EntityClass, deps: allDeps };
-}
-
-/**
- * Cas spécifique des badges : seules certaines dépendances.
- */
-function _buildCustomMeta(tag: "Badge" | "Answer"): EntityMeta {
-  const EntityClass = EntityRegistry.get(tag) as EntityClass;
-  const deps: EntityDeps = {
-    EndpointApi: EntityRegistry.get("EndpointApi"),
-    User: EntityRegistry.get("User"),
-    Organization: EntityRegistry.get("Organization"),
-    Project: EntityRegistry.get("Project")
-  };
-  (deps as any)[tag] = EntityClass;
-  return { entityClass: EntityClass, deps };
-}

package/src/api/Event.ts

@@ -1,360 +0,0 @@
-import { ApiError } from "../error.js";
-import { BaseEntity, PaginatorPage, PaginatorState } from "./BaseEntity.js";
-import { transformEntityRefs } from "../types/transforms.js";
-
-import type { AddEventData, GetAttendeesAdminData, GetAttendeesNoAdminData } from "./EndpointApi.types.js";
-import type { User } from "./User.js";
-import type { EventTransforms } from "../types/transforms.js";
-
-type EventItemNormalized = import("./serverDataType/Event.js").EventItemNormalized;
-
-export class Event extends BaseEntity<EventItemNormalized> {
-  static override entityType = "events";
-  static override entityTag = "Event";
-
-  /** Bloc de création où injecter les champs costum (CostumScope). */
-  static override COSTUM_ADD_CONSTANT = "ADD_EVENT";
-
-  static override SCHEMA_CONSTANTS: string[] = [
-    "ADD_EVENT",
-    "UPDATE_BLOCK_SLUG",
-    "PROFIL_IMAGE"
-  ];
-
-  static ADD_BLOCKS = new Map([
-    ["ADD_EVENT", "addEvent"],
-    ["PROFIL_IMAGE", "updateImageProfil"]
-  ] as const);
-
-  static UPDATE_BLOCKS = new Map([
-    ["UPDATE_BLOCK_SLUG", "updateSlug"],
-    ["PROFIL_IMAGE", "updateImageProfil"]
-  ] as const);
-
-  override defaultFields: Record<string, any> = {
-    typeElement: this.getEntityType()
-  };
-
-  override removeFields: string[] = [
-    "typeElement"
-  ];
-
-  override transforms: EventTransforms = {
-    parent: transformEntityRefs,
-    organizer: transformEntityRefs
-  };
-
-  override _add = async (payload: Record<string, any>): Promise<void> => {
-    if (!this._calledFromSave) {
-      throw new ApiError("utilisation invalide de _add, utilisez save", 400);
-    }
-
-    payload.id = this._newId?.();
-    if (payload.slug) delete payload.slug;
-
-    for (const [constant, methodName] of Array.from(Event.ADD_BLOCKS)) {
-      const blockData = this._extractChangedFieldsFromSchema(
-        this.apiClient,
-        constant,
-        { ...payload, ...this.defaultFields },
-        () => {}
-      );
-      if (blockData && Object.keys(blockData).length > 0) {
-        const data = await this._invokeBlockMethod(Event.ADD_BLOCKS, methodName, blockData);
-        if (!this.id && data?.map?.id) {
-          this._draftData.id = data.map.id;
-          this._draftData.slug = data.map.slug;
-        }
-      }
-    }
-  };
-
-  override _update = async (payload: Record<string, any>): Promise<boolean> => {
-    if(!this.isAdmin({ checkHierarchy: true })){
-      throw new ApiError("Vous n'avez pas les droits pour modifier cet événement", 403);
-    }
-
-    if (!this._calledFromSave) {
-      throw new ApiError("utilisation invalide de _update, utilisez save", 400);
-    }
-
-    // Entité costum-scopée : tout l'UPDATE part en UN `element/save` (pendant de l'ADD, hooks costum). cf. BaseEntity.
-    if (this._costumCtx) return this._saveCostumViaElementSave(payload);
-
-    let hasChanged = false;
-
-    const blockData = this._extractAllValidFieldsFromSchema(
-      this.apiClient,
-      "ADD_EVENT",
-      { ...payload, ...this.defaultFields },
-      () => this.initialDraftData,
-      this.removeFields
-    );
-    if (blockData && Object.keys(blockData).length > 0) {
-      await this["addEvent"](blockData);
-      hasChanged = true;
-    }
-
-    if (payload.id) delete payload.id;
-
-    for (const [constant, methodName] of Array.from(Event.UPDATE_BLOCKS)) {
-      const blockData = this._extractChangedFieldsFromSchema(
-        this.apiClient,
-        constant,
-        { ...payload, ...this.defaultFields },
-        () => this.initialDraftData,
-        this.removeFields
-      );
-      if (blockData && Object.keys(blockData).length > 0) {
-        await this._invokeBlockMethod(Event.UPDATE_BLOCKS, methodName, blockData);
-        hasChanged = true;
-      }
-    }
-
-    return hasChanged;
-  };
-
-  async addEvent(data: Partial<AddEventData> = {}): Promise<unknown> {
-
-    // Si le parent direct n'est pas l'utilisateur connecté (ex: création via une org),
-    // on injecte l'organizer dans le payload. Sans ça, le default schéma `{ "@userId": ... }`
-    // pose me comme organizer — ce qui est faux pour `me.org().event()`.
-    // NB: this.isMe est trompeur ici car userContext propage jusqu'au User connecté
-    // (donc isMe=true même quand le parent direct est une org).
-    if (this.parent && this.parent.id && this.parent.id !== this.userId && !data.organizer) {
-      (data as any).organizer = {};
-      (data as any).organizer[`${this.parent.id}`] = {
-        type: this.parent.getEntityType(),
-        name: (this.parent as any).name
-      };
-    }
-
-    return this.callIsConnected(() => this.endpointApi.addEvent(data as AddEventData));
-  }
-
-  /**
-   * Supprime cet événement via `DELETE_ELEMENT` (`type=events`).
-   *
-   * **Garde** : auteur de l'événement (`serverData.creator`) OU administrateur
-   * de l'organisation/projet organisateur (via `serverData.organizer` × hiérarchie).
-   * cf. {@link BaseEntity#_deleteViaElement}.
-   *
-   * Après succès : données vidées + `_isDeleted = true`.
-   *
-   * @param reason - Raison transmise au backend (audit). Défaut `"delete event"`.
-   * @throws {ApiError} 400 si l'événement n'a pas d'id.
-   * @throws {ApiError} 403 si ni auteur ni admin de l'organisateur.
-   */
-  async delete(reason: string = "delete event"): Promise<void> {
-    await this._deleteViaElement(this.getEntityType(), reason);
-  }
-
-
-  override async getOrganizations(): Promise<never> {
-    throw new ApiError(`getOrganizations n'existe pas dans ${this.constructor.name}`, 501);
-  }
-
-
-  override async getProjects(): Promise<never> {
-    throw new ApiError(`getProjects n'existe pas dans ${this.constructor.name}`, 501);
-  }
-
-
-  override async getEvents(): Promise<never> {
-    throw new ApiError(`getEvents - les sous-events ne sont pas encore implémentés dans ${this.constructor.name}`, 501);
-  }
-
-
-  override async getPois(): Promise<never> {
-    throw new ApiError(`getPois n'existe pas dans ${this.constructor.name}`, 501);
-  }
-
-
-  override async getBadgesIssuer(): Promise<never> {
-    throw new ApiError(`getBadgesIssuer n'existe pas dans ${this.constructor.name}`, 501);
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#getNews}
-   *
-   * Récupère les actualités de l'événement.
-   */
-  override async getNews(data: Parameters<BaseEntity<EventItemNormalized>["getNews"]>[0] = {}) {
-    return super.getNews(data);
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#getSubscribers}
-   *
-   * Récupère les abonnés de l'événement.
-   */
-  override async getSubscribers(data: Parameters<BaseEntity<EventItemNormalized>["getSubscribers"]>[0] = {}) {
-    return super.getSubscribers(data);
-  }
-
-  /**
-   * Récupérer les participants d'un événement.
-   * Constant : GET_ATTENDEES_NO_ADMIN
-   * @param data - Paramètres (partiels) de recherche/pagination.
-   * @param options - Options supplémentaires.
-   * @param options.toBeValidated - Indique si les participants doivent être validés.
-   * @param options.isAdmin - Indique si l'utilisateur est admin.
-   * @param options.isInviting - Indique si l'utilisateur est en attente d'invitation.
-   * @param options.roles - Liste des rôles à filtrer.
-   * @param isNext - Indique si c'est une recherche suivante (pagination).
-   * @returns - Un objet contenant le nombre de participants et la liste des participants.
-   * @throws {ApiResponseError} - Si une erreur se produit lors de la récupération des participants.
-   *
-   * @example
-   * // Récupérer tous les participants
-   * const participants = await project.getAttendees();
-   *
-   * // Récupérer les participants avec validation en attente
-   * const participantsToBeValidated = await project.getAttendees({}, { toBeValidated: true });
-   *
-   * // Récupérer les participants avec un rôle spécifique
-   * const contributorsWithRole = await project.getAttendees({}, { roles: ["admin"] });
-   *
-   * // Récupérer les participants administrateurs
-   * const adminParticipants = await project.getAttendees({}, { isAdmin: true });
-   *
-   * // Récupérer les participants en attente d'invitation
-   * const invitingParticipants = await project.getAttendees({}, { isInviting: true });
-   *
-   */
-  async getAttendees(
-    data: Partial<GetAttendeesNoAdminData | GetAttendeesAdminData> = {},
-    options: {
-      toBeValidated?: boolean;
-      isAdmin?: boolean;
-      isAdminPending?: boolean;
-      isInviting?: boolean;
-      roles?: any[];
-      restoredState?: PaginatorState;
-    } = {}
-  ): Promise<PaginatorPage<User>> {
-    data.searchType = this._getDefaultFromEndpoint("GET_ATTENDEES_NO_ADMIN", "searchType") as GetAttendeesNoAdminData["searchType"];
-    // data.searchBy = "ALL";
-
-    const paginator = this._createPaginatorEngine({
-      initialData: data,
-      methodName: "getAttendees",
-      restoredState: options?.restoredState,
-      finalizer: async (finalData) => {
-
-        const { toBeValidated, isAdmin, isInviting, isAdminPending, roles = [] } = options;
-
-        if(this.isMe){
-          finalData.pathParams = { id: this.id };
-          // NOTE : dans le schema je crois que si pas de finalData.filters alors le default ce fait avec finalData.pathParams
-          // finalData.filters = {
-          //   [`links.events.${this.id}`]: { "$exists": true },
-          //   [`links.events.${this.id}.toBeValidated`]: { "$exists": false },
-          //   [`links.events.${this.id}.isInviting`]: { "$exists": false }
-          // };
-          finalData.filters = this._buildLinkFilters(this.id, { linkType: "events", toBeValidated, isAdmin, isAdminPending, isInviting, roles });
-        } else {
-          delete finalData?.pathParams;
-          finalData.filters = this._buildLinkFilters(this.id, { linkType: "events", toBeValidated: false, isAdmin, isInviting, roles });
-        }
-  
-        const fetchFn = this.isMe
-          ? () => this.callIsMe(() => this.endpointApi.getAttendeesAdmin(finalData))
-          : () => this.endpointApi.getAttendeesNoAdmin(finalData);
-
-        return fetchFn();
-      }
-    });
-
-    return paginator.next() as Promise<PaginatorPage<User>>;
-  }
-
-  override async project(): Promise<never> {
-    throw new ApiError(`project n'existe pas dans ${this.constructor.name}`, 501);
-  }
-
-
-  override async poi(): Promise<never> {
-    throw new ApiError(`poi n'existe pas dans ${this.constructor.name}`, 501);
-  }
-
-
-  override async form(): Promise<never> {
-    throw new ApiError(`form n'existe pas dans ${this.constructor.name}`, 501);
-  }
-
-
-  override async event(): Promise<never> {
-    throw new ApiError(`les sous-events ne sont pas encore implémentés dans ${this.constructor.name}`, 501);
-  }
-
-
-  override async badge(): Promise<never> {
-    throw new ApiError(`badge n'existe pas dans ${this.constructor.name}`, 501);
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#news}
-   *
-   * Crée une instance de news et la récupère si nécessaire.
-   */
-  override async news(newsData: Parameters<BaseEntity<EventItemNormalized>["news"]>[0] = {}) {
-    return super.news(newsData);
-  }
-
-  /**
-   * ───────────────────────────────
-   *  Lien utilisateur ↔ event
-   *  (participation, abonnement)
-   * ───────────────────────────────
-   */
-
-  /**
-   * {@inheritDoc BaseEntity#requestToJoin}
-   *
-   * Rejoindre l'événement en tant que participant.
-   */
-  override async requestToJoin() {
-    return super.requestToJoin();
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#acceptInvitation}
-   *
-   * Accepte une invitation à rejoindre l'événement.
-   * Cette action valide un lien en attente avec l'option `isInviting`.
-   */
-  override async acceptInvitation() {
-    return super.acceptInvitation();
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#leave}
-   *
-   * Quitte l'événement, que ce soit en tant que participant ou administrateur.
-   * Cette action supprime le lien entre l'utilisateur et l'événement.
-   */
-  override async leave() {
-    return super.leave();
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#follow}
-   *
-   * Suivre un événement.
-   * Cette action permet à l'utilisateur de suivre un événement.
-   */
-  override async follow() {
-    return super.follow();
-  }
-
-  /**
-   * {@inheritDoc BaseEntity#unfollow}
-   *
-   * Se désabonne d'un événement.
-   */
-  override async unfollow() {
-    return super.unfollow();
-  }
-  
-}