import { Token, Address, ExchangePrices, PoolPrices, AdapterExchangeParam, SimpleExchangeParam, PoolLiquidity, Logger, ExchangeTxInfo, OptimalSwapExchange, PreprocessTransactionOptions, TransferFeeParams, NumberAsString, DexExchangeParam } from '../../types';
import { SwapSide, Network } from '../../constants';
import { IDex } from '../idex';
import { IDexHelper } from '../../dex-helper/idex-helper';
import { DexalotData, PairData, PairDataMap, PriceDataMap, DexalotAPIParameters, TokenAddrDataMap, TokenDataMap } from './types';
import { SimpleExchangeWithRestrictions } from '../simple-exchange-with-restrictions';
import { Interface } from 'ethers/lib/utils';
import { Method } from '../../dex-helper/irequest-wrapper';
export declare class Dexalot extends SimpleExchangeWithRestrictions implements IDex<DexalotData> {
    readonly network: Network;
    readonly dexKey: string;
    readonly dexHelper: IDexHelper;
    protected adapters: import("../../types").AdapterMappings;
    readonly dexalotRouterAddress: string;
    protected rfqInterface: Interface;
    readonly isStatePollingDex = true;
    readonly hasConstantPriceLargeAmounts = false;
    readonly needWrapNative = false;
    readonly isFeeOnTransferSupported = false;
    private rateFetcher;
    private dexalotAuthToken;
    private pricesCacheKey;
    private pairsCacheKey;
    private tokensAddrCacheKey;
    private tokensCacheKey;
    private tokensMap;
    static dexKeysWithNetwork: {
        key: string;
        networks: Network[];
    }[];
    logger: Logger;
    constructor(network: Network, dexKey: string, dexHelper: IDexHelper, adapters?: import("../../types").AdapterMappings, dexalotRouterAddress?: string, rfqInterface?: Interface);
    initializePricing(blockNumber: number): Promise<void>;
    getAdapters(side: SwapSide): {
        name: string;
        index: number;
    }[] | null;
    getPairString(baseToken: Token, quoteToken: Token): string;
    getPairData(srcToken: Token, destToken: Token): Promise<PairData | null>;
    getIdentifier(srcAddress: Address, destAddress: Address): string;
    getPoolIdentifiers(srcToken: Token, destToken: Token, side: SwapSide, blockNumber: number): Promise<string[]>;
    getCachedPairs(): Promise<PairDataMap | null>;
    getCachedPrices(): Promise<PriceDataMap | null>;
    getCachedTokensAddr(): Promise<TokenAddrDataMap | null>;
    getCachedTokens(): Promise<TokenDataMap | null>;
    normalizeAddress(address: string): string;
    denormalizeAddress(address: string): string;
    normalizeToken(token: Token): Token;
    denormalizeToken(token: Token): Token;
    calculateOrderPrice(amounts: bigint[], orderbook: string[][], baseToken: Token, quoteToken: Token, isInputQuote: boolean): bigint[];
    getPricesVolume(srcToken: Token, destToken: Token, amounts: bigint[], side: SwapSide, blockNumber: number, limitPools?: string[], transferFees?: TransferFeeParams): Promise<null | ExchangePrices<DexalotData>>;
    generateRFQError(errorStr: string, swapIdentifier: string): void;
    preProcessTransaction(optimalSwapExchange: OptimalSwapExchange<DexalotData>, srcToken: Token, destToken: Token, side: SwapSide, options: PreprocessTransactionOptions): Promise<[OptimalSwapExchange<DexalotData>, ExchangeTxInfo]>;
    getCalldataGasCost(poolPrices: PoolPrices<DexalotData>): number | number[];
    getTokenFromAddress(address: Address): Token;
    getAdapterParam(srcToken: string, destToken: string, srcAmount: string, destAmount: string, data: DexalotData, side: SwapSide): AdapterExchangeParam;
    getSimpleParam(srcToken: string, destToken: string, srcAmount: string, destAmount: string, data: DexalotData, side: SwapSide): Promise<SimpleExchangeParam>;
    getDexParam(srcToken: Address, destToken: Address, srcAmount: NumberAsString, destAmount: NumberAsString, recipient: Address, data: DexalotData, side: SwapSide): DexExchangeParam;
    getTopPoolsForToken(tokenAddress: Address, limit: number): Promise<PoolLiquidity[]>;
    getAPIReqParams(endpoint: string, method: Method): DexalotAPIParameters;
    releaseResources(): void;
}