import { BaseEntity } from "./BaseEntity.js";
import { Notifications } from "./Notifications.js";
import { type CostumScope } from "../costum/runtime.js";
import type { Badge } from "./Badge.js";
import type { PaginatorPage, PaginatorState } from "./BaseEntity.js";
import type { ChangePasswordData, DeleteAccountData, GetSubscriptionsAdminData, GetSubscriptionsData, GetOrganizationsNoAdminData, GetOrganizationsAdminData, GetUserEligiblePlacesData, GetFriendsAdminData } from "./EndpointApi.types.js";
import type { Organization } from "./Organization.js";
import type { KnownCostumSlug } from "../costum/types.js";
import type { NotificationItemData } from "./serverDataType/Notification.js";
import type { EntityTypes } from "@/types/entities.js";
type ApiClient = import("../ApiClient.js").default;
type UserItemNormalized = import("./serverDataType/User.js").UserItemNormalized;
export declare class User extends BaseEntity<UserItemNormalized> {
    static entityType: "citoyens";
    static entityTag: string;
    static SCHEMA_CONSTANTS: string[];
    static UPDATE_BLOCKS: Map<"UPDATE_BLOCK_DESCRIPTION" | "UPDATE_BLOCK_INFO" | "UPDATE_BLOCK_SOCIAL" | "UPDATE_BLOCK_LOCALITY" | "UPDATE_BLOCK_SLUG" | "PROFIL_IMAGE", "updateImageProfil" | "updateDescription" | "updateSocial" | "updateLocality" | "updateInfo" | "updateSlug">;
    defaultFields: Record<string, any>;
    removeFields: string[];
    transforms: Record<string, (val: any, full: any) => any>;
    /**
     * Crée une instance de `User`.
     *
     * @param parent
     *        L'ApiClient, une entité parente, ou tout objet exposant `apiClient`.
     * @param {{ id?: string, slug?: string }} data  Données initiales (il faut au moins `id` OU `slug`).
     * @param {{
     *   EndpointApi: EndpointApiDep,
     *   Organization: typeof import("./Organization.js").Organization,
     *   Project: typeof import("./Project.js").Project,
     *   Event: typeof import("./Event.js").Event,
     *   Poi: typeof import("./Poi.js").Poi,
     *   Badge: typeof import("./Badge.js").Badge,
     *   News: typeof import("./News.js").News
     * }} deps
     * @throws {ApiError} Si `EndpointApi` n'est pas injecté, ou si `id`/`slug` manquent,
     *                    ou si une des classes dépendantes n'est pas injectée.
     */
    constructor(parent: ApiClient | any, data: {
        id?: string;
        slug?: string;
    }, deps: {
        EndpointApi: any;
        Organization: typeof import("./Organization.js").Organization;
        Project: typeof import("./Project.js").Project;
        Event: typeof import("./Event.js").Event;
        Poi: typeof import("./Poi.js").Poi;
        Badge: typeof import("./Badge.js").Badge;
        News: typeof import("./News.js").News;
        Comment: typeof import("./Comment.js").Comment;
        Answer: typeof import("./Answer.js").Answer;
        Form?: typeof import("./Form.js").Form;
        Classified?: typeof import("./Classified.js").Classified;
        Action?: typeof import("./Action.js").Action;
    });
    get slug(): any;
    get isMe(): boolean;
    get parentIsMe(): boolean;
    get isActingUser(): boolean;
    /** @returns {"citoyens"} */
    getEntityType(): "citoyens";
    /**
     * Rôles de l'utilisateur (depuis `serverData.roles`, présent sur `me` après authenticate/meInfo —
     * `ME_PROJECTION` garde `roles` et exclut `pwd`/tokens). Vide si non chargé ou profil public.
     */
    get roles(): Record<string, unknown>;
    /**
     * Super-admin global STRICT (`roles.superAdmin === true`) — équivalent legacy `Role::isUserSuperAdmin`,
     * et c'est le gate RÉEL de l'export admin (`exportElements`). N'inclut PAS `adminPlatform`.
     */
    isSuperAdmin(): boolean;
    /**
     * Admin de plateforme (`roles.adminPlatform === true`). Rôle hors-legacy (absent du PHP), posé en base.
     * NB : le backend NE le traite PLUS comme super-admin (retiré de `isUserSuperAdmin` pour byte-fidélité) —
     * ne l'utiliser que pour des features plateforme dédiées, pas pour gater une action que le backend refusera.
     */
    isAdminPlatform(): boolean;
    /**
     * Accès admin plateforme large : `superAdmin || adminPlatform`. Pour gater l'UI d'outils plateforme.
     * ⚠ Le backend n'accorde l'édition/suppression qu'au `superAdmin` strict (+ droits costum) — un
     * `adminPlatform` pur verra l'UI mais sera refusé au save/delete.
     */
    canPlatformAdmin(): boolean;
    /**
     * L'utilisateur connecté est-il ADMIN DU COSTUM `slug` (droit-parapluie back-office) ? = admin (lien
     * `isAdmin` validé) de l'élément HÔTE du costum. Pendant client de `Authorisation::isCostumAdmin` :
     * résout le host via `getElementsKey` (slug → contextId/contextType) puis lit
     * `me.links.<memberOf|projects|events>[hostId].isAdmin`.
     * ⚠ ASYNC (1 requête) : à résoudre UNE fois par contexte /admin, PAS par ligne de liste.
     * NB : ne couvre pas le fallback `costum.admins` (rare) — seul le chemin admin-du-host est vérifié client-side.
     */
    isCostumAdmin(slug: string): Promise<boolean>;
    /**
       * Récupère le profil complet de l'utilisateur.
       * Si l'utilisateur est connecté, on appelle le endpoint ME_INFO_URL,
       * sinon, on peut imaginer appeler un endpoint public.
       *
       * @returns Le profil complet.
       */
    get(): Promise<Record<string, any>>;
    /**
     * Changer le mot de passe : Permet de changer le mot de passe d'un utilisateur.
     * Constant : CHANGE_PASSWORD
     * @param data - Données envoyées à l'API
     * @returns - Les données de réponse.
     * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
     * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
     * @throws {Error} - En cas d'erreur inattendue.
     */
    changePassword(data: ChangePasswordData): Promise<unknown>;
    /**
     * Supprimer un compte : Permet de supprimer un compte utilisateur.
     * Constant : DELETE_ACCOUNT
     * @param data - Données envoyées à l'API
     * @returns - Les données de réponse.
     * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
     * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
     * @throws {Error} - En cas d'erreur inattendue.
     */
    delete(data: DeleteAccountData): Promise<unknown>;
    /**
     * Sauvegarde les modifications de l'utilisateur en appelant les endpoints correspondants.
     * Seul l'utilisateur connecté peut se modifier lui-même.
     *
     * @returns - Données serveur mises à jour si applicable.
     * @throws {ApiError} - Si l'utilisateur n'est pas autorisé.
     */
    save(): Promise<Record<string, any>>;
    _add: () => Promise<never>;
    /**
     * Met à jour les blocs modifiés de l'utilisateur via les constantes de schéma définies.
     *
     * @param payload - Données courantes à comparer et envoyer.
     * @returns - Indique s'il y a eu une modification réelle.
     * @throws {ApiError} - Si l'utilisateur n'est pas autorisé à effectuer cette action.
     */
    _update: (payload: Record<string, any>) => Promise<boolean>;
    static fromServerData(data: any, parent: any, deps: any): User;
    /**
     * {@inheritDoc BaseEntity#updateSettings}
     *
     * Mettre à jour les paramètres utilisateur : Mise à jour des paramètres spécifiques d'un utilisateur.
     */
    updateSettings(data: Parameters<BaseEntity<UserItemNormalized>["updateSettings"]>[0]): Promise<unknown>;
    /**
     * {@inheritDoc BaseEntity#updateDescription}
     *
     * Mettre à jour la description d'un élément : Permet de mettre à jour la description courte et complète d'un élément.
     */
    updateDescription(data: Parameters<BaseEntity<UserItemNormalized>["updateDescription"]>[0]): Promise<unknown>;
    /**
     * {@inheritDoc BaseEntity#updateInfo}
     *
     * Mettre à jour les informations d'un élément : Permet de mettre à jour les informations générales d'un élément (nom, contacts, etc.).
     */
    updateInfo(data: Parameters<BaseEntity<UserItemNormalized>["updateInfo"]>[0]): Promise<unknown>;
    /**
     * {@inheritDoc BaseEntity#updateSocial}
     *
     * Mettre à jour les réseaux sociaux d'un élément : Permet de mettre à jour les liens vers les réseaux sociaux d'un élément.
     */
    updateSocial(data: Parameters<BaseEntity<UserItemNormalized>["updateSocial"]>[0]): Promise<unknown>;
    /**
     * {@inheritDoc BaseEntity#updateLocality}
     *
     * Mettre à jour les localités d'un élément : Permet de mettre à jour l'adresse et les informations géographiques d'un élément.
     */
    updateLocality(data: Parameters<BaseEntity<UserItemNormalized>["updateLocality"]>[0]): Promise<unknown>;
    /**
     * {@inheritDoc BaseEntity#updateSlug}
     *
     * Mettre à jour le slug d'un élément : Permet de mettre à jour le slug pour une URL simplifiée.
     */
    updateSlug(data: Parameters<BaseEntity<UserItemNormalized>["updateSlug"]>[0]): Promise<unknown>;
    /**
     * {@inheritDoc BaseEntity#updateImageProfil}
     *
     * Mettre à jour l'image de profil : Permet de mettre à jour l'image de profil d'un utilisateur ou d'une entité.
     */
    updateImageProfil(data: Parameters<BaseEntity<UserItemNormalized>["updateImageProfil"]>[0]): Promise<unknown>;
    /**
     * {@inheritDoc BaseEntity#updateImageBanner}
     *
     * Mettre à jour l'image de bannière : Permet de mettre à jour l'image de bannière d'un utilisateur ou d'une entité.
     */
    updateImageBanner(data: Parameters<BaseEntity<UserItemNormalized>["updateImageBanner"]>[0]): Promise<unknown>;
    /**
     * {@inheritDoc BaseEntity#getOrganizations}
     * @param [data]
     *
     * Récupérer les organisations d'un utilisateur : Récupère la liste des organisations auxquelles l'utilisateur appartient.
     * Constant : GET_ORGANIZATIONS_ADMIN | GET_ORGANIZATIONS_NO_ADMIN
     */
    getOrganizations(data?: Partial<GetOrganizationsAdminData | GetOrganizationsNoAdminData>, options?: {
        restoredState?: PaginatorState;
    }): Promise<PaginatorPage<Organization>>;
    /**
     * Récupère les lieux (organizations) memberOf de l'utilisateur, filtrés
     * côté serveur par des filters arbitraires (tags, source.key, etc.) et
     * un flag `notSourceKey` configurables.
     *
     * Mirroir de `getOrganizations` mais permet de passer dynamiquement les
     * filtres du finder du formulaire (vue collaborative coform/place), pour
     * que la pagination soit correcte (filtrage côté serveur, pas côté client).
     *
     * Constant : GET_USER_ELIGIBLE_PLACES
     */
    getEligiblePlaces(data?: Partial<GetUserEligiblePlacesData>, options?: {
        restoredState?: PaginatorState;
    }): Promise<PaginatorPage<Organization>>;
    /**
     * {@inheritDoc BaseEntity#getProjects}
     *
     * Récupérer les projets d'un utilisateur : Récupère la liste des projets auxquels l'utilisateur contribue.
     */
    getProjects(data?: Parameters<BaseEntity<UserItemNormalized>["getProjects"]>[0]): Promise<PaginatorPage<import("./Project.js").Project>>;
    /**
     * {@inheritDoc BaseEntity#getEvents}
     *
     * Récupère les événements d'un utilisateur.
     */
    getEvents(data?: Parameters<BaseEntity<UserItemNormalized>["getEvents"]>[0]): Promise<PaginatorPage<import("./Event.js").Event>>;
    /**
     * {@inheritDoc BaseEntity#getPois}
     *
     * Récupérer les POIs
     */
    getPois(data?: Parameters<BaseEntity<UserItemNormalized>["getPois"]>[0]): Promise<PaginatorPage<import("./Poi.js").Poi>>;
    /**
     * {@inheritDoc BaseEntity#getNews}
     *
     * Récupérer les actualités : Récupère la liste des actualités liées à l'utilisateur.
     */
    getNews(data?: Parameters<BaseEntity<UserItemNormalized>["getNews"]>[0]): Promise<import("./News.js").News[]>;
    /**
     * Récupérer les amis administrables : Récupère les amis administrée par l’utilisateur.
     * Constant : GET_FRIENDS_ADMIN
     * question : qui peut voir la liste d'amis, seulement l'utilisateur connecté ? ou tous les utilisateurs connectés ?
     * actuellement, c'est tous les utilisateurs connectés
     */
    getFriends(data?: Partial<GetFriendsAdminData>, options?: {
        restoredState?: PaginatorState;
    }): Promise<PaginatorPage<User>>;
    /**
     * Récupérer les suivis
     * Constant : GET_SUBSCRIPTIONS / GET_SUBSCRIPTIONS_ADMIN
     */
    getSubscriptions(data?: Partial<GetSubscriptionsAdminData | GetSubscriptionsData>, options?: {
        restoredState?: PaginatorState;
    }): Promise<PaginatorPage<BaseEntity<any>>>;
    /**
     * {@inheritDoc BaseEntity#getSubscribers}
     *
     * Récupérer les abonnés
     */
    getSubscribers(data?: Parameters<BaseEntity<UserItemNormalized>["getSubscribers"]>[0]): Promise<PaginatorPage<User>>;
    /**
     * Obtenir la liste des événements
     * Constant : GET_EVENTS
     * TODO : il n'est pas fait encore pour GET_EVENTS_ADMIN / GET_EVENTS_NO_ADMIN comme les autres dans endpointApi
     */
    /**
     * {@inheritDoc BaseEntity#getBadgesIssuer}
     *
     * Liste des badges créés par l'utilisateur
     */
    getBadgesIssuer(data?: Parameters<BaseEntity<UserItemNormalized>["getBadgesIssuer"]>[0]): Promise<PaginatorPage<Badge>>;
    /**
     * Liste des badges associés à l'utilisateur
     *
     * TODO : documenté le fonctionnement et sont utilisation avec un exemple
     */
    getBadges(filter?: Record<string, any>): Promise<Badge[]>;
    /**
     * {@inheritDoc BaseEntity#getGallery}
     *
     * Récupérer la galerie de l'utilisateur
     */
    getGallery(data?: Parameters<BaseEntity<UserItemNormalized>["getGallery"]>[0]): Promise<Record<string, any>>;
    user(userData: {
        id?: string;
        slug?: string;
    }): Promise<User>;
    /**
     * {@inheritDoc BaseEntity#organization}
     *
     * Crée une instance d'organisation et récupère son profil si nécessaire.
     */
    organization(organizationData?: Parameters<BaseEntity<UserItemNormalized>["organization"]>[0]): Promise<Organization>;
    /**
     * {@inheritDoc BaseEntity#project}
     *
     * Crée une instance de projet et récupère son profil si nécessaire.
     */
    project(projectData?: Parameters<BaseEntity<UserItemNormalized>["project"]>[0]): Promise<import("./Project.js").Project>;
    /**
     * Bloqué sur User : un Form nécessite un costumContext (slug d'Organization/Project)
     * que User n'a pas. Utilisez `user.organization({slug}).then(o => o.form({id}))`
     * ou `user.project({slug}).then(p => p.form({id}))` pour la chaîne propagée.
     */
    form(): Promise<never>;
    /**
     * {@inheritDoc BaseEntity#news}
     *
     * Crée une instance de news et la récupère si nécessaire.
     */
    news(newsData?: Parameters<BaseEntity<UserItemNormalized>["news"]>[0]): Promise<import("./News.js").News>;
    /**
     * {@inheritDoc BaseEntity#poi}
     *
     * Crée une instance de POI et la récupère si nécessaire.
     */
    poi(poiData?: Parameters<BaseEntity<UserItemNormalized>["poi"]>[0]): Promise<import("./Poi.js").Poi>;
    /**
     * {@inheritDoc BaseEntity#event}
     *
     * Crée une instance d'événement et la récupère si nécessaire.
     */
    event(eventData?: Parameters<BaseEntity<UserItemNormalized>["event"]>[0]): Promise<import("./Event.js").Event>;
    /**
     * Ouvre un *scope costum* : les entités créées via le scope (`poi`/`organization`/`project`/`event`)
     * portent le contexte costum (costumSlug + champs costum validés par le binding du costum à `element/save`).
     *
     * @example
     * const tl = await me.costum("reseauTierslieux");
     * const org = await tl.organization({ name: "Mon TL", manageModel: "Association", buildingSurfaceArea: "120" });
     * await org.save();
     *
     * Deux formes :
     *  - `me.costum(slug)` : slug d'un costum du registry (autocomplété) OU n'importe quel slug (`string`) —
     *    le backend reste l'autorité de validité (`found`). Slug hors registry sans champ → inc1b (résolution live).
     *  - `me.costum(entity)` : ouvre un scope FIELDLESS depuis une entité DÉJÀ CHARGÉE (org/projet/event qui porte
     *    un costum), zéro fetch — `source.key` = slug de l'entité. Cas « créer sous ce site nu ».
     *
     * @param arg - slug (`KnownCostumSlug | string`) OU une entité chargée porteuse d'un costum.
     */
    costum(slug: KnownCostumSlug | (string & {})): Promise<CostumScope>;
    costum(entity: BaseEntity): Promise<CostumScope>;
    /**
     * {@inheritDoc BaseEntity#badge}
     *
     * Crée une instance de badge et la récupère si nécessaire.
     */
    badge(badgeData?: Parameters<BaseEntity<UserItemNormalized>["badge"]>[0]): Promise<Badge>;
    /**
     * ───────────────────────────────
     *  Lien utilisateur ↔ utilisateur (ami)
     *  (demander, valider, se retirer)
     * ───────────────────────────────
     */
    /**
     * Envoie une demande d'amitié à cet utilisateur.
     * L'utilisateur ciblé devra valider la demande pour établir la relation.
     *
     * @returns - Résultat de la requête.
     * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'action est interdite.
     */
    sendFriendRequest(): Promise<unknown>;
    /**
     * Accepte une demande d'amitié envoyée par cet utilisateur.
     * Cette action établit un lien entre les deux utilisateurs.
     *
     * @returns - Résultat de la validation du lien.
     * @throws {ApiError} - Si aucune invitation n'est en attente ou si l'action est interdite.
     */
    acceptFriendRequest(): Promise<unknown>;
    /**
     * Supprime la relation d'amitié avec cet utilisateur.
     * Cette action annule tout lien existant entre les deux profils.
     *
     * @returns - Résultat de la suppression.
     * @throws {ApiError} - Si aucune relation n'existe.
     */
    removeFriend(): Promise<unknown>;
    requestToJoin(): Promise<never>;
    requestToJoinAdmin(): Promise<never>;
    acceptInvitation(): Promise<never>;
    leave(): Promise<never>;
    /**
     * Suivre un utilisateur
     * Cette action permet à l'utilisateur connecté de suivre un autre utilisateur.
     * Elle nécessite que l'utilisateur soit connecté.
     *
     * @returns - Résultat de la requête.
     * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'action est interdite.
     */
    follow(): Promise<unknown>;
    /**
     * Se désabonner d'un utilisateur
     * Cette action permet à l'utilisateur connecté de se désabonner d'un autre utilisateur.
     * Elle nécessite que l'utilisateur soit connecté.
     *
     * @returns - Résultat de la requête.
     * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'action est interdite.
     */
    unfollow(): Promise<unknown>;
    /**
     * Vérifie si l'utilisateur connecté est ami avec cet utilisateur.
     * @param options - Options de vérification.
     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
     * @returns - True si l'utilisateur connecté est ami, sinon false.
     * @throws {ApiError} - Si l'utilisateur n'est pas connecté.
     */
    isFriend(options?: {
        silent?: boolean;
    }): boolean;
    /**
     * Vérifie si l'utilisateur suit l'entité.
     * @param options - Options de vérification.
     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
     * @returns - `true` si l'utilisateur suit l'entité, `false` sinon.
     * @throws {ApiError}
     */
    isFollower(options?: {
        silent?: boolean;
    }): boolean;
    /**
     * Vérifie si l'utilisateur est abonné à l'entité.
     * @param options - Options de vérification.
     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
     * @returns - `true` si l'utilisateur est abonné, `false` sinon.
     * @throws {ApiError}
     */
    isFollowing(options?: {
        silent?: boolean;
    }): boolean;
    /**
     * Retourne une entité à partir d'un slug.
     * @param slug - Le slug de l'entité à récupérer.
     * @returns L'entité correspondante au slug.
     */
    entityBySlug(slug: string): Promise<EntityTypes>;
    /**
     * Valide les préconditions de base (connexion, entité, parent, type).
     * @private
     * @param methodName - Nom de la méthode appelante (pour les messages d'erreur).
     * @param expectedTypes - Types d'entité parent autorisés.
     * @throws {ApiError} 401 - Si l'utilisateur n'est pas connecté.
     * @throws {ApiError} 404 - Si l'utilisateur n'est pas enregistré.
     * @throws {ApiError} 404 - Si l'entité parente n'est pas enregistrée.
     * @throws {ApiError} 400 - Si le type d'entité parent n'est pas valide.
     */
    private _validateBasePreconditions;
    /**
     * Valide les préconditions pour les méthodes nécessitant d'être membre.
     * @private
     * @param methodName - Nom de la méthode appelante (pour les messages d'erreur).
     * @param expectedTypes - Types d'entité parent autorisés.
     * @throws {ApiError} 401 - Si l'utilisateur n'est pas connecté.
     * @throws {ApiError} 404 - Si l'utilisateur n'est pas enregistré.
     * @throws {ApiError} 404 - Si l'entité parente n'est pas enregistrée.
     * @throws {ApiError} 401 - Si l'utilisateur connecté n'est pas membre de l'entité parente.
     * @throws {ApiError} 400 - Si le type d'entité parent n'est pas valide.
     */
    private _validateMemberPreconditions;
    /**
     * Valide les préconditions pour les méthodes nécessitant d'être administrateur.
     * @private
     * @param methodName - Nom de la méthode appelante (pour les messages d'erreur).
     * @param expectedTypes - Types d'entité parent autorisés.
     * @throws {ApiError} 401 - Si l'utilisateur n'est pas connecté.
     * @throws {ApiError} 404 - Si l'utilisateur n'est pas enregistré.
     * @throws {ApiError} 404 - Si l'entité parente n'est pas enregistrée.
     * @throws {ApiError} 401 - Si l'utilisateur connecté n'est pas membre de l'entité parente.
     * @throws {ApiError} 401 - Si l'utilisateur connecté n'est pas administrateur de l'entité parente.
     * @throws {ApiError} 400 - Si le type d'entité parent n'est pas valide.
     */
    private _validateAdminPreconditions;
    /**
     * Récupère le lien parent pour l'utilisateur actuel.
     *
     * @returns Le lien parent de l'utilisateur ou `null` s'il n'existe pas.
     * @private
     */
    private _getParentLinkForUser;
    /**
     * Valide les préconditions et retourne le lien parent.
     *
     * @param methodName - Nom de la méthode appelante (pour les messages d'erreur).
     * @param expectedTypes - Types d'entité parent autorisés.
     * @param options - Options de validation.
     * @param options.silent - Si `true`, retourne `null` au lieu de lever une exception. Par défaut `true`.
     * @returns - Le lien parent de l'utilisateur, ou `null` si validation échoue.
     * @throws {ApiError} - Si `silent` est `false` et que les préconditions ne sont pas remplies.
     * @private
     */
    private _getValidatedParentLink;
    /**
     * Rafraîchit l'utilisateur et l'entité parente après une action.
     * @private
     */
    private _refreshWithParent;
    /**
     * Vérifie si l'utilisateur est administrateur de l'entité parente.
     *
     * Cette méthode permet de vérifier si un utilisateur possède les droits d'administration
     * sur l'organisation ou le projet parent. Elle est particulièrement utile après avoir
     * récupéré des membres via `getMembers()` pour déterminer leur niveau de permissions.
     *
     * @returns `true` si l'utilisateur est administrateur de l'entité parente, `false` sinon.
     *
     * @throws {ApiError} 401 - Si l'utilisateur n'est pas connecté.
     * @throws {ApiError} 401 - Si l'utilisateur connecté n'est pas administrateur de l'entité parente.
     * @throws {ApiError} 404 - Si l'utilisateur n'est pas enregistré (pas d'ID).
     * @throws {ApiError} 404 - Si l'entité parente n'est pas enregistrée (pas d'ID).
     * @throws {ApiError} 400 - Si l'entité parente n'est pas de type "organizations" ou "projects".
     *
     * @example
     * // Vérifier les admins d'une organisation
     * const org = await me.organization({ slug: "openAtlas" });
     * const members = await org.getMembers();
     *
     * for (const member of members.results) {
     *   if (member.getEntityType() === "citoyens") {
     *     if (member.isAdmin()) {
     *       console.log(`${member.data.name} est administrateur`);
     *     }
     *   }
     * }
     *
     * @example
     * // Récupérer uniquement les membres admins
     * const org = await me.organization({ slug: "myOrg" });
     * const adminMembers = await org.getMembers({}, { isAdmin: true });
     *
     * // Vérifier chaque admin
     * for (const admin of adminMembers.results) {
     *   if (admin.getEntityType() === "citoyens" && admin.isAdmin()) {
     *     console.log(`${admin.data.name} a les droits admin`);
     *   }
     * }
     */
    isAdmin(options?: {
        silent?: boolean;
    }): boolean;
    /**
     * Vérifie si l'utilisateur est membre de l'organisation parente.
     *
     * Cette méthode permet de vérifier si un utilisateur est membre actif d'une organisation.
     * Elle est utile pour déterminer si un utilisateur a accès aux ressources de l'organisation.
     *
     * @returns `true` si l'utilisateur est membre validé de l'organisation parente, `false` sinon.
     *
     * @throws {ApiError} 401 - Si l'utilisateur n'est pas connecté.
     * @throws {ApiError} 401 - Si l'utilisateur connecté n'est pas administrateur de l'entité parente.
     * @throws {ApiError} 404 - Si l'utilisateur n'est pas enregistré (pas d'ID).
     * @throws {ApiError} 404 - Si l'entité parente n'est pas enregistrée (pas d'ID).
     * @throws {ApiError} 400 - Si l'entité parente n'est pas de type "organizations".
     *
     * @example
     * // Vérifier les membres d'une organisation
     * const org = await me.organization({ slug: "myOrg" });
     * const members = await org.getMembers();
     *
     * for (const member of members.results) {
     *   if (member.getEntityType() === "citoyens" && member.isMember()) {
     *     console.log(`${member.data.name} est membre de l'organisation`);
     *   }
     * }
     */
    isMember(options?: {
        silent?: boolean;
    }): boolean;
    /**
     * Vérifie si l'utilisateur est contributeur du projet parent.
     *
     * Cette méthode permet de vérifier si un utilisateur est contributeur actif d'un projet.
     * Elle est utile pour déterminer si un utilisateur peut participer aux activités du projet.
     *
     * @returns `true` si l'utilisateur est contributeur validé du projet parent, `false` sinon.
     *
     * @throws {ApiError} 401 - Si l'utilisateur n'est pas connecté.
     * @throws {ApiError} 401 - Si l'utilisateur connecté n'est pas administrateur de l'entité parente.
     * @throws {ApiError} 404 - Si l'utilisateur n'est pas enregistré (pas d'ID).
     * @throws {ApiError} 404 - Si l'entité parente n'est pas enregistrée (pas d'ID).
     * @throws {ApiError} 400 - Si l'entité parente n'est pas de type "projects".
     *
     * @example
     * // Vérifier les contributeurs d'un projet
     * const project = await me.project({ slug: "myProject" });
     * const contributors = await project.getContributors();
     *
     * for (const contributor of contributors.results) {
     *   if (contributor.getEntityType() === "citoyens" && contributor.isContributor()) {
     *     console.log(`${contributor.data.name} est contributeur du projet`);
     *   }
     * }
     */
    isContributor(options?: {
        silent?: boolean;
    }): boolean;
    /**
     * Vérifie si l'utilisateur est participant de l'événement parent.
     *
     * Cette méthode permet de vérifier si un utilisateur est inscrit comme participant à un événement.
     * Elle est utile pour déterminer si un utilisateur a confirmé sa participation à l'événement.
     *
     * @returns `true` si l'utilisateur est participant validé de l'événement parent, `false` sinon.
     *
     * @throws {ApiError} 401 - Si l'utilisateur n'est pas connecté.
     * @throws {ApiError} 401 - Si l'utilisateur connecté n'est pas administrateur de l'entité parente.
     * @throws {ApiError} 404 - Si l'utilisateur n'est pas enregistré (pas d'ID).
     * @throws {ApiError} 404 - Si l'entité parente n'est pas enregistrée (pas d'ID).
     * @throws {ApiError} 400 - Si l'entité parente n'est pas de type "events".
     *
     * @example
     * // Vérifier les participants d'un événement
     * const event = await me.event({ slug: "myEvent" });
     * const attendees = await event.getAttendees();
     *
     * for (const attendee of attendees.results) {
     *   if (attendee.getEntityType() === "citoyens" && attendee.isAttendee()) {
     *     console.log(`${attendee.data.name} participe à l'événement`);
     *   }
     * }
     */
    isAttendee(options?: {
        silent?: boolean;
    }): boolean;
    /**
     * Vérifie si l'utilisateur a une invitation en attente d'acceptation pour l'entité parente.
     *
     * Cette méthode vérifie si l'utilisateur a été invité à rejoindre l'organisation, le projet
     * ou l'événement parent, mais n'a pas encore accepté l'invitation (`isInviting: true`).
     *
     * @returns {boolean} `true` si l'utilisateur a une invitation en attente, `false` sinon
     * @throws {ApiError} Si l'utilisateur n'est pas connecté, pas admin du parent, ou si le parent n'est pas défini
     *
     * @example
     * ```typescript
     * const org = await me.organization({ slug: "myOrg" });
     * const members = await org.getMembers();
     * const invitedUser = members.results.find(m => m.isInviting());
     * console.log("Invitation en attente:", invitedUser?.data.name);
     * ```
     */
    isInviting(options?: {
        silent?: boolean;
    }): boolean;
    /**
     * Vérifie si l'utilisateur connecté a envoyé une invitation d'ami à cet utilisateur.
     *
     * @param options - Options de vérification.
     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
     * @returns - `true` si une invitation d'ami est en attente, `false` sinon.
     */
    isInvitingFriend(options?: {
        silent?: boolean;
    }): boolean;
    /**
     * Vérifie si l'utilisateur a une invitation en attente avec des droits d'admin.
     *
     * Cette méthode vérifie si l'utilisateur a été invité à rejoindre l'organisation ou le projet
     * parent en tant qu'administrateur, mais n'a pas encore accepté (`isInviting: true` et `isAdmin: true`).
     *
     * @returns {boolean} `true` si l'utilisateur a une invitation admin en attente, `false` sinon
     * @throws {ApiError} Si l'utilisateur n'est pas connecté, pas admin du parent, ou si le parent n'est pas défini
     *
     * @example
     * ```typescript
     * const org = await me.organization({ slug: "myOrg" });
     * const members = await org.getMembers();
     * const invitedAdmin = members.results.find(m => m.isInvitingAdmin());
     * console.log("Invitation admin en attente:", invitedAdmin?.data.name);
     * ```
     */
    isInvitingAdmin(options?: {
        silent?: boolean;
    }): boolean;
    /**
     * Vérifie si l'utilisateur a une demande de promotion admin en attente de validation.
     *
     * Cette méthode vérifie si l'utilisateur a demandé ou a été proposé pour devenir administrateur
     * de l'organisation ou du projet parent, mais la demande n'a pas encore été validée (`isAdminPending: true`).
     *
     * @returns {boolean} `true` si l'utilisateur a une demande admin en attente, `false` sinon
     * @throws {ApiError} Si l'utilisateur n'est pas connecté, pas admin du parent, ou si le parent n'est pas défini
     *
     * @example
     * ```typescript
     * const org = await me.organization({ slug: "myOrg" });
     * const members = await org.getMembers();
     * const pendingAdmin = members.results.find(m => m.isAdminPending());
     * if (pendingAdmin) {
     *   await pendingAdmin.validateAdminRequest();
     * }
     * ```
     */
    isAdminPending(options?: {
        silent?: boolean;
    }): boolean;
    /**
     * Vérifie si l'utilisateur a une demande d'adhésion en attente de validation.
     *
     * Cette méthode vérifie si l'utilisateur a demandé à rejoindre l'organisation, le projet
     * ou l'événement parent, mais la demande n'a pas encore été validée par un administrateur (`toBeValidated: true`).
     *
     * @returns {boolean} `true` si l'utilisateur a une demande en attente, `false` sinon
     * @throws {ApiError} Si l'utilisateur n'est pas connecté, pas admin du parent, ou si le parent n'est pas défini
     *
     * @example
     * ```typescript
     * const org = await me.organization({ slug: "myOrg" });
     * const members = await org.getMembers();
     * const pendingUser = members.results.find(m => m.isToBeValidated());
     * if (pendingUser) {
     *   await pendingUser.validateMemberRequest();
     * }
     * ```
     */
    isToBeValidated(options?: {
        silent?: boolean;
    }): boolean;
    /**
     * Vérifie si cet utilisateur a envoyé une demande d'ami en attente de validation.
     *
     * @param options - Options de vérification.
     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
     * @returns - `true` si une demande d'ami est en attente de validation, `false` sinon.
     */
    isToBeValidatedFriend(options?: {
        silent?: boolean;
    }): boolean;
    /**
     * Envoie une demande pour rejoindre l'entité parente.
     *
     * Cette méthode permet à un admin de créer une demande de connexion pour un utilisateur
     * vers l'organisation ou le projet parent. Si l'utilisateur n'a pas encore de lien,
     * une demande de connexion est créée.
     *
     * @param {Object} [options] - Options de la méthode
     * @param {boolean} [options.admin=false] - Si true, utilise "admin" comme connectType au lieu du type par défaut (connectTypeConnect)
     * @returns {Promise<unknown>} La réponse de l'API après création de la demande
     * @throws {ApiError} Si l'utilisateur n'est pas connecté, pas admin, ou si le parent n'est pas défini
     * @throws {ApiError} Si l'utilisateur est déjà en attente de validation
     * @throws {ApiError} Si l'utilisateur est déjà connecté à l'entité
     *
     * @example
     * ```typescript
     * // Un admin récupère les membres et envoie une invitation (type par défaut)
     * const org = await me.organization({ slug: "myOrg" });
     * const users = await org.getMembers();
     * const user = users.results[0];
     * await user.sendRequestToJoinParent();
     *
     * // Avec le type admin explicite
     * await user.sendRequestToJoinParent({ admin: true });
     * ```
     */
    sendRequestToJoinParent({ admin }?: {
        admin: boolean;
    }): Promise<unknown>;
    /**
     * Valide une demande de membre en attente de validation.
     *
     * Cette méthode permet à un admin de valider une demande d'adhésion d'un utilisateur
     * qui est en attente (`toBeValidated: true`). Après validation, l'utilisateur devient
     * membre actif de l'entité parente.
     *
     * @returns {Promise<unknown>} La réponse de l'API après validation
     * @throws {ApiError} Si l'utilisateur n'est pas connecté, pas admin, ou si le parent n'est pas défini
     * @throws {ApiError} Si l'utilisateur n'a pas de demande en attente
     *
     * @example
     * ```typescript
     * // Un admin valide une demande en attente
     * const org = await me.organization({ slug: "myOrg" });
     * const members = await org.getMembers();
     * const pendingUser = members.results.find(u => u.serverData.links?.memberOf?.[org.id]?.toBeValidated);
     * await pendingUser.validateMemberRequest();
     * ```
     */
    validateMemberRequest(): Promise<unknown>;
    /**
     * Valide une demande d'admin en attente.
     *
     * Cette méthode permet à un admin de valider une demande de promotion au statut d'admin
     * pour un utilisateur qui est en attente (`isAdminPending: true`). Après validation,
     * l'utilisateur devient admin de l'entité parente.
     *
     * @returns {Promise<unknown>} La réponse de l'API après validation
     * @throws {ApiError} Si l'utilisateur n'est pas connecté, pas admin, ou si le parent n'est pas défini
     * @throws {ApiError} Si l'utilisateur n'a pas de demande d'admin en attente
     *
     * @example
     * ```typescript
     * // Un admin valide une demande de promotion à admin
     * const org = await me.organization({ slug: "myOrg" });
     * const members = await org.getMembers();
     * const pendingAdmin = members.results.find(u => u.serverData.links?.memberOf?.[org.id]?.isAdminPending);
     * await pendingAdmin.validateAdminRequest();
     * ```
     */
    validateAdminRequest(): Promise<unknown>;
    /**
     * Retire un utilisateur de l'entité parente.
     *
     * Cette méthode permet à un admin de déconnecter un membre de l'organisation ou du projet parent.
     * L'utilisateur perd tous ses liens avec l'entité (membre, admin, etc.).
     *
     * @returns {Promise<unknown>} La réponse de l'API après déconnexion
     * @throws {ApiError} Si l'utilisateur n'est pas connecté, pas admin, ou si le parent n'est pas défini
     * @throws {ApiError} Si l'utilisateur n'est pas membre de l'entité
     *
     * @example
     * ```typescript
     * // Un admin retire un membre
     * const org = await me.organization({ slug: "myOrg" });
     * const members = await org.getMembers();
     * const userToRemove = members.results[0];
     * await userToRemove.removeFromParent();
     * ```
     */
    removeFromParent(): Promise<unknown>;
    /**
     * Promeut un utilisateur au statut d'admin de l'entité parente.
     *
     * Cette méthode permet à un admin de promouvoir un membre ordinaire au statut d'admin
     * de l'organisation ou du projet parent.
     *
     * @returns {Promise<unknown>} La réponse de l'API après promotion
     * @throws {ApiError} Si l'utilisateur n'est pas connecté, pas admin, ou si le parent n'est pas défini
     * @throws {ApiError} Si l'utilisateur n'est pas membre de l'entité
     * @throws {ApiError} Si l'utilisateur est déjà admin
     *
     * @example
     * ```typescript
     * // Un admin promeut un membre au statut d'admin
     * const org = await me.organization({ slug: "myOrg" });
     * const members = await org.getMembers();
     * const userToPromote = members.results.find(u => !u.isAdmin());
     * await userToPromote.promoteToAdmin();
     * ```
     */
    promoteToAdmin(): Promise<unknown>;
    /**
     * Rétrograde un admin au statut de membre ordinaire.
     *
     * Cette méthode permet à un admin de rétrograder un autre admin au statut de membre
     * ordinaire de l'organisation ou du projet parent. L'utilisateur perd ses privilèges d'admin
     * mais reste membre de l'entité.
     *
     * @returns {Promise<unknown>} La réponse de l'API après rétrogradation
     * @throws {ApiError} Si l'utilisateur n'est pas connecté, pas admin, ou si le parent n'est pas défini
     * @throws {ApiError} Si l'utilisateur n'est pas admin de l'entité
     *
     * @example
     * ```typescript
     * // Un admin rétrograde un autre admin
     * const org = await me.organization({ slug: "myOrg" });
     * const admins = await org.getMembers({}, { isAdmin: true });
     * const adminToDemote = admins.results.find(u => u.isAdmin());
     * await adminToDemote.demoteFromAdmin();
     * ```
     */
    demoteFromAdmin(): Promise<unknown>;
    /** Gestionnaire de notifications, créé paresseusement et mis en cache. */
    private _notifications?;
    /**
     * Point d'entrée `me.notifications` (composition, PAS une entité BaseEntity).
     * Sûr : endpointApi/apiClient sont initialisés dans le constructeur avant tout accès getter.
     */
    get notifications(): Notifications;
    /**
     * Récupère les notifications (mode liste). STATELESS + plat (`NotificationItemData[]`),
     * idéal comme `queryFn` React Query / prefetch SSR — ne touche PAS le manager réactif
     * (`me.notifications`). `ApiClient._transformData` garantit `notif` = tableau (map -> array
     * + `id` injecté), donc on fait confiance à la normalisation amont.
     * pathParams.id est OBLIGATOIRE : le défaut "@userId" ne matche pas le pattern de l'endpoint.
     */
    fetchNotifications({ indexMin }?: {
        indexMin?: number;
    }): Promise<NotificationItemData[]>;
    /**
     * Compte les notifications NON VUES (badge). STATELESS. refreshTimestamp = maintenant ->
     * le serveur renvoie `countNotif` (total non-vus) + une liste vide.
     */
    fetchNotificationsCount(): Promise<number>;
    /** Marque une notification comme lue (MARK_NOTIFICATION_AS_READ). */
    markNotificationAsRead(id: string): Promise<unknown>;
    /** Marque toutes les notifications comme vues/lues (NOTIFICATION_UPDATE). */
    markAllNotifications(action: "seen" | "read"): Promise<unknown>;
    /** Supprime toutes les notifications de l'utilisateur (REMOVE_ALL_NOTIFICATIONS). */
    removeAllNotifications(): Promise<unknown>;
}
export {};