import { Token, Address, ExchangePrices, PoolPrices, AdapterExchangeParam, PoolLiquidity, TransferFeeParams, Logger, DexExchangeParam, NumberAsString } from '../../types';
import { SwapSide, Network } from '../../constants';
import { Interface } from 'ethers/lib/utils';
import { IDex } from '../../dex/idex';
import { IDexHelper } from '../../dex-helper/idex-helper';
import { AlgebraIntegralData, Pool } from './types';
import { SimpleExchange } from '../simple-exchange';
import { AlgebraIntegralEventPool } from './algebra-integral-pool';
export declare class AlgebraIntegral extends SimpleExchange implements IDex<AlgebraIntegralData> {
    readonly network: Network;
    readonly dexKey: string;
    readonly dexHelper: IDexHelper;
    readonly routerIface: Interface;
    readonly quoterIface: Interface;
    readonly config: import("./types").DexParams;
    readonly EventPoolImplementation: typeof AlgebraIntegralEventPool;
    readonly hasConstantPriceLargeAmounts = false;
    readonly needWrapNative = true;
    readonly isFeeOnTransferSupported = true;
    private readonly factory;
    private updatePoolsTvlTimer?;
    private feeUpdateIntervalTask?;
    protected eventPools: Record<string, AlgebraIntegralEventPool | null>;
    private poolInitPromises;
    private topPoolsCache;
    protected stateMulticallIface: Interface;
    static dexKeysWithNetwork: {
        key: string;
        networks: Network[];
    }[];
    logger: Logger;
    constructor(network: Network, dexKey: string, dexHelper: IDexHelper, routerIface?: Interface, quoterIface?: Interface, config?: import("./types").DexParams, EventPoolImplementation?: typeof AlgebraIntegralEventPool);
    initializePricing(blockNumber: number): Promise<void>;
    getPool(token0: Address, token1: Address, deployer: string, poolAddress: Address, blockNumber: number): Promise<AlgebraIntegralEventPool | null>;
    private _initPool;
    protected updateAllPoolFees(): Promise<void>;
    getAdapters(side: SwapSide): {
        name: string;
        index: number;
    }[] | null;
    getPoolIdentifier(srcAddress: Address, destAddress: Address, deployerAddress: Address): string;
    getPoolIdentifiers(srcToken: Token, destToken: Token, side: SwapSide, blockNumber: number): Promise<string[]>;
    getPricesVolume(srcToken: Token, destToken: Token, amounts: bigint[], side: SwapSide, blockNumber: number, limitPools?: string[], transferFees?: TransferFeeParams): Promise<null | ExchangePrices<AlgebraIntegralData>>;
    protected getPricingFromRpc(from: Token, to: Token, amounts: bigint[], side: SwapSide, pools: Pool[], transferFees: TransferFeeParams, blockNumber: number): Promise<Array<{
        prices: bigint[];
        gasCost: number | number[];
        pool: Pool;
    }>>;
    buildQuoteCallData(from: string, to: string, deployer: string, amount: bigint, isSELL: boolean): {
        target: string;
        gasLimit: number;
        callData: string;
        decodeFunction: (result: import("../../lib/multi-wrapper").MultiResult<import("@ethersproject/bytes").BytesLike> | import("@ethersproject/bytes").BytesLike) => bigint;
    };
    getCalldataGasCost(poolPrices: PoolPrices<AlgebraIntegralData>): number | number[];
    getDexParam(srcToken: Address, destToken: Address, srcAmount: NumberAsString, destAmount: NumberAsString, recipient: Address, data: AlgebraIntegralData, side: SwapSide): DexExchangeParam;
    getAdapterParam(srcToken: string, destToken: string, srcAmount: string, destAmount: string, data: AlgebraIntegralData, side: SwapSide): AdapterExchangeParam;
    updatePoolState(): Promise<void>;
    private querySubgraphPools;
    getTopPoolsForToken(tokenAddress: Address, limit: number): Promise<PoolLiquidity[]>;
    private _encodePath;
    private _sortTokens;
    releaseResources(): void;
}