import { type OrbitDB, KeyValueDatabase, OpenDatabaseOptions } from "@orbitdb/core";
import { type FeedDatabaseType } from "@orbitdb/feed-db";
import { type OrderedKeyValueDatabaseType } from "@orbitdb/ordered-keyvalue-db";
import { type SetDatabaseType } from "@orbitdb/set-db";
import { TypedFeed, TypedKeyValue, TypedOrderedKeyValue, TypedSet } from "@constl/bohr-db";
import { type JSONSchemaType } from "ajv";
import { Semaphore } from "@chriscdn/promise-semaphore";
import { type ServiceMap } from "@libp2p/interface";
import type { schémaFonctionOublier, élémentsBd } from "./types.js";
import type { HeliaLibp2p } from "helia";
import type { Libp2p } from "libp2p";
import type { ServicesLibp2p } from "./sfip/index.js";
export declare const réessayer: <T>({ f, signal, }: {
    f: () => Promise<T>;
    signal: AbortSignal;
}) => Promise<T>;
export type Store = FeedDatabaseType | SetDatabaseType | KeyValueDatabase | OrderedKeyValueDatabaseType;
type KeysMatching<T extends object, V> = {
    [K in keyof T]-?: T[K] extends V ? K : never;
}[keyof T];
export declare const préparerOrbite: () => void;
export declare function initOrbite<T extends ServicesLibp2p = ServicesLibp2p>({ sfip, dossierOrbite, }: {
    sfip: HeliaLibp2p<Libp2p<T>>;
    dossierOrbite: string;
}): Promise<OrbitDB<T>>;
type bdOuverte<T extends Store> = {
    bd: T;
    idsRequêtes: Set<string>;
};
export declare class GestionnaireOrbite<T extends ServiceMap = ServiceMap> {
    orbite: OrbitDB<T>;
    _bdsOrbite: {
        [key: string]: bdOuverte<Store>;
    };
    verrouOuvertureBd: Semaphore;
    _oublierNettoyageBdsOuvertes?: schémaFonctionOublier;
    signaleurArrêt: AbortController;
    constructor({ orbite, signaleurArrêt, }: {
        orbite: OrbitDB<T>;
        signaleurArrêt?: AbortController;
    });
    get identity(): OrbitDB["identity"];
    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;
    }>;
    créerBdIndépendante({ type, options, nom, }: {
        type: "set" | "ordered-keyvalue" | "keyvalue" | "feed";
        options: Omit<OpenDatabaseOptions, "type">;
        nom?: string;
    }): Promise<string>;
    effacerBd({ id }: {
        id: string;
    }): Promise<void>;
    private lancerNettoyageBdsOuvertes;
    appliquerFonctionBdOrbite<T extends KeysMatching<Store, (...args: unknown[]) => unknown>>({ idBd, fonction, args, }: {
        idBd: string;
        fonction: T;
        args: Parameters<Store[T]>;
    }): Promise<ReturnType<Store[T]>>;
    fermer({ arrêterOrbite }: {
        arrêterOrbite: boolean;
    }): Promise<void>;
}
export declare class GestionnaireOrbiteGénéral {
    gestionnaires: {
        [idOrbite: string]: GestionnaireOrbite;
    };
    constructor();
    obtGestionnaireOrbite<T extends ServiceMap = ServiceMap>({ orbite, signaleurArrêt, }: {
        orbite: OrbitDB<T>;
        signaleurArrêt?: AbortController;
    }): GestionnaireOrbite;
    fermer({ orbite, arrêterOrbite, signaleurArrêt, }: {
        orbite: OrbitDB<ServiceMap>;
        arrêterOrbite: boolean;
        signaleurArrêt: AbortController;
    }): Promise<void>;
}
export declare const gestionnaireOrbiteGénéral: GestionnaireOrbiteGénéral;
export {};