import type { DB, DBTransaction } from '@matrixai/db';
import type { PromiseCancellable } from '@matrixai/async-cancellable';
import type { ContextTimed, ContextTimedInput } from '@matrixai/contexts';
import type { NodeId } from '../nodes/types.js';
import type NodeManager from '../nodes/NodeManager.js';
import type GestaltGraph from '../gestalts/GestaltGraph.js';
import type { GestaltId, GestaltIdEncoded } from '../gestalts/types.js';
import type IdentitiesManager from '../identities/IdentitiesManager.js';
import type { IdentityData, IdentityId, ProviderId, ProviderIdentityClaimId, ProviderIdentityId, ProviderPaginationToken } from '../identities/types.js';
import type KeyRing from '../keys/KeyRing.js';
import type { SignedClaim } from '../claims/types.js';
import type TaskManager from '../tasks/TaskManager.js';
import type { TaskHandler, TaskHandlerId } from '../tasks/types.js';
import type { ClaimLinkIdentity, ClaimLinkNode } from '../claims/payloads/index.js';
import type { DiscoveryQueueInfo } from './types.js';
import type { AgentClientManifest } from '../nodes/agent/callers/index.js';
import Logger from '@matrixai/logger';
import { createDestroyStartStop } from '@matrixai/async-init';
interface Discovery extends createDestroyStartStop.CreateDestroyStartStop {
}
declare class Discovery {
    static createDiscovery({ db, keyRing, gestaltGraph, identitiesManager, nodeManager, taskManager, discoverVertexTimeoutTime, rediscoverCheckIntervalTime, // 1 hour
    rediscoverVertexDelayTime, // 1 hour
    rediscoverSkipTime, // 1 hour
    staleVertexThresholdTime, // 3 days
    logger, fresh, }: {
        db: DB;
        keyRing: KeyRing;
        gestaltGraph: GestaltGraph;
        identitiesManager: IdentitiesManager;
        nodeManager: NodeManager<AgentClientManifest>;
        taskManager: TaskManager;
        discoverVertexTimeoutTime?: number;
        rediscoverCheckIntervalTime?: number;
        rediscoverVertexDelayTime?: number;
        rediscoverSkipTime?: number;
        staleVertexThresholdTime?: number;
        logger?: Logger;
        fresh?: boolean;
    }): Promise<Discovery>;
    protected logger: Logger;
    protected db: DB;
    protected keyRing: KeyRing;
    protected gestaltGraph: GestaltGraph;
    protected identitiesManager: IdentitiesManager;
    protected nodeManager: NodeManager<AgentClientManifest>;
    protected taskManager: TaskManager;
    protected discoverVertexTimeoutTime: number;
    /**
     * Interval delay used when checking for nodes to rediscover
     */
    protected rediscoverCheckIntervalTime: number;
    /**
     * The threshold used when deciding to rediscover a vertex based on how long ago it was processed
     */
    protected rediscoverVertexThresholdTime: number;
    /**
     * The time since a vertex has been processed where re processing will be skipped
     */
    protected rediscoverSkipTime: number;
    /**
     * The time threshold for
     */
    protected staleVertexThresholdTime: number;
    protected discoverVertexHandler: TaskHandler;
    readonly discoverVertexHandlerId: TaskHandlerId;
    /**
     * This handler is run periodically to check if nodes are ready to be rediscovered
     */
    protected checkRediscoveryHandler: TaskHandler;
    readonly checkRediscoveryHandlerId: TaskHandlerId;
    constructor({ keyRing, db, gestaltGraph, identitiesManager, nodeManager, taskManager, discoverVertexTimeoutTime, rediscoverCheckIntervalTime, rediscoverVertexDelayTime, rediscoverSkipTime, staleVertexThresholdTime, logger, }: {
        db: DB;
        keyRing: KeyRing;
        gestaltGraph: GestaltGraph;
        identitiesManager: IdentitiesManager;
        nodeManager: NodeManager<AgentClientManifest>;
        taskManager: TaskManager;
        discoverVertexTimeoutTime: number;
        rediscoverCheckIntervalTime: number;
        rediscoverVertexDelayTime: number;
        rediscoverSkipTime: number;
        staleVertexThresholdTime: number;
        logger: Logger;
    });
    start({ fresh, }?: {
        fresh?: boolean;
    }): Promise<void>;
    stop(): Promise<void>;
    destroy(): Promise<void>;
    /**
     * Queues a node for discovery. Internally calls `pushKeyToDiscoveryQueue`.
     */
    queueDiscoveryByNode(nodeId: NodeId, lastProcessedCutoffTime?: number): Promise<void>;
    /**
     * Queues an identity for discovery. Internally calls
     * `pushKeyToDiscoveryQueue`.
     */
    queueDiscoveryByIdentity(providerId: ProviderId, identityId: IdentityId, lastProcessedCutoffTime?: number): Promise<void>;
    /**
     * This returns the discovery queue
     */
    getDiscoveryQueue(tran?: DBTransaction): AsyncGenerator<DiscoveryQueueInfo, void, void>;
    protected processVertex(vertex: GestaltIdEncoded, lastProcessedCutoffTime?: number, ctx?: Partial<ContextTimed>): PromiseCancellable<void>;
    protected processNode(nodeId: NodeId, lastProcessedCutoffTime: number | undefined, ctx: ContextTimed): Promise<void>;
    protected processClaimLinkNode(signedClaim: SignedClaim<ClaimLinkNode>, nodeId: NodeId, lastProcessedCutoffTime?: number): Promise<void>;
    protected processClaimLinkIdentity(signedClaim: SignedClaim<ClaimLinkIdentity>, nodeId: NodeId, lastProcessedCutoffTime: number | undefined, ctx: ContextTimed): Promise<void>;
    protected processIdentity(id: ProviderIdentityId, lastProcessedCutoffTime: number | undefined, ctx: ContextTimed): Promise<void>;
    /**
     * Will resolve once all existing discovery tasks have finished.
     * Returns the number of existing tasks that were awaited.
     */
    waitForDiscoveryTasks(scheduled?: boolean): Promise<number>;
    /**
     * Simple check for whether there are existing discovery tasks.
     * Returns the number of tasks to avoid boolean blindness.
     */
    protected hasDiscoveryTasks(): Promise<number>;
    /**
     * Creates a task that to discover a vertex.
     * Will not create a new task if an existing task for the vertex exists.
     *
     * The task can be scheduled with an optional delay.
     * If the task already exists then the delay will be updated
     */
    protected scheduleDiscoveryForVertex(vertex: GestaltId, delay?: number, lastProcessedCutoffTime?: number, parent?: GestaltId, ignoreActive?: boolean, tran?: DBTransaction): Promise<void>;
    /**
     * Helper function to retrieve the IdentityInfo of an identity on a provider.
     * All claims in the returned IdentityInfo are verified by the node it claims
     * to link to.
     * Returns undefined if no identity info to be retrieved (either no provider
     * or identity data found).
     */
    protected getIdentityInfo(providerId: ProviderId, identityId: IdentityId, ctx: Partial<ContextTimedInput>): Promise<IdentityData | undefined>;
    /**
     * Helper function to retrieve and verify the claims of an identity on a given
     * provider. Connects with each node the identity claims to be linked with,
     * and verifies the claim with the public key of the node.
     *
     * This method never throws if ctx has aborted, opting instead to return early
     * with a lastProviderPaginationToken so that the caller can process the partially
     * requested Claims as well as resume progress when calling again.
     */
    protected verifyIdentityClaims(providerId: ProviderId, identityId: IdentityId, providerPaginationToken: ProviderPaginationToken | undefined, ctx: ContextTimed): Promise<{
        identityClaims: Record<ProviderIdentityClaimId, SignedClaim<ClaimLinkIdentity>>;
        lastProviderPaginationToken?: ProviderPaginationToken;
    }>;
    /**
     * Checks previously discovered vertices for ones to be re-added back on to the queue
     */
    checkRediscovery(lastProcessedCutoffTime: number, tran?: DBTransaction, ctx?: Partial<ContextTimedInput>): Promise<void>;
    /**
     * Returns true if the vertex was processed after the given time
     */
    protected processedTimeGreaterThan(vertex: GestaltId, time: number, tran?: DBTransaction): Promise<boolean>;
}
export default Discovery;