import { CondensedAsset, NetworkAssets } from '../../types/api/assets';
import { BridgeParams, BridgeStep, BridgeValidation } from '../../types/api/bridge';
import { NonFungibleTokenFee } from '../../types/api/fees';
import { NetworkReserveAmounts, Network, AssetReserveAmounts, AssetMinAmount, NetworkMinAmounts } from '../../types/api/networks';
import { PaginatedTransfers, TransferParams } from '../../types/api/transfers';
import { Fetcher } from '../../utils/fetch.js';
export declare class HashportApiClient {
    private baseUrl;
    private configUrl;
    constructor(mode?: 'mainnet' | 'testnet');
    /**
     * Returns an array of objects representing assets on each supported network.
     * Assets are a map of the token's EVM address or Hedera ID to the token details.
     */
    assets(): Fetcher<NetworkAssets[], Record<string, unknown>, NetworkAssets[]>;
    /**
     * Returns reserve amounts for supported assets. If no parameters are
     * provided, it will return an object where the keys are the chain ids of
     * each supported network mapped to token objects. These token objects are
     * maps of the token's EVM address or Hedera ID mapped to the token's
     * reserve amounts and details.
     *
     * You can also provide the network chain id and EVM address / Hedera ID as
     * parameters. This will only return token reserve amounts and details
     * related to one token. */
    assetAmounts(): Fetcher<NetworkReserveAmounts>;
    assetAmounts(networkId: number, assetId: string): Fetcher<AssetReserveAmounts>;
    /**
     * Returns a mapping of supported chain id to block explorer url.
     */
    explorers(): Fetcher<Record<number, string>>;
    /**
     * Validates a bridging operation, returning a error if any of the
     * parameters have been input incorrectly.
     */
    validateBridgeParams(params: BridgeParams): Fetcher<BridgeValidation>;
    /**
     * Returns an array of steps to follow in order to execute a porting
     * transaction.
     *
     * Steps can be of 3 types: `Hedera`, `polling`, or `evm`.
     * `Hedera` steps will include parameters to pass to a particulate transaction
     * query, `polling` steps include a polling interval in seconds, and `evm`
     * steps will provide an abi for making a contract call.
     *  */
    bridge(params: BridgeParams): Fetcher<BridgeStep[]>;
    /**
     * Returns fee amounts pertaining to NFT porting operations. Return value
     * is a mapping of a network's chain id to the supported NFTs of that
     * network. Each NFT object is also a map where the key represents the
     * collection id, and the value is the fee data.
     */
    nftFees(): Fetcher<NonFungibleTokenFee>;
    /**
     * Returns supported network names and chain ids.
     * */
    networks(): Fetcher<Network[]>;
    /**
     * Returns all supported assets for a given network. Return value is a
     * mapping of the token's EVM address or Hedera ID to its info. If
     * `bridgeableNetworks` is present in the token info payload, it represents
     * a mapping of bridgeable network chain ids to a `network` object and the
     * `wrappedAsset`'s address/ID.
     *
     * You can optionally pass in an id to get information related to a specific
     * token. If the asset is not supported, an error will be thrown.
     */
    networkAssets(networkChainId: number): Fetcher<Record<string, CondensedAsset>>;
    networkAssets(networkChainId: number, assetId: string): Fetcher<CondensedAsset>;
    /**
     * Returns minimum amounts required to complete a porting transaction. If
     * no parameters are provided, it will return an object where the keys
     * represent the network's chain id and the values are a 1 to 1 pairing of
     * the token's EVM address or Hedera ID to the amount. The amounts are
     * presented as strings representing the smallest denomination of the
     * token, according to its decimals.
     */
    minAmounts(): Fetcher<NetworkMinAmounts>;
    minAmounts(networkId: number, assetId: string): Fetcher<AssetMinAmount>;
    /**
     * Returns the total count of transfers that have occured on the bridge
     * along with an array of transfer information. The return value is
     * paginated and each payload is limited to 50 items. You can also filter
     * results by originator, timestamp (must be in RFC3339Nano format), token
     * id, and transaction id.
     */
    transfers(params?: TransferParams): Fetcher<PaginatedTransfers>;
}