/// <reference types="node" />
/// <reference types="node" />
import { Database } from '@liskhq/lisk-db';
import { EventEmitter } from 'events';
import * as liskP2P from '@liskhq/lisk-p2p';
import { Logger } from '../../logger';
import { NetworkConfig } from '../../types';
import { Endpoint } from './endpoint';
interface NodeInfoOptions {
    [key: string]: unknown;
    readonly lastBlockID: Buffer;
    readonly height: number;
    readonly maxHeightPrevoted: number;
    readonly blockVersion: number;
    readonly legacy?: Buffer[];
}
interface NetworkConstructor {
    readonly options: NetworkConfig;
}
interface P2PRequestPacket extends liskP2P.p2pTypes.P2PRequestPacket {
    readonly peerId: string;
}
interface P2PMessagePacket extends liskP2P.p2pTypes.P2PMessagePacket {
    readonly peerId: string;
}
type P2PRPCEndpointHandler = (input: {
    data: unknown;
    peerId: string;
}) => unknown;
type P2PEventHandler = (input: {
    data: Buffer | undefined;
    peerId: string;
}) => void;
interface NetworkInitArgs {
    chainID: Buffer;
    logger: Logger;
    nodeDB: Database;
}
export declare class Network {
    readonly events: EventEmitter;
    private readonly _options;
    private readonly _endpoint;
    private _logger;
    private _nodeDB;
    private _chainID;
    private _secret;
    private _p2p;
    private _endpoints;
    private _eventHandlers;
    private _saveIntervalID?;
    private _nodeInfoOptions;
    constructor({ options }: NetworkConstructor);
    init(args: NetworkInitArgs): Promise<void>;
    start(): Promise<void>;
    stop(): Promise<void>;
    get endpoint(): Endpoint;
    registerEndpoint(endpoint: string, handler: P2PRPCEndpointHandler): void;
    registerHandler(event: string, handler: P2PEventHandler): void;
    request(requestPacket: liskP2P.p2pTypes.P2PRequestPacket): Promise<liskP2P.p2pTypes.P2PResponsePacket>;
    send(sendPacket: liskP2P.p2pTypes.P2PMessagePacket): void;
    requestFromPeer(requestPacket: P2PRequestPacket): Promise<liskP2P.p2pTypes.P2PResponsePacket>;
    sendToPeer(sendPacket: P2PMessagePacket): void;
    broadcast(broadcastPacket: liskP2P.p2pTypes.P2PMessagePacket): void;
    getConnectedPeers(): ReadonlyArray<liskP2P.p2pTypes.PeerInfo>;
    getNetworkStats(): liskP2P.p2pTypes.NetworkStats;
    getDisconnectedPeers(): ReadonlyArray<liskP2P.p2pTypes.PeerInfo>;
    applyPenaltyOnPeer(penaltyPacket: liskP2P.p2pTypes.P2PPenalty): void;
    applyNodeInfo(data: Partial<NodeInfoOptions>): void;
}
export {};