import type { DB, DBTransaction, LevelPath } from '@matrixai/db';
import type { Gestalt, GestaltAction, GestaltActions, GestaltKey, GestaltLinkId, GestaltNodeInfo, GestaltIdentityInfo, GestaltLink, GestaltLinkNode, GestaltInfo, GestaltLinkIdentity, GestaltId } from './types.js';
import type { ClaimId, NodeId, ProviderIdentityId } from '../ids/types.js';
import type ACL from '../acl/ACL.js';
import Logger from '@matrixai/logger';
import { createDestroyStartStop } from '@matrixai/async-init';
interface GestaltGraph extends createDestroyStartStop.CreateDestroyStartStop {
}
declare class GestaltGraph {
    static createGestaltGraph({ db, acl, logger, fresh, }: {
        db: DB;
        acl: ACL;
        logger?: Logger;
        fresh?: boolean;
    }): Promise<GestaltGraph>;
    protected logger: Logger;
    protected db: DB;
    protected acl: ACL;
    readonly dbPath: Readonly<LevelPath>;
    /**
     * Gestalt adjacency matrix represented as a collection vertex pairs.
     * Each vertex can be `GestaltNodeKey` or `GestaltIdentityKey`.
     * These are the allowable structures:
     * `GestaltGraph/matrix/{GestaltKey} -> null`
     * `GestaltGraph/matrix/{GestaltKey}/{GestaltKey} -> {raw(GestaltLinkId)}`
     */
    readonly dbMatrixPath: Readonly<LevelPath>;
    /**
     * Gestalt links.
     * `GestaltGraph/links/{GestaltLinkId} -> {json(GestaltLink)}`
     */
    readonly dbLinksPath: Readonly<LevelPath>;
    /**
     * Node information
     * `GestaltGraph/nodes/{GestaltKey} -> {json(GestaltNodeInfo)}`
     */
    readonly dbNodesPath: Readonly<LevelPath>;
    /**
     * Identity information
     * `GestaltGraph/identities/{GestaltKey} -> {json(GestaltIdentityInfo)}`
     */
    readonly dbIdentitiesPath: LevelPath;
    /**
     * Last processed collection
     * `GestaltGraph/VertexProcessedTime/{GestaltIdEncoded} -> number`
     */
    protected vertexProcessedTimePath: LevelPath;
    /**
     * Last processed collection
     * `GestaltGraph/vertexProcessedTimeOrder/{number}/{GestaltIdEncoded} -> gestaltIdEncoded`
     */
    protected vertexProcessedTimeOrderPath: LevelPath;
    protected nodeClaimIdOldestPath: LevelPath;
    protected generateGestaltLinkId: () => GestaltLinkId;
    constructor({ db, acl, logger }: {
        db: DB;
        acl: ACL;
        logger: Logger;
    });
    start({ fresh }?: {
        fresh?: boolean;
    }): Promise<void>;
    stop(): Promise<void>;
    destroy(): Promise<void>;
    /**
     * Sets a node in the graph
     * Can be used to update an existing node
     * If this is a new node, it will set a new node pointer
     * to a new gestalt permission in the acl
     */
    setNode(nodeInfo: GestaltNodeInfo, tran?: DBTransaction): Promise<['node', NodeId]>;
    setIdentity(identityInfo: GestaltIdentityInfo, tran?: DBTransaction): Promise<['identity', ProviderIdentityId]>;
    unsetNode(nodeId: NodeId, tran?: DBTransaction): Promise<void>;
    unsetIdentity(providerIdentityId: ProviderIdentityId, tran?: DBTransaction): Promise<void>;
    setVertex(gestaltInfo: GestaltInfo, tran?: DBTransaction): Promise<GestaltId>;
    unsetVertex(gestaltId: GestaltId, tran?: DBTransaction): Promise<void>;
    /**
     * Updates the last processed time in the database for the given vertex
     */
    setVertexProcessedTime(vertex: GestaltId, processedTime: number, tran?: DBTransaction): Promise<void>;
    /**
     * Removes the last processed time for a vertex
     */
    unsetVertexProcessedTime(vertex: GestaltId, tran?: DBTransaction): Promise<void>;
    /**
     * Gets the last processed time for a vertex
     */
    getVertexProcessedTime(vertex: GestaltId, tran?: DBTransaction): Promise<number | undefined>;
    /**
     * Gets the last processed time for a vertex
     */
    getVertexProcessedTimes({ order, seek, limit, }?: {
        order?: 'asc' | 'desc';
        seek?: number;
        limit?: number;
    }, tran?: DBTransaction): AsyncGenerator<[GestaltId, number]>;
    /**
     * Updates the newest `ClaimId` for a node if it's newer than the current id stored
     */
    setClaimIdNewest(nodeId: NodeId, claimId: ClaimId, tran?: DBTransaction): Promise<void>;
    getClaimIdNewest(nodeId: NodeId, tran?: DBTransaction): Promise<ClaimId | undefined>;
    /**
     * This checks if the link node has matching issuer and subject.
     * It does not however verify the signatures.
     * Verifying signatures should be done before linking the nodes in the GG
     */
    linkNodeAndNode(nodeInfo1: GestaltNodeInfo, nodeInfo2: GestaltNodeInfo, linkNode: Omit<GestaltLinkNode, 'id'>, tran?: DBTransaction): Promise<GestaltLinkId>;
    linkNodeAndIdentity(nodeInfo: GestaltNodeInfo, identityInfo: GestaltIdentityInfo, linkIdentity: Omit<GestaltLinkIdentity, 'id'>, tran?: DBTransaction): Promise<GestaltLinkId>;
    linkVertexAndVertex(gestaltInfo1: ['node', GestaltNodeInfo], gestaltInfo2: ['node', GestaltNodeInfo], link: ['node', Omit<GestaltLinkNode, 'id'>], tran?: DBTransaction): Promise<GestaltLinkId>;
    linkVertexAndVertex(gestaltInfo1: ['node', GestaltNodeInfo], gestaltInfo2: ['identity', GestaltIdentityInfo], link: ['identity', Omit<GestaltLinkIdentity, 'id'>], tran?: DBTransaction): Promise<GestaltLinkId>;
    linkVertexAndVertex(gestaltInfo1: ['identity', GestaltIdentityInfo], gestaltInfo2: ['node', GestaltNodeInfo], link: ['identity', Omit<GestaltLinkIdentity, 'id'>], tran?: DBTransaction): Promise<GestaltLinkId>;
    unlinkNodeAndNode(nodeId1: NodeId, nodeId2: NodeId, tran?: DBTransaction): Promise<void>;
    unlinkNodeAndIdentity(nodeId: NodeId, providerIdentityId: ProviderIdentityId, tran?: DBTransaction): Promise<void>;
    unlinkVertexAndVertex(gestaltId1: ['node', NodeId], gestaltId2: ['node', NodeId], tran?: DBTransaction): Promise<void>;
    unlinkVertexAndVertex(gestaltId1: ['node', NodeId], gestaltId2: ['identity', ProviderIdentityId], tran?: DBTransaction): Promise<void>;
    unlinkVertexAndVertex(gestaltId1: ['identity', ProviderIdentityId], gestaltId2: ['node', NodeId], tran?: DBTransaction): Promise<void>;
    getGestaltActions(gestaltId: GestaltId, tran?: DBTransaction): Promise<GestaltActions>;
    setGestaltAction(gestaltId: GestaltId, action: GestaltAction, tran?: DBTransaction): Promise<void>;
    unsetGestaltAction(gestaltId: GestaltId, action: GestaltAction, tran?: DBTransaction): Promise<void>;
    getGestalts(tran?: DBTransaction): AsyncGenerator<Gestalt>;
    getGestalt(gestaltId: GestaltId, tran?: DBTransaction): Promise<Gestalt | undefined>;
    getGestaltByNode(nodeId: NodeId, tran?: DBTransaction): Promise<Gestalt | undefined>;
    getGestaltByIdentity(providerIdentityId: ProviderIdentityId, tran?: DBTransaction): Promise<Gestalt | undefined>;
    getNode(nodeId: NodeId, tran?: DBTransaction): Promise<GestaltNodeInfo | undefined>;
    getIdentity(providerIdentityId: ProviderIdentityId, tran?: DBTransaction): Promise<GestaltIdentityInfo | undefined>;
    getVertex(gestaltId: ['node', NodeId], tran?: DBTransaction): Promise<['node', GestaltNodeInfo] | undefined>;
    getVertex(gestaltId: ['identity', ProviderIdentityId], tran?: DBTransaction): Promise<['identity', GestaltIdentityInfo] | undefined>;
    getVertex(gestaltId: GestaltId, tran?: DBTransaction): Promise<GestaltInfo | undefined>;
    getLinkById(linkId: GestaltLinkId, tran?: DBTransaction): Promise<GestaltLink | undefined>;
    getLink(gestaltId1: ['node', NodeId], gestaltId2: ['node', NodeId], tran?: DBTransaction): Promise<['node', GestaltLinkNode] | undefined>;
    getLink(gestaltId1: ['identity', ProviderIdentityId], gestaltId2: ['node', NodeId], tran?: DBTransaction): Promise<['identity', GestaltLinkIdentity] | undefined>;
    getLink(gestaltId1: ['node', NodeId], gestaltId2: ['identity', ProviderIdentityId], tran?: DBTransaction): Promise<['identity', GestaltLinkIdentity] | undefined>;
    getLinks(gestaltId: GestaltId, tran?: DBTransaction): AsyncGenerator<[GestaltId, GestaltLink]>;
    /**
     * Gets a gestalt using BFS.
     * During execution the`visited` set indicates the vertexes that have been queued.
     * This BFS algorithm has to 2 stages:
     *   1. processing the vertex information.
     *   2. processing the vertex links by iterating the vertex neighbours.
     * When processing vertex information we need to avoid queued duplicate vertexes.
     * When processing vertex links we need to avoid already processed links.
     * When finished, the `visited` set indicates the vertexes that have been processed.
     */
    protected getGestaltByKey(gestaltKey: GestaltKey, visited: Set<string> | undefined, tran: DBTransaction): Promise<Gestalt | undefined>;
    protected getIdentityLinkedNodeId(providerIdentityId: ProviderIdentityId, tran: DBTransaction): Promise<NodeId | undefined>;
}
export default GestaltGraph;