import { Contract as ContractMulti, Provider as ProviderMulti } from 'ethcall';
import { BigNumber, Contract, Signer } from 'ethers';
import { Address, AuctionStatus, CallData, Loan, PoolInfoUtils, SignerOrProvider } from '../types';
import { ClaimableReserveAuction } from './ClaimableReserveAuction';
import { PoolUtils } from './PoolUtils';
import { Liquidation } from './Liquidation';
import { Bucket } from './Bucket';
export interface LoanEstimate extends Loan {
    /** hypothetical lowest utilized price (LUP) assuming additional debt was drawn */
    lup: BigNumber;
    /** index of this hypothetical LUP */
    lupIndex: number;
}
export interface DebtInfo {
    /** total unaccrued debt in pool at the current block height */
    pendingDebt: BigNumber;
    /** debt accrued by pool as of the last pool interaction */
    accruedDebt: BigNumber;
    /** debt under liquidation */
    debtInAuction: BigNumber;
}
export interface KickerInfo {
    /** liquidation bond able to be withdrawn */
    claimable: BigNumber;
    /** liquidation bond not yet able to be withdrawn */
    locked: BigNumber;
}
export interface PriceInfo {
    /** price of the highest price bucket with deposit */
    hpb: BigNumber;
    /** fenwick index of the HPB */
    hpbIndex: number;
    /** highest threshold price */
    htp: BigNumber;
    /** fenwick index of the HTP */
    htpIndex: number;
    /** lowest utilized price */
    lup: BigNumber;
    /** fenwick index of the LUP */
    lupIndex: number;
    /** lowest bucket at which withdrawals are locked due to liquidation debt */
    llb: BigNumber;
    /** fenwick index of the lowest liquidation locked bucket */
    llbIndex: number;
}
export interface Stats {
    /** amount of liquidity in the pool (including utilized liquidity) */
    poolSize: BigNumber;
    /** pending amount of debt in the pool */
    debt: BigNumber;
    /** amount of debt under liquidation */
    liquidationDebt: BigNumber;
    /** number of loans in the pool */
    loansCount: number;
    /** minimum amount of debt a borrower can draw */
    minDebtAmount: BigNumber;
    /** collateralization ratio expressed as percentage */
    collateralization: BigNumber;
    /** meaningful actual utilization of the pool (MAU) */
    actualUtilization: BigNumber;
    /** pool target utilization (TU), related to inverse of collateralization */
    targetUtilization: BigNumber;
    /** the amount of excess quote tokens */
    reserves: BigNumber;
    /** denominated in quote token, or `0` if no reserves can be auctioned */
    claimableReserves: BigNumber;
    /** amount of claimable reserves which has not yet been taken */
    claimableReservesRemaining: BigNumber;
    /** current price at which `1` quote token may be purchased, denominated in `Ajna` */
    reserveAuctionPrice: BigNumber;
    /** interest rate paid by borrowers */
    borrowRate: BigNumber;
    /** the timestamp of the last interest rate update. */
    interestRateLastUpdated: Date;
    /** can be multiplied by t0debt (obtained elsewhere) to determine current debt */
    pendingInflator: BigNumber;
}
/**
 * Abstract baseclass used for pools, regardless of collateral type.
 */
export declare abstract class Pool {
    provider: SignerOrProvider;
    contract: Contract;
    contractMulti: ContractMulti;
    poolInfoContractUtils: PoolInfoUtils;
    contractUtilsMulti: ContractMulti;
    poolAddress: Address;
    collateralAddress: Address;
    collateralSymbol?: string;
    quoteAddress: Address;
    quoteSymbol?: string;
    ajnaAddress: Address;
    name: string;
    utils: PoolUtils;
    ethcallProvider: ProviderMulti;
    lenderHelper: Contract;
    constructor(provider: SignerOrProvider, poolAddress: string, ajnaAddress: string, contract: Contract, contractMulti: ContractMulti);
    initialize(): Promise<void>;
    /**
     * Approve this pool to manage Ajna token.
     * @param signer pool user
     * @param allowance approval amount (or MaxUint256)
     * @returns promise to transaction
     */
    ajnaApprove(signer: Signer, allowance: BigNumber): Promise<import("../types").WrappedTransaction>;
    /**
     * Approve this pool to manage quote token.
     * @param signer pool user
     * @param allowance normalized approval amount (or MaxUint256)
     * @returns promise to transaction
     */
    quoteApprove(signer: Signer, allowance: BigNumber): Promise<import("../types").WrappedTransaction>;
    /**
     * Retrieves pool reference prices.
     * @returns {@link PriceInfo}
     */
    getPrices(): Promise<PriceInfo>;
    /**
     * Retrieves pool statistics.
     * @returns {@link Stats}
     */
    getStats(): Promise<Stats>;
    /**
     * Measuring from highest price bucket with liquidity, determines index at which all liquidity in
     * the book has been utilized by specified debt; useful for estimating LUP.
     * @param debtAmount pool debt to be applied to liquidity
     * @returns fenwick index
     */
    depositIndex(debtAmount: BigNumber): Promise<any>;
    /**
     * Enables signer to bundle transactions together atomically in a single request.
     * @param signer consumer initiating transactions
     * @param callData array of transactions to sign and submit
     * @returns promise to transaction
     */
    multicall(signer: Signer, callData: Array<CallData>): Promise<import("../types").WrappedTransaction>;
    lpAllowance(index: BigNumber, spender: Address, owner: Address): Promise<any>;
    increaseLPAllowance(signer: Signer, indexes: Array<number>, amounts: Array<BigNumber>): Promise<import("../types").WrappedTransaction>;
    /**
     * Checks if LP allowances are sufficient to memorialize position.
     * @param signer Consumer initiating transactions.
     * @param indices Fenwick index of the desired bucket.
     * @returns `true` if LP allowances are sufficient to memorialize position otherwise `false`.
     */
    areLPAllowancesSufficient(signer: Signer, indices: Array<number>): Promise<boolean>;
    /**
     * @param minPrice lowest desired price
     * @param maxPrice highest desired price
     * @returns array of {@link Bucket}s between specified prices
     */
    getBucketsByPriceRange(minPrice: BigNumber, maxPrice: BigNumber): Bucket[];
    /**
      Retrieves origination fee rate for this pool; multiply by new debt to get fee.
      @returns origination fee rate, in WAD precision
     */
    getOriginationFeeRate(): Promise<BigNumber>;
    /**
     * Retrieve information for a specific loan.
     * @param borrowerAddress identifies the loan
     * @returns {@link Loan}
     */
    getLoan(borrowerAddress: Address): Promise<Loan>;
    /**
     * Retrieve information for a list of loans.
     * @param borrowerAddresses identifies the loans
     * @returns map of Loans, indexed by borrowerAddress
     */
    getLoans(borrowerAddresses: Array<Address>): Promise<Map<Address, Loan>>;
    /**
     * @param borrowerAddress identifies the loan under liquidation
     * @returns {@link Liquidation} models liquidation of a specific loan
     */
    getLiquidation(borrowerAddress: Address): Liquidation;
    /**
     * Retrieve statuses for multiple liquidations from the PoolInfoUtils contract.
     * @param borrowerAddresses identifies loans under liquidation
     * @returns map of AuctionStatuses, indexed by borrower address
     */
    getLiquidationStatuses(borrowerAddresses: Array<Address>): Promise<Map<Address, AuctionStatus>>;
    /**
     * Calculates bond required to liquidate a borrower.
     * @param npTpRatio relationship between neutral price and threshold price
     * @param borrowerDebt loan debt
     * @returns required liquidation bond, in WAD precision
     */
    calculateLiquidationBond(npTpRatio: BigNumber, borrowerDebt: BigNumber): BigNumber;
    /**
     * Calculate a loan's neutral price.
     * @param thresholdPrice loan debt * 1.04 / pledged collateral
     * @param npTpRatio relationship between neutral price and threshold price
     * @returns neutral price, in WAD precision
     */
    calculateNeutralPrice(thresholdPrice: BigNumber, npTpRatio: BigNumber): BigNumber;
    /**
     * Calculate neutral price to threshold price approx. "ratio".
     * @param rate current pool "borrower" interest rate
     * @returns relationship between the neutral price and threshold price
     */
    calculateNpTpRatio(rate: BigNumber): BigNumber;
    /**
     * Initiates a liquidation of a loan.
     * @param signer kicker
     * @param borrowerAddress identifies the loan to liquidate
     * @param limitIndex reverts if neutral price of loan drops below this bucket before TX processed
     * @returns promise to transaction
     */
    kick(signer: Signer, borrowerAddress: Address, limitIndex?: number): Promise<import("../types").WrappedTransaction>;
    /**
     * Checks whether threshold price of a loan is currently above the LUP;
     * does NOT estimate whether it would be profitable to liquidate the loan.
     * @param borrowerAddress identifies the loan to check
     * @returns true if loan may be liquidated, otherwise false
     */
    isKickable(borrowerAddress: Address): Promise<boolean>;
    /**
     * Retrieves status of an auction kicker's liquidation bond.
     * @param kickerAddress identifies the actor who kicked liquidations
     */
    kickerInfo(kickerAddress: Address): Promise<KickerInfo>;
    /**
     * Called by kickers to withdraw liquidation bond from one or more auctions kicked.
     * @param signer kicker
     * @param maxAmount optional amount of bond to withdraw; defaults to all
     * @returns promise to transaction
     */
    withdrawBonds(signer: Signer, maxAmount?: BigNumber): Promise<import("../types").WrappedTransaction>;
    /**
     * Estimates how drawing more debt and/or pledging more collateral would impact loan.
     * @param borrowerAddress identifies the loan
     * @param debtAmount additional amount of debt to draw (or 0)
     * @param collateralAmount additional amount of collateral to pledge (or 0)
     * @returns {@link LoanEstimate}
     */
    estimateLoan(borrowerAddress: Address, debtAmount: BigNumber, collateralAmount: BigNumber): Promise<LoanEstimate>;
    /**
     * Estimates how repaying debt and/or pulling collateral would impact loan.
     * @param borrowerAddress identifies the loan
     * @param debtAmount amount of debt to repay (or 0)
     * @param collateralAmount amount of collateral to pull (or 0)
     * @returns {@link LoanEstimate}
     */
    estimateRepay(borrowerAddress: Address, debtAmount: BigNumber, collateralAmount: BigNumber): Promise<LoanEstimate>;
    /**
     * Determines whether interest rate will increase, decrease, or remain the same as a result of
     * updating the interest rate, without regard to the 12-hour rate update interval.
     * @param poolStats pool statistics obtained from @link{Pool.getStats}
     */
    estimateUpdateInterest(poolStats: Stats): BigNumber;
    /**
     * May be called periodically by actors to adjust interest rate if no other TXes have occurred
     * in the past 12 hours.
     * @param signer actor who wants to update the interest rate
     * @returns transaction
     */
    updateInterest(signer: Signer): Promise<import("../types").WrappedTransaction>;
    /**
     * Updates the neutral price of a borrower's own loan, often useful after partial repayment.
     * @param borrower borrower who wishes to stamp their own loan
     */
    stampLoan(signer: Signer): Promise<import("../types").WrappedTransaction>;
    /**
     * Returns `Claimable Reserve Auction` (`CRA`) wrapper object.
     * @returns CRA wrapper object
     */
    getClaimableReserveAuction(): ClaimableReserveAuction;
    /**
     * Create a new empty LP token for the purpose of memorializing lender position(s).
     * @param signer lender
     * @param subset optional subset of NFT ids in pool
     * @returns promise to transaction
     */
    mintLPToken(signer: Signer, subset?: Array<number>): Promise<import("../types").WrappedTransaction>;
    /**
     * Burn an empty LP token which has already been redeemed for LP in all buckets.
     * @param signer LP token holder
     * @param tokenId identifies the empty token to burn
     * @returns promise to transaction
     */
    burnLPToken(signer: Signer, tokenId: BigNumber): Promise<import("../types").WrappedTransaction>;
    approvePositionManagerLPTransferor(signer: Signer): Promise<import("../types").WrappedTransaction>;
    /**
     * Approve lend helper to manage quote token.
     * @param signer pool user
     * @param allowance normalized approval amount (or MaxUint256)
     * @returns promise to transaction
     */
    quoteApproveHelper(signer: Signer, allowance: BigNumber): Promise<import("../types").WrappedTransaction>;
    approveLenderHelperLPTransferor(signer: Signer): Promise<import("../types").WrappedTransaction>;
    isLenderHelperLPTransferorApproved(signer: Signer): Promise<boolean>;
    increaseLenderHelperLPAllowance(signer: Signer, indexes: Array<number>, amounts: Array<BigNumber>): Promise<import("../types").WrappedTransaction>;
    isLPTransferorApproved(signer: Signer): Promise<boolean>;
    revokePositionManagerLPTransferor(signer: Signer): Promise<import("../types").WrappedTransaction>;
}