import { PromiseEventWrap } from './model/PromiEventWrap';
import { IWeb3ClientStatus } from './interfaces/IWeb3ClientStatus';
import { ClientStatus } from './model/ClientStatus';
import { ClientPoolTrace } from './ClientPoolStats';
import { IWeb3ClientOptions } from './interfaces/IWeb3Client';
import { RateLimitGuard } from './handlers/RateLimitGuard';
import { Web3BatchRequests } from './Web3BatchRequests';
import { Rpc, RpcTypes } from '../rpc/Rpc';
import { PromiseEvent } from '../class/PromiseEvent';
import { TTransport } from '../rpc/transports/ITransport';
import { TRpc } from '../rpc/RpcBase';
import { TEth } from '../models/TEth';
import { DataLike } from '../utils/types';
export interface IRpcConfig {
    url?: string;
    options?: TTransport.Options.Http | TTransport.Options.Ws;
    /** Will be a preferred node for submitting transactions */
    safe?: boolean;
    distinct?: boolean;
    wallet?: boolean;
    web3?: TTransport.Transport | Promise<TTransport.Transport>;
    name?: string;
    /** Will be used only if manually requested with .getWeb3, or .getNodeUrl */
    manual?: boolean;
    /** max block range per request when getting for example the past logs*/
    fetchableBlockRange?: number;
    /** True if the node supports traceTransaction calls */
    traceable?: boolean;
    rateLimit?: string;
    blockRangeLimit?: string | number;
    batchLimit?: number;
    methods?: {
        exclude?: string[];
        only?: string[];
    };
}
export interface IPoolWeb3Request {
    ws?: boolean;
    preferSafe?: boolean;
    /** Request wallet node to submit unsigned transactions */
    wallet?: boolean;
    distinct?: boolean;
    name?: string;
    /** HTTP Web3 Client traces */
    trace?: ClientPoolTrace;
    /** Supported node features */
    node?: {
        url?: string;
        /** Supports traceTransaction */
        traceable?: boolean;
    };
    /** RPC method - will find the node that has the configuration */
    method?: string;
    batchRequestCount?: number;
    blockRangeCount?: number;
}
export declare class ClientPool {
    private discoveredPartial;
    private discoveredFull;
    private clients;
    private ws;
    /** Minimum rate limit range to assume the RPC is alive */
    MINIMUM_BLOCK_RANGE: number;
    constructor(config: IWeb3ClientOptions);
    callBatched(data: {
        requests: (rpc: Rpc) => Promise<Web3BatchRequests.IRpcRequest[]>;
        map?: (results: any[]) => any;
    }, opts?: IPoolWeb3Request): Promise<any>;
    call<TResult>(fn: (wClient: WClient) => Promise<TResult>, opts?: IPoolWeb3Request): Promise<TResult>;
    getRpc(options?: IPoolWeb3Request): Promise<Rpc>;
    getWrappedWeb3(options?: IPoolWeb3Request): Promise<WClient>;
    getNodeURL(options?: IPoolWeb3Request): Promise<string>;
    releaseWeb3(): Promise<void>;
    getOptionForFetchableRange(blockRangeLimits?: WClient['blockRangeLimits']): number;
    wrappedPromiEvent<T>(asyncFactory: () => Promise<T>): PromiseEvent<T>;
    callPromiEvent<TResult extends PromiseEvent<any>>(fn: (web3: WClient) => TResult, opts?: {
        preferSafe?: boolean;
        parallel?: number;
        silent?: boolean;
        distinct?: boolean;
        wallet?: boolean;
    }, used?: Map<WClient, number>, errors?: any[], root?: PromiseEventWrap): TResult;
    getNodeStats(): {
        success: number;
        fail: number;
        ping: number;
        url: string;
    }[];
    getNodeInfos(options?: {
        timeout?: number;
        calls?: ('net_peerCount' | 'eth_blockNumber' | 'eth_syncing' | 'net_version')[];
    }): Promise<IWeb3ClientStatus[]>;
    private next;
    private getClientWithLowestWaitTime;
    /**
     * We may have tens of Nodes to communicate with. Discover LIVE and operating nodes.
     * Resolves when first 3 active nodes are discovered, to prevent waiting for all of them.
     * @returns
     * - Ready Promise - in case 3 clients look good
     * - Complete Promise - when all clients are resolved
     */
    private discoverLive;
}
export declare class WClient {
    lastStatus: number;
    lastDate: number;
    status: 'ok' | 'off' | 'ping';
    requests: {
        success: number;
        fail: number;
        ping: number;
    };
    rpc: Rpc;
    config: IRpcConfig;
    rateLimitGuard: RateLimitGuard;
    /** For getLogs method, as some providers limit the range request or page result value */
    blockRangeLimits: {
        blocks?: number;
        results?: number;
    };
    batchLimit?: number;
    healthy(): boolean;
    private updateRateLimitInfo;
    updateBlockRangeInfo(info: WClient['blockRangeLimits']): void;
    constructor(mix: IRpcConfig);
    send<TResult>(fn: (web3: WClient) => PromiseEvent<TResult>): Promise<{
        status: ClientStatus;
        error?: any;
        result?: PromiseEvent<TResult>;
    }>;
    sendSignedTransaction(tx: TEth.Hex): PromiseEvent<TEth.TxReceipt>;
    sendTransaction(tx: any): PromiseEvent<TEth.TxReceipt>;
    sign(address: TEth.Address, message: string): Promise<string>;
    signTypedData(address: TEth.Address, typedData: DataLike<RpcTypes.TypedData>): Promise<TEth.Hex>;
    callBatched<TResult = any>(requests: TRpc.IRpcAction[]): Promise<TResult[]>;
    call<TResult extends PromiseLike<any>>(fn: (wClient: WClient) => TResult, options?: {
        batchRequestCount?: number;
    }): Promise<{
        status: ClientStatus;
        error?: any;
        result?: Awaited<TResult>;
        time: number;
    }>;
    callPromiEvent<TResult extends PromiseEvent<any>>(fn: (web3: WClient) => TResult): TResult;
    callSubscription<TResult extends PromiseEvent<any>>(fn: (web3: WClient) => TResult): TResult;
    onComplete(status: ClientStatus, timeMs: number): void;
    ensureConnected(): Promise<Error>;
    getRequestCount(): number;
    /**
     * Checks the rate limit wait time, so that the POOL can select the wClient with shortest wait time
     **/
    getRateLimitGuardTime(): number;
    private getSpanLimit;
}