import { Account, AddressString, Asset, Block, Contract, DeveloperProvider, GetOptions, Hash256String, Input, InputOutput, IterOptions, NetworkSettings, NetworkType, Output, Peer, PrivateNetworkSettings, RawAction, RawCallReceipt, RawInvocationData, RelayTransactionResult, ScriptBuilderParam, StorageItem, Transaction, TransactionReceipt } from '@neo-one/client-common-browserify';
import BigNumber from 'bignumber.js';
import { JSONRPCProvider, JSONRPCProviderManager } from './JSONRPCProvider';
export interface NEOONEDataProviderOptions {
    readonly network: NetworkType;
    readonly rpcURL: string | JSONRPCProvider | JSONRPCProviderManager;
    readonly iterBlocksFetchTimeoutMS?: number;
    readonly iterBlocksBatchSize?: number;
}
export declare class NEOONEDataProvider implements DeveloperProvider {
    readonly network: NetworkType;
    private mutableClient;
    private readonly iterBlocksFetchTimeoutMS;
    private readonly iterBlocksBatchSize;
    constructor({ network, rpcURL, iterBlocksFetchTimeoutMS, iterBlocksBatchSize }: NEOONEDataProviderOptions);
    setRPCURL(rpcURL: string): void;
    getUnclaimed(address: AddressString): Promise<{
        readonly unclaimed: readonly Input[];
        readonly amount: BigNumber;
    }>;
    getClaimAmount(input: Input): Promise<BigNumber>;
    getUnspentOutputs(address: AddressString): Promise<readonly InputOutput[]>;
    relayTransaction(transaction: string): Promise<RelayTransactionResult>;
    getTransactionReceipt(hash: Hash256String, options?: GetOptions): Promise<TransactionReceipt>;
    getInvocationData(hash: Hash256String): Promise<RawInvocationData>;
    testInvoke(transaction: string): Promise<RawCallReceipt>;
    getAccount(address: AddressString): Promise<Account>;
    getAsset(hash: Hash256String): Promise<Asset>;
    getBlock(hashOrIndex: Hash256String | number, options?: GetOptions): Promise<Block>;
    iterBlocks(options?: IterOptions): AsyncIterable<Block>;
    getBestBlockHash(): Promise<Hash256String>;
    getBlockCount(): Promise<number>;
    getContract(address: AddressString): Promise<Contract>;
    getMemPool(): Promise<readonly Hash256String[]>;
    getTransaction(hash: Hash256String): Promise<Transaction>;
    getOutput(input: Input): Promise<Output>;
    getConnectedPeers(): Promise<readonly Peer[]>;
    getNetworkSettings(): Promise<NetworkSettings>;
    iterActionsRaw(options?: IterOptions): AsyncIterable<RawAction>;
    call(contract: AddressString, method: string, params: ReadonlyArray<ScriptBuilderParam | undefined>): Promise<RawCallReceipt>;
    runConsensusNow(): Promise<void>;
    updateSettings(options: Partial<PrivateNetworkSettings>): Promise<void>;
    getSettings(): Promise<PrivateNetworkSettings>;
    fastForwardOffset(seconds: number): Promise<void>;
    fastForwardToTime(seconds: number): Promise<void>;
    reset(): Promise<void>;
    getNEOTrackerURL(): Promise<string | undefined>;
    resetProject(): Promise<void>;
    iterStorage(address: AddressString): AsyncIterable<StorageItem>;
    private convertStorageItem;
    private convertBlock;
    private convertTransaction;
    private convertConfirmedTransaction;
    private convertTransactionBase;
    private convertAttributes;
    private convertInputs;
    private convertInput;
    private convertOutputs;
    private convertOutput;
    private convertContract;
    private convertContractParameterType;
    private convertInvocationData;
    private convertStorageChange;
    private convertAsset;
    private convertAssetType;
    private getAccountInternal;
    private convertNetworkSettings;
    private convertRelayTransactionResult;
    private convertVerifyResult;
    private capture;
}