import { Libp2p } from "@libp2p/interface";
import { எண்ணிக்கை } from "ennikkai";
import { TypedFeed, TypedKeyValue, TypedOrderedKeyValue, TypedSet } from "@constl/bohr-db";
import { JSONSchemaType } from "ajv";
import { HeliaLibp2p } from "helia";
import { TypedEmitter } from "tiny-typed-emitter";
import { Automatisations } from "./automatisation.js";
import { BDs } from "./bds.js";
import { Épingles } from "./epingles.js";
import { Favoris, ÉpingleCompte, ÉpingleFavorisAvecId } from "./favoris.js";
import { Licences } from "./licences.js";
import { MotsClefs } from "./motsClefs.js";
import { Nuées } from "./nu\u00E9es.js";
import { Profil } from "./profil.js";
import { Projets } from "./projets.js";
import { Recherche } from "./recherche/index.js";
import { Réseau } from "./reseau.js";
import { Tableaux } from "./tableaux.js";
import { Variables } from "./variables.js";
import { type OptionsContrôleurConstellation } from "./acc\u00E8s/cntrlConstellation.js";
import { Jsonifiable, RecursivePartial, schémaFonctionOublier, schémaFonctionSuivi, schémaRetourFonctionRechercheParProfondeur, élémentsBd } from "./types.js";
import { rôles } from "./acc\u00E8s/consts.js";
import { type GestionnaireOrbite, Store } from "./orbite.js";
import { Protocoles } from "./protocoles.js";
import type { ServicesLibp2p } from "./sfip/index.js";
import type { ContenuMessageRejoindreCompte } from "./reseau.js";
import type { objRôles } from "./acc\u00E8s/types.js";
import type { SetDatabaseType } from "@orbitdb/set-db";
import type { OrderedKeyValueDatabaseType } from "@orbitdb/ordered-keyvalue-db";
import type { FeedDatabaseType } from "@orbitdb/feed-db";
import type { createOrbitDB, OrbitDB, KeyValueDatabase, OpenDatabaseOptions } from "@orbitdb/core";
export declare const CLEF_N_CHANGEMENT_COMPTES = "n changements compte";
type schémaFonctionRéduction<T, U> = (branches: T) => U;
type ÉvénementsClient<T extends ServicesLibp2p = ServicesLibp2p> = {
    comptePrêt: (args: {
        idCompte: string;
    }) => void;
    erreurInitialisation: (args: Error) => void;
    sfipEtOrbitePrêts: (args: {
        sfip: HeliaLibp2p<Libp2p<T>>;
        orbite: GestionnaireOrbite;
    }) => void;
};
export type infoAccès = {
    idCompte: string;
    rôle: keyof objRôles;
};
export interface Signature {
    signature: string;
    clefPublique: string;
}
export interface optsConstellation<T extends ServicesLibp2p = ServicesLibp2p> {
    dossier?: string;
    domaines?: string[];
    pairsParDéfaut?: string[];
    sujetRéseau?: string;
    protocoles?: string[];
    orbite?: optsOrbite<T>;
    messageVerrou?: string;
}
export type optsInitOrbite<T extends ServicesLibp2p = ServicesLibp2p> = Omit<Parameters<typeof createOrbitDB>[0], "ipfs" | "directory"> & {
    directory?: string;
    ipfs?: HeliaLibp2p<Libp2p<T>>;
};
export type optsOrbite<T extends ServicesLibp2p = ServicesLibp2p> = OrbitDB<T> | optsInitOrbite<T>;
export type structureBdCompte = {
    protocoles?: string;
    nomsDispositifs?: string;
    profil?: string;
    motsClefs?: string;
    variables?: string;
    bds?: string;
    projets?: string;
    nuées?: string;
    favoris?: string;
    réseau?: string;
    automatisations?: string;
};
export declare const schémaStructureBdCompte: JSONSchemaType<structureBdCompte>;
export type structureNomsDispositifs = {
    [idDispositif: string]: {
        nom?: string;
        type?: string;
    };
};
export declare const schémaStructureNomsDispositifs: JSONSchemaType<structureNomsDispositifs>;
export declare class Constellation<T extends ServicesLibp2p = ServicesLibp2p> {
    _opts: optsConstellation<T>;
    événements: TypedEmitter<ÉvénementsClient<T>>;
    orbite?: GestionnaireOrbite;
    sfip?: HeliaLibp2p<Libp2p<T>>;
    épingles: Épingles;
    profil: Profil;
    bds: BDs;
    tableaux: Tableaux;
    variables: Variables;
    réseau: Réseau;
    favoris: Favoris;
    projets: Projets;
    recherche: Recherche;
    motsClefs: MotsClefs;
    automatisations: Automatisations;
    nuées: Nuées;
    licences: Licences;
    protocoles: Protocoles;
    erreurInitialisation?: Error;
    _orbiteExterne: boolean;
    _sfipExterne: boolean;
    idCompte?: string;
    sujet_réseau: string;
    motsDePasseRejoindreCompte: {
        [key: string]: number;
    };
    ennikkai: எண்ணிக்கை;
    _intervaleVerrou?: NodeJS.Timeout;
    signaleurArrêt: AbortController;
    constructor(opts?: optsConstellation<T>);
    dossier(): Promise<string>;
    _initialiser(): Promise<void>;
    _initialiserComposantes(): Promise<void>;
    _fermerComposantes(): Promise<void>;
    _créerBdCompte({ orbite }: {
        orbite: OrbitDB<T>;
    }): Promise<string>;
    épinglerCompte({ idCompte, options, }: {
        idCompte: string;
        options?: RecursivePartial<ÉpingleCompte>;
    }): Promise<void>;
    suivreÉpingleCompte({ idCompte, f, idCompteQuiÉpingle, }: {
        idCompte: string;
        f: schémaFonctionSuivi<ÉpingleCompte | undefined>;
        idCompteQuiÉpingle?: string;
    }): Promise<schémaFonctionOublier>;
    détecterTypeDispositif(): string | undefined;
    attendreSfipEtOrbite(): Promise<{
        orbite: GestionnaireOrbite;
        sfip: HeliaLibp2p<Libp2p<T>>;
    }>;
    attendreInitialisée(): Promise<{
        idCompte: string;
    }>;
    verrouillerDossier({ message }: {
        message?: string;
    }): Promise<void>;
    spécifierMessageVerrou({ message, }: {
        message: Jsonifiable;
    }): Promise<void>;
    effacerVerrou(): Promise<void>;
    _générerSFIPetOrbite(): Promise<{
        sfip: HeliaLibp2p<Libp2p<T>>;
        orbite: OrbitDB<T>;
    }>;
    obtOptionsAccès(): Promise<OptionsContrôleurConstellation>;
    suivreRésolutionÉpingle({ épingle, f, ignorer, }: {
        épingle: ÉpingleFavorisAvecId<ÉpingleCompte>;
        f: schémaFonctionSuivi<Set<string>>;
        ignorer?: Set<string>;
    }): Promise<() => Promise<void>>;
    ouvrirBd<T extends KeyValueDatabase>({ id, type, signal, options, }: {
        id: string;
        type: "keyvalue";
        signal?: AbortSignal;
        options?: Omit<OpenDatabaseOptions, "type">;
    }): Promise<{
        bd: T;
        fOublier: schémaFonctionOublier;
    }>;
    ouvrirBd<T extends FeedDatabaseType>({ id, type, signal, options, }: {
        id: string;
        type: "feed";
        signal?: AbortSignal;
        options?: Omit<OpenDatabaseOptions, "type">;
    }): Promise<{
        bd: T;
        fOublier: schémaFonctionOublier;
    }>;
    ouvrirBd<T extends SetDatabaseType>({ id, type, signal, options, }: {
        id: string;
        type: "set";
        signal?: AbortSignal;
        options?: Omit<OpenDatabaseOptions, "type">;
    }): Promise<{
        bd: T;
        fOublier: schémaFonctionOublier;
    }>;
    ouvrirBd<T extends OrderedKeyValueDatabaseType>({ id, type, signal, options, }: {
        id: string;
        type: "ordered-keyvalue";
        signal?: AbortSignal;
        options?: Omit<OpenDatabaseOptions, "type">;
    }): Promise<{
        bd: T;
        fOublier: schémaFonctionOublier;
    }>;
    ouvrirBd<T extends Store>({ id, signal, }: {
        id: string;
        signal?: AbortSignal;
        options?: Omit<OpenDatabaseOptions, "type">;
    }): Promise<{
        bd: T;
        fOublier: schémaFonctionOublier;
    }>;
    ouvrirBd<T extends Store>({ id, type, signal, options, }: {
        id: string;
        type?: "keyvalue" | "feed" | "set" | "ordered-keyvalue";
        signal?: AbortSignal;
        options?: Omit<OpenDatabaseOptions, "type">;
    }): Promise<{
        bd: T;
        fOublier: schémaFonctionOublier;
    }>;
    ouvrirBdTypée<U extends {
        [clef: string]: élémentsBd;
    }, T = TypedKeyValue<U>>({ id, type, schéma, signal, options, }: {
        id: string;
        type: "keyvalue";
        schéma: JSONSchemaType<U>;
        signal?: AbortSignal;
        options?: Omit<OpenDatabaseOptions, "type">;
    }): Promise<{
        bd: T;
        fOublier: schémaFonctionOublier;
    }>;
    ouvrirBdTypée<U extends élémentsBd, T = TypedFeed<U>>({ id, type, schéma, signal, options, }: {
        id: string;
        type: "feed";
        schéma: JSONSchemaType<U>;
        signal?: AbortSignal;
        options?: Omit<OpenDatabaseOptions, "type">;
    }): Promise<{
        bd: T;
        fOublier: schémaFonctionOublier;
    }>;
    ouvrirBdTypée<U extends élémentsBd, T = TypedSet<U>>({ id, type, schéma, signal, options, }: {
        id: string;
        type: "set";
        schéma: JSONSchemaType<U>;
        signal?: AbortSignal;
        options?: Omit<OpenDatabaseOptions, "type">;
    }): Promise<{
        bd: T;
        fOublier: schémaFonctionOublier;
    }>;
    ouvrirBdTypée<U extends {
        [clef: string]: élémentsBd;
    }, T = TypedOrderedKeyValue<U>>({ id, type, schéma, signal, options, }: {
        id: string;
        type: "ordered-keyvalue";
        schéma: JSONSchemaType<U>;
        signal?: AbortSignal;
        options?: Omit<OpenDatabaseOptions, "type">;
    }): Promise<{
        bd: T;
        fOublier: schémaFonctionOublier;
    }>;
    signer({ message }: {
        message: string;
    }): Promise<Signature>;
    vérifierSignature({ signature, message, }: {
        signature: Signature;
        message: string;
    }): Promise<boolean>;
    suivreDispositifs({ f, idCompte, }: {
        f: schémaFonctionSuivi<string[]>;
        idCompte?: string;
    }): Promise<schémaFonctionOublier>;
    nommerDispositif({ idDispositif, nom, type, }: {
        idDispositif?: string;
        nom?: string;
        type?: string;
    }): Promise<void>;
    suivreNomsDispositifs({ idCompte, f, }: {
        idCompte?: string;
        f: schémaFonctionSuivi<structureNomsDispositifs>;
    }): Promise<schémaFonctionOublier>;
    suivreNomDispositif({ idCompte, idDispositif, f, }: {
        idDispositif: string;
        idCompte?: string;
        f: schémaFonctionSuivi<{
            type?: string;
            nom?: string;
        }>;
    }): Promise<schémaFonctionOublier>;
    générerInvitationRejoindreCompte(): Promise<{
        idCompte: string;
        codeSecret: string;
    }>;
    révoquerInvitationRejoindreCompte({ codeSecret, }: {
        codeSecret?: string;
    }): Promise<void>;
    considérerRequêteRejoindreCompte({ requête, }: {
        requête: ContenuMessageRejoindreCompte;
    }): Promise<void>;
    empreinteInvitation({ idDispositif, codeSecret, }: {
        idDispositif: string;
        codeSecret: string;
    }): string;
    demanderEtPuisRejoindreCompte({ idCompte, codeSecret, }: {
        idCompte: string;
        codeSecret: string;
    }): Promise<void>;
    ajouterDispositif({ idDispositif, }: {
        idDispositif: string;
    }): Promise<void>;
    enleverDispositif({ idDispositif, }: {
        idDispositif: string;
    }): Promise<void>;
    rejoindreCompte({ idCompte }: {
        idCompte: string;
    }): Promise<void>;
    donnerAccès({ idBd, identité, rôle, }: {
        idBd: string;
        identité: string;
        rôle: keyof objRôles;
    }): Promise<void>;
    suivreIdCompte({ f, }: {
        f: schémaFonctionSuivi<string>;
    }): Promise<schémaFonctionOublier>;
    obtIdLibp2p(): Promise<string>;
    obtIdDispositif(): Promise<string>;
    obtIdentitéOrbite(): Promise<OrbitDB["identity"]>;
    obtIdCompte(): Promise<string>;
    copierContenuBdDic<T extends {
        [clef: string]: élémentsBd;
    } & Record<C, string>, C extends string, U extends {
        [clef: string]: élémentsBd;
    }>({ bdBase, nouvelleBd, clef, schéma, ordonnée, }: {
        bdBase: TypedKeyValue<T>;
        nouvelleBd: TypedKeyValue<T>;
        clef: C;
        schéma: JSONSchemaType<U>;
        ordonnée?: boolean;
    }): Promise<void>;
    suivreBd<U extends {
        [clef: string]: élémentsBd;
    }, T extends TypedKeyValue<U> = TypedKeyValue<U>>({ id, f, type, schéma, }: {
        id: string;
        f: schémaFonctionSuivi<T>;
        type: "keyvalue";
        schéma?: JSONSchemaType<U>;
    }): schémaFonctionOublier;
    suivreBd<U extends élémentsBd = élémentsBd, T = TypedSet<U>>({ id, f, type, schéma, }: {
        id: string;
        f: schémaFonctionSuivi<T>;
        type: "set";
        schéma?: JSONSchemaType<U>;
    }): schémaFonctionOublier;
    suivreBd<U extends {
        [clef: string]: élémentsBd;
    }, T = TypedOrderedKeyValue<U>>({ id, f, type, schéma, }: {
        id: string;
        f: schémaFonctionSuivi<T>;
        type: "ordered-keyvalue";
        schéma?: JSONSchemaType<U>;
    }): schémaFonctionOublier;
    suivreBd({ id, f, }: {
        id: string;
        f: schémaFonctionSuivi<Store>;
    }): schémaFonctionOublier;
    suivreBdDeClef<T>({ id, clef, f, fSuivre, }: {
        id: string;
        clef: string;
        f: schémaFonctionSuivi<T | undefined>;
        fSuivre: (args: {
            id: string;
            fSuivreBd: schémaFonctionSuivi<T>;
        }) => Promise<schémaFonctionOublier>;
    }): Promise<schémaFonctionOublier>;
    suivreBdDic<T extends {
        [clef: string]: élémentsBd;
    }>({ id, schéma, f, }: {
        id: string;
        schéma?: JSONSchemaType<T>;
        f: schémaFonctionSuivi<T>;
    }): Promise<schémaFonctionOublier>;
    suivreBdDicOrdonnée<T extends {
        [clef: string]: élémentsBd;
    }>({ id, schéma, f, }: {
        id: string;
        schéma?: JSONSchemaType<T>;
        f: schémaFonctionSuivi<{
            key: Extract<keyof T, "string">;
            value: T[keyof T];
            hash: string;
        }[]>;
    }): Promise<schémaFonctionOublier>;
    suivreBdDicDeClef<T extends {
        [key: string]: élémentsBd;
    }>({ id, clef, schéma, f, }: {
        id: string;
        clef: string;
        schéma: JSONSchemaType<T>;
        f: schémaFonctionSuivi<T>;
    }): Promise<schémaFonctionOublier>;
    suivreBdDicOrdonnéeDeClef<T extends {
        [clef: string]: élémentsBd;
    }>({ id, clef, schéma, f, }: {
        id: string;
        clef: string;
        schéma: JSONSchemaType<T>;
        f: schémaFonctionSuivi<{
            key: string;
            value: T[keyof T];
        }[]>;
    }): Promise<schémaFonctionOublier>;
    suivreBdListeDeClef<T extends élémentsBd>({ id, clef, f, schéma, renvoyerValeur, }: {
        id: string;
        clef: string;
        f: schémaFonctionSuivi<{
            value: T;
            hash: string;
        }[]>;
        schéma?: JSONSchemaType<T>;
        renvoyerValeur: false;
    }): Promise<schémaFonctionOublier>;
    suivreBdListeDeClef<T extends élémentsBd>({ id, clef, f, schéma, renvoyerValeur, }: {
        id: string;
        clef: string;
        f: schémaFonctionSuivi<T[]>;
        schéma?: JSONSchemaType<T>;
        renvoyerValeur?: true;
    }): Promise<schémaFonctionOublier>;
    suivreBdListeDeClef<T extends élémentsBd>({ id, clef, f, schéma, renvoyerValeur, }: {
        id: string;
        clef: string;
        f: schémaFonctionSuivi<T[] | {
            value: T;
            hash: string;
        }[]>;
        schéma?: JSONSchemaType<T>;
        renvoyerValeur?: true;
    }): Promise<schémaFonctionOublier>;
    suivreBdListe<T extends élémentsBd>({ id, f, schéma, renvoyerValeur, }: {
        id: string;
        f: schémaFonctionSuivi<T[]>;
        schéma?: JSONSchemaType<T>;
        renvoyerValeur?: true;
    }): Promise<schémaFonctionOublier>;
    suivreBdListe<T extends élémentsBd>({ id, f, schéma, renvoyerValeur, }: {
        id: string;
        f: schémaFonctionSuivi<{
            value: T;
            hash: string;
        }[]>;
        schéma?: JSONSchemaType<T>;
        renvoyerValeur: false;
    }): Promise<schémaFonctionOublier>;
    suivreTypeObjet({ idObjet, f, }: {
        idObjet: string;
        f: schémaFonctionSuivi<"motClef" | "variable" | "bd" | "projet" | "nuée" | undefined>;
    }): Promise<schémaFonctionOublier>;
    suivreEmpreinteTêtesBdRécursive({ idBd, f, }: {
        idBd: string;
        f: schémaFonctionSuivi<string>;
    }): Promise<schémaFonctionOublier>;
    suivreBdsDeBdListe<T extends élémentsBd, U, V>({ id, f, fBranche, fIdDeBranche, fRéduction, }: {
        id: string;
        f: schémaFonctionSuivi<V[]>;
        fBranche: (args: {
            id: string;
            fSuivreBranche: schémaFonctionSuivi<U>;
            branche: T;
        }) => Promise<schémaFonctionOublier | undefined>;
        fIdDeBranche?: (b: T) => string;
        fRéduction?: schémaFonctionRéduction<U[], V[]>;
    }): Promise<schémaFonctionOublier>;
    suivreBdsDeBdDic<T extends élémentsBd, U, V>({ id, f, fBranche, fIdDeBranche, fRéduction, }: {
        id: string;
        f: schémaFonctionSuivi<V[]>;
        fBranche: (args: {
            id: string;
            fSuivreBranche: schémaFonctionSuivi<U>;
            branche: T;
        }) => Promise<schémaFonctionOublier | undefined>;
        fIdDeBranche?: (b: T) => string;
        fRéduction?: schémaFonctionRéduction<U[], V[]>;
    }): Promise<schémaFonctionOublier>;
    suivreBdsDeFonctionRecherche<T extends élémentsBd, U, V>({ fListe, f, fBranche, fIdDeBranche, fRéduction, }: {
        fListe: (fSuivreRacine: (éléments: T[]) => Promise<void>) => Promise<schémaRetourFonctionRechercheParProfondeur>;
        f: schémaFonctionSuivi<V[]>;
        fBranche: ({ id, fSuivreBranche, branche, }: {
            id: string;
            fSuivreBranche: schémaFonctionSuivi<U>;
            branche: T;
        }) => Promise<schémaFonctionOublier | undefined>;
        fIdDeBranche?: (b: T) => string;
        fRéduction?: schémaFonctionRéduction<U[], V[]>;
    }): Promise<schémaRetourFonctionRechercheParProfondeur>;
    suivreBdSelonCondition({ fRacine, fCondition, f, }: {
        fRacine: (fSuivreRacine: (id: string) => Promise<void>) => Promise<schémaFonctionOublier>;
        fCondition: (id: string, fSuivreCondition: schémaFonctionSuivi<boolean>) => Promise<schémaFonctionOublier>;
        f: schémaFonctionSuivi<string>;
    }): Promise<schémaFonctionOublier>;
    suivreBdsSelonCondition<T extends schémaFonctionOublier | ({
        fOublier: schémaFonctionOublier;
    } & {
        [key: string]: unknown;
    })>({ fListe, fCondition, f, }: {
        fListe: ({ fSuivreRacine, }: {
            fSuivreRacine: (ids: string[]) => Promise<void>;
        }) => Promise<T>;
        fCondition: (id: string, fSuivreCondition: schémaFonctionSuivi<boolean>) => Promise<schémaFonctionOublier>;
        f: schémaFonctionSuivi<string[]>;
    }): Promise<T>;
    obtFichierSFIP({ id, max, }: {
        id: string;
        max?: number;
    }): Promise<Uint8Array | null>;
    obtItérableAsyncSFIP({ id, }: {
        id: string;
    }): Promise<AsyncIterable<Uint8Array>>;
    ajouterÀSFIP({ contenu, nomFichier, }: {
        contenu: Uint8Array;
        nomFichier: string;
    }): Promise<string>;
    obtClefStockageClient({ clef, parCompte, }: {
        clef: string;
        parCompte?: boolean;
    }): Promise<string>;
    obtDeStockageLocal({ clef, parCompte, }: {
        clef: string;
        parCompte?: boolean;
    }): Promise<string | null>;
    sauvegarderAuStockageLocal({ clef, val, parCompte, }: {
        clef: string;
        val: string;
        parCompte?: boolean;
    }): Promise<void>;
    effacerDeStockageLocal({ clef, parCompte, }: {
        clef: string;
        parCompte: boolean;
    }): Promise<void>;
    obtIdBd<K extends string>({ nom, racine, type, }: {
        nom: K;
        racine: string;
        type?: "feed" | "keyvalue" | "ordered-keyvalue" | "set";
    }): Promise<string>;
    créerBdIndépendante({ type, optionsAccès, nom, }: {
        type: "feed" | "set" | "keyvalue" | "ordered-keyvalue";
        optionsAccès?: OptionsContrôleurConstellation;
        nom?: string;
    }): Promise<string>;
    effacerBd({ id }: {
        id: string;
    }): Promise<void>;
    obtOpsAccès({ idBd, }: {
        idBd: string;
    }): Promise<OptionsContrôleurConstellation>;
    suivrePermission({ idObjet, f, }: {
        idObjet: string;
        f: schémaFonctionSuivi<(typeof rôles)[number] | undefined>;
    }): Promise<schémaFonctionOublier>;
    suivrePermissionÉcrire({ id, f, }: {
        id: string;
        f: schémaFonctionSuivi<boolean>;
    }): Promise<schémaFonctionOublier>;
    permission({ idObjet, }: {
        idObjet: string;
    }): Promise<(typeof rôles)[number] | undefined>;
    suivreAccèsBd({ id, f, }: {
        id: string;
        f: schémaFonctionSuivi<infoAccès[]>;
    }): Promise<schémaFonctionOublier>;
    suivreBdsRécursives({ idBd, f, }: {
        idBd: string;
        f: schémaFonctionSuivi<string[]>;
    }): Promise<schémaFonctionOublier>;
    fermer(): Promise<void>;
    effacerDispositif(): Promise<void>;
    exporterDispositif({ nomFichier, }: {
        nomFichier: string;
    }): Promise<void>;
    rétablirDispositif(): Promise<void>;
    static créer<T extends ServicesLibp2p = ServicesLibp2p>(opts?: optsConstellation<T>): Promise<Constellation<T>>;
}
export {};