import { ContainerType, Type, ValueOf } from "@chainsafe/ssz";
import { ChainForkConfig } from "@lodestar/config";
import { BeaconState, Epoch, RootHex, Slot, ValidatorIndex } from "@lodestar/types";
import { EmptyArgs, EmptyMeta, EmptyRequest, EmptyResponseData } from "../../utils/codecs.js";
import { Endpoint, RouteDefinitions } from "../../utils/index.js";
import { ExecutionOptimisticFinalizedAndVersionMeta, VersionMeta } from "../../utils/metadata.js";
import { StateArgs } from "./beacon/state.js";
import { FilterGetPeers, NodePeer, PeerDirection, PeerState } from "./node.js";
export type SyncChainDebugState = {
    targetRoot: string | null;
    targetSlot: number | null;
    syncType: string;
    status: string;
    startEpoch: number;
    peers: number;
    batches: any[];
};
export type GossipQueueItem = {
    topic: unknown;
    propagationSource: string;
    data: Uint8Array;
    addedTimeMs: number;
    seenTimestampSec: number;
};
export type PeerScoreStat = {
    peerId: string;
    lodestarScore: number;
    gossipScore: number;
    ignoreNegativeGossipScore: boolean;
    score: number;
    lastUpdate: number;
};
export type GossipPeerScoreStat = {
    peerId: string;
};
/**
 * A multiaddr with peer ID or ENR string.
 *
 * Supported formats:
 * - Multiaddr with peer ID: `/ip4/192.168.1.1/tcp/9000/p2p/16Uiu2HAmKLhW7...`
 * - ENR: `enr:-IS4QHCYrYZbAKWCBRlAy5zzaDZXJBGkcnh4MHcBFZntXNFrdvJjX04jRzjzCBOo...`
 *
 * For multiaddrs, the string must contain a /p2p/ component with the peer ID.
 * For ENRs, the TCP multiaddr and peer ID are extracted from the encoded record.
 */
export type DirectPeer = string;
export type RegenQueueItem = {
    key: string;
    args: unknown;
    addedTimeMs: number;
};
export type BlockProcessorQueueItem = {
    blockSlots: Slot[];
    jobOpts: Record<string, string | number | boolean | undefined>;
    addedTimeMs: number;
};
export type StateCacheItem = {
    slot: Slot;
    root: RootHex;
    /** Total number of reads */
    reads: number;
    /** Unix timestamp (ms) of the last read */
    lastRead: number;
    checkpointState: boolean;
};
export type LodestarNodePeer = NodePeer & {
    agentVersion: string;
    status: unknown | null;
    metadata: unknown | null;
    agentClient: string;
    lastReceivedMsgUnixTsMs: number;
    lastStatusUnixTsMs: number;
    connectedUnixTsMs: number;
};
export type BlacklistedBlock = {
    root: RootHex;
    slot: Slot | null;
};
export type LodestarThreadType = "main" | "network" | "discv5";
declare const HistoricalSummariesResponseType: ContainerType<{
    slot: import("@chainsafe/ssz").UintNumberType;
    historicalSummaries: import("@chainsafe/ssz").ListCompositeType<ContainerType<{
        blockSummaryRoot: import("@chainsafe/ssz").ByteVectorType;
        stateSummaryRoot: import("@chainsafe/ssz").ByteVectorType;
    }>>;
    proof: import("@chainsafe/ssz").ArrayType<Type<Uint8Array<ArrayBufferLike>>, unknown, unknown>;
}>;
export type HistoricalSummariesResponse = ValueOf<typeof HistoricalSummariesResponseType>;
export type CustodyInfo = {
    /** Earliest slot for which the node has custodied data columns */
    earliestCustodiedSlot: Slot;
    /** Number of custody groups the node is responsible for */
    custodyGroupCount: number;
    /** List of column indices the node is custodying */
    custodyColumns: number[];
};
export type Endpoints = {
    /** Trigger to write a heapdump to disk at `dirpath`. May take > 1min */
    writeHeapdump: Endpoint<"POST", {
        thread?: LodestarThreadType;
        dirpath?: string;
    }, {
        query: {
            thread?: LodestarThreadType;
            dirpath?: string;
        };
    }, {
        filepath: string;
    }, EmptyMeta>;
    /** Trigger to write 10m network thread profile to disk */
    writeProfile: Endpoint<"POST", {
        thread?: LodestarThreadType;
        duration?: number;
        dirpath?: string;
    }, {
        query: {
            thread?: LodestarThreadType;
            duration?: number;
            dirpath?: string;
        };
    }, {
        result: string;
    }, EmptyMeta>;
    /** TODO: description */
    getLatestWeakSubjectivityCheckpointEpoch: Endpoint<"GET", EmptyArgs, EmptyRequest, Epoch, EmptyMeta>;
    /** TODO: description */
    getSyncChainsDebugState: Endpoint<"GET", EmptyArgs, EmptyRequest, SyncChainDebugState[], EmptyMeta>;
    /** Dump all items in a gossip queue, by gossipType */
    getGossipQueueItems: Endpoint<"GET", {
        gossipType: string;
    }, {
        params: {
            gossipType: string;
        };
    }, unknown[], EmptyMeta>;
    /** Dump all items in the regen queue */
    getRegenQueueItems: Endpoint<"GET", EmptyArgs, EmptyRequest, RegenQueueItem[], EmptyMeta>;
    /** Dump all items in the block processor queue */
    getBlockProcessorQueueItems: Endpoint<"GET", EmptyArgs, EmptyRequest, BlockProcessorQueueItem[], EmptyMeta>;
    /** Dump a summary of the states in the block state cache and checkpoint state cache */
    getStateCacheItems: Endpoint<"GET", EmptyArgs, EmptyRequest, StateCacheItem[], EmptyMeta>;
    /** Dump peer gossip stats by peer */
    getGossipPeerScoreStats: Endpoint<"GET", EmptyArgs, EmptyRequest, GossipPeerScoreStat[], EmptyMeta>;
    /** Dump lodestar score stats by peer */
    getLodestarPeerScoreStats: Endpoint<"GET", EmptyArgs, EmptyRequest, PeerScoreStat[], EmptyMeta>;
    /** Run GC with `global.gc()` */
    runGC: Endpoint<"POST", EmptyArgs, EmptyRequest, EmptyResponseData, EmptyMeta>;
    /** Drop all states in the state cache */
    dropStateCache: Endpoint<"POST", EmptyArgs, EmptyRequest, EmptyResponseData, EmptyMeta>;
    /** Connect to peer at this multiaddress */
    connectPeer: Endpoint<"POST", {
        peerId: string;
        multiaddrs: string[];
    }, {
        query: {
            peerId: string;
            multiaddr: string[];
        };
    }, EmptyResponseData, EmptyMeta>;
    /** Disconnect peer */
    disconnectPeer: Endpoint<"POST", {
        peerId: string;
    }, {
        query: {
            peerId: string;
        };
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Add a direct peer at runtime.
     * Direct peers maintain permanent mesh connections without GRAFT/PRUNE negotiation.
     * Accepts either a multiaddr with peer ID or an ENR string.
     */
    addDirectPeer: Endpoint<"POST", {
        peer: DirectPeer;
    }, {
        query: {
            peer: string;
        };
    }, {
        peerId: string;
    }, EmptyMeta>;
    /** Remove a peer from direct peers */
    removeDirectPeer: Endpoint<"DELETE", {
        peerId: string;
    }, {
        query: {
            peerId: string;
        };
    }, {
        removed: boolean;
    }, EmptyMeta>;
    /** Get list of direct peer IDs */
    getDirectPeers: Endpoint<"GET", EmptyArgs, EmptyRequest, string[], EmptyMeta>;
    /** Same to node api with new fields */
    getPeers: Endpoint<"GET", FilterGetPeers, {
        query: {
            state?: PeerState[];
            direction?: PeerDirection[];
        };
    }, LodestarNodePeer[], {
        count: number;
    }>;
    /** Returns root/slot of blacklisted blocks */
    getBlacklistedBlocks: Endpoint<"GET", EmptyArgs, EmptyRequest, BlacklistedBlock[], EmptyMeta>;
    /** Returns historical summaries and proof for a given state ID */
    getHistoricalSummaries: Endpoint<"GET", StateArgs, {
        params: {
            state_id: string;
        };
    }, HistoricalSummariesResponse, ExecutionOptimisticFinalizedAndVersionMeta>;
    getPersistedCheckpointState: Endpoint<"GET", {
        /** The checkpoint in `<root>:<epoch>` format to be returned instead of the latest safe checkpoint state */
        checkpointId?: string;
    }, {
        query: {
            checkpoint_id?: string;
        };
    }, BeaconState, VersionMeta>;
    /**
     * Returns the validator indices that are currently being monitored by the validator monitor.
     */
    getMonitoredValidatorIndices: Endpoint<"GET", EmptyArgs, EmptyRequest, ValidatorIndex[], EmptyMeta>;
    /** Dump Discv5 Kad values */
    discv5GetKadValues: Endpoint<"GET", EmptyArgs, EmptyRequest, string[], EmptyMeta>;
    /**
     * Dump level-db entry keys for a given Bucket declared in code, or for all buckets.
     */
    dumpDbBucketKeys: Endpoint<"GET", {
        /** Must be the string name of a bucket entry: `allForks_blockArchive` */
        bucket: string;
    }, {
        params: {
            bucket: string;
        };
    }, string[], EmptyMeta>;
    /** Return all entries in the StateArchive index with bucket index_stateArchiveRootIndex */
    dumpDbStateIndex: Endpoint<"GET", EmptyArgs, EmptyRequest, {
        root: RootHex;
        slot: Slot;
    }[], EmptyMeta>;
    /** Get custody information for data columns */
    getCustodyInfo: Endpoint<"GET", EmptyArgs, EmptyRequest, CustodyInfo, EmptyMeta>;
};
export declare function getDefinitions(_config: ChainForkConfig): RouteDefinitions<Endpoints>;
export {};
//# sourceMappingURL=lodestar.d.ts.map