import BigNumber from "bignumber.js";
import Web3 from "web3";
import BN from "bn.js";
import PromiEvent from "web3/promiEvent";
import { Provider } from "web3/providers";
import { NetworkData } from "./lib/network";
import { StorageProvider } from "./storage/interface";
import { BalanceAction, BalanceDetails, Config, MarketDetails, MatchDetails, NumberInput, Options, Order, OrderbookFilter, OrderInputs, OrderStatus, SwapperdBalanceDetails, SwapperdConnectionStatus, TokenCode, TraderOrder, Transaction, TransactionOptions, TransactionStatus, WBTCOrder, WithdrawTransactionOptions } from "./types";
import { DarknodeRegistryContract } from "./contracts/bindings/darknode_registry";
import { ERC20Contract } from "./contracts/bindings/erc20";
import { OrderbookContract } from "./contracts/bindings/orderbook";
import { RenExBalancesContract } from "./contracts/bindings/ren_ex_balances";
import { RenExSettlementContract } from "./contracts/bindings/ren_ex_settlement";
import { RenExTokensContract } from "./contracts/bindings/ren_ex_tokens";
import { WyreContract } from "./contracts/bindings/wyre";
export * from "./types";
export { errors } from "./errors";
export { StorageProvider } from "./storage/interface";
export { deserializeBalanceAction, deserializeTraderOrder, serializeBalanceAction, serializeTraderOrder } from "./storage/serializers";
/**
 * This is the concrete class that implements the IRenExSDK interface.
 *
 * @class RenExSDK
 */
export declare class RenExSDK {
    errors: {
        CouldNotFindSwap: string;
        CouldNotAuthorizeSwapper: string;
        InvalidBuffer: string;
        InvalidHex: string;
        UnableToConvertToHexadecimalRepresentation: string;
        UnableToConvertToBase64Representation: string;
        UnableToConvertToBuffer: string;
        UnableToRetrieveStatus: string;
        UnableToRetrieveSwaps: string;
        UnableToFindMatchingSwap: string;
        UnableToSubmitSwap: string;
        UserRejectedSwap: string;
        InvalidPrice: string;
        InvalidVolume: string;
        InvalidMinimumVolume: string;
        EthGasStationError: string;
        CouldNotConnectSwapServer: string;
        Unimplemented: string;
        CanceledByUser: string;
        SignatureCanceledByUser: string;
        UnsignedTransaction: string;
        InvalidOrderDetails: string;
        NumericalPrecision: string;
        FailedDeposit: string;
        FailedBalanceCheck: string;
        InsufficientBalance: string;
        InsufficientFunds: string;
        UnsupportedFilterStatus: string;
        UnknownOrderStatus: string;
        InvalidStoragePath: string;
    };
    _networkData: NetworkData;
    _swapperdConnectionStatus: SwapperdConnectionStatus;
    _storage: StorageProvider;
    _contracts: {
        renExSettlement: RenExSettlementContract;
        renExTokens: RenExTokensContract;
        renExBalances: RenExBalancesContract;
        orderbook: OrderbookContract;
        darknodeRegistry: DarknodeRegistryContract;
        erc20: Map<TokenCode, ERC20Contract>;
        wyre: WyreContract;
    };
    _cachedTokenDetails: Map<TokenCode, Promise<{
        addr: string;
        decimals: string | number | BN;
        registered: boolean;
    }>>;
    swapperd: {
        getStatus: () => SwapperdConnectionStatus;
        getID: () => Promise<string>;
        getVersion: () => Promise<string>;
        isConnected: () => boolean;
        refreshStatus: () => Promise<SwapperdConnectionStatus>;
        resetStatus: () => Promise<SwapperdConnectionStatus>;
        authorize: () => Promise<SwapperdConnectionStatus>;
        fetchBalances: (tokens: string[]) => Promise<Map<string, SwapperdBalanceDetails>>;
        fetchAddresses: (tokens: string[]) => Promise<string[]>;
        wrap: (amount: NumberInput, token: string) => Promise<WBTCOrder>;
        unwrap: (amount: NumberInput, token: string) => Promise<WBTCOrder>;
    };
    atom: {
        getStatus: () => SwapperdConnectionStatus;
        getID: () => Promise<string>;
        getVersion: () => Promise<string>;
        isConnected: () => boolean;
        refreshStatus: () => Promise<SwapperdConnectionStatus>;
        resetStatus: () => Promise<SwapperdConnectionStatus>;
        authorize: () => Promise<SwapperdConnectionStatus>;
        fetchBalances: (tokens: string[]) => Promise<Map<string, SwapperdBalanceDetails>>;
        fetchAddresses: (tokens: string[]) => Promise<string[]>;
        wrap: (amount: NumberInput, token: string) => Promise<WBTCOrder>;
        unwrap: (amount: NumberInput, token: string) => Promise<WBTCOrder>;
    };
    utils: {
        normalizePrice: (price: NumberInput, roundUp?: boolean | undefined) => NumberInput;
        normalizeVolume: (volume: NumberInput, roundUp?: boolean | undefined) => NumberInput;
        normalizeOrder: (order: OrderInputs) => OrderInputs;
    };
    private _web3;
    private _address;
    private _config;
    /**
     * Creates an instance of RenExSDK.
     * @param {Provider} provider
     * @memberof RenExSDK
     */
    constructor(provider: Provider, options?: Options);
    fetchBalances: (tokens: string[]) => Promise<Map<string, BalanceDetails>>;
    fetchBalanceActionStatus: (txHash: string) => Promise<TransactionStatus>;
    fetchOrderStatus: (orderID: string) => Promise<OrderStatus>;
    fetchMatchDetails: (orderID: string) => Promise<MatchDetails | undefined>;
    fetchOrderbook: (filter: OrderbookFilter) => Promise<Order[]>;
    fetchOrderBlockNumber: (orderID: string) => Promise<number>;
    fetchMarkets: () => Promise<MarketDetails[]>;
    fetchSupportedTokens: () => Promise<string[]>;
    fetchSupportedSwapperdTokens: () => Promise<string[]>;
    fetchSupportedAtomicTokens: () => Promise<string[]>;
    withdraw: (value: NumberInput, token: string, options?: WithdrawTransactionOptions | undefined) => Promise<{
        balanceAction: BalanceAction;
        promiEvent: PromiEvent<Transaction> | null;
    }>;
    openOrder: (order: OrderInputs, options?: TransactionOptions | undefined) => Promise<{
        traderOrder: TraderOrder;
        promiEvent: PromiEvent<Transaction> | null;
    }>;
    cancelOrder: (orderID: string, options?: TransactionOptions | undefined) => Promise<{
        promiEvent: PromiEvent<Transaction> | null;
    }>;
    fetchDarknodeFeePercent: () => Promise<BigNumber>;
    fetchWrappingFeePercent: () => Promise<BigNumber>;
    fetchUnwrappingFeePercent: () => Promise<BigNumber>;
    fetchMinEthTradeVolume: () => Promise<BigNumber>;
    fetchGasPrice: () => Promise<number | undefined>;
    fetchTraderOrders: (options?: {
        refresh: boolean;
    }) => Promise<TraderOrder[]>;
    fetchBalanceActions: (options?: {
        refresh: boolean;
    }) => Promise<BalanceAction[]>;
    refreshBalanceActionStatuses: () => Promise<Map<string, TransactionStatus>>;
    refreshOrderStatuses: () => Promise<Map<string, OrderStatus>>;
    getWeb3: () => Web3;
    getAddress: () => string;
    getConfig: () => Config;
    setAddress: (addr: string) => void;
    updateProvider: (provider: Provider) => void;
    private setupStorageProvider;
}
export default RenExSDK;