@communecter/cocolight-api-client 1.0.54 → 1.0.56

package/types/api/BaseEntity.d.ts

@@ -1,124 +1,235 @@
+import type { UpdateSettingsData, UpdateBlockDescriptionData, UpdateBlockInfoData, UpdateBlockSocialData, UpdateBlockLocalityData, GetNewsData, GetGalleryData, GlobalAutocompleteCostumData, CostumEventRequestActorsData, CostumEventRequestSubeventsData, CostumEventRequestDatesData, CostumEventRequestElementEventData, CostumEventRequestCategoriesData, CostumEventRequestEventData, CostumEventRequestLinkTlToEventData, CostumEventRequestLoadContextTagData, GetOrganizationsAdminData, GetOrganizationsNoAdminData, GetProjectsAdminData, GetProjectsNoAdminData, GetPoisAdminData, GetPoisNoAdminData, GetSubscribersData, GetBadgesData } from "./EndpointApi.types.js";
+import type { TransformsMap } from "../types/entities.js";
 /**
- * @typedef {import("../ApiClient.js").default} ApiClient
- * @typedef {import("./EndpointApi.js").default} EndpointApi
+ * Types pour les méthodes d'entité (organization, project, poi, event, badge, news)
+ * Permettent soit de récupérer une entité existante (GET), soit de créer une nouvelle instance (CREATE)
  */
+type OrganizationInput = {
+    id: string;
+} | {
+    slug: string;
+} | Record<string, any>;
+type ProjectInput = {
+    id: string;
+} | {
+    slug: string;
+} | Record<string, any>;
+type PoiInput = {
+    id: string;
+} | {
+    slug: string;
+} | Record<string, any>;
+type EventInput = {
+    id: string;
+} | {
+    slug: string;
+} | Record<string, any>;
+type BadgeInput = {
+    id: string;
+} | Record<string, any>;
+type NewsInput = {
+    id: string;
+} | Record<string, any>;
+type ApiClient = import("../ApiClient.js").default;
+type EndpointApi = import("./EndpointApi.js").default;
+type User = import("./User.js").User;
+type Organization = import("./Organization.js").Organization;
+type Project = import("./Project.js").Project;
+type EventEntity = import("./Event.js").Event;
+type Poi = import("./Poi.js").Poi;
+type News = import("./News.js").News;
+type Badge = import("./Badge.js").Badge;
+type Comment = import("./Comment.js").Comment;
+type AnyEntity = User | Organization | Project | Poi | EventEntity | Badge | News | Comment;
+type ParentLike = BaseEntity<any> & {
+    apiClient: ApiClient;
+    userContext?: User | null;
+};
+type EndpointApiCtor = {
+    new (apiClient: ApiClient): EndpointApi;
+};
+type EndpointApiDep = EndpointApi | EndpointApiCtor;
+interface Deps {
+    EndpointApi: EndpointApiDep;
+    User?: any;
+    Organization?: any;
+    Project?: any;
+    Poi?: any;
+    Event?: any;
+    Badge?: any;
+    News?: any;
+    Comment?: any;
+}
+interface BaseEntityConfig {
+    entityTag?: string;
+}
+interface EntityTypeMap {
+    citoyens: User;
+    organizations: Organization;
+    projects: Project;
+    events: EventEntity;
+    poi: Poi;
+    news: News;
+    badges: Badge;
+    comments: Comment;
+}
+type ReadableWithMeta = import("stream").Readable & {
+    path?: string;
+    mimeType?: string;
+};
+type UploadInput = File | Blob | Buffer | import("stream").Readable;
+type ValidatedUpload = File | Buffer | ReadableWithMeta;
+export interface PaginatorPage<T> {
+    count: {
+        total: number;
+    };
+    results: T[];
+    pageIndex: number;
+    pageNumber: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+    next?: () => Promise<PaginatorPage<T>>;
+    prev?: () => Promise<PaginatorPage<T>>;
+}
+/**
+ * Type helper pour extraire les noms de méthodes depuis un Map as const
+ *
+ * @example
+ * static UPDATE_BLOCKS = new Map([
+ *   ["UPDATE_BLOCK_DESCRIPTION", "updateDescription"],
+ *   ["UPDATE_BLOCK_INFO", "updateInfo"]
+ * ] as const);
+ *
+ * type MethodNames = ExtractMethodNames<typeof MyClass.UPDATE_BLOCKS>;
+ * // Result: "updateDescription" | "updateInfo"
+ */
+export type ExtractMethodNames<T> = T extends Map<any, infer V> ? V extends readonly (readonly [any, infer M])[] ? M : never : never;
+interface LinkMeta {
+    linkType: "memberOf" | "projects" | "events" | "friends";
+    connectTypeConnect: "member" | "contributor" | "attendee" | "friend";
+    connectTypeDisconnect: "members" | "contributors" | "attendees" | "friends";
+}
+type BaseEntityCtor = typeof BaseEntity & {
+    entityTag: string;
+    entityType: "citoyens" | "organizations" | "projects" | "events" | "poi" | "badges" | "news" | "comments";
+    SCHEMA_CONSTANTS: string | string[];
+};
+interface FilterValueExistsOnly {
+    $exists: boolean;
+}
+interface FilterValueInOnly {
+    $in: string[];
+}
+interface FilterValueCombined {
+    $in: string[];
+    $exists: boolean;
+}
+type FilterValue = FilterValueExistsOnly | FilterValueInOnly | FilterValueCombined;
+type LinkFilters = Record<string, FilterValue>;
+interface MinimalUserLink {
+    toBeValidated?: boolean;
+    isInviting?: boolean;
+}
+type EntityFilterValue = string | boolean | RegExp | ((value: any) => boolean);
+type EntityFilters = Record<string, EntityFilterValue>;
+interface LinkEntitiesOptions {
+    key?: string;
+    mapFn?: (entity: any) => any;
+}
+type Deletable = {
+    _isDeleted?: boolean;
+};
+type ReactiveData = Record<string, any> & {
+    __isReactive?: boolean;
+    __raw?: any;
+};
+interface FinalizerResult<TOut> {
+    results: TOut[];
+    count: {
+        total: number;
+    } & Record<string, any>;
+}
+type EntityType = "citoyens" | "organizations" | "projects" | "events" | "poi" | "badges" | "news";
 /**
  * Classe de base pour toutes les entités métiers : utilisateurs, projets, organisations, etc.
  * Fournit un système de brouillon (draft), transformation, appel API sécurisé,
  * et gestion de données côté client avec support du mode offline.
+ * @template object TServerData
  * @abstract
  */
-export class BaseEntity {
+export declare class BaseEntity<TServerData = any> {
+    __entityTag: string;
+    deps: Partial<Deps>;
+    apiClient: ApiClient;
+    parent: ParentLike | null;
+    userContext: User | null;
+    endpointApi: EndpointApi;
+    data: any;
+    meta?: any;
+    _draftData: ReactiveData;
+    _initialDraftData: Record<string, any>;
+    _serverData: TServerData & ReactiveData;
+    _calledFromSave: boolean;
+    _syncReactiveDraft: boolean;
+    _isDeleted: boolean;
+    _add?: ((payload: any) => Promise<void | unknown>) | undefined;
+    _update?: ((payload: any) => Promise<boolean>) | undefined;
+    _allowedFieldsCache?: string[];
+    _allowedFieldsMetadata?: {
+        combinedSchema: any;
+        transforms: TransformsMap;
+        removeFields: string[];
+    };
     static entityTag: string;
+    static entityType?: string;
+    static SCHEMA_CONSTANTS?: string | string[];
     /**
-     * Crée une nouvelle instance d'entité à partir des données du serveur.
-     *
-     * @param {Object} data - Données du serveur.
-     * @param {BaseEntity} parent - Instance parente.
-     * @param {Object} deps - Dépendances injectées.
-     * @returns {BaseEntity} Nouvelle instance d'entité.
+     * Vérifie que l'objet n'a pas été supprimé.
+     * @throws {ApiError} - Si l'objet a été supprimé.
      */
-    static fromServerData(data: any, parent: BaseEntity, deps: any): BaseEntity;
+    protected _checkNotDeleted(): void;
     /**
-     * Restaure les données sérialisées en un objet d'origine.
+     * Constructeur de l'entité.
      *
-     * @param {Object} obj - L'objet à restaurer.
-     * @returns {Object} L'objet restauré.
-     */
-    static _revive(obj: any): any;
-    /**
-     * Crée une instance d'entité à partir de données JSON.
+     * `parent` peut être :
+     *  - une instance d'ApiClient
+     *  - une instance d'entité (User, Organization, Project, Poi, Event, Badge, News)
      *
-     * @param {Object} json - Données JSON à utiliser.
-     * @param {Object} parent - Instance parente.
-     * @param {Object} deps - Dépendances injectées.
-     * @returns {object} Nouvelle instance d'entité.
+     * @param parent
+     * @param data         - Données initiales.
+     * @param deps          - Dépendances injectées (EndpointApi, autres entités).
+     * @param config - Configuration optionnelle (ex. `entityTag`).
+     * @throws {ApiError} Si `parent` est invalide ou si `deps.EndpointApi` n'est ni une instance ni un constructeur.
      */
-    static fromJSON(json: any, parent: any, deps: any): object;
+    constructor(parent: ApiClient | ParentLike, data?: object, deps?: Partial<Deps>, config?: BaseEntityConfig);
     /**
-     * Constructeur de l'entité.
-     * @param {Object} parent - L'ApiClient ou une entité parente.
-     * @param {Object} parent.apiClient - Instance de l'ApiClient.
-     * @param {Object} [parent.parent] - Instance parente.
-     * @param {Object} [data={}] - Données initiales.
-     * @param {Object} [deps={}] - Dépendances injectées (EndpointApi, autres entités).
-     * @param {Object|function} deps.EndpointApi - Instance de l'API.
-     * @param {function} deps.User - Classe d'entité utilisateur.
-     * @param {function} deps.Organization - Classe d'entité organisation.
-     * @param {function} deps.Project - Classe d'entité projet.
-     * @param {function} deps.Poi - Classe d'entité point d'intérêt.
-     * @param {function} deps.Event - Classe d'entité événement.
-     * @param {function} deps.Badge - Classe d'entité badge.
-     * @param {function} deps.News - Classe d'entité actualité.
-     * @param {string} [config.entityTag] - Tag d'entité (ex: "User", "Organization").
-     * @param {Object} [config={}] - Configuration optionnelle.
-     * @throws {ApiError} Si les dépendances ou parent sont invalides.
-     */
-    constructor(parent: {
-        apiClient: any;
-        parent?: any;
-    }, data?: any, deps?: {
-        EndpointApi: any | Function;
-        User: Function;
-        Organization: Function;
-        Project: Function;
-        Poi: Function;
-        Event: Function;
-        Badge: Function;
-        News: Function;
-    }, config?: any);
-    /** @type {Object} Données de brouillon modifiables */
-    _draftData: any;
-    /** @type {Object} Snapshot initial des données de brouillon */
-    _initialDraftData: any;
-    /** @type {Object|null} Données reçues du serveur */
-    _serverData: any | null;
-    /** @type {boolean} Indique si `save()` est en cours */
-    _calledFromSave: boolean;
-    /** @type {boolean} Indique si le draft est synchronisé avec le serveur */
-    _syncReactiveDraft: boolean;
-    __entityTag: any;
-    deps: {
-        EndpointApi: any | Function;
-        User: Function;
-        Organization: Function;
-        Project: Function;
-        Poi: Function;
-        Event: Function;
-        Badge: Function;
-        News: Function;
-    };
-    /** @type {ApiClient} */
-    apiClient: ApiClient;
-    parent: {
-        apiClient: any;
-        parent?: any;
-    };
-    userContext: any;
-    /** @type {EndpointApi} */
-    endpointApi: EndpointApi;
-    data: any;
-    getEntityTag: (__entityTag: any) => any;
-    /** @returns {string|null} Identifiant de l'entité */
+     * Permet de récupérer le constructeur typé correctement.
+     */
+    protected _getCtor(): BaseEntityCtor;
+    getEntityTag: (__entityTag: string | undefined) => string | undefined;
+    /** @returns Identifiant de l'entité */
     get id(): string | null;
-    /** @returns {string|null} Slug de l'entité */
+    /** @returns Slug de l'entité */
     get slug(): string | null;
-    /** Définit un ID (utilisé en interne) */
-    _id(newId: any): void;
-    /** @returns {boolean} Indique si l'utilisateur est connecté */
+    /**
+     * Définit un ID (utilisé en interne)
+     * @param newId - Nouvel ID à définir.
+    */
+    _id(newId: string): void;
+    /** @returns Indique si l'utilisateur est connecté */
     get isConnected(): boolean;
-    /** @returns {string|null} Identifiant utilisateur associé */
+    /** @returns Identifiant utilisateur associé */
     get userId(): string | null;
-    /** @returns {Object} Données de brouillon courantes */
-    get draftData(): any;
-    /** @returns {Object} Données de brouillon initiales */
-    get initialDraftData(): any;
-    /** @returns {Object|null} Données brutes du serveur */
-    get serverData(): any | null;
-    /** @returns {boolean} Indique si cette entité représente l'utilisateur connecté */
+    /** @returns Données de brouillon courantes (réactif) */
+    get draftData(): ReactiveData;
+    /** @returns Données de brouillon initiales (non-réactif) */
+    get initialDraftData(): Record<string, any>;
+    /** @returns Données brutes du serveur */
+    get serverData(): TServerData;
+    /** @returns Indique si cette entité représente l'utilisateur connecté */
     get isMe(): boolean;
-    /** @returns {string} Type de l'entité (ex: 'citoyens') */
-    getEntityType(): string;
+    /** @returns Type de l'entité (ex: 'citoyens') */
+    getEntityType(): "citoyens" | "organizations" | "projects" | "events" | "poi" | "badges" | "news" | "comments";
     /**
      * Indique si le draft contient des modifications par rapport aux données initiales.
      * @returns {boolean}
@@ -126,46 +237,61 @@ export class BaseEntity {
     hasChanges(): boolean;
     /**
      * Rafraîchit l'entité en rechargeant ses données depuis le serveur.
-     * @returns {Promise<Object>} Données mises à jour
+     * @returns Données mises à jour
      */
-    refresh(): Promise<any>;
+    refresh(): Promise<Record<string, any>>;
     /**
      * Sauvegarde les modifications locales vers le serveur (add ou update).
-     * @returns {Promise<Object>} Données serveur mises à jour
+     * @returns Données serveur mises à jour (après éventuel `refresh()`)
+     */
+    save(): Promise<Record<string, any>>;
+    /**
+     * Crée une nouvelle instance d'entité à partir des données du serveur.
+     *
+     * @param data - Données du serveur.
+     * @param parent - Instance parente (ApiClient ou BaseEntity).
+     * @param deps - Dépendances injectées (classes d'entités disponibles).
+     * @returns Nouvelle instance d'entité.
+     */
+    static fromServerData(data: object, parent: ApiClient | ParentLike, deps: object): BaseEntity<any>;
+    /**
+     * Hook pour transformer les données du serveur avant qu'elles ne soient appliquées.
+     * Peut être overridé dans les classes filles pour transformer des champs imbriqués en instances d'entités.
+     *
+     * @param data - Les données brutes du serveur.
+     * @returns Les données transformées.
+     * @protected
      */
-    save(): Promise<any>;
+    protected _transformServerData(data: TServerData): TServerData;
     /**
      * Met à jour les données de l'entité avec de nouvelles données.
      *
-     * @param {Object} newData - Les nouvelles données à appliquer.
-     * @returns {void}
-     * @private
+     * @param newData - Les nouvelles données à appliquer.
+     * @param {{ forceInitialDraftReset?: boolean }} [options]
+     * @protected
      */
-    private _setData;
-    _updateDraftPreservingUserChanges(draft: any): void;
+    protected _setData(newData: TServerData, { forceInitialDraftReset }?: {
+        forceInitialDraftReset?: boolean;
+    }): void;
+    _updateDraftPreservingUserChanges(draft: Record<string, any>): void;
     _resetInitialDraftData(): void;
     _toRawDeep(obj: any): any;
     /**
      * Champs à ajouter automatiquement à chaque draft (ex: `typeElement`).
      * Souvent utilisés dans les conditions `if/then` du JSON Schema.
-     * @type {Object<string, any>}
      */
     defaultFields: {
-        [x: string]: any;
+        [key: string]: any;
     };
     /**
      * Champs à exclure explicitement du draft et des payloads.
-     * @type {string[]}
      */
     removeFields: string[];
     /**
      * Transformations à appliquer à certains champs lors de la lecture depuis le draft.
      * Clé = champ, valeur = fonction (val, full) => valeur transformée.
-     * @type {Object<string, function(any, object): any>}
      */
-    transforms: {
-        [x: string]: (arg0: any, arg1: object) => any;
-    };
+    transforms: TransformsMap;
     /**
      * ───────────────────────────────
      * JSON
@@ -174,19 +300,45 @@ export class BaseEntity {
     /**
      * Convertit l'instance en JSON pour l'envoi au serveur.
      *
-     * @returns {Object} Représentation JSON de l'instance.
-     */
-    toJSON(): any;
+     * @returns Représentation JSON de l'instance.
+     */
+    toJSON(): {
+        __entityTag: string;
+        __isSerializedEntity: boolean;
+        serverData: any;
+        parent: {
+            id?: string;
+            type?: string;
+            __entityTag?: string;
+            slug?: string;
+        } | null;
+    };
     _serialize(obj: any): any;
     /**
      * Supprime les propriétés non sérialisables d'un objet.
      *
-     * @param {Object} obj - L'objet à nettoyer.
-     * @param {WeakSet} [seen] - Ensemble pour éviter les références circulaires.
-     * @returns {Object} L'objet nettoyé.
+     * @param obj - L'objet à nettoyer.
+     * @param seen - Ensemble pour éviter les références circulaires.
+     * @returns L'objet nettoyé.
      * @private
      */
     private _removeUnserializables;
+    /**
+     * Restaure les données sérialisées en un objet d'origine.
+     *
+     * @param obj - L'objet à restaurer.
+     * @returns L'objet restauré.
+     */
+    static _revive(obj: object): any;
+    /**
+     * Crée une instance d'entité à partir de données JSON.
+     *
+     * @param json - Données JSON à utiliser.
+     * @param parent - Instance parente.
+     * @param deps - Dépendances injectées.
+     * @returns Nouvelle instance d'entité.
+     */
+    static fromJSON(json: unknown, parent?: ApiClient | BaseEntity<any> | null, deps?: object): BaseEntity<any>;
     /**
      * ───────────────────────────────
      * UtilMixin
@@ -195,74 +347,72 @@ export class BaseEntity {
     /**
      * Appelle une méthode de l'API.
      *
-     * @param {string} constant - Le nom de la méthode à appeler.
-     * @param {object} data - Les données à passer à la méthode.
-     * @returns {Promise<any>} - La promesse de la méthode appelée.
+     * @param constant - Le nom de la méthode à appeler.
+     * @param data - Les données à passer à la méthode.
+     * @returns - `response.data` transformé ; peut être `null` si la requête est **mise en file** (offline/breaker).
      * @throws {ApiValidationError} - Si une erreur se produit lors de l'appel de l'API.
      * @throws {ApiResponseError} - Si une erreur se produit lors de l'appel de l'API.
      * @throws {ApiClientError} - Si l'utilisateur n'est pas authentifié.
      */
-    call(constant: string, data?: object): Promise<any>;
+    call(constant: string, data?: object): Promise<unknown>;
     /**
      * Appelle une méthode de l'API si l'utilisateur n'est pas connecté.
      *
-     * @param {string} constant - Le nom de la méthode à appeler.
-     * @param {object} data - Les données à passer à la méthode.
-     * @returns {Promise<any>} - La promesse de la méthode appelée.
+     * @param constant - Le nom de la méthode à appeler.
+     * @param data - Les données à passer à la méthode.
+     * @returns - `response.data` ou `null` si enqueue offline/breaker.
      * @throws {ApiAuthenticationError} - Si l'utilisateur est connecté.
      * @throws {ApiValidationError} - Si une erreur se produit lors de l'appel de l'API.
      * @throws {ApiResponseError} - Si une erreur se produit lors de l'appel de l'API.
      * @throws {ApiClientError} - Si une erreur se produit lors de l'appel de l'API.
      */
-    callNoConnected(constant: string, data?: object): Promise<any>;
+    callNoConnected(constant: string, data?: object): Promise<unknown>;
     /**
      * Appelle une méthode de l'API si l'utilisateur est connecté.
      *
-     * @param {string|function} param - Le nom de la méthode à appeler ou une fonction de rappel.
-     * @param {object} data - Les données à passer à la méthode.
-     * @returns {Promise<any>} - La promesse de la méthode appelée.
+     * @param param - Le nom de la méthode à appeler ou une fonction de rappel.
+     * @param data - Les données à passer à la méthode.
+     * @returns - `response.data` ou `null` si enqueue offline/breaker.
      * @throws {ApiAuthenticationError} - Si l'utilisateur n'est pas connecté.
      * @throws {ApiValidationError} - Si une erreur se produit lors de l'appel de l'API.
      * @throws {ApiResponseError} - Si une erreur se produit lors de l'appel de l'API.
      * @throws {ApiClientError} - Si une erreur se produit lors de l'appel de l'API.
      */
-    callIsConnected(param: string | Function, data?: object): Promise<any>;
+    callIsConnected(param: string | (() => Promise<any>), data?: object): Promise<unknown>;
     /**
      * Appelle une méthode de l'API si l'utilisateur est lui-même.
      *
-     * @param {string|function} param - Le nom de la méthode à appeler ou une fonction de rappel.
-     * @param {object} data - Les données à passer à la méthode.
-     * @returns {Promise<any>} - La promesse de la méthode appelée.
+     * @param param - Le nom de la méthode à appeler ou une fonction de rappel.
+     * @param data - Les données à passer à la méthode.
+     * @returns - `response.data` ou `null` si enqueue offline/breaker.
      * @throws {ApiAuthenticationError} - Si l'utilisateur n'est pas lui-même.
      * @throws {ApiValidationError} - Si une erreur se produit lors de l'appel de l'API.
      * @throws {ApiResponseError} - Si une erreur se produit lors de l'appel de l'API.
      * @throws {ApiClientError} - Si une erreur se produit lors de l'appel de l'API.
      */
-    callIsMe(param: string | Function, data?: object): Promise<any>;
+    callIsMe(param: string | (() => Promise<any>), data?: object): Promise<unknown>;
     /**
      * Valide une image d'entrée.
      *
-     * @param {File|Blob|Buffer|ReadableStream} imageInput - L'image à valider.
-     * @returns {Promise<File|Buffer|ReadableStream>} - L'image validée.
+     * @param imageInput - L'image à valider.
+     * @returns - L'image validée.
      * @private
      */
-    private _validateImage;
+    protected _validateImage(imageInput: UploadInput): Promise<ValidatedUpload>;
     /**
      * Valide un fichier d'entrée.
      *
-     * @param {File|Blob|Buffer|ReadableStream} fileInput - Le fichier à valider.
-     * @returns {Promise<File|Buffer|ReadableStream>} - Le fichier validé.
+     * @param fileInput - Le fichier à valider.
+     * @returns - Le fichier validé.
      * @private
      */
-    private _validateFile;
+    protected _validateFile(fileInput: UploadInput): Promise<ValidatedUpload>;
     /**
      * Valide les entrées d'upload de fichiers.
      *
-     * @param {File|Blob|Buffer|ReadableStream} input - Le fichier à valider.
-     * @param {Object} options - Options de validation.
-     * @param {Array} options.allowedMimeTypes - Types MIME autorisés.
-     * @param {string} options.expectedType - Type de fichier attendu (ex: "image", "file").
-     * @returns {Promise<File|Buffer|ReadableStream>} - Le fichier validé.
+     * @param input - Le fichier à valider.
+     * @param {{ allowedMimeTypes?: string[], expectedType?: "image"|"file"|"any" }} options - Options de validation.
+     * @returns - Le fichier validé.
      * @throws {ApiValidationError} - Si le type de fichier est invalide.
      * @throws {Error} - Si le type de fichier est inconnu.
      * @private
@@ -270,18 +420,18 @@ export class BaseEntity {
     private _validateUploadInput;
     /**
      * Transforme un Buffer en ReadableStream équivalent à fs.createReadStream
-     * @param {Buffer} buffer - Le buffer contenant les données binaires
-     * @param {string} filename - Nom de fichier (utilisé dans FormData)
-     * @param {string} mimeType - Type MIME (utilisé dans FormData)
-     * @returns {Object} - { stream, filename, mimeType }
+     * @param buffer - Le buffer contenant les données binaires
+     * @param [filename="file.bin"] - Nom de fichier (utilisé dans FormData)
+     * @param [mimeType="application/octet-stream"] - Type MIME (utilisé dans FormData)
+     * @returns - Readable doté de `path` et `mimeType`
      * @private
      */
     private _createReadStreamFromBuffer;
     /**
      * Transforme un Buffer en ReadableStream.
      *
-     * @param {Buffer} buffer - Le buffer à transformer.
-     * @returns {Promise<stream.Readable>} - Un ReadableStream.
+     * @param buffer - Le buffer à transformer.
+     * @returns - Un ReadableStream.
      * @throws {Error} - Si appelé dans le navigateur.
      * @private
      */
@@ -289,7 +439,7 @@ export class BaseEntity {
     /**
      * Crée un PassThrough stream pour le traitement des fichiers.
      *
-     * @returns {Promise<stream.PassThrough>} - Un PassThrough stream.
+     * @returns - Un PassThrough stream.
      * @throws {Error} - Si appelé dans le navigateur.
      * @private
      */
@@ -297,100 +447,139 @@ export class BaseEntity {
     /**
      * Supprime les propriétés d'un objet en fonction d'une liste de clés.
      *
-     * @param {Object} obj - L'objet source.
-     * @param {Array} propsToRemove - Liste des clés à supprimer
-     * @param {boolean} [deep=false] - Si vrai, supprime les propriétés de manière récursive.
-     * @returns {Object} - Un nouvel objet sans les propriétés supprimées.
+     * @param obj - L'objet source.
+     * @param propsToRemove - Liste des clés à supprimer
+     * @returns - Un nouvel objet sans les propriétés supprimées.
      * @private
      */
     private _omitProps;
     /**
      * Extrait les propriétés d'un objet en fonction d'une liste de clés.
      *
-     * @param {Object} obj - L'objet source.
-     * @param {Array} keys - Liste des clés à extraire.
-     * @param {Object} [transforms={}] - Transformations à appliquer aux valeurs.
-     * @returns {Object} - Un nouvel objet contenant les propriétés extraites.
+     * @param obj - L'objet source.
+     * @param keys - Liste des clés à extraire.
+     * @param [transforms={}] - Transformations à appliquer aux valeurs.
+     * @returns - Un nouvel objet contenant les propriétés extraites.
      * @private
      */
     private _pickProps;
     /**
      * Vérifie si au moins une clé est présente dans l'objet et n'est pas nulle.
      *
-     * @param {Object} obj - L'objet à vérifier.
-     * @param {Array} keys - Liste des clés à vérifier.
-     * @returns {boolean} - true si au moins une clé est présente et non nulle, sinon false.
+     * @param obj - L'objet à vérifier.
+     * @param keys - Liste des clés à vérifier.
+     * @returns - true si au moins une clé est présente et non nulle, sinon false.
      * @private
      */
     private _hasAtLeastOne;
     /**
      * Crée un proxy filtré pour une liste d'entités.
-     * @param {Array} list - Liste d'entités.
-     * @returns {Proxy} Proxy filtré.
      * @private
      */
-    private _createFilteredProxy;
+    _createFilteredProxy<T extends Deletable>(list: T[]): T[];
     /**
      * Génère un nouvel identifiant unique.
-     * @returns {string} Un identifiant unique.
-     * @private
+     * @returns Un identifiant unique.
+     * @protected
      */
-    private _newId;
+    protected _newId(): string;
     /**
      * ───────────────────────────────
      * DraftStateMixin
      * ───────────────────────────────
      */
+    /**
+     * Recalcule les champs autorisés en fonction de l'état actuel du draft.
+     * Utilisé pour validation dynamique dans le proxy this.data.
+     * @returns Liste des champs autorisés
+     * @private
+     */
+    private _getAllowedFieldsForCurrentState;
     /**
      * Crée un proxy combinant draft + serveur, avec transformations facultatives.
-     * @param {Object} server
-     * @param {Object} draft
-     * @param {Array} allowedFields - champs autorisés dans le draft
-     * @param {Object} [transforms={}] - transformateurs de lecture
-     * @param {Object} [options={}] - options
-     * @returns {Proxy}
+     * @param apiClient
+     * @param [server={}]
+     * @param [draft={}]
+     * @param _allowedFields - champs autorisés dans le draft (fallback si pas de metadata)
+     * @param [transforms={}] - transformateurs de lecture
+     * @param {{ throwOnError?: boolean }} [options={}] - options
+     * @param [entity=this] - référence à l'entité pour recalcul dynamique
+     * @returns {object}
      * @private
      */
     private _createDraftProxy;
     /**
      * Extrait les champs modifiables d'un schéma JSON.
      *
-     * @param {Object} schema - Le schéma JSON à analyser.
-     * @param {Object} data - Les données à comparer.
-     * @param {Object} ctx - Contexte d'extraction (pour la récursion).
-     * @param {Object} ctx.defs - Définitions de schéma.
-     * @param {Set} ctx.visited - Ensemble des schémas déjà visités.
-     * @returns {Array} - Liste des champs modifiables.
+     * @param schema - Le schéma JSON à analyser.
+     * @param data - Les données à comparer.
+     * @param ctx - Contexte d'extraction (pour la récursion).
+     * @param ctx.defs - Définitions de schéma.
+     * @param ctx.visited - Ensemble des schémas déjà visités.
+     * @returns Liste des champs modifiables (propriétés `writeable` implicites).
      * @private
      */
     private _extractWritableFields;
     /**
      * Construit un brouillon et un proxy à partir des données et du schéma.
      *
-     * @param {Object} options - Options de construction.
-     * @param {Object} options.data - Données à utiliser pour le brouillon.
-     * @param {Object} [options.serverData=null] - Données du serveur.
-     * @param {string|Array} options.constant - Nom de la constante ou tableau de constantes.
-     * @param {ApiClient} options.apiClient - Instance de l'API.
-     * @param {Object} [options.transforms={}] - Transformations à appliquer.
-     * @param {boolean} [options.throwOnError=true] - Si vrai, lève une erreur en cas de problème.
-     * @param {Array} [options.removeFields=[]] - Liste des champs à ignorer.
-     * @returns {Object} - Objet contenant le brouillon et le proxy.
+     * @param options - Options de construction.
+     * @param options.data - Données à utiliser pour le brouillon.
+     * @param options.serverData - Données du serveur.
+     * @param options.previousDraft - Brouillon précédent pour la réactivité.
+     * @param options.constant - Nom de la constante ou tableau de constantes.
+     * @param options.apiClient - Instance de l'API.
+     * @param options.transforms - Transformations à appliquer.
+     * @param options.throwOnError - Si vrai, lève une erreur en cas de problème.
+     * @param options.removeFields - Liste des champs à ignorer.
+     * @returns Draft réactif, proxy combiné, snapshot initial.
      * @private
      */
     private _buildDraftAndProxy;
+    /**
+     * Invoque une méthode de bloc de manière type-safe.
+     * Élimine le besoin de casts `as any` dans les classes dérivées.
+     *
+     * @param blocks - Le Map contenant les noms de méthodes (doit être `as const`)
+     * @param methodName - Le nom de la méthode à invoquer
+     * @param blockData - Les données à passer à la méthode
+     * @returns La valeur retournée par la méthode
+     * @protected
+     *
+     * @example
+     * // Dans une classe dérivée :
+     * await this._invokeBlockMethod(User.UPDATE_BLOCKS, methodName, blockData);
+     */
+    protected _invokeBlockMethod<T extends Map<string, any>>(blocks: T, methodName: string, blockData: any): Promise<any>;
     /**
      * Extrait les champs modifiés du schéma.
      *
-     * @param {ApiClient} apiClient - Instance de l'API.
-     * @param {string} constant - Nom de la constante.
-     * @param {Object} data - Données à comparer.
-     * @param {Function} getInitialDraft - Fonction pour obtenir le brouillon initial.
-     * @param {Array} removeFields - Liste des champs à ignorer.
-     * @returns {Object|null} - Champs modifiés ou null.
+     * @param apiClient - Instance de l'API.
+     * @param constant - Nom de la constante.
+     * @param data - Données à comparer.
+     * @param getInitialDraft - Fonction pour obtenir le brouillon initial.
+     * @param removeFields - Liste des champs à ignorer.
+     * @returns - Champs modifiés ou `null` si aucun changement.
+     * @protected
+     */
+    /**
+     * Détecte si une valeur est un type d'upload (Buffer, File, Blob, Stream)
+     * @param obj - La valeur à tester
+     * @returns true si c'est un type d'upload
+     * @private
+     */
+    private _isUploadType;
+    /**
+     * Compare deux valeurs de manière intelligente :
+     * - Types d'upload (Buffer, File, etc.) : comparaison par référence
+     * - Autres types : comparaison JSON
+     * @param current - Valeur actuelle
+     * @param initial - Valeur initiale
+     * @returns true si les valeurs sont différentes
      * @private
      */
-    private _extractChangedFieldsFromSchema;
+    private _compareValues;
+    _extractChangedFieldsFromSchema(apiClient: ApiClient, constant: string, data: Record<string, any> | undefined, getInitialDraft: () => Record<string, any> | void, removeFields?: string[]): Record<string, any> | null;
     /**
      * Extrait tous les champs valides selon le schéma, et retourne uniquement ceux qui ont changé par rapport au draft initial.
      * Contrairement à `_extractChangedFieldsFromSchema`, cette méthode retourne l'ensemble des champs valides (`updated`)
@@ -401,15 +590,15 @@ export class BaseEntity {
      * - des champs non exclus dans `removeFields`
      * - des champs définis dans `data` (les `undefined` sont ignorés)
      *
-     * @param {ApiClient} apiClient - L’instance de client API contenant les schémas.
-     * @param {string} constant - Le nom de la constante de schéma (ex: "ADD_EVENT").
-     * @param {Object} data - Les nouvelles données à comparer avec le draft initial.
-     * @param {() => Object} getInitialDraft - Fonction qui retourne le draft initial (souvent `this.initialDraftData`).
-     * @param {string[]} [removeFields=[]] - Champs à ignorer même s’ils sont valides.
-     * @returns {Object|null} - Un objet `updated` avec les champs valides si au moins un champ a changé, sinon `null`.
+     * @param apiClient - L'instance de client API contenant les schémas.
+     * @param constant - Le nom de la constante de schéma (ex: "ADD_EVENT").
+     * @param data - Les nouvelles données à comparer avec le draft initial.
+     * @param getInitialDraft - Fonction qui retourne le draft initial (souvent `this.initialDraftData`).
+     * @param removeFields - Champs à ignorer même s'ils sont valides.
+     * @returns - Un objet `updated` avec les champs valides si au moins un champ a changé, sinon `null`.
      * @private
      */
-    private _extractAllValidFieldsFromSchema;
+    _extractAllValidFieldsFromSchema(apiClient: ApiClient, constant: string, data: Record<string, any> | undefined, getInitialDraft: () => Record<string, any>, removeFields?: string[]): Record<string, any> | null;
     /**
      * ───────────────────────────────
      * MutualEntityMixin
@@ -417,69 +606,81 @@ export class BaseEntity {
      */
     /**
      * Résout l'identifiant de l'entité si seul le slug est fourni.
-     * @param {string} type - Le type d'entité (ex : "citoyens", "organizations", "projects").
-     * @returns {Promise<string>} L'identifiant résolu.
+     * @param type - Le type d'entité (ex : "citoyens", "organizations", "projects").
+     * @returns L'identifiant résolu.
+     * @throws {ApiResponseError} - Si le slug ne correspond pas à l'entité attendue.
+     * @throws {ApiError} - Si l'identifiant ne peut pas être résolu.
+     * @throws {ApiResponseError} - Si une erreur se produit lors de la récupération
      * @private
      */
     private _resolveId;
     /**
      * Récupère le profil public de l'entité.
      *
-     * @returns {Promise<Object>} - Les données du profil public.
-     * @private
+     * @returns - Les données du profil public.
+     * @protected
      */
-    private _getPublicProfile;
+    protected _getPublicProfile(): Promise<Record<string, any>>;
     /**
      * Récupère la classe d'entité et ses dépendances à partir du type d'entité.
      *
-     * @param {string} entityType - Le type d'entité.
-     * @return {{ entityClass: Function, deps: Object } | null}
      * @private
      */
     private _getEntityMeta;
     /**
      * Lier des données d'entité à une instance d'entité.
      *
-     * @param {string} entityType - Le type d'entité (ex : "citoyens", "organisations", "projets").
-     * @param {Object} entityData - Les données de l'entité à lier.
-     * @return {Object} L'entité liée.
+     * @param entityType - Le type d'entité (ex : "citoyens", "organisations", "projets").
+     * @param entityData - Les données de l'entité à lier.
+     * @return L'entité liée ou les données brutes si la metadata n'existe pas.
      * @private
      */
-    private _linkEntity;
+    _linkEntity(entityType: string, entityData: object): AnyEntity | object;
+    /**
+     * Transforme un objet imbriqué avec {id, type} en instance d'entité.
+     * Utilisé pour transformer des champs comme author, target, etc.
+     *
+     * @param obj - L'objet à transformer (doit avoir au minimum {id, type}).
+     * @returns L'instance d'entité ou l'objet original si la transformation échoue.
+     * @protected
+     */
+    protected _linkNestedEntity<T = any>(obj: any): T | any;
     /**
      * Récupère et lie une entité à partir de son ID.
      *
-     * @param {string} entityType - Le type d'entité.
-     * @param {string} entityId - L'identifiant de l'entité.
-     * @param {Object} [options] - Options supplémentaires :
-     * @param {boolean} [options.skipGet] - Si true, ne pas appeler `get()` sur l'entité.
-     * @return {Promise<Object|null>} L'entité liée ou null.
+     * @param entityType - Le type d'entité.
+     * @param entityId - L'identifiant de l'entité.
+     * @param options - Options supplémentaires :
+     * @param options.skipGet - Si true, ne pas appeler `get()` sur l'entité.
+     * @return L'entité liée ou null.
      * @private
      */
-    private _linkEntityById;
+    _linkEntityById(entityType: string, entityId: string, options?: {
+        skipGet?: boolean;
+    }): Promise<AnyEntity | null>;
     /**
      * Lie une liste d'entités à partir de leurs données.
      *
-     * @param {Array<Object>} results - Liste de données d'entités.
-     * @return {Array<Object>} Liste d'entités liées.
+     * @param results - Liste de données d'entités.
+     * @return Liste d'entités liées.
      * @private
      */
-    private _linkEntities;
+    protected _linkEntities(results: any[]): any[];
     /**
      * Lie des entités présentes dans `this.serverData` à partir de leurs IDs,
      * en les filtrant dynamiquement et en optionnellement les transformant.
      *
-     * @param {string} entityType - Le type d'entité (ex : "badges", "citoyens", etc.).
-     * @param {Object} filters - Clés/valeurs de filtres dynamiques. Les valeurs peuvent être :
+     * @param entityType - Le type d'entité (ex : "badges", "citoyens", etc.).
+     * @param filters - Clés/valeurs de filtres dynamiques. Les valeurs peuvent être :
      *   - un littéral (comparaison stricte ou intelligente selon le type),
      *   - une chaîne (utilise `includes` insensible à la casse),
      *   - une RegExp (appliquée si la valeur est une chaîne),
      *   - une fonction `(value) => boolean`.
-     * @param {Object} [options] - Options supplémentaires :
-     * @param {string} [options.key] - Le champ de `this.serverData` à utiliser (par défaut = entityType).
-     * @param {Function} [options.mapFn] - Fonction de transformation `(entity) => any` appliquée au résultat.
+     * @param options - Options supplémentaires :
+     * @param options.key - Le champ de `this.serverData` à utiliser (par défaut = entityType).
+     * @param options.mapFn - Fonction de transformation `(entity) => any` appliquée au résultat.
      *
-     * @return {Promise<Array<Object>>} Liste des entités liées, filtrées et éventuellement transformées.
+     * @return Liste des entités liées, filtrées et éventuellement transformées.
      *
      * @example
      * // Tous les badges avec `name` contenant "codev"
@@ -504,79 +705,82 @@ export class BaseEntity {
      *   mapFn: (badge) => badge.meta.name
      * });
      */
-    linkEntitiesFromServerData(entityType: string, filters?: any, options?: {
-        key?: string;
-        mapFn?: Function;
-    }): Promise<Array<any>>;
+    linkEntitiesFromServerData(entityType: string, filters?: EntityFilters, options?: LinkEntitiesOptions): Promise<any[]>;
     /**
      * Crée une instance d'entité à partir des données fournies.
-     * @param {string} entityType - Le type d'entité (ex : "citoyens", "organisations", "projets").
-     * @param {Object} entityData - Les données de l'entité.
-     * @return {Object} L'entité créée.
+     * @template keyof EntityTypeMap T
+     * @param entityType
+     * @param entityData
+     * @return {EntityTypeMap[T]}
      * @private
      */
-    private _entityInstanceData;
+    _entityInstanceData<T extends keyof EntityTypeMap>(entityType: T, entityData: object): EntityTypeMap[T];
     /**
      * Crée une instance d'entité, et déclenche get() si certaines propriétés sont présentes.
-     * @param {string} entityType
-     * @param {Object} entityData
-     * @return {Promise<Object>}
+     * @template keyof EntityTypeMap T
+     * @param entityType
+     * @param [entityData={}]
+     * @return {Promise<EntityTypeMap[T]>}
      */
-    entity(entityType: string, entityData?: any): Promise<any>;
+    entity<T extends keyof EntityTypeMap>(entityType: T, entityData?: object): Promise<EntityTypeMap[T]>;
     /**
      * Récupère et lie une entité à partir de son slug.
-     * @param {string} slug - Le slug de l'entité.
-     * @return {Promise<Object|null>} L'entité liée ou null.
+     * @param slug - Le slug de l'entité.
+     * @return L'entité liée.
+     * @throws {ApiError} Si le slug est vide.
+     * @throws {ApiResponseError} Si le slug n'existe pas ou est invalide.
      */
-    entityBySlug(slug: string): Promise<any | null>;
+    entityBySlug(slug: string): Promise<AnyEntity>;
     /**
      * Construit dynamiquement des filtres sur un lien entre entités
      *
-     * @param {string} id - L'ID de l'entité cible.
-     * @param {Object} options - Options de filtrage.
-     * @param {"memberOf" | "projects"} [options.linkType] - Le type de lien (ex: "memberOf", "projects", etc.).
-     * @param {boolean} [options.isAdmin] - Si défini, filtre selon l'existence de isAdmin.
-     * @param {boolean} [options.isAdminPending] - Si défini, filtre selon l'existence de isAdminPending.
-     * @param {boolean} [options.isInviting] - Si défini, filtre selon l'existence de isInviting.
-     * @param {boolean} [options.toBeValidated] - Si défini, filtre selon l'existence de toBeValidated.
-     * @param {Array<string>} [options.roles] - Rôles à filtrer.
-     * @returns {Object} - Un objet de filtres à passer à une requête.
+     * @param id - L'ID de l'entité cible.
+     * @param options - Options de filtrage.
+     * @param options.linkType - Le type de lien (ex: "memberOf", "projects", etc.).
+     * @param options.isAdmin - Si défini, filtre selon l'existence de isAdmin.
+     * @param options.isAdminPending - Si défini, filtre selon l'existence de isAdminPending.
+     * @param options.isInviting - Si défini, filtre selon l'existence de isInviting.
+     * @param options.toBeValidated - Si défini, filtre selon l'existence de toBeValidated.
+     * @param options.roles - Rôles à filtrer.
+     * @returns - Un objet de filtres à passer à une requête.
      * @throws {TypeError} - Si les types des paramètres ne sont pas valides.
-     * @private
+     * @protected
      */
-    private _buildLinkFilters;
+    _buildLinkFilters(id: string | null, { linkType, isAdmin, isAdminPending, isInviting, toBeValidated, roles }: {
+        linkType: "memberOf" | "projects" | "events";
+        isAdmin?: boolean;
+        isAdminPending?: boolean;
+        isInviting?: boolean;
+        toBeValidated?: boolean;
+        roles?: string[];
+    }): LinkFilters;
     /**
      * Retourne les métadonnées de lien pour une entité :
      * - `linkType` : clé dans `serverData.links`
      * - `connectTypeConnect` : valeur envoyée pour `connect()`
      * - `connectTypeDisconnect` : valeur envoyée pour `disconnect()`
-     * @typedef {Object} LinkMeta
-     * @property {string} linkType
-     * @property {string} connectTypeConnect
-     * @property {string} connectTypeDisconnect
-     * @returns {LinkMeta}
      * @throws {ApiError} - Si le type d'entité est inconnu.
-     * @private
+     * @protected
      */
-    private _getLinkMeta;
+    protected _getLinkMeta(): LinkMeta;
     /**
      * Vérifie si l'entité prend en charge les opérations de lien (`connect`, `disconnect`, etc.).
      * Utilise `_getLinkMeta()` comme source unique de vérité.
      *
      * @throws {ApiError} - Si l'entité ne supporte pas les liens.
-     * @private
+     * @protected
      */
-    private _checkLinkableEntity;
+    protected _checkLinkableEntity(): void;
     /**
      * Retourne le lien de l'utilisateur connecté avec l'entité cible (dans `parent.serverData.links`)
-     * @private
+     * @protected
      */
-    private _getLinkFromConnectedUser;
+    protected _getLinkFromConnectedUser(): import("./serverDataType/common.js").LinkProjectRef | import("./serverDataType/common.js").LinkEventsRef | import("./serverDataType/common.js").LinkfriendsRef | import("./serverDataType/common.js").LinkMemberOfUserRef | null;
     /**
      * Soumet une demande de connexion à une entité (ex : membre, contributeur),
      * ou valide l'invitation si elle existe déjà.
      *
-     * @returns {Promise<Object>} - Résultat de l'API
+     * @returns - Résultat de l'API
      * @throws {ApiError} - En cas d'erreur de connexion ou d'invitation.
      * @private
      */
@@ -592,7 +796,7 @@ export class BaseEntity {
     /**
      * Accepte une demande de lien (ex : invitation à rejoindre un groupe).
      *
-     * @returns {Promise<Object>} - Résultat de l'API
+     * @returns - Résultat de l'API
      * @throws {ApiError} - En cas d'erreur de connexion ou d'invitation.
      * @private
      */
@@ -600,7 +804,7 @@ export class BaseEntity {
     /**
      * Annule une demande de lien ou se déconnecte d'une entité.
      *
-     * @returns {Promise<Object>} - Résultat de l'API
+     * @returns - Résultat de l'API
      * @throws {ApiError} - En cas d'erreur de connexion ou d'invitation.
      * @private
      */
@@ -613,245 +817,257 @@ export class BaseEntity {
     /**
      * Récupérer le profil public de l'entité
      *
-     * @returns {Promise<Object>} - Les données de réponse.
+     * @returns - Les données de réponse.
      */
-    get(): Promise<any>;
+    get(): Promise<Record<string, any>>;
     /**
      * Mettre à jour les paramètres d'un élément : Mise à jour des paramètres spécifiques d'un élément.
      * Constant : UPDATE_SETTINGS
-     * @param {Object} data - Les données à envoyer.
-     * @param {string} data.type - data.type
-     * @param {undefined} data.value - data.value
-     * @returns {Promise<Object>} - Les données de réponse.
+     * @param data
+     * @returns - Les données de réponse.
      * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
      * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
      * @throws {Error} - En cas d'erreur inattendue.
      */
-    updateSettings(data?: {
-        type: string;
-        value: undefined;
-    }): Promise<any>;
+    updateSettings(data: Omit<UpdateSettingsData, "idEntity" | "typeEntity">): Promise<unknown>;
     /**
      * Mettre à jour la description d'un élément : Permet de mettre à jour la description courte et complète d'un élément.
      * Constant : UPDATE_BLOCK_DESCRIPTION
-     * @param {Object} data - Les données à envoyer.
-     * @param {string} data.descMentions - Mentions dans la description (default: "")
-     * @param {string} data.shortDescription - Courte description
-     * @param {string} data.description - Description complète
-     * @returns {Promise<Object>} - Les données de réponse.
+     * @param data - Les données à envoyer.
+     * @returns - Les données de réponse.
      * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
      * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
      * @throws {Error} - En cas d'erreur inattendue.
      */
-    updateDescription(data?: {
-        descMentions: string;
-        shortDescription: string;
-        description: string;
-    }): Promise<any>;
+    updateDescription(data: Omit<UpdateBlockDescriptionData, "id" | "typeElement" | "block">): Promise<unknown>;
     /**
-       * Mettre à jour les informations d'un élément : Permet de mettre à jour les informations générales d'un élément (nom, contacts, etc.).
-       * Constant : UPDATE_BLOCK_INFO
-       */
-    updateInfo(data?: {}): Promise<any>;
+     * Mettre à jour les informations d'un élément : Permet de mettre à jour les informations générales d'un élément (nom, contacts, etc.).
+     * Constant : UPDATE_BLOCK_INFO
+     * @param data - Les données à envoyer.
+     * @returns - Les données de réponse.
+     * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+     * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
+     * @throws {Error} - En cas d'erreur inattendue.
+     */
+    updateInfo(data: Omit<UpdateBlockInfoData, "id" | "typeElement" | "block">): Promise<unknown>;
     /**
      * Mettre à jour les réseaux sociaux d'un élément : Permet de mettre à jour les liens vers les réseaux sociaux d'un élément.
      * Constant : UPDATE_BLOCK_SOCIAL
+     * @param data - Les données à envoyer.
+     * @returns - Les données de réponse.
+     * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+     * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
+     * @throws {Error} - En cas d'erreur inattendue.
+     */
+    updateSocial(data: Omit<UpdateBlockSocialData, "id" | "typeElement" | "block">): Promise<unknown>;
+    /**
+     * @private
+     */
+    private _isPostalAddress;
+    /**
+     * @private
      */
-    updateSocial(data?: {}): Promise<any>;
+    private _isGeo;
+    /**
+     * @private
+     */
+    private _isGeoPosition;
     /**
      * Mettre à jour les localités d'un élément : Permet de mettre à jour l'adresse et les informations géographiques d'un élément.
      * Constant : UPDATE_BLOCK_LOCALITY
+     * @param data - Les données à envoyer.
+     * @returns - Les données de réponse.
+     * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+     * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
+     * @throws {Error} - En cas d'erreur inattendue.
      */
-    updateLocality(data?: {}): Promise<any>;
+    updateLocality(data: Omit<UpdateBlockLocalityData, "id" | "typeElement" | "block">): Promise<unknown>;
     /**
      * Mettre à jour le slug d'un élément : Permet de mettre à jour le slug pour une URL simplifiée.
      * Constant : UPDATE_BLOCK_SLUG
-     * @param {Object} data - Les données à envoyer.
-     * @param {string} data.slug - Le nouveau slug à appliquer.
-     * @returns {Promise<Object>} - Les données de réponse.
+     * @param data - Les données à envoyer.
+     * @param data.slug - Le nouveau slug à appliquer.
+     * @returns - Les données de réponse.
      */
     updateSlug({ slug }: {
         slug: string;
-    }): Promise<any>;
+    }): Promise<unknown>;
     /**
      * Mettre à jour l'image de profil : Permet de mettre à jour l'image de profil d'un utilisateur ou d'une entité.
      * Constant : PROFIL_IMAGE
-     * @param {Object} data - Les données à envoyer.
-     * @param {string} data.profil_avatar - L'image de profil à mettre à jour.
-     * @returns {Promise<Object>} - Les données de réponse.
+     * @param data - Les données à envoyer.
+     * @param data.profil_avatar - L'image de profil à mettre à jour.
+     * @returns - Les données de réponse.
      */
     updateImageProfil({ profil_avatar: image }: {
-        profil_avatar: string;
-    }): Promise<any>;
+        profil_avatar: UploadInput;
+    }): Promise<unknown>;
     /**
      * Crée une instance d'organisation et récupère son profil si nécessaire.
      *
-     * @param {Object} organizationData - Les données nécessaires pour initialiser l'organisation.
-     * @returns {Promise<Organization>} Une promesse qui résout l'objet Organisation créé.
+     * @param organizationData - Les données pour initialiser l'organisation.
+     *                          - Si { id } ou { slug } : récupère l'organisation existante (GET)
+     *                          - Sinon : crée une nouvelle instance (CREATE)
+     * @returns Une promesse qui résout l'objet Organisation créé.
      * @throws {Error} Si une erreur se produit lors de la création de l'organisation.
      */
-    organization(organizationData?: any): Promise<Organization>;
+    organization(organizationData?: OrganizationInput): Promise<Organization>;
     /**
      * Crée une instance de projet et récupère son profil si nécessaire.
      *
-     * @param {Object} projectData - Les données nécessaires pour initialiser le projet.
-     * @returns {Promise<Project>} Une promesse qui résout l'objet Projet créé.
+     * @param projectData - Les données pour initialiser le projet.
+     *                     - Si { id } ou { slug } : récupère le projet existant (GET)
+     *                     - Sinon : crée une nouvelle instance (CREATE)
+     * @returns Une promesse qui résout l'objet Projet créé.
      * @throws {Error} Si une erreur se produit lors de la création du projet.
      */
-    project(projectData?: any): Promise<Project>;
+    project(projectData?: ProjectInput): Promise<Project>;
     /**
      * Crée une instance de POI et la récupère si nécessaire.
      *
-     * @param {Object} poiData - Les données nécessaires pour initialiser le POI.
-     * @returns {Promise<Poi>} Une promesse qui résout l'objet POI créé.
+     * @param poiData - Les données pour initialiser le POI.
+     *                 - Si { id } ou { slug } : récupère le POI existant (GET)
+     *                 - Sinon : crée une nouvelle instance (CREATE)
+     * @returns Une promesse qui résout l'objet POI créé.
      * @throws {Error} Si une erreur se produit lors de la création du POI.
      */
-    poi(poiData?: any): Promise<Poi>;
+    poi(poiData?: PoiInput): Promise<Poi>;
     /**
      * Crée une instance d'événement et la récupère si nécessaire.
      *
-     * @param {Object} eventData - Les données nécessaires pour initialiser l'événement.
-     * @returns {Promise<Event>} Une promesse qui résout l'objet Événement créé.
+     * @param eventData - Les données pour initialiser l'événement.
+     *                   - Si { id } ou { slug } : récupère l'événement existant (GET)
+     *                   - Sinon : crée une nouvelle instance (CREATE)
+     * @returns Une promesse qui résout l'objet Événement créé.
      * @throws {Error} Si une erreur se produit lors de la création de l'événement.
      */
-    event(eventData?: any): Promise<Event>;
+    event(eventData?: EventInput): Promise<EventEntity>;
     /**
      * Crée une instance de badge et la récupère si nécessaire.
      *
-     * @param {Object} badgeData - Les données nécessaires pour initialiser le badge.
-     * @returns {Promise<Badge>} Une promesse qui résout l'objet Badge créé.
+     * @param badgeData - Les données pour initialiser le badge.
+     *                   - Si { id } : récupère le badge existant (GET)
+     *                   - Sinon : crée une nouvelle instance (CREATE)
+     * @returns Une promesse qui résout l'objet Badge créé.
      * @throws {Error} Si une erreur se produit lors de la création du badge.
      */
-    badge(badgeData?: any): Promise<Badge>;
+    badge(badgeData?: BadgeInput): Promise<Badge>;
     /**
      * Crée une instance de news et la récupère si nécessaire.
      *
-     * @param {Object} newsData - Les données nécessaires pour initialiser la news.
-     * @returns {Promise<News>} Une promesse qui résout l'objet News créé.
+     * @param newsData - Les données pour initialiser la news.
+     *                  - Si { id } : récupère la news existante (GET)
+     *                  - Sinon : crée une nouvelle instance (CREATE)
+     * @returns Une promesse qui résout l'objet News créé.
      * @throws {Error} Si une erreur se produit lors de la création de la news.
      */
-    news(newsData?: any): Promise<News>;
+    news(newsData?: NewsInput): Promise<News>;
     /**
      * Récupérer les organisations d'une entitée : la liste des organisations dont l'entité est membre ou admin valide.
      * Constant : GET_ORGANIZATIONS_ADMIN | GET_ORGANIZATIONS_NO_ADMIN
-     * @param {Object} data - Les données à envoyer.
-     * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
-     * @returns {Promise<Object>} - Les données de réponse.
+     * @param data - Paramètres (partiels) de recherche/pagination.
+     * @returns - Les données de réponse.
      */
-    getOrganizations(data?: any): Promise<any>;
+    getOrganizations(data?: Partial<GetOrganizationsAdminData | GetOrganizationsNoAdminData>): Promise<PaginatorPage<Organization>>;
     /**
      * Récupérer les projets d'une entitée : liste des projets de l'entité ou elle est "parent" ou "contributeur".
      * Constant : GET_PROJECTS_ADMIN | GET_PROJECTS_NO_ADMIN
-     * @param {Object} data - Les données à envoyer.
-     * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
-     * @returns {Promise<Object>} - Les données de réponse.
+     * @param data - Paramètres (partiels) de recherche/pagination.
+     * @returns - Les données de réponse.
      */
-    getProjects(data?: any): Promise<any>;
+    getProjects(data?: Partial<GetProjectsAdminData | GetProjectsNoAdminData>): Promise<PaginatorPage<Project>>;
     /**
      * Récupérer les POIs d'une entité : liste des POIs de l'entité ou elle est "parent".
      * Constant : GET_POIS_NO_ADMIN / GET_POIS_ADMIN
-     * @param {Object} data - Les données à envoyer.
-     * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
-     * @returns {Promise<Object>} - Les données de réponse.
+     * @param data - Paramètres (partiels) de recherche/pagination.
+     * @returns - Les données de réponse.
      */
-    getPois(data?: any): Promise<any>;
+    getPois(data?: Partial<GetPoisAdminData | GetPoisNoAdminData>): Promise<PaginatorPage<Poi>>;
     /**
      * Récupérer les abonnés d'une entité
      * Constant : GET_SUBSCRIBERS
-     * @param {Object} data - Les données à envoyer.
-     * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
-     * @returns {Promise<Object>} - Les données de réponse.
+     * @param data - Paramètres (partiels) de recherche/pagination.
+     * @returns - Les données de réponse.
      */
-    getSubscribers(data?: any): Promise<any>;
+    getSubscribers(data?: Partial<GetSubscribersData>): Promise<PaginatorPage<User>>;
     /**
      * Liste des badges créés par l'entité
      * Constant : GET_BADGES
-     * @param {Object} data - Les données à envoyer.
-     * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
-     * @returns {Promise<Object>} - Les données de réponse.
+     * @param data - Paramètres (partiels) de recherche/pagination.
+     * @returns - Les données de réponse.
      */
-    getBadgesIssuer(data?: any): Promise<any>;
+    getBadgesIssuer(data?: Partial<GetBadgesData>): Promise<PaginatorPage<Badge>>;
     /**
-     * Récupérer les actualités : Récupère la liste d’actualités selon plusieurs critères.
+     * Récupérer les actualités : Récupère la liste d'actualités selon plusieurs critères.
      * Constant : GET_NEWS
-     * @param {Object} data - Les données à envoyer.
-     * @param {number} data.dateLimit - Limite de date timestamp ou 0 (default: 0)
-     * @param {object} data.search - data.search
-     * @param {string} data.search.name - Nom ou terme recherché (default: "")
-     * @param {number} data.indexStep - Nombre de résultats par page (default: 12)
-     * @returns {Promise<Object>} - Les données de réponse.
+     * @param data - Paramètres (partiels) de recherche/pagination.
+     * @returns - Les données de réponse.
      * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
      * @throws {Error} - En cas d'erreur inattendue.
      */
-    getNews(data?: {
-        dateLimit: number;
-        search: {
-            name: string;
-        };
-        indexStep: number;
-    }): Promise<any>;
+    getNews(data?: Partial<Omit<GetNewsData, "pathParams">>): Promise<News[]>;
     /**
      * Récupérer la galerie d'une entité.
      * Constant : GET_GALLERY
-     * @param {Object} data - Les données à envoyer.
-     * @param {string} data.pathParams.docType - Type de document (default: "image")
-     * @param {string} data.contentKey - Clé de contenu pour la galerie (default: "null")
-     * @param {string} data.folderId - ID du dossier pour la galerie (default: "null")
-     * @returns {Promise<Object>} - Les données de réponse.
+     * @param data - Paramètres (partiels) de recherche.
+     * @returns - Les données de réponse.
      * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
      * @throws {Error} - En cas d'erreur inattendue.
      */
-    getGallery(data?: any): Promise<any>;
+    getGallery(data?: Partial<Omit<GetGalleryData, "pathParams">> & {
+        pathParams?: {
+            docType?: "image" | "file";
+        };
+    }): Promise<Record<string, any>>;
     /**
      * Soumet une demande pour rejoindre l'entité courante (ex. organisation, projet, événement...).
      * Si une invitation est en attente, elle est automatiquement acceptée.
      *
-     * @returns {Promise<Object>} - Résultat de la demande ou de la validation.
+     * @returns - Résultat de la demande ou de la validation.
      * @throws {ApiError} - Si l'entité ne supporte pas l'action ou si une demande est déjà en cours.
      */
-    requestToJoin(): Promise<any>;
+    requestToJoin(): Promise<unknown>;
     /**
      * Soumet une demande pour devenir administrateur de l'entité courante.
      * Si une invitation est en attente, elle est automatiquement validée.
      *
-     * @returns {Promise<Object>} - Résultat de la demande ou de la validation.
+     * @returns - Résultat de la demande ou de la validation.
      * @throws {ApiError} - Si l'entité ne supporte pas l'action ou si une demande est déjà en cours.
      */
-    requestToJoinAdmin(): Promise<any>;
+    requestToJoinAdmin(): Promise<unknown>;
     /**
      * Accepte une invitation à rejoindre l'entité courante.
      * Ne fonctionne que si un lien avec `isInviting` est détecté.
      *
-     * @returns {Promise<Object>} - Résultat de l'acceptation de l'invitation.
+     * @returns - Résultat de l'acceptation de l'invitation.
      * @throws {ApiError} - Si aucune invitation n'est en attente ou si l'entité ne supporte pas cette action.
      */
-    acceptInvitation(): Promise<any>;
+    acceptInvitation(): Promise<unknown>;
     /**
      * Se désengage de l'entité courante : quitte un rôle (membre, contributeur, etc.).
      *
-     * @returns {Promise<Object>} - Résultat de la déconnexion.
+     * @returns - Résultat de la déconnexion.
      * @throws {ApiError} - Si l'entité ne supporte pas l'action ou si l'utilisateur n'est pas lié à cette entité.
      */
-    leave(): Promise<any>;
+    leave(): Promise<unknown>;
     /**
      * S'abonne à l'entité courante.
      *
-     * @returns {Promise<Object>} - Résultat de l'abonnement.
+     * @returns - Résultat de l'abonnement.
      * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité n'est pas enregistrée.
      */
-    follow(): Promise<any>;
+    follow(): Promise<unknown>;
     /**
      * Se désabonne de l'entité courante.
      *
-     * @returns {Promise<Object>} - Résultat de la désinscription.
+     * @returns - Résultat de la désinscription.
      * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité n'est pas enregistrée.
      */
-    unfollow(): Promise<any>;
+    unfollow(): Promise<unknown>;
     /**
      * Vérifie si l'utilisateur est connecté et a accès à l'entité.
      *
-     * @param {string} action - Action à effectuer.
-     * @returns {void}
+     * @param action - Action à effectuer.
      * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité n'est pas enregistrée.
      * @private
      */
@@ -859,159 +1075,248 @@ export class BaseEntity {
     /**
      * Vérifie si l'utilisateur a un lien valide avec l'entité.
      *
-     * @param {Object} userLink - Lien de l'utilisateur avec l'entité.
-     * @param {boolean} userLink.toBeValidated - Indique si le lien est en attente de validation.
-     * @param {boolean} userLink.isInviting - Indique si l'utilisateur a été invité.
-     * @returns {boolean} - `true` si le lien est valide, `false` sinon.
-     * @private
+     * @param userLink
+     * @returns - `true` si le lien est valide, `false` sinon.
+     * @protected
      */
-    private _validateUserLink;
+    protected _validateUserLink(userLink: MinimalUserLink | null | undefined): boolean;
     /**
      * Vérifie si l'entité est d'un type spécifique.
      *
-     * @param {...string} types - Types d'entité attendus.
+     * @param types - Types d'entité attendus.
      * @throws {ApiError} - Si l'entité n'est pas du type attendu.
-     * @private
+     * @protected
      */
-    private _assertEntityType;
+    protected _assertEntityType(...types: string[]): void;
     /**
      * Vérifie si l'entité est liée à un type de lien spécifique.
      *
-     * @param {string} linkType - Type de lien à vérifier.
-     * @returns {boolean} - `true` si l'entité est liée, `false` sinon.
-     * @private
+     * @param linkType - Type de lien à vérifier.
+     * @returns - `true` si l'entité est liée, `false` sinon.
+     * @protected
      */
-    private _isLinked;
+    protected _isLinked(linkType: string): boolean;
     /**
      * Vérifie si l'utilisateur est l'auteur de l'entité.
      *
-     * @returns {boolean} - `true` si l'utilisateur est l'auteur, `false` sinon.
+     * @returns - `true` si l'utilisateur est l'auteur, `false` sinon.
      * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si les données du serveur ne sont pas disponibles.
      */
     isAuthor(): boolean;
     /**
      * Vérifie si l'utilisateur est administrateur de l'entité.
      *
-     * @returns {boolean} - `true` si l'utilisateur est administrateur, `false` sinon.
+     * @returns - `true` si l'utilisateur est administrateur, `false` sinon.
      * @throws {ApiError}
      */
     isAdmin(): boolean;
     /**
      * Vérifie si l'utilisateur est soit l'auteur, soit administrateur de l'entité.
      *
-     * @returns {boolean} - `true` si l'utilisateur est l'auteur ou administrateur, `false` sinon.
+     * @returns - `true` si l'utilisateur est l'auteur ou administrateur, `false` sinon.
      * @throws {ApiError}
      */
     isAuthorOrAdmin(): boolean;
     /**
      * Vérifie si l'utilisateur est membre de l'entité.
      *
-     * @returns {boolean} - `true` si l'utilisateur est membre, `false` sinon.
+     * @returns - `true` si l'utilisateur est membre, `false` sinon.
      * @throws {ApiError}
      */
     isMember(): boolean;
     /**
      * Vérifie si l'utilisateur est contributeur de l'entité.
      *
-     * @returns {boolean} - `true` si l'utilisateur est contributeur, `false` sinon.
+     * @returns - `true` si l'utilisateur est contributeur, `false` sinon.
      * @throws {ApiError}
      */
     isContributor(): boolean;
     /**
      * Vérifie si l'utilisateur est participant de l'entité.
      *
-     * @returns {boolean} - `true` si l'utilisateur est participant, `false` sinon.
+     * @returns - `true` si l'utilisateur est participant, `false` sinon.
      * @throws {ApiError}
      */
     isAttendee(): boolean;
     /**
      * Vérifie si l'utilisateur suit l'entité.
      *
-     * @returns {boolean} - `true` si l'utilisateur suit l'entité, `false` sinon.
+     * @returns - `true` si l'utilisateur suit l'entité, `false` sinon.
      * @throws {ApiError}
      */
     isFollower(): boolean;
     /**
      * Vérifie si l'utilisateur est abonné à l'entité.
      *
-     * @returns {boolean} - `true` si l'utilisateur est abonné, `false` sinon.
+     * @returns - `true` si l'utilisateur est abonné, `false` sinon.
      * @throws {ApiError}
      */
     isFollowing(): boolean;
     /**
      * Récupère le JSON personnalisé de l'entité
      *
-     * @returns {Promise<Object>} - Le JSON personnalisé de l'entité.
+     * @returns - Le JSON personnalisé de l'entité.
      * @throws {ApiError} - Si le slug de l'entité n'est pas défini.
      */
-    getCostumJson(): Promise<any>;
+    getCostumJson(): Promise<unknown>;
     /**
      * Génère des plages d'index pour la pagination.
      *
-     * @param {Array<string>} searchType - Types de recherche.
-     * @param {number} indexStep - Pas d'index.
-     * @param {Object} previousRanges - Plages précédentes.
-     * @returns {Object} - Plages d'index générées.
+     * @param searchType - Types de recherche.
+     * @param indexStep - Pas d'index.
+     * @param previousRanges - Plages précédentes.
+     * @returns - Plages d'index générées.
      * @private
      */
     private _generateRanges;
     /**
      * Normalise le compte des résultats.
      *
-     * @param {Object} count - Compte des résultats.
-     * @returns {Object} - Compte normalisé.
+     * @param count - Compte des résultats.
+     * @returns - Compte normalisé.
      * @private
      */
     private _normalizeCount;
     /**
      * Récupère une valeur par défaut depuis un endpoint donné.
      *
-     * @param {string} constant - Le nom unique de l’endpoint (ex: "GET_ORGANIZATIONS_NO_ADMIN")
-     * @param {string} path - Le chemin vers la propriété (ex: "searchType")
-     * @returns {*} La valeur par défaut, ou undefined si non trouvée
+     * @param constant - Le nom unique de l'endpoint (ex: "GET_ORGANIZATIONS_NO_ADMIN")
+     * @param path - Le chemin vers la propriété (ex: "searchType")
+     * @returns La valeur par défaut, ou undefined si non trouvée
      */
-    _getDefaultFromEndpoint(constant: string, path: string): any;
+    _getDefaultFromEndpoint(constant: string, path: string): unknown;
     /**
-     * Coeur de pagination stateless et réutilisable, sans logique métier.
-     *
-     * @param {Object} config
-     * @param {Object} config.initialData - Paramètres de départ
-     * @param {Function} config.finalizer - Fonction async qui retourne { results, count }
-     *
-     * @returns {Object} paginator avec .next() et .prev()
+     * Coeur de pagination stateless et réutilisable.
      */
-    _createPaginatorEngine({ initialData, finalizer }: {
-        initialData: any;
-        finalizer: Function;
-    }): any;
+    _createPaginatorEngine<TData extends Record<string, any>, TOut>({ initialData, finalizer }: {
+        initialData: Partial<TData>;
+        finalizer: (data: TData) => Promise<FinalizerResult<TOut>>;
+    }): {
+        next: () => Promise<PaginatorPage<TOut>>;
+    };
     /**
-   * Injection de contexte Communecter dans une requête finalizer.
-   *
-   * @param {Function} baseFinalizer - fonction async(data) => { results, count }
-   * @returns {Function} fonction enrichie
-   */
-    _withCostumContext(baseFinalizer: Function): Function;
+     * Injection de contexte Communecter dans une requête finalizer.
+     */
+    _withCostumContext<TIn extends Record<string, unknown>, TOut>(baseFinalizer: (data: TIn & {
+        costumSlug: string;
+        contextId: string;
+        contextType: EntityType;
+        sourceKey: string[];
+    }) => Promise<TOut>): (data: TIn) => Promise<TOut>;
     /**
      * ───────────────────────────────
      *  custom
      * ───────────────────────────────
      */
     /**
-     * Recherche liée à l'entité, version stateless.
+     * Recherche globale liée au *costum* (stateless).
+     * Injecte automatiquement le contexte (slug/id/type) via `_withCostumContext`,
+     * puis pagine via `_createPaginatorEngine`. Cette méthode renvoie **directement
+     * la première page** (rétro-compatible) avec `.results`, `.count`, et des helpers
+     * de pagination si disponibles.
      *
-     * @param {Object} data - Données initiales de recherche.
-     * @returns {Object} - Un paginateur avec .next(), .prev(), etc.
-     */
-    searchCostum(data?: any): any;
-    costumEventRequestActors(data?: {}): Promise<any>;
-    costumEventRequestSubevents(data?: {}): Promise<any>;
-    costumEventRequestDates(data?: {}): Promise<any>;
-    costumEventRequestElementEvent(data?: {}): Promise<any>;
-    costumEventRequestCategories(data?: {}): Promise<any>;
-    costumEventRequestEvent(data?: {}): Promise<any>;
-    costumEventRequestLinkTlToEvent(data?: {}): Promise<any>;
-    costumEventRequestLoadContextTag(data?: {}): Promise<any>;
+     * Remarque : les éléments de `results` peuvent être hétérogènes (multi-collections)
+     * et éventuellement « liés » en entités par le moteur interne de pagination.
+     *
+     * @param data
+     *        Paramètres de recherche (partiels — les valeurs manquantes sont complétées
+     *        par le moteur de pagination et le contexte).
+     * @returns
+     *          Première page paginée : `results` (T[]), `count.total`, `hasNext`, etc.
+     * @throws {ApiResponseError}
+     * @throws {Error}
+     *
+     * @example
+     * // Recherche simple (première page)
+     * const page = await entity.searchCostum({ name: "marseille", searchType: ["projects"], indexStep: 12, indexMin: 0 });
+     * console.log(page.results, page.count.total);
+     *
+     * @example
+     * // Paginer
+     * if (page.hasNext) {
+     *   const nextPage = await page.next();
+     *   console.log(nextPage.pageNumber, nextPage.results.length);
+     * }
+     */
+    searchCostum(data?: Partial<GlobalAutocompleteCostumData>): Promise<PaginatorPage<any>>;
+    /**
+     * @param data
+     *        Paramètres de recherche (partiels — les valeurs manquantes sont complétées
+     *        par le moteur de pagination et le contexte).
+     * @returns
+     *          Première page paginée : `results` (T[]), `count.total`, `hasNext`, etc.
+     * @throws {ApiResponseError}
+     * @throws {Error}
+     */
+    costumEventRequestActors(data?: Partial<Omit<CostumEventRequestActorsData, "pathParams">>): Promise<unknown>;
+    /**
+     * @param data
+     *        Paramètres de recherche (partiels — les valeurs manquantes sont complétées
+     *        par le moteur de pagination et le contexte).
+     *          Première page paginée : `results` (T[]), `count.total`, `hasNext`, etc.
+     * @throws {ApiResponseError}
+     * @throws {Error}
+     */
+    costumEventRequestSubevents(data?: Partial<Omit<CostumEventRequestSubeventsData, "pathParams">>): Promise<unknown>;
+    /**
+     * @param data
+     *        Paramètres de recherche (partiels — les valeurs manquantes sont complétées
+     *        par le moteur de pagination et le contexte).
+     * @returns
+     *          Première page paginée : `results` (T[]), `count.total`, `hasNext`, etc.
+     * @throws {ApiResponseError}
+     * @throws {Error}
+     */
+    costumEventRequestDates(data?: Partial<Omit<CostumEventRequestDatesData, "pathParams">>): Promise<unknown>;
+    /**
+     * @param data
+     *        Paramètres de recherche (partiels — les valeurs manquantes sont complétées
+     *        par le moteur de pagination et le contexte).
+     * @returns
+     *          Première page paginée : `results` (T[]), `count.total`, `hasNext`, etc.
+     * @throws {ApiResponseError}
+     * @throws {Error}
+     */
+    costumEventRequestElementEvent(data?: Partial<Omit<CostumEventRequestElementEventData, "pathParams">>): Promise<unknown>;
+    /**
+     * @param data
+     *        Paramètres de recherche (partiels — les valeurs manquantes sont complétées
+     *        par le moteur de pagination et le contexte).
+     * @returns
+     *          Première page paginée : `results` (T[]), `count.total`, `hasNext`, etc.
+     * @throws {ApiResponseError}
+     * @throws {Error}
+     */
+    costumEventRequestCategories(data?: Partial<Omit<CostumEventRequestCategoriesData, "pathParams">>): Promise<unknown>;
+    /**
+     * @param data
+     *        Paramètres de recherche (partiels — les valeurs manquantes sont complétées
+     *        par le moteur de pagination et le contexte).
+     * @returns
+     *          Première page paginée : `results` (T[]), `count.total`, `hasNext`, etc.
+     * @throws {ApiResponseError}
+     * @throws {Error}
+     */
+    costumEventRequestEvent(data?: Partial<Omit<CostumEventRequestEventData, "pathParams">>): Promise<unknown>;
+    /**
+     * @param data
+     *        Paramètres de recherche (partiels — les valeurs manquantes sont complétées
+     *        par le moteur de pagination et le contexte).
+     * @returns
+     *          Première page paginée : `results` (T[]), `count.total`, `hasNext`, etc.
+     * @throws {ApiResponseError}
+     * @throws {Error}
+     */
+    costumEventRequestLinkTlToEvent(data: Pick<CostumEventRequestLinkTlToEventData, "tl" | "event"> & Partial<Omit<CostumEventRequestLinkTlToEventData, "tl" | "event" | "pathParams">>): Promise<unknown>;
+    /**
+     * @param data
+     *        Paramètres de recherche (partiels — les valeurs manquantes sont complétées
+     *        par le moteur de pagination et le contexte).
+     * @returns
+     *          Première page paginée : `results` (T[]), `count.total`, `hasNext`, etc.
+     * @throws {ApiResponseError}
+     * @throws {Error}
+     */
+    costumEventRequestLoadContextTag(data?: Partial<Omit<CostumEventRequestLoadContextTagData, "pathParams">>): Promise<unknown>;
 }
 export default BaseEntity;
-export type ApiClient = import("../ApiClient.js").default;
-export type EndpointApi = import("./EndpointApi.js").default;