import { Semaphore } from "@chriscdn/promise-semaphore";
import { TypedEmitter } from "tiny-typed-emitter";
import { Constellation, Signature } from "./client.js";
import { ComposanteClientDic } from "./composanteClient.js";
import type { Pushable } from "it-pushable";
import type { ÉpingleFavorisAvecId } from "./favoris.js";
import type { élémentBdListeDonnées, élémentDonnées } from "./tableaux.js";
import type { infoAuteur, infoRésultat, résultatObjectifRecherche, résultatRecherche, schémaFonctionOublier, schémaFonctionSuivi, schémaFonctionSuivreConfianceRecherche, schémaFonctionSuivreObjectifRecherche, schémaFonctionSuivreQualitéRecherche, schémaRetourFonctionRechercheParN, schémaRetourFonctionRechercheParProfondeur } from "./types.js";
import type { erreurValidation } from "./valid.js";
type clefObjet = "bds" | "variables" | "motsClefs" | "projets" | "nuées";
export type infoDispositif = {
    idLibp2p: string;
    idDispositif: string;
    idCompte: string;
    clefPublique: string;
    signatures: {
        id: string;
        publicKey: string;
    };
    nChangementsCompte: number;
};
export type statutDispositif = {
    infoDispositif: infoDispositif;
    vuÀ?: number;
};
export type élémentBdMembres = {
    idCompte: string;
    dispositifs: string[];
};
export type itemRechercheProfondeur = {
    profondeur: number;
} & {
    [key: string]: unknown;
};
export type infoMembreRéseau = {
    idCompte: string;
    profondeur: number;
    confiance: number;
};
export type infoRelation = {
    de: string;
    pour: string;
    confiance: number;
    profondeur: number;
};
export interface infoConfiance {
    idCompte: string;
    confiance: number;
}
export interface infoBloqué {
    idCompte: string;
    privé: boolean;
}
export interface infoMembre {
    idCompte: string;
    protocoles: string[];
    dispositifs: infoDispositif[];
}
export interface statutMembre {
    infoMembre: infoMembre;
    vuÀ?: number;
}
export interface infoRéplications {
    membres: statutMembre[];
    dispositifs: {
        épingle: ÉpingleFavorisAvecId;
        dispositif: {
            idDispositif: string;
            vuÀ?: number;
        };
    }[];
}
export interface résultatRechercheSansScore<T extends infoRésultat> {
    id: string;
    objectif: résultatObjectifRecherche<T>;
    confiance: number;
    qualité: number;
}
export type élémentDeMembre<T extends élémentBdListeDonnées> = {
    idCompte: string;
    élément: élémentDonnées<T>;
};
export type élémentDeMembreAvecValid<T extends élémentBdListeDonnées> = élémentDeMembre<T> & {
    valid: erreurValidation[];
};
export type bdDeMembre = {
    idCompte: string;
    bd: string;
};
export type MessageDirecte = MessageDirecteRequêteRejoindreCompte | MessageDirecteSalut | MessageDirecteTexte;
export type ContenuMessageSalut = {
    contenu: {
        idLibp2p: string;
        idDispositif: string;
        idCompte: string;
        clefPublique: string;
        signatures: {
            id: string;
            publicKey: string;
        };
        nChangementsCompte: number;
    };
    signature: Signature;
};
export type MessageDirecteRequêteRejoindreCompte = {
    type: "Je veux rejoindre ce compte";
    contenu: ContenuMessageRejoindreCompte;
};
export type MessageDirecteSalut = {
    type: "Salut !";
    contenu: ContenuMessageSalut;
};
export type ContenuMessageRejoindreCompte = {
    idDispositif: string;
    empreinteVérification: string;
};
export type MessageDirecteTexte = {
    type: "texte";
    contenu: {
        message: string;
    };
};
export type statutConfianceMembre = "FIABLE" | "BLOQUÉ" | "NEUTRE";
type structureBdPrincipaleRéseau = {
    [idCompte: string]: statutConfianceMembre;
};
type ÉvénementsRéseau = {
    changementConnexions: () => void;
    messageDirecte: (args: {
        de: string;
        message: MessageDirecte;
    }) => void;
    changementMembresBloqués: () => void;
    membreVu: () => void;
};
export declare class Réseau extends ComposanteClientDic<structureBdPrincipaleRéseau> {
    client: Constellation;
    bloquésPrivés: Set<string>;
    verrouFlux: Semaphore;
    dispositifsEnLigne: {
        [key: string]: statutDispositif;
    };
    connexionsDirectes: {
        [key: string]: Pushable<Uint8Array>;
    };
    fsOublier: schémaFonctionOublier[];
    événements: TypedEmitter<ÉvénementsRéseau>;
    constructor({ client }: {
        client: Constellation;
    });
    initialiser(): Promise<void>;
    obtFluxDispositif({ idDispositif, signal, }: {
        idDispositif: string;
        signal?: AbortSignal;
    }): Promise<Pushable<Uint8Array>>;
    obtFluxPair({ idPair, signal, }: {
        idPair: string;
        signal?: AbortSignal;
    }): Promise<Pushable<Uint8Array>>;
    envoyerMessageGossipsub({ message, sujet, }: {
        message: unknown;
        sujet?: string;
    }): Promise<string[]>;
    suivreMessagesGossipsub({ sujet, f, }: {
        sujet: string;
        f: schémaFonctionSuivi<string>;
    }): Promise<schémaFonctionOublier>;
    suivreMesAdresses({ f, }: {
        f: schémaFonctionSuivi<string[]>;
    }): Promise<schémaFonctionOublier>;
    connecterÀAdresse({ adresse }: {
        adresse: string;
    }): Promise<void>;
    envoyerMessageAuDispositif({ msg, idDispositif, signal, }: {
        msg: MessageDirecte;
        idDispositif: string;
        signal?: AbortSignal;
    }): Promise<void>;
    envoyerMessageAuPair({ msg, idPair, signal, }: {
        msg: MessageDirecte;
        idPair: string;
        signal?: AbortSignal;
    }): Promise<void>;
    envoyerMessageAuMembre({ msg, idCompte, }: {
        msg: MessageDirecte;
        idCompte: string;
    }): Promise<void>;
    suivreMessagesDirectes({ f, type, de, }: {
        f: schémaFonctionSuivi<MessageDirecte>;
        type?: MessageDirecte["type"] | MessageDirecte["type"][];
        de?: string;
    }): Promise<schémaFonctionOublier>;
    direSalut({ idPair }: {
        idPair: string;
    }): Promise<void>;
    envoyerDemandeRejoindreCompte({ codeSecret, }: {
        codeSecret: string;
    }): Promise<void>;
    recevoirSalut({ message, }: {
        message: ContenuMessageSalut;
    }): Promise<void>;
    _nettoyerDispositifsEnLigne(): void;
    _sauvegarderDispositifsEnLigne(): Promise<void>;
    _validerInfoMembre({ info, }: {
        info: infoDispositif;
    }): Promise<boolean>;
    faireConfianceAuMembre({ idCompte, }: {
        idCompte: string;
    }): Promise<void>;
    nePlusFaireConfianceAuMembre({ idCompte, }: {
        idCompte: string;
    }): Promise<void>;
    suivreFiables({ f, idCompte, }: {
        f: schémaFonctionSuivi<string[]>;
        idCompte?: string;
    }): Promise<schémaFonctionOublier>;
    _initaliserBloquésPrivés(): Promise<void>;
    _sauvegarderBloquésPrivés(): Promise<void>;
    bloquerMembre({ idCompte, privé, }: {
        idCompte: string;
        privé?: boolean;
    }): Promise<void>;
    débloquerMembre({ idCompte }: {
        idCompte: string;
    }): Promise<void>;
    suivreBloquésPubliques({ f, idCompte, }: {
        f: schémaFonctionSuivi<string[]>;
        idCompte?: string;
    }): Promise<schémaFonctionOublier>;
    suivreBloqués({ f, idCompte, }: {
        f: schémaFonctionSuivi<infoBloqué[]>;
        idCompte?: string;
    }): Promise<schémaFonctionOublier>;
    suivreRelationsImmédiates({ f, idCompte, }: {
        f: schémaFonctionSuivi<infoConfiance[]>;
        idCompte?: string;
    }): Promise<schémaFonctionOublier>;
    suivreRelationsConfiance({ f, profondeur, idCompteDébut, }: {
        f: schémaFonctionSuivi<infoRelation[]>;
        profondeur?: number;
        idCompteDébut?: string;
    }): Promise<schémaRetourFonctionRechercheParProfondeur>;
    suivreComptesRéseau({ f, profondeur, idCompteDébut, }: {
        f: schémaFonctionSuivi<infoMembreRéseau[]>;
        profondeur?: number;
        idCompteDébut?: string;
    }): Promise<schémaRetourFonctionRechercheParProfondeur>;
    suivreComptesRéseauEtEnLigne({ f, profondeur, idCompteDébut, }: {
        f: schémaFonctionSuivi<infoMembreRéseau[]>;
        profondeur?: number;
        idCompteDébut?: string;
    }): Promise<schémaRetourFonctionRechercheParProfondeur>;
    suivreConfianceMonRéseauPourMembre({ idCompte, f, profondeur, idCompteRéférence, }: {
        idCompte: string;
        f: schémaFonctionSuivi<number>;
        profondeur: number;
        idCompteRéférence?: string;
    }): Promise<schémaRetourFonctionRechercheParProfondeur>;
    suivreConnexionsPostesSFIP({ f, }: {
        f: schémaFonctionSuivi<{
            pair: string;
            adresses: string[];
        }[]>;
    }): Promise<schémaFonctionOublier>;
    suivreConnexionsDispositifs({ f, }: {
        f: schémaFonctionSuivi<statutDispositif[]>;
    }): Promise<schémaFonctionOublier>;
    suivreConnexionsMembres({ f, }: {
        f: schémaFonctionSuivi<statutMembre[]>;
    }): Promise<schémaFonctionOublier>;
    suivreProtocolesMembre({ f, idCompte, }: {
        f: schémaFonctionSuivi<{
            [key: string]: string[];
        }>;
        idCompte?: string;
    }): Promise<schémaFonctionOublier>;
    suivreProtocolesDispositif({ idDispositif, f, }: {
        idDispositif?: string;
        f: schémaFonctionSuivi<string[]>;
    }): Promise<schémaFonctionOublier>;
    rechercher<T extends infoRésultat>({ f, nRésultatsDésirés, fRecherche, fConfiance, fQualité, fObjectif, fScore, }: {
        f: schémaFonctionSuivi<résultatRecherche<T>[]>;
        fRecherche: (args: {
            idCompte: string;
            fSuivi: (x: string[] | undefined) => Promise<void>;
        }) => Promise<schémaFonctionOublier>;
        fConfiance: schémaFonctionSuivreConfianceRecherche;
        nRésultatsDésirés?: number;
        fQualité: schémaFonctionSuivreQualitéRecherche;
        fObjectif?: schémaFonctionSuivreObjectifRecherche<T>;
        fScore?: (r: résultatRechercheSansScore<T>) => number;
    }): Promise<schémaRetourFonctionRechercheParN>;
    rechercherMembres<T extends infoRésultat>({ f, nRésultatsDésirés, fObjectif, }: {
        f: schémaFonctionSuivi<résultatRecherche<T>[]>;
        nRésultatsDésirés?: number;
        fObjectif?: schémaFonctionSuivreObjectifRecherche<T>;
    }): Promise<schémaRetourFonctionRechercheParN>;
    suivreConfianceAuteurs({ idItem, clef, f, }: {
        idItem: string;
        clef: clefObjet;
        f: schémaFonctionSuivi<number>;
    }): Promise<schémaFonctionOublier>;
    rechercherObjets<T extends infoRésultat>({ f, clef, nRésultatsDésirés, fRecherche, fRechercheLesMiens, fQualité, fObjectif, toutLeRéseau, }: {
        f: schémaFonctionSuivi<résultatRecherche<T>[]>;
        clef: clefObjet;
        nRésultatsDésirés?: number;
        fRecherche: (args: {
            idCompte: string;
            f: (objets: string[] | undefined) => void;
        }) => Promise<schémaFonctionOublier>;
        fRechercheLesMiens: (fSuivreRacine: (objets: string[]) => Promise<void>) => Promise<schémaFonctionOublier>;
        fQualité: schémaFonctionSuivreQualitéRecherche;
        fObjectif?: schémaFonctionSuivreObjectifRecherche<T>;
        toutLeRéseau?: boolean;
    }): Promise<schémaRetourFonctionRechercheParN>;
    rechercherNuées<T extends infoRésultat>({ f, nRésultatsDésirés, fObjectif, toutLeRéseau, }: {
        f: schémaFonctionSuivi<résultatRecherche<T>[]>;
        nRésultatsDésirés?: number;
        fObjectif?: schémaFonctionSuivreObjectifRecherche<T>;
        toutLeRéseau?: boolean;
    }): Promise<schémaRetourFonctionRechercheParN>;
    rechercherBds<T extends infoRésultat>({ f, nRésultatsDésirés, fObjectif, toutLeRéseau, }: {
        f: schémaFonctionSuivi<résultatRecherche<T>[]>;
        nRésultatsDésirés?: number;
        fObjectif?: schémaFonctionSuivreObjectifRecherche<T>;
        toutLeRéseau?: boolean;
    }): Promise<schémaRetourFonctionRechercheParN>;
    rechercherVariables<T extends infoRésultat>({ f, nRésultatsDésirés, fObjectif, toutLeRéseau, }: {
        f: schémaFonctionSuivi<résultatRecherche<T>[]>;
        nRésultatsDésirés?: number;
        fObjectif?: schémaFonctionSuivreObjectifRecherche<T>;
        toutLeRéseau?: boolean;
    }): Promise<schémaRetourFonctionRechercheParN>;
    rechercherMotsClefs<T extends infoRésultat>({ f, nRésultatsDésirés, fObjectif, toutLeRéseau, }: {
        f: schémaFonctionSuivi<résultatRecherche<T>[]>;
        nRésultatsDésirés?: number;
        fObjectif?: schémaFonctionSuivreObjectifRecherche<T>;
        toutLeRéseau?: boolean;
    }): Promise<schémaRetourFonctionRechercheParN>;
    rechercherProjets<T extends infoRésultat>({ f, nRésultatsDésirés, fObjectif, toutLeRéseau, }: {
        f: schémaFonctionSuivi<résultatRecherche<T>[]>;
        nRésultatsDésirés?: number;
        fObjectif?: schémaFonctionSuivreObjectifRecherche<T>;
        toutLeRéseau?: boolean;
    }): Promise<schémaRetourFonctionRechercheParN>;
    suivreAuteursObjet({ idObjet, clef, f, }: {
        idObjet: string;
        clef: clefObjet;
        f: schémaFonctionSuivi<infoAuteur[]>;
    }): Promise<schémaFonctionOublier>;
    suivreAuteursMotClef({ idMotClef, f, }: {
        idMotClef: string;
        f: schémaFonctionSuivi<infoAuteur[]>;
    }): Promise<schémaFonctionOublier>;
    suivreAuteursVariable({ idVariable, f, }: {
        idVariable: string;
        f: schémaFonctionSuivi<infoAuteur[]>;
    }): Promise<schémaFonctionOublier>;
    suivreAuteursBd({ idBd, f, }: {
        idBd: string;
        f: schémaFonctionSuivi<infoAuteur[]>;
    }): Promise<schémaFonctionOublier>;
    suivreAuteursProjet({ idProjet, f, }: {
        idProjet: string;
        f: schémaFonctionSuivi<infoAuteur[]>;
    }): Promise<schémaFonctionOublier>;
    suivreAuteursNuée({ idNuée, f, }: {
        idNuée: string;
        f: schémaFonctionSuivi<infoAuteur[]>;
    }): Promise<schémaFonctionOublier>;
    suivreObjetsMembre({ idCompte, fListeObjets, fSuivi, }: {
        idCompte: string;
        fListeObjets: (args: {
            fSuivreRacine: (ids: string[]) => Promise<void>;
        }) => Promise<schémaFonctionOublier>;
        fSuivi: schémaFonctionSuivi<string[]>;
    }): Promise<schémaFonctionOublier>;
    suivreBdsMembre({ idCompte, f, }: {
        idCompte: string;
        f: schémaFonctionSuivi<string[]>;
    }): Promise<schémaFonctionOublier>;
    suivreProjetsMembre({ idCompte, f, }: {
        idCompte: string;
        f: schémaFonctionSuivi<string[] | undefined>;
    }): Promise<schémaFonctionOublier>;
    suivreFavorisMembre({ idCompte, f, }: {
        idCompte: string;
        f: schémaFonctionSuivi<ÉpingleFavorisAvecId[]>;
    }): Promise<schémaFonctionOublier>;
    suivreVariablesMembre({ idCompte, f, }: {
        idCompte: string;
        f: schémaFonctionSuivi<string[] | undefined>;
    }): Promise<schémaFonctionOublier>;
    suivreMotsClefsMembre({ idCompte, f, }: {
        idCompte: string;
        f: schémaFonctionSuivi<string[] | undefined>;
    }): Promise<schémaFonctionOublier>;
    suivreNuéesMembre({ idCompte, f, }: {
        idCompte: string;
        f: schémaFonctionSuivi<string[] | undefined>;
    }): Promise<schémaFonctionOublier>;
    suivreFavorisObjet({ idObjet, f, profondeur, }: {
        idObjet: string;
        f: schémaFonctionSuivi<{
            épingle: ÉpingleFavorisAvecId;
            idCompte: string;
        }[]>;
        profondeur: number;
    }): Promise<schémaRetourFonctionRechercheParProfondeur>;
    suivreRéplications({ idObjet, f, profondeur, }: {
        idObjet: string;
        f: schémaFonctionSuivi<infoRéplications>;
        profondeur: number;
    }): Promise<schémaRetourFonctionRechercheParProfondeur>;
    suivreBdsDeNuée({ idNuée, f, nRésultatsDésirés, }: {
        idNuée: string;
        f: schémaFonctionSuivi<string[]>;
        nRésultatsDésirés?: number;
    }): Promise<schémaRetourFonctionRechercheParProfondeur>;
    suivreÉlémentsDeTableauxUniques<T extends élémentBdListeDonnées>({ idNuéeUnique, clef, f, nBds, }: {
        idNuéeUnique: string;
        clef: string;
        f: schémaFonctionSuivi<élémentDeMembre<T>[]>;
        nBds?: number;
    }): Promise<schémaRetourFonctionRechercheParProfondeur>;
    fermer(): Promise<void>;
}
export {};