import { type PeerId } from "@libp2p/interface";
import { PublicSignKey } from "@peerbit/crypto";
import { type CanPerformOperations, type CanRead, type DocumentsLike, type Operation } from "@peerbit/document";
import { type AppendOptions } from "@peerbit/log";
import { Program } from "@peerbit/program";
import { type ReplicationOptions } from "@peerbit/shared-log";
import { FromTo, IdentityRelation } from "./identity-graph.js";
type IdentityGraphArgs = {
    canRead?: CanRead<FromTo>;
    replicate?: ReplicationOptions;
};
export declare class IdentityGraph extends Program<IdentityGraphArgs> {
    relationGraph: DocumentsLike<IdentityRelation, FromTo>;
    constructor(props?: {
        id?: Uint8Array;
        relationGraph?: DocumentsLike<IdentityRelation, FromTo>;
    });
    canPerform(properties: CanPerformOperations<IdentityRelation>): Promise<boolean>;
    open(options?: IdentityGraphArgs): Promise<void>;
    addRelation(to: PublicSignKey | PeerId, options?: AppendOptions<Operation>): Promise<void>;
}
/**
 * Not shardeable since we can not query trusted relations, because this would lead to a recursive problem where we then need to determine whether the responder is trusted or not
 */
type TrustedNetworkArgs = {
    replicate?: ReplicationOptions;
};
export declare class TrustedNetwork extends Program<TrustedNetworkArgs> {
    rootTrust: PublicSignKey;
    trustGraph: DocumentsLike<IdentityRelation, FromTo>;
    private _lastWarmupAt;
    constructor(props: {
        id?: Uint8Array;
        rootTrust: PublicSignKey | PeerId;
    });
    open(options?: TrustedNetworkArgs): Promise<void>;
    canPerform(properties: CanPerformOperations<IdentityRelation>): Promise<boolean>;
    canRead(relation: any, publicKey?: PublicSignKey): Promise<boolean>;
    add(trustee: PublicSignKey | PeerId, options?: AppendOptions<Operation>): Promise<IdentityRelation>;
    hasRelation(trustee: PublicSignKey | PeerId, truster?: PublicSignKey | PeerId): Promise<boolean>;
    getRelation(trustee: PublicSignKey | PeerId, truster?: PublicSignKey | PeerId): Promise<IdentityRelation>;
    /**
     * Follow trust path back to trust root.
     * Trust root is always trusted.
     * Hence if
     * Root trust A trust B trust C
     * C is trusted by Root
     * @param trustee
     * @param truster the truster "root", if undefined defaults to the root trust
     * @returns true, if trusted
     */
    isTrusted(trustee: PublicSignKey | PeerId, truster?: PublicSignKey | PeerId): Promise<boolean>;
    _isTrustedLocal(trustee: PublicSignKey, truster?: PublicSignKey): Promise<boolean>;
    getTrusted(): Promise<PublicSignKey[]>;
    hashCode(): string;
}
export {};
//# sourceMappingURL=controller.d.ts.map