import { Allocation, AllocationStatus, Epoch, GraphNode, Subgraph, SubgraphDeployment, NetworkEpoch, BlockPointer, HorizonTransitionValue, Provision, POIData } from '@graphprotocol/indexer-common';
import { GraphHorizonContracts, SubgraphServiceContracts } from '@graphprotocol/toolshed/deployments';
import { Address, Eventual, Logger, SubgraphDeploymentID } from '@graphprotocol/common-ts';
import { HDNodeWallet, Provider } from 'ethers';
import { IndexerOptions } from '../network-specification';
import { SubgraphClient } from '../subgraph-client';
export declare class NetworkMonitor {
    networkCAIPID: string;
    private contracts;
    private indexerOptions;
    private logger;
    private graphNode;
    private networkSubgraph;
    private ethereum;
    private epochSubgraph;
    constructor(networkCAIPID: string, contracts: GraphHorizonContracts & SubgraphServiceContracts, indexerOptions: IndexerOptions, logger: Logger, graphNode: GraphNode, networkSubgraph: SubgraphClient, ethereum: Provider, epochSubgraph: SubgraphClient);
    poiDisputeMonitoringEnabled(): boolean;
    currentEpochNumber(): Promise<number>;
    maxAllocationDuration(): Promise<HorizonTransitionValue>;
    /**
     * Returns the amount of free stake for the indexer.
     *
     * The free stake is the amount of tokens that the indexer can use to stake in
     * new allocations.
     *
     * Horizon: It's calculated as the difference between the tokens
     * available in the provision and the tokens already locked allocations.
     *
     * Legacy: It's given by the indexer's stake capacity.
     *
     * @returns The amount of free stake for the indexer.
     */
    freeStake(): Promise<HorizonTransitionValue<bigint, bigint>>;
    /**
     * Check if the network of the allocation is supported
     *
     * (todo-future: check if present in the epoch subgraph)
     * @param allocation: Allocation to check
     * @returns network `alias` if the network is supported, `null` otherwise
     */
    allocationNetworkAlias(allocation: Allocation): Promise<string | null>;
    allocation(allocationID: string): Promise<Allocation>;
    allocations(status: AllocationStatus): Promise<Allocation[]>;
    provision(indexer: string, dataService: string): Promise<Provision>;
    epochs(epochNumbers: number[]): Promise<Epoch[]>;
    recentlyClosedAllocations(currentEpoch: number, range: number): Promise<Allocation[]>;
    closedAllocations(subgraphDeploymentId: SubgraphDeploymentID): Promise<Allocation[]>;
    subgraphs(ids: string[]): Promise<Subgraph[]>;
    subgraphDeployment(ipfsHash: string): Promise<SubgraphDeployment | undefined>;
    subgraphDeployments(): Promise<SubgraphDeployment[]>;
    networkCurrentEpoch(): Promise<NetworkEpoch>;
    currentEpoch(networkID: string): Promise<NetworkEpoch>;
    fetchPOIBlockPointer(deploymentNetworkAlias: string, allocation: Allocation): Promise<BlockPointer>;
    resolvePOI(allocation: Allocation, poi: string | undefined, publicPOI: string | undefined, blockNumber: number | undefined, force: boolean): Promise<POIData>;
    monitorNetworkPauses(logger: Logger, contracts: GraphHorizonContracts & SubgraphServiceContracts, networkSubgraph: SubgraphClient): Promise<Eventual<boolean>>;
    monitorIsOperator(logger: Logger, indexerAddress: Address, wallet: HDNodeWallet): Promise<Eventual<boolean>>;
    monitorIsHorizon(logger: Logger, interval?: number): Promise<Eventual<boolean>>;
    claimableAllocations(disputableEpoch: number): Promise<Allocation[]>;
    disputableAllocations(currentEpoch: number, deployments: SubgraphDeploymentID[], minimumAllocation: number): Promise<Allocation[]>;
    private isHorizon;
    private isOperator;
    private _resolvePOI;
    private _resolvePOIBlockNumber;
    private _resolvePublicPOI;
    private _resolveIndexingStatus;
}