import type { ComputeTransactionResponse } from "./resources.js";
export type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
export type RpcClientOptions = {
    endpoints: string | readonly string[];
    fetch?: FetchLike;
    timeoutMs?: number;
    retries?: number;
    maxResponseBytes?: number;
    /** Reject every endpoint whose `/v1/chain/get_info` chain id does not match. */
    expectedChainId?: string;
};
export type RpcRequestOptions = {
    retries?: number;
    retry?: "safe" | "never";
    validate?: (value: unknown) => void;
};
export type GetInfoResponse = {
    server_version?: string;
    chain_id: string;
    head_block_num: number;
    last_irreversible_block_num: number;
    head_block_id: string;
    head_block_time: string;
    head_block_producer?: string;
    [key: string]: unknown;
};
export type GetBlockResponse = {
    timestamp: string;
    producer?: string;
    confirmed?: number;
    previous?: string;
    transaction_mroot?: string;
    action_mroot?: string;
    schedule_version?: number;
    producer_signature?: string;
    id: string;
    block_num: number;
    ref_block_prefix?: number;
    [key: string]: unknown;
};
export type TableRowsRequest = {
    code: string;
    scope: string;
    table: string;
    json?: boolean;
    lower_bound?: string | number;
    upper_bound?: string | number;
    limit?: number;
    key_type?: string;
    index_position?: string | number;
    reverse?: boolean;
    show_payer?: boolean;
};
export type TableRowsResponse<T> = {
    rows: T[];
    more: boolean | string;
    next_key?: string;
};
export type TableByScopeRequest = {
    code: string;
    table?: string;
    lower_bound?: string;
    upper_bound?: string;
    limit?: number;
    reverse?: boolean;
};
export type TableByScopeRow = {
    code: string;
    scope: string;
    table: string;
    payer: string;
    count: number;
};
export type PackedTransaction = {
    signatures: string[];
    compression?: number;
    packed_context_free_data?: string;
    packed_trx: string;
};
export type SendTransaction2Request = PackedTransaction & {
    return_failure_trace?: boolean;
    retry_trx?: boolean;
};
export declare class RpcError extends Error {
    readonly status: number;
    readonly endpoint: string;
    readonly payload: unknown;
    constructor(message: string, status: number, endpoint: string, payload?: unknown);
}
export declare class RpcTimeoutError extends Error {
    readonly endpoint: string;
    readonly timeoutMs: number;
    constructor(endpoint: string, timeoutMs: number);
}
export declare class RpcResponseError extends RpcError {
    constructor(endpoint: string, status: number, payload: string);
}
export declare class RpcResponseTooLargeError extends RpcError {
    readonly maxResponseBytes: number;
    constructor(endpoint: string, status: number, maxResponseBytes: number);
}
export declare class RpcChainMismatchError extends RpcError {
    readonly expectedChainId: string;
    readonly actualChainId: string;
    constructor(endpoint: string, expectedChainId: string, actualChainId: string, payload?: unknown);
}
export declare function assertGetInfoResponse(value: unknown): asserts value is GetInfoResponse;
export declare function assertGetBlockResponse(value: unknown): asserts value is GetBlockResponse;
export declare function assertRequiredKeysResponse(value: unknown): asserts value is {
    required_keys: string[];
};
export declare class RpcClient {
    #private;
    readonly endpoints: readonly string[];
    constructor(options: RpcClientOptions);
    request<T>(path: string, body?: unknown, signal?: AbortSignal, options?: RpcRequestOptions): Promise<T>;
    getInfo(signal?: AbortSignal): Promise<GetInfoResponse>;
    getBlock(blockNumOrId: number | string, signal?: AbortSignal): Promise<GetBlockResponse>;
    getBlockInfo(blockNum: number, signal?: AbortSignal): Promise<GetBlockResponse>;
    getAccount<T = Record<string, unknown>>(accountName: string, signal?: AbortSignal): Promise<T>;
    getAbi(accountName: string, signal?: AbortSignal): Promise<{
        account_name: string;
        abi: unknown;
    }>;
    getRawAbi<T = Record<string, unknown>>(accountName: string, signal?: AbortSignal): Promise<T>;
    getCodeHash<T = Record<string, unknown>>(accountName: string, signal?: AbortSignal): Promise<T>;
    getTableRows<T = Record<string, unknown>>(args: TableRowsRequest, signal?: AbortSignal): Promise<TableRowsResponse<T>>;
    getTableByScope(args: TableByScopeRequest, signal?: AbortSignal): Promise<{
        rows: TableByScopeRow[];
        more: string;
    }>;
    getCurrencyBalance(code: string, account: string, symbol?: string, signal?: AbortSignal): Promise<string[]>;
    getCurrencyStats<T = Record<string, unknown>>(code: string, symbol: string, signal?: AbortSignal): Promise<T>;
    getRequiredKeys(transaction: unknown, availableKeys: string[], signal?: AbortSignal): Promise<{
        required_keys: string[];
    }>;
    computeTransaction<T = ComputeTransactionResponse>(transaction: PackedTransaction, signal?: AbortSignal): Promise<T>;
    pushTransaction<T = Record<string, unknown>>(transaction: PackedTransaction, signal?: AbortSignal): Promise<T>;
    sendTransaction<T = Record<string, unknown>>(transaction: PackedTransaction, signal?: AbortSignal): Promise<T>;
    sendTransaction2<T = Record<string, unknown>>(transaction: SendTransaction2Request, signal?: AbortSignal): Promise<T>;
}
export { extractTransactionResourceUsage } from "./resources.js";
export type { ComputeTransactionResponse, TransactionResourceReceipt, TransactionResourceUsage, } from "./resources.js";
export { AntelopeTransactionHistory, HyperionClient, HyperionError, SpringFinalityClient, isSpringTransactionStatusUnsupported, } from "./history.js";
export type { HyperionClientOptions, TransactionObservation, } from "./history.js";
//# sourceMappingURL=index.d.ts.map