import { Address, NumberAsString, OptimalSwapExchange, SwapSide } from '@paraswap/core';
import { AsyncOrSync } from 'ts-essentials';
import { Network } from '../../constants';
import { IDexHelper } from '../../dex-helper';
import { AdapterExchangeParam, DexExchangeParam, ExchangePrices, ExchangeTxInfo, Logger, PoolLiquidity, PoolPrices, PreprocessTransactionOptions, Token, TransferFeeParams } from '../../types';
import { IDex } from '../idex';
import { SimpleExchangeWithRestrictions } from '../simple-exchange-with-restrictions';
import { CablesData } from './types';
import { Interface } from 'ethers/lib/utils';
import { BebopData } from '../bebop/types';
export declare class Cables extends SimpleExchangeWithRestrictions implements IDex<any> {
    readonly network: Network;
    readonly dexKey: string;
    readonly dexHelper: IDexHelper;
    readonly mainnetRFQAddress: string;
    protected rfqInterface: Interface;
    static dexKeysWithNetwork: {
        key: string;
        networks: Network[];
    }[];
    readonly isStatePollingDex = true;
    private readonly rateFetcher;
    logger: Logger;
    private tokensMap;
    hasConstantPriceLargeAmounts: boolean;
    constructor(network: Network, dexKey: string, dexHelper: IDexHelper, mainnetRFQAddress?: string, rfqInterface?: Interface);
    preProcessTransaction(optimalSwapExchange: OptimalSwapExchange<CablesData>, srcToken: Token, destToken: Token, side: SwapSide, options: PreprocessTransactionOptions): Promise<[OptimalSwapExchange<CablesData>, ExchangeTxInfo]>;
    getAdapterParam(srcToken: string, destToken: string, srcAmount: string, destAmount: string, data: BebopData, side: SwapSide): AdapterExchangeParam;
    getDexParam(srcToken: Address, destToken: Address, srcAmount: NumberAsString, destAmount: NumberAsString, recipient: Address, data: CablesData, side: SwapSide): DexExchangeParam;
    normalizeToken(token: Token): Token;
    normalizeTokenAddress(address: Address): Address;
    getPoolIdentifier(srcAddress: Address, destAddress: Address): string;
    getPoolIdentifiers(srcToken: Token, destToken: Token, side: SwapSide, blockNumber: number): Promise<string[]>;
    calculateOrderPrice(amounts: bigint[], orderbook: string[][], baseToken: Token, quoteToken: Token, isInputQuote: boolean): bigint[];
    calculatePriceSwap(prices: string[][], requiredQty: number, qtyMode: Boolean): any;
    getPricesVolume(srcToken: Token, destToken: Token, amounts: bigint[], side: SwapSide, blockNumber: number, limitPools?: string[], transferFees?: TransferFeeParams, isFirstSwap?: boolean): Promise<ExchangePrices<CablesData> | null>;
    getCalldataGasCost(poolPrices: PoolPrices<CablesData>): number | number[];
    initializePricing(blockNumber: number): Promise<void>;
    getAdapters(side: SwapSide): {
        name: string;
        index: number;
    }[] | null;
    releaseResources?(): AsyncOrSync<void>;
    normalizeAddress(address: string): string;
    setTokensMap(): Promise<void>;
    getTopPoolsForToken(tokenAddress: Address, limit: number): Promise<PoolLiquidity[]>;
    /**
     * CACHED UTILS
     */
    getCachedTokens(): Promise<any>;
    getCachedPairs(): Promise<any>;
    getCachedPrices(): Promise<any>;
    getCachedTokensAddr(): Promise<any>;
    getPairString(baseToken: Token, quoteToken: Token): string;
    private findKeyByAddress;
    getPairData(srcToken: Token, destToken: Token): Promise<any>;
}