import { C as Cursor, B as Bytes, w as Client, S as StatusRequest, u as ClientCallOptions, f as StatusResponse, l as StreamDataRequest, v as StreamDataOptions, r as StreamDataResponse } from './protocol.de1adebd.mjs';

type FetchBlockRangeArgs<TFilter> = {
    startBlock: bigint;
    maxBlock: bigint;
    force: boolean;
    clampAllowed: boolean;
    filter: TFilter;
};
type FetchBlockRangeResult<TBlock> = {
    startBlock: bigint;
    endBlock: bigint;
    data: FetchBlockResult<TBlock>[];
};
type FetchBlockResult<TBlock> = {
    block: TBlock | null;
    cursor: Cursor | undefined;
    endCursor: Cursor;
};
type BlockInfo = {
    blockNumber: bigint;
    blockHash: Bytes;
    parentBlockHash: Bytes;
};
type FetchBlockByHashArgs<TFilter> = {
    blockHash: Bytes;
};
type FetchBlockByHashResult<TBlock> = {
    data: FetchBlockResult<TBlock>;
    blockInfo: BlockInfo;
};
type FetchCursorRangeArgs = {
    startBlockNumber: bigint;
    endBlockNumber: bigint;
};
type FetchCursorArgs = {
    blockTag: "latest" | "finalized";
    blockNumber?: undefined;
    blockHash?: undefined;
} | {
    blockTag?: undefined;
    blockNumber: bigint;
    blockHash?: undefined;
} | {
    blockTag?: undefined;
    blockNumber?: undefined;
    blockHash: Bytes;
};
type ValidateFilterResult = {
    valid: true;
    error?: undefined;
} | {
    valid: false;
    error: string;
};
declare abstract class RpcStreamConfig<TFilter, TBlock> {
    abstract headRefreshIntervalMs(): number;
    abstract finalizedRefreshIntervalMs(): number;
    abstract fetchCursorRange(args: FetchCursorRangeArgs): Promise<BlockInfo[]>;
    abstract fetchCursor(args: FetchCursorArgs): Promise<BlockInfo | null>;
    abstract validateFilter(filter: TFilter): ValidateFilterResult;
    abstract fetchBlockRange(args: FetchBlockRangeArgs<TFilter>): Promise<FetchBlockRangeResult<TBlock>>;
    abstract fetchHeaderByHash(args: FetchBlockByHashArgs<TFilter>): Promise<FetchBlockByHashResult<TBlock>>;
}

declare class RpcClient<TFilter, TBlock> implements Client<TFilter, TBlock> {
    private config;
    constructor(config: RpcStreamConfig<TFilter, TBlock>);
    status(_request?: StatusRequest, _options?: ClientCallOptions): Promise<StatusResponse>;
    streamData(request: StreamDataRequest<TFilter>, options?: StreamDataOptions): AsyncIterable<StreamDataResponse<TBlock>>;
}
declare function createRpcClient<TFilter, TBlock>(config: RpcStreamConfig<TFilter, TBlock>): RpcClient<TFilter, TBlock>;

declare class RpcDataStream<TFilter, TBlock> {
    private config;
    private request;
    private options?;
    private heartbeatIntervalMs;
    constructor(config: RpcStreamConfig<TFilter, TBlock>, request: StreamDataRequest<TFilter>, options?: StreamDataOptions | undefined);
    [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
    private initialize;
}

type index_BlockInfo = BlockInfo;
type index_FetchBlockByHashArgs<TFilter> = FetchBlockByHashArgs<TFilter>;
type index_FetchBlockByHashResult<TBlock> = FetchBlockByHashResult<TBlock>;
type index_FetchBlockRangeArgs<TFilter> = FetchBlockRangeArgs<TFilter>;
type index_FetchBlockRangeResult<TBlock> = FetchBlockRangeResult<TBlock>;
type index_FetchBlockResult<TBlock> = FetchBlockResult<TBlock>;
type index_FetchCursorArgs = FetchCursorArgs;
type index_FetchCursorRangeArgs = FetchCursorRangeArgs;
type index_RpcClient<TFilter, TBlock> = RpcClient<TFilter, TBlock>;
declare const index_RpcClient: typeof RpcClient;
type index_RpcDataStream<TFilter, TBlock> = RpcDataStream<TFilter, TBlock>;
declare const index_RpcDataStream: typeof RpcDataStream;
type index_RpcStreamConfig<TFilter, TBlock> = RpcStreamConfig<TFilter, TBlock>;
declare const index_RpcStreamConfig: typeof RpcStreamConfig;
type index_ValidateFilterResult = ValidateFilterResult;
declare const index_createRpcClient: typeof createRpcClient;
declare namespace index {
  export { index_RpcClient as RpcClient, index_RpcDataStream as RpcDataStream, index_RpcStreamConfig as RpcStreamConfig, index_createRpcClient as createRpcClient };
  export type { index_BlockInfo as BlockInfo, index_FetchBlockByHashArgs as FetchBlockByHashArgs, index_FetchBlockByHashResult as FetchBlockByHashResult, index_FetchBlockRangeArgs as FetchBlockRangeArgs, index_FetchBlockRangeResult as FetchBlockRangeResult, index_FetchBlockResult as FetchBlockResult, index_FetchCursorArgs as FetchCursorArgs, index_FetchCursorRangeArgs as FetchCursorRangeArgs, index_ValidateFilterResult as ValidateFilterResult };
}

export { RpcStreamConfig as R, RpcClient as g, createRpcClient as h, index as i, RpcDataStream as j };
export type { BlockInfo as B, FetchBlockRangeArgs as F, ValidateFilterResult as V, FetchBlockResult as a, FetchBlockRangeResult as b, FetchBlockByHashArgs as c, FetchBlockByHashResult as d, FetchCursorArgs as e, FetchCursorRangeArgs as f };