import { BigNumber, providers } from 'ethers';
import BaseService from '../commons/BaseService';
import { eEthereumTxType, EthereumTransactionTypeExtended, tEthereumAddress, transactionType } from '../commons/types';
import { ERC20_2612Interface } from '../erc20-2612';
import { IERC20ServiceInterface } from '../erc20-contract';
import { IERC721ServiceInterface } from '../erc721-contract';
import { WETHGatewayInterface } from '../wethgateway-contract';
import { WPunkGatewayInterface } from '../wpunkgateway-contract';
import { LPAcceptBidWithCredit, LPAuction, LPBatchBuyWithCredit, LPBorrowParamsType, LPBuyWithCredit, LPERC721LiquidationCall, LPFlashClaim, LPLiquidationCall, LPLiquidationERC721, LPRepayParamsType, LPRepayWithPermitParamsType, LPRepayWithPTokensType, LPSetERC721UsageAsCollateral, LPSetUsageAsCollateral, LPSignERC20ApprovalType, LPSupplyERC721ParamsType, LPSupplyParamsType, LPSupplyWithPermitType, LPWithdrawERC721ParamsType, LPWithdrawParamsType } from './lendingPoolTypes';
import { ApeCoinStaking, DataTypes, IPool } from './typechain/IPool';
import ApeCompoundStrategyStruct = DataTypes.ApeCompoundStrategyStruct;
export declare type BatchEventResultMap = Record<number, {
    fulfilled: boolean;
    rejected: boolean;
}>;
export declare type BatchEventResultCallback = (resultMap: BatchEventResultMap, finished: boolean) => void;
export interface PoolInterface {
    supply: (args: LPSupplyParamsType) => Promise<EthereumTransactionTypeExtended[]>;
    supplyERC721: (args: LPSupplyERC721ParamsType) => Promise<EthereumTransactionTypeExtended[]>;
    signERC20Approval: (args: LPSignERC20ApprovalType) => Promise<string>;
    supplyWithPermit: (args: LPSupplyWithPermitType) => Promise<EthereumTransactionTypeExtended[]>;
    withdraw: (args: LPWithdrawParamsType) => Promise<EthereumTransactionTypeExtended[]>;
    withdrawERC721: (args: LPWithdrawERC721ParamsType) => Promise<EthereumTransactionTypeExtended[]>;
    borrow: (args: LPBorrowParamsType) => Promise<EthereumTransactionTypeExtended[]>;
    repay: (args: LPRepayParamsType) => Promise<EthereumTransactionTypeExtended[]>;
    repayWithPermit: (args: LPRepayWithPermitParamsType) => Promise<EthereumTransactionTypeExtended[]>;
    setUsageAsCollateral: (args: LPSetUsageAsCollateral) => Promise<EthereumTransactionTypeExtended[]>;
    setUserUseERC721AsCollateral: (args: LPSetERC721UsageAsCollateral) => Promise<EthereumTransactionTypeExtended[]>;
    flashClaim: (args: LPFlashClaim) => Promise<EthereumTransactionTypeExtended[]>;
    buyWithCredit: (args: LPBuyWithCredit) => Promise<EthereumTransactionTypeExtended[]>;
    batchBuyWithCredit: (args: LPBatchBuyWithCredit) => Promise<EthereumTransactionTypeExtended[]>;
    startAuction: (args: LPAuction) => Promise<EthereumTransactionTypeExtended[]>;
    endAuction: (args: LPAuction) => Promise<EthereumTransactionTypeExtended[]>;
    liquidationERC721: (args: LPLiquidationERC721) => Promise<EthereumTransactionTypeExtended[]>;
}
export declare type LendingPoolMarketConfigV3 = {
    POOL: tEthereumAddress;
    WETH_GATEWAY?: tEthereumAddress;
    CrytoPunkAddress?: tEthereumAddress;
    WpunkGatewayAddress?: tEthereumAddress;
};
export declare type FulfillmentComponent = {
    orderIndex: number;
    itemIndex: number;
};
export declare type Fulfillment = {
    offerComponents: FulfillmentComponent[];
    considerationComponents: FulfillmentComponent[];
};
export declare class Pool extends BaseService<IPool> implements PoolInterface {
    readonly erc20Service: IERC20ServiceInterface;
    readonly erc721Service: IERC721ServiceInterface;
    readonly poolAddress: string;
    readonly crytoPunkAddress: string;
    readonly wethGatewayService: WETHGatewayInterface;
    readonly wpunkGatewayService: WPunkGatewayInterface;
    readonly erc20_2612Service: ERC20_2612Interface;
    constructor(provider: providers.Provider, lendingPoolConfig?: LendingPoolMarketConfigV3);
    supply({ user, reserve, amount, onBehalfOf, referralCode }: LPSupplyParamsType): Promise<EthereumTransactionTypeExtended[]>;
    supplyERC721({ user, reserve, token_ids, onBehalfOf, referralCode, }: LPSupplyERC721ParamsType): Promise<EthereumTransactionTypeExtended[]>;
    signERC20Approval({ user, reserve, amount, deadline }: LPSignERC20ApprovalType): Promise<string>;
    supplyWithPermit({ user, reserve, onBehalfOf, amount, referralCode, signature, deadline, }: LPSupplyWithPermitType): Promise<EthereumTransactionTypeExtended[]>;
    withdraw({ user, reserve, amount, onBehalfOf, aTokenAddress }: LPWithdrawParamsType): Promise<EthereumTransactionTypeExtended[]>;
    withdrawERC721({ user, reserve, token_ids, onBehalfOf, xTokenAddress, }: LPWithdrawERC721ParamsType): Promise<EthereumTransactionTypeExtended[]>;
    borrow({ user, reserve, amount, debtTokenAddress, onBehalfOf, referralCode, }: LPBorrowParamsType): Promise<EthereumTransactionTypeExtended[]>;
    repay({ user, reserve, amount, onBehalfOf }: LPRepayParamsType): Promise<EthereumTransactionTypeExtended[]>;
    repayWithPTokens({ user, amount, reserve }: LPRepayWithPTokensType): Promise<EthereumTransactionTypeExtended[]>;
    repayWithPermit({ user, reserve, amount, onBehalfOf, signature, deadline, }: LPRepayWithPermitParamsType): Promise<EthereumTransactionTypeExtended[]>;
    setUsageAsCollateral({ user, reserve, usageAsCollateral }: LPSetUsageAsCollateral): Promise<EthereumTransactionTypeExtended[]>;
    setUserUseERC721AsCollateral({ user, reserve, tokenIds, usageAsCollateral, }: LPSetERC721UsageAsCollateral): Promise<EthereumTransactionTypeExtended[]>;
    liquidationCall({ liquidator, liquidatedUser, debtReserve, collateralReserve, purchaseAmount, getAToken, liquidateAll, }: LPLiquidationCall): Promise<EthereumTransactionTypeExtended[]>;
    liquidationERC721Call({ liquidator, liquidatedUser, debtReserve, collateralReserve, collateralTokenId, purchaseAmount, getNToken, liquidateAll, }: LPERC721LiquidationCall): Promise<EthereumTransactionTypeExtended[]>;
    flashClaim({ user, receiver, nftAssets, tokenIds, airdropContractAddr, airdropTokenTypes, airdropTokenAddrs, airdropTokenIds, airdropEncodedData, }: LPFlashClaim): Promise<EthereumTransactionTypeExtended[]>;
    getUserAccountData({ user }: {
        user: string;
    }): Promise<[BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
        totalCollateralBase: BigNumber;
        totalDebtBase: BigNumber;
        availableBorrowsBase: BigNumber;
        currentLiquidationThreshold: BigNumber;
        ltv: BigNumber;
        healthFactor: BigNumber;
        erc721HealthFactor: BigNumber;
    }>;
    buyWithCredit({ marketProtocolAddr, marketPlaceType, marketProtocolData, onBehalfOf, buyNowAmount, payLaterAmount, }: LPBuyWithCredit): Promise<EthereumTransactionTypeExtended[]>;
    batchBuyWithCredit({ marketProtocolAddrs, marketPlaceTypes, marketProtocolData, onBehalfOf, buyNowAmount, payLaterAmount, }: LPBatchBuyWithCredit): Promise<EthereumTransactionTypeExtended[]>;
    acceptBidWithCredit({ orderProtocolData, acceptProtocolData, marketProtocolAddr, creditData, onBehalfOf, isCollectionBid, nftId, }: LPAcceptBidWithCredit): Promise<EthereumTransactionTypeExtended[]>;
    startAuction({ user, collateralAsset, collateralTokenId, from }: LPAuction): Promise<EthereumTransactionTypeExtended[]>;
    endAuction({ user, collateralAsset, collateralTokenId, from }: LPAuction): Promise<EthereumTransactionTypeExtended[]>;
    setAuctionValidityTime({ user, from }: {
        user: tEthereumAddress;
        from: tEthereumAddress;
    }): Promise<EthereumTransactionTypeExtended[]>;
    liquidationERC721({ from, user, collateralAsset, collateralTokenId, liquidationAmount, receiveNToken, }: LPLiquidationERC721): Promise<EthereumTransactionTypeExtended[]>;
    getUserConfiguration({ user }: {
        user: tEthereumAddress;
    }): Promise<DataTypes.UserConfigurationMapStructOutput>;
    getAuctionData({ asset, tokenId, }: {
        asset: string;
        tokenId: string;
    }): Promise<DataTypes.AuctionDataStructOutput>;
    decreaseLiquidity({ asset, tokenId, liquidityDecrease, amount0Min, amount1Min, onBehalfOf, receiveETHAsWETH, }: {
        asset: string;
        tokenId: string;
        liquidityDecrease: string;
        amount0Min: string;
        amount1Min: string;
        onBehalfOf: string;
        receiveETHAsWETH: boolean;
    }): EthereumTransactionTypeExtended;
    depositApeCoin({ address, apeCoinAddress, tokenId, borrowAmount, cashAmount, bakcTokenId, bakcBorrowAmount, bakcCashAmount, user, }: {
        address: string;
        apeCoinAddress: string;
        tokenId: number;
        borrowAmount: number;
        cashAmount: number;
        bakcTokenId?: number;
        bakcBorrowAmount?: number;
        bakcCashAmount?: number;
        user: string;
    }): EthereumTransactionTypeExtended;
    withdrawApeCoin(address: string, nfts: ApeCoinStaking.SingleNftStruct[], user: string): EthereumTransactionTypeExtended;
    claimApecoin(address: string, tokenIds: number[], user: string): {
        tx: () => Promise<transactionType>;
        txType: eEthereumTxType;
        gas: import("../commons/types").GasResponse;
    };
    unstakeApePositionAndRepay(address: string, tokenId: number, user: string): {
        tx: () => Promise<transactionType>;
        txType: eEthereumTxType;
        gas: import("../commons/types").GasResponse;
    };
    withdrawBAKC(address: string, user: string, bakcPaired: {
        mainTokenId: number;
        bakcTokenId: number;
        amount: number;
        isUncommit: boolean;
    }): {
        tx: () => Promise<transactionType>;
        txType: eEthereumTxType;
        gas: import("../commons/types").GasResponse;
    };
    claimBAKC(address: string, user: string, bakcPaired: Array<{
        mainTokenId: number;
        bakcTokenId: number;
    }>): {
        tx: () => Promise<transactionType>;
        txType: eEthereumTxType;
        gas: import("../commons/types").GasResponse;
    };
    getUserApeCompoundStrategy(user: string): Promise<DataTypes.ApeCompoundStrategyStructOutput>;
    /**
     *
     * @param strategy
     *  {
     *         ty: 0;
     *         swapTokenOut: 0 ;
     *         uint256 swapPercent: 0.6 * 10000;
     *  }
     */
    setApeCompoundStrategy(strategy: ApeCompoundStrategyStruct, user: string): {
        tx: () => Promise<transactionType>;
        txType: eEthereumTxType;
        gas: import("../commons/types").GasResponse;
    };
    movePositionFromBendDAO(loanIds: string[], user: string): {
        tx: () => Promise<transactionType>;
        txType: eEthereumTxType;
        gas: import("../commons/types").GasResponse;
    };
    getReserveData(asset: string): Promise<DataTypes.ReserveDataStructOutput>;
    initiateBlurExchangeRequest(blurBuyWithCreditRequestStructs: DataTypes.BlurBuyWithCreditRequestStruct[], user: string): Promise<{
        tx: () => Promise<transactionType>;
        txType: eEthereumTxType;
        gas: import("../commons/types").GasResponse;
    }>;
    listenBlurExchangeRequestResultEvent(list: Array<{
        collection: string;
        tokenId: number;
    }>, callback: BatchEventResultCallback): void;
    getReserveDataInBatch(assets: string[]): Promise<DataTypes.ReserveDataStructOutput[]>;
    initiateAcceptBlurBidsRequest(requests: DataTypes.AcceptBlurBidsRequestStruct[], user: string): {
        tx: () => Promise<transactionType>;
        txType: eEthereumTxType;
        gas: import("../commons/types").GasResponse;
    };
    fulfillAcceptBlurBidsRequest(requests: DataTypes.AcceptBlurBidsRequestStruct[], user: string): {
        tx: () => Promise<transactionType>;
        txType: eEthereumTxType;
        gas: import("../commons/types").GasResponse;
    };
    rejectAcceptBlurBidsRequest(requests: DataTypes.AcceptBlurBidsRequestStruct[], user: string): {
        tx: () => Promise<transactionType>;
        txType: eEthereumTxType;
        gas: import("../commons/types").GasResponse;
    };
    getAcceptBlurBidsRequestStatus(request: DataTypes.AcceptBlurBidsRequestStruct): Promise<number>;
}
//# sourceMappingURL=index.d.ts.map