import { BlockHash, Option } from '@dedot/codecs';
import type { ChainHeadRuntimeVersion, OperationId, StorageQuery, StorageResult } from '@dedot/types/json-rpc';
import { HashFn } from '@dedot/utils';
import { Deferred, HexString } from '@dedot/utils';
import type { IJsonRpcClient } from '../../../types.js';
import { Archive } from '../Archive.js';
import { JsonRpcGroup, type JsonRpcGroupOptions } from '../JsonRpcGroup.js';
export type OperationHandler<T = any> = {
    operationId: OperationId;
    defer: Deferred<T>;
    storageResults?: Array<StorageResult>;
    hash: BlockHash;
};
export type PendingRequest<T = any> = {
    method: string;
    params: any[];
    defer: Deferred<T>;
};
export type PinnedBlock = {
    hash: BlockHash;
    number: number;
    parent: BlockHash;
    runtime?: ChainHeadRuntimeVersion;
    runtimeUpgraded?: boolean;
};
export type ChainHeadEvent = 'newBlock' | 'bestBlock' | 'finalizedBlock' | 'bestChainChanged';
export declare class ChainHead extends JsonRpcGroup<ChainHeadEvent> {
    #private;
    constructor(client: IJsonRpcClient<any>, options?: Partial<JsonRpcGroupOptions>);
    /**
     * Attach an Archive instance as fallback for operations that fail due to unpinned blocks.
     * When a ChainHeadBlockNotPinnedError occurs, the operation will automatically fallback
     * to the Archive API to attempt to retrieve the data from historical blocks.
     *
     * @param archive - Archive instance to use as fallback
     * @returns this ChainHead instance for method chaining
     */
    withArchive(archive: Archive): this;
    /**
     * Override send() to track pending requests for retry on network disconnection
     */
    send<T = any>(method: string, ...params: any[]): Promise<T>;
    runtimeVersion(): Promise<ChainHeadRuntimeVersion>;
    bestRuntimeVersion(): Promise<ChainHeadRuntimeVersion>;
    finalizedHash(): Promise<BlockHash>;
    bestHash(): Promise<BlockHash>;
    bestBlock(): Promise<PinnedBlock>;
    finalizedBlock(): Promise<PinnedBlock>;
    /**
     * Returns the detected hasher for the chain
     * Returns undefined if detection failed (client should use default)
     */
    hasher(): Promise<HashFn | undefined>;
    findBlock(hash: BlockHash): PinnedBlock | undefined;
    isPinned(hash: BlockHash): boolean;
    /**
     * chainHead_unfollow
     */
    unfollow(): Promise<void>;
    /**
     * chainHead_follow
     */
    follow(force?: boolean): Promise<void>;
    /**
     * chainHead_body
     */
    body(at?: BlockHash): Promise<Array<HexString>>;
    /**
     * chainHead_call
     */
    call(func: string, params?: HexString, at?: BlockHash): Promise<HexString>;
    /**
     * chainHead_header
     */
    header(at?: BlockHash): Promise<Option<HexString>>;
    /**
     * chainHead_storage
     */
    storage(items: Array<StorageQuery>, childTrie?: string | null, at?: BlockHash): Promise<Array<StorageResult>>;
    /**
     * chainHead_stopOperation
     * @protected
     */
    protected stopOperation(operationId: OperationId): Promise<void>;
    /**
     * chainHead_continue
     * @protected
     */
    protected continue(operationId: OperationId): Promise<void>;
    /**
     * chainHead_unpin
     * @protected
     */
    protected unpin(hashes: BlockHash | BlockHash[]): Promise<void>;
    /**
     * Clears the internal cache used for storing query results (both chainHead & archive instances)
     * This can be useful for memory management or when you want to force fresh data retrieval.
     *
     * @example
     * ```typescript
     * // Clear all cached results
     * chainHead.clearCache();
     * ```
     */
    clearCache(): void;
    holdBlock(hash: BlockHash): void;
    releaseBlock(hash: BlockHash): void;
}