import { MonetaryAmount } from "@interlay/monetary-js";
import { ApiPromise } from "@polkadot/api";
import { AddressOrPair } from "@polkadot/api/types";
import { AccountId } from "@polkadot/types/interfaces";
import { DexStablePrimitivesPool, DexStablePrimitivesBasePool } from "@polkadot/types/lookup";
import { TokensAPI } from "./tokens";
import { CurrencyExt, LpCurrency, StableLpToken } from "../types";
import { LiquidityPool, Trade, PooledCurrencies, StandardLiquidityPool, StableLiquidityPool } from "./amm/";
import { ExtrinsicData } from "../types/extrinsic";
export interface AMMAPI {
    /**
     * Get all LP tokens.
     *
     * @returns {Promise<Array<LpCurrency>>} Array of all standard and stable LP tokens.
     */
    getLpTokens(): Promise<Array<LpCurrency>>;
    /**
     * Get optimal trade for provided trade type and amount.
     *
     * @param {MonetaryAmount<CurrencyExt>} inputAmount Amount to be exchanged.
     * @param {CurrencyExt} outputCurrency Currency to purchase.
     * @param {Array<LiquidityPool>} pools Array of all liquidity pools.
     * @returns {Trade | null} Optimal trade information or null if the trade is not possible.
     */
    getOptimalTrade(inputAmount: MonetaryAmount<CurrencyExt>, outputCurrency: CurrencyExt, pools: Array<LiquidityPool>): Trade | null;
    /**
     * Get liquidity provided by account.
     *
     * @param {AccountId} accountId Account to get provided liquidity information about.
     * @returns {Promise<Array<MonetaryAmount<LpCurrency>>>} Array of LP token amounts that represent
     *          account's positions in respective liquidity pools.
     */
    getLiquidityProvidedByAccount(accountId: AccountId): Promise<Array<MonetaryAmount<LpCurrency>>>;
    /**
     * Get all liquidity pools.
     *
     * @returns {Promise<Array<LiquidityPool>>} All liquidity pools.
     */
    getLiquidityPools(): Promise<Array<LiquidityPool>>;
    /**
     * Get claimable farming reward amounts for all farmed liquidity provided by account.
     *
     * @param accountId Account id for which to get claimable rewards.
     * @param accountLiquidity Amount of liquidity the account has provided.
     * @param pools All liquidity pools.
     * @returns Map of LpCurrency -> Array of reward monetary amounts.
     */
    getClaimableFarmingRewards(accountId: AccountId, accountLiquidity: Array<MonetaryAmount<LpCurrency>>, pools: Array<LiquidityPool>): Promise<Map<LpCurrency, Array<MonetaryAmount<CurrencyExt>>>>;
    /**
     * Swap assets.
     *
     * @param {Trade} trade Trade object containing information about the trade.
     * @param {MonetaryAmount<CurrencyExt>} minimumAmountOut Minimum output amount to be received.
     * @param {AddressOrPair} recipient Recipient address.
     * @param {number | string} deadline Deadline block for the swap transaction.
     * @returns {ExtrinsicData} A submittable extrinsic and an event that is emitted when extrinsic is submitted.
     */
    swap(trade: Trade, minimumAmountOut: MonetaryAmount<CurrencyExt>, recipient: AddressOrPair, deadline: number | string): ExtrinsicData;
    /**
     * Adds liquidity to liquidity pool
     *
     * @param {PooledCurrencies} amounts Array of monetary amounts of pooled currencies
     * sorted in the same order as in the pool.
     * @param {LiquidityPool} pool Type of liquidity pool.
     * @param {number} maxSlippage Maximum allowed slippage.
     * @param {number} deadline Deadline block number.
     * @param {AddressOrPair} recipient Recipient of the liquidity pool token.
     * @returns {Promise<ExtrinsicData>} A submittable extrinsic and an event that is emitted when extrinsic is submitted.
     */
    addLiquidity(amounts: PooledCurrencies, pool: LiquidityPool, maxSlippage: number, deadline: number, recipient: AddressOrPair): Promise<ExtrinsicData>;
    /**
     * Removes liquidity from pool.
     *
     * @param {MonetaryAmount<LpCurrency>} amount Amount of LP token to be removed
     * @param {LiquidityPool} pool Liquidity pool to remove from.
     * @param {number} maxSlippage Maximum allowed slippage.
     * @param {number} deadline Deadline block number.
     * @param {AddressOrPair} recipient Recipient of the pooled currencies.
     * @returns {Promise<ExtrinsicData>} A submittable extrinsic and an event that is emitted when extrinsic is submitted.
     * @note Removes `amount` of liquidity in LP token, breaks it down and transfers to account.
     */
    removeLiquidity(amount: MonetaryAmount<LpCurrency>, pool: LiquidityPool, maxSlippage: number, deadline: number, recipient: AddressOrPair): Promise<ExtrinsicData>;
    /**
     * Claim all pending farming rewards.
     *
     * @param claimableRewards Map of LpToken -> Array of reward monetary amounts -> supposed to be
     *                         output of `getClaimableFarmingRewards`
     * @returns {ExtrinsicData} A submittable extrinsic and an event that is emitted when extrinsic is submitted.
     */
    claimFarmingRewards(claimableRewards: Map<LpCurrency, Array<MonetaryAmount<CurrencyExt>>>): ExtrinsicData;
}
export declare class DefaultAMMAPI implements AMMAPI {
    private api;
    private tokensAPI;
    static getStablePoolInfo(poolData: DexStablePrimitivesPool): DexStablePrimitivesBasePool | null;
    static getStableLpTokenFromPoolData(poolId: number, basePoolData: DexStablePrimitivesBasePool): StableLpToken;
    constructor(api: ApiPromise, tokensAPI: TokensAPI);
    getOptimalTrade(inputAmount: MonetaryAmount<CurrencyExt>, outputCurrency: CurrencyExt, pools: Array<LiquidityPool>): Trade | null;
    getLiquidityProvidedByAccount(accountId: AccountId): Promise<Array<MonetaryAmount<LpCurrency>>>;
    private _getStandardLpTokens;
    private _getStableLpTokens;
    getLpTokens(): Promise<Array<LpCurrency>>;
    private _poolHasZeroLiquidity;
    private _getStandardPoolReserveBalances;
    private _getPoolRewardAmountsYearly;
    private _getStandardLiquidityPool;
    getStandardLiquidityPools(blockTimeMs: number): Promise<Array<StandardLiquidityPool>>;
    private _getStablePoolPooledCurrencies;
    private _getStablePoolAmplificationCoefficient;
    private _getStableBasePooledCurrenciesAdjustedToLpTokenAmount;
    private _getStableLiquidityPoolData;
    private _getStableMetaPoolBasePool;
    private _getStableLiquidityPool;
    getStableLiquidityPools(blockTimeMs: number): Promise<Array<StableLiquidityPool>>;
    getLiquidityPools(): Promise<Array<LiquidityPool>>;
    private _swapThroughStandardPoolsOnly;
    private _swapThroughStandardAndStablePools;
    private _getFarmingRewardCurrencyIds;
    private _getClaimableFarmingRewardsByPool;
    getClaimableFarmingRewards(accountId: AccountId, accountLiquidity: MonetaryAmount<LpCurrency>[], pools: LiquidityPool[]): Promise<Map<LpCurrency, Array<MonetaryAmount<CurrencyExt>>>>;
    swap(trade: Trade, minimumAmountOut: MonetaryAmount<CurrencyExt>, recipient: AddressOrPair, deadline: number | string): ExtrinsicData;
    private _getLiquidityDepositStandardPoolParams;
    private _getLiquidityDepositStablePoolParams;
    addLiquidity(amounts: PooledCurrencies, pool: LiquidityPool, maxSlippage: number, deadline: number, recipient: AddressOrPair): Promise<ExtrinsicData>;
    private _getLiquidityWithdrawalStandardPoolParams;
    private _getLiquidityWithdrawalStablePoolParams;
    removeLiquidity(amount: MonetaryAmount<LpCurrency>, pool: LiquidityPool, maxSlippage: number, // Percentage.
    deadline: number, recipient: AddressOrPair): Promise<ExtrinsicData>;
    claimFarmingRewards(claimableRewards: Map<LpCurrency, MonetaryAmount<CurrencyExt>[]>): ExtrinsicData;
}