import { HttpProvider, WebsocketProvider } from 'web3-providers';
import { ProviderType, Web3Versions } from '../enums';
import { IExtraProviderLoggingOptions } from '../models/iextra-provider-logging-options';
import { IBaseProviderOptions } from './models/ibase-provider-options';
import { IBulkSaveToLogs } from './models/ibulk-save-to-logs';
import { ISendAsyncPayload } from './models/isend-async-payload';
export declare class TerminalBaseProvider {
    private _providerType;
    private _isCustomProvider;
    private _baseOptions;
    connected: boolean;
    host: string | undefined;
    protected web3Version: Web3Versions;
    protected extraProviderLoggingOptions?: IExtraProviderLoggingOptions | undefined;
    protected _provider: HttpProvider | WebsocketProvider;
    protected _chainId: string | undefined;
    private _apiService;
    private _baseProviderOptions;
    constructor(_providerType: ProviderType, _isCustomProvider: boolean, _baseOptions: IBaseProviderOptions);
    /**
     * Save to logs
     * @param payload The payload
     * @param result The result
     * @param responseTimeMs The response time
     * @param isError If its a error
     */
    saveJsonRpcLog(payload: ISendAsyncPayload, result: any, responseTimeMs: number | undefined, isError?: boolean): Promise<void>;
    /**
     * Send async jsonrpc method interceptor (backwards compatibility)
     * @param payload The jsonrpc payload
     * @param callback The callback
     */
    sendAsync(payload: ISendAsyncPayload | ISendAsyncPayload[], callback: (error: Error | null, result: any) => void): Promise<void>;
    /**
     * Send jsonrpc method interceptor
     * @param method The jsonrpc method (in some old cases it may send the `ISendAsyncPayload` interface)
     * @param parameters The parameters
     * @param _fromSendAsync This tells us if send async did the call which means `saveJsonRpcLog` has already
     *                       been called. web3 have different behaviour between 1.0 and 2.0 so have to handle
     *                       some edge cases here.
     */
    send(methodOrPayload: string | ISendAsyncPayload, parameters?: any[], _fromSendAsync?: boolean): Promise<any>;
    /**
     * Send batch will just send 1 at the time for now
     * @param methods The method
     * @param moduleInstance The module instances
     */
    sendBatch(methods: any[], moduleInstance: any): Promise<any[]>;
    /**
     * Get network id if provider has it
     */
    get networkVersion(): string | undefined;
    /**
     * Get selected addresss if the provider has it
     */
    get selectedAddress(): string | undefined | null;
    /**
     * Get chain id if the provider has it
     */
    get chainId(): string | undefined;
    /**
     * Expose enable
     */
    enable(): Promise<string[]>;
    /**
     * Register event listeners
     * @param eventName The event name
     * @param callback The callback
     */
    on(eventName: string, callback: Function): void;
    /**
     * Get chain id
     * @param provider The provider
     */
    protected getChainId(provider: any): Promise<string>;
    /**
     * Save bulk to logs
     * @param bulkPayloads The bulk payload
     */
    protected saveBulkToLogs(bulkPayloads: IBulkSaveToLogs[]): void;
    /**
     * Set the chain id
     */
    protected setChainId(provider: any, web3Version?: Web3Versions | undefined): Promise<void>;
    /**
     * Get websocket provider host
     */
    protected getWebsocketProviderHost(): string;
    /**
     * Send async ack to register integration in the backend
     */
    protected sendAck(chainId: string | undefined): Promise<void>;
    /**
     * Parse the network version
     * @param networkVersion The network version
     */
    private parseNetworkVerion;
    /**
     * Send async on the provider wrapped in a promise
     * so you can just await it and it will resolve the old style
     * callback for you
     * @param payload The JSONRPC payload
     */
    private sendAsyncOnProviderPromiseWrapper;
    /**
     * Get the host, we need to do this everytime so we can fetch the latest
     * nodeUrl on some providers who change that constantly
     */
    private getHost;
    /**
     * Get http provider host
     */
    private getHttpProviderHost;
    /**
     * Build up metamask error message for the logs
     * @param error The error
     */
    private buildUpMetaMaskErrorMessage;
    /**
     * On some providers like `web3-provider-engine` they expose
     * `sendAsync` over other the rest so handle edge case where providers
     * expose this over `send`
     * @param provider The provider
     */
    private shouldCallSendAsync;
    /**
     * Return true if using web3 provider engine
     */
    private isUsingWeb3ProviderEngine;
}