/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import type {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  PopulatedTransaction,
  Signer,
  utils,
} from "ethers";
import type {
  FunctionFragment,
  Result,
  EventFragment,
} from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type {
  TypedEventFilter,
  TypedEvent,
  TypedListener,
  OnEvent,
} from "./common";

export type ClearingConfigurationStruct = {
  drawAmount: BigNumberish;
  trancheDesiredRatios: BigNumberish[];
  maxExcessPercentage: BigNumberish;
  minExcessPercentage: BigNumberish;
};

export type ClearingConfigurationStructOutput = [
  BigNumber,
  BigNumber[],
  BigNumber,
  BigNumber
] & {
  drawAmount: BigNumber;
  trancheDesiredRatios: BigNumber[];
  maxExcessPercentage: BigNumber;
  minExcessPercentage: BigNumber;
};

export type LendingPoolInfoStruct = {
  trancheAddresses: string[];
  pendingPool: string;
};

export type LendingPoolInfoStructOutput = [string[], string] & {
  trancheAddresses: string[];
  pendingPool: string;
};

export type TrancheConfigStruct = {
  ratio: BigNumberish;
  interestRate: BigNumberish;
  minDepositAmount: BigNumberish;
  maxDepositAmount: BigNumberish;
};

export type TrancheConfigStructOutput = [
  BigNumber,
  BigNumber,
  BigNumber,
  BigNumber
] & {
  ratio: BigNumber;
  interestRate: BigNumber;
  minDepositAmount: BigNumber;
  maxDepositAmount: BigNumber;
};

export type PoolConfigurationStruct = {
  tranches: TrancheConfigStruct[];
  drawRecipient: string;
  desiredDrawAmount: BigNumberish;
  trancheInterestChangeEpochDelay: BigNumberish;
  targetExcessLiquidityPercentage: BigNumberish;
  minimumExcessLiquidityPercentage: BigNumberish;
};

export type PoolConfigurationStructOutput = [
  TrancheConfigStructOutput[],
  string,
  BigNumber,
  BigNumber,
  BigNumber,
  BigNumber
] & {
  tranches: TrancheConfigStructOutput[];
  drawRecipient: string;
  desiredDrawAmount: BigNumber;
  trancheInterestChangeEpochDelay: BigNumber;
  targetExcessLiquidityPercentage: BigNumber;
  minimumExcessLiquidityPercentage: BigNumber;
};

export interface ILendingPoolAbiInterface extends utils.Interface {
  functions: {
    "acceptDeposit(address,address,uint256)": FunctionFragment;
    "acceptWithdrawal(address,address,uint256)": FunctionFragment;
    "allowance(address,address)": FunctionFragment;
    "applyInterests(uint256)": FunctionFragment;
    "approve(address,uint256)": FunctionFragment;
    "availableFunds()": FunctionFragment;
    "balanceOf(address)": FunctionFragment;
    "calculateMaximumLossAmount()": FunctionFragment;
    "claimRepaidLoss(address,address,uint256)": FunctionFragment;
    "depositFirstLossCapital(uint256)": FunctionFragment;
    "drawFunds(uint256)": FunctionFragment;
    "feesOwedAmount()": FunctionFragment;
    "forceImmediateWithdrawal(address,address,uint256)": FunctionFragment;
    "getClearingConfig()": FunctionFragment;
    "getLendingPoolInfo()": FunctionFragment;
    "isLendingPoolTranche(address)": FunctionFragment;
    "lendingPoolTrancheCount()": FunctionFragment;
    "lendingPoolTranches()": FunctionFragment;
    "pendingPool()": FunctionFragment;
    "poolConfiguration()": FunctionFragment;
    "repayLoss(address,uint256,uint256)": FunctionFragment;
    "repayOwedFunds(uint256)": FunctionFragment;
    "reportLoss(uint256,bool)": FunctionFragment;
    "stop()": FunctionFragment;
    "totalSupply()": FunctionFragment;
    "trancheConfigurationDepositLimits(address)": FunctionFragment;
    "trancheIndex(address)": FunctionFragment;
    "transfer(address,uint256)": FunctionFragment;
    "transferFrom(address,address,uint256)": FunctionFragment;
    "updateDesiredDrawAmount(uint256)": FunctionFragment;
    "updateDrawRecipient(address)": FunctionFragment;
    "updateMaximumDepositAmount(address,uint256)": FunctionFragment;
    "updateMinimumDepositAmount(address,uint256)": FunctionFragment;
    "updateMinimumExcessLiquidityPercentage(uint256)": FunctionFragment;
    "updateTargetExcessLiquidityPercentage(uint256)": FunctionFragment;
    "updateTrancheDesiredRatios(uint256[])": FunctionFragment;
    "updateTrancheInterestRate(address,uint256)": FunctionFragment;
    "updateTrancheInterestRateChangeEpochDelay(uint256)": FunctionFragment;
    "userBalance(address)": FunctionFragment;
    "userOwedAmount()": FunctionFragment;
    "verifyClearingConfig((uint256,uint256[],uint256,uint256))": FunctionFragment;
    "withdrawFirstLossCapital(uint256,address)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "acceptDeposit"
      | "acceptWithdrawal"
      | "allowance"
      | "applyInterests"
      | "approve"
      | "availableFunds"
      | "balanceOf"
      | "calculateMaximumLossAmount"
      | "claimRepaidLoss"
      | "depositFirstLossCapital"
      | "drawFunds"
      | "feesOwedAmount"
      | "forceImmediateWithdrawal"
      | "getClearingConfig"
      | "getLendingPoolInfo"
      | "isLendingPoolTranche"
      | "lendingPoolTrancheCount"
      | "lendingPoolTranches"
      | "pendingPool"
      | "poolConfiguration"
      | "repayLoss"
      | "repayOwedFunds"
      | "reportLoss"
      | "stop"
      | "totalSupply"
      | "trancheConfigurationDepositLimits"
      | "trancheIndex"
      | "transfer"
      | "transferFrom"
      | "updateDesiredDrawAmount"
      | "updateDrawRecipient"
      | "updateMaximumDepositAmount"
      | "updateMinimumDepositAmount"
      | "updateMinimumExcessLiquidityPercentage"
      | "updateTargetExcessLiquidityPercentage"
      | "updateTrancheDesiredRatios"
      | "updateTrancheInterestRate"
      | "updateTrancheInterestRateChangeEpochDelay"
      | "userBalance"
      | "userOwedAmount"
      | "verifyClearingConfig"
      | "withdrawFirstLossCapital"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "acceptDeposit",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "acceptWithdrawal",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "allowance",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "applyInterests",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "approve",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "availableFunds",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
  encodeFunctionData(
    functionFragment: "calculateMaximumLossAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "claimRepaidLoss",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "depositFirstLossCapital",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "drawFunds",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "feesOwedAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "forceImmediateWithdrawal",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getClearingConfig",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getLendingPoolInfo",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isLendingPoolTranche",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "lendingPoolTrancheCount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "lendingPoolTranches",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "pendingPool",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "poolConfiguration",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "repayLoss",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "repayOwedFunds",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "reportLoss",
    values: [BigNumberish, boolean]
  ): string;
  encodeFunctionData(functionFragment: "stop", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "totalSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "trancheConfigurationDepositLimits",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "trancheIndex",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "transfer",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferFrom",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateDesiredDrawAmount",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateDrawRecipient",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "updateMaximumDepositAmount",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateMinimumDepositAmount",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateMinimumExcessLiquidityPercentage",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateTargetExcessLiquidityPercentage",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateTrancheDesiredRatios",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "updateTrancheInterestRate",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateTrancheInterestRateChangeEpochDelay",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "userBalance", values: [string]): string;
  encodeFunctionData(
    functionFragment: "userOwedAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "verifyClearingConfig",
    values: [ClearingConfigurationStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawFirstLossCapital",
    values: [BigNumberish, string]
  ): string;

  decodeFunctionResult(
    functionFragment: "acceptDeposit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "acceptWithdrawal",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "applyInterests",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "availableFunds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "calculateMaximumLossAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimRepaidLoss",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "depositFirstLossCapital",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "drawFunds", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "feesOwedAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "forceImmediateWithdrawal",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getClearingConfig",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getLendingPoolInfo",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isLendingPoolTranche",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lendingPoolTrancheCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lendingPoolTranches",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "pendingPool",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "poolConfiguration",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "repayLoss", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "repayOwedFunds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "reportLoss", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stop", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "totalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "trancheConfigurationDepositLimits",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "trancheIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateDesiredDrawAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateDrawRecipient",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateMaximumDepositAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateMinimumDepositAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateMinimumExcessLiquidityPercentage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateTargetExcessLiquidityPercentage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateTrancheDesiredRatios",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateTrancheInterestRate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateTrancheInterestRateChangeEpochDelay",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "userBalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "userOwedAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "verifyClearingConfig",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawFirstLossCapital",
    data: BytesLike
  ): Result;

  events: {
    "Approval(address,address,uint256)": EventFragment;
    "DepositAccepted(address,address,uint256)": EventFragment;
    "FeesOwedIncreased(uint256,uint256)": EventFragment;
    "FirstLossCapitalAdded(uint256)": EventFragment;
    "FirstLossCapitalLossReported(uint256,uint256)": EventFragment;
    "FirstLossCapitalWithdrawn(uint256)": EventFragment;
    "FundsDrawn(uint256)": EventFragment;
    "ImmediateWithdrawal(address,address,uint256,uint256)": EventFragment;
    "InterestApplied(address,uint256,uint256)": EventFragment;
    "LendingPoolStopped()": EventFragment;
    "LossReported(uint256)": EventFragment;
    "OwedFundsRepaid(uint256,uint256)": EventFragment;
    "PaidFees(uint256)": EventFragment;
    "RemovedTrancheInterestRateUpdate(address,uint256,uint256)": EventFragment;
    "Transfer(address,address,uint256)": EventFragment;
    "UpdatedDesiredDrawAmount(uint256)": EventFragment;
    "UpdatedDrawRecipient(address)": EventFragment;
    "UpdatedMaximumDepositAmount(address,uint256)": EventFragment;
    "UpdatedMinimumDepositAmount(address,uint256)": EventFragment;
    "UpdatedMinimumExcessLiquidityPercentage(uint256)": EventFragment;
    "UpdatedTargetExcessLiquidityPercentage(uint256)": EventFragment;
    "UpdatedTrancheDesiredRatios(uint256[])": EventFragment;
    "UpdatedTrancheInterestRate(address,uint256,uint256)": EventFragment;
    "UpdatedTrancheInterestRateChangeEpochDelay(uint256)": EventFragment;
    "WithdrawalAccepted(address,address,uint256,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DepositAccepted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FeesOwedIncreased"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FirstLossCapitalAdded"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "FirstLossCapitalLossReported"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FirstLossCapitalWithdrawn"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FundsDrawn"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ImmediateWithdrawal"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "InterestApplied"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LendingPoolStopped"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LossReported"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwedFundsRepaid"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PaidFees"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "RemovedTrancheInterestRateUpdate"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UpdatedDesiredDrawAmount"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UpdatedDrawRecipient"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "UpdatedMaximumDepositAmount"
  ): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "UpdatedMinimumDepositAmount"
  ): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "UpdatedMinimumExcessLiquidityPercentage"
  ): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "UpdatedTargetExcessLiquidityPercentage"
  ): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "UpdatedTrancheDesiredRatios"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UpdatedTrancheInterestRate"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "UpdatedTrancheInterestRateChangeEpochDelay"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "WithdrawalAccepted"): EventFragment;
}

export interface ApprovalEventObject {
  owner: string;
  spender: string;
  value: BigNumber;
}
export type ApprovalEvent = TypedEvent<
  [string, string, BigNumber],
  ApprovalEventObject
>;

export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;

export interface DepositAcceptedEventObject {
  user: string;
  tranche: string;
  amount: BigNumber;
}
export type DepositAcceptedEvent = TypedEvent<
  [string, string, BigNumber],
  DepositAcceptedEventObject
>;

export type DepositAcceptedEventFilter = TypedEventFilter<DepositAcceptedEvent>;

export interface FeesOwedIncreasedEventObject {
  epoch: BigNumber;
  feesIncreasedAmount: BigNumber;
}
export type FeesOwedIncreasedEvent = TypedEvent<
  [BigNumber, BigNumber],
  FeesOwedIncreasedEventObject
>;

export type FeesOwedIncreasedEventFilter =
  TypedEventFilter<FeesOwedIncreasedEvent>;

export interface FirstLossCapitalAddedEventObject {
  amountAdded: BigNumber;
}
export type FirstLossCapitalAddedEvent = TypedEvent<
  [BigNumber],
  FirstLossCapitalAddedEventObject
>;

export type FirstLossCapitalAddedEventFilter =
  TypedEventFilter<FirstLossCapitalAddedEvent>;

export interface FirstLossCapitalLossReportedEventObject {
  lossId: BigNumber;
  amount: BigNumber;
}
export type FirstLossCapitalLossReportedEvent = TypedEvent<
  [BigNumber, BigNumber],
  FirstLossCapitalLossReportedEventObject
>;

export type FirstLossCapitalLossReportedEventFilter =
  TypedEventFilter<FirstLossCapitalLossReportedEvent>;

export interface FirstLossCapitalWithdrawnEventObject {
  amountWithdrawn: BigNumber;
}
export type FirstLossCapitalWithdrawnEvent = TypedEvent<
  [BigNumber],
  FirstLossCapitalWithdrawnEventObject
>;

export type FirstLossCapitalWithdrawnEventFilter =
  TypedEventFilter<FirstLossCapitalWithdrawnEvent>;

export interface FundsDrawnEventObject {
  amount: BigNumber;
}
export type FundsDrawnEvent = TypedEvent<[BigNumber], FundsDrawnEventObject>;

export type FundsDrawnEventFilter = TypedEventFilter<FundsDrawnEvent>;

export interface ImmediateWithdrawalEventObject {
  user: string;
  tranche: string;
  shares: BigNumber;
  amount: BigNumber;
}
export type ImmediateWithdrawalEvent = TypedEvent<
  [string, string, BigNumber, BigNumber],
  ImmediateWithdrawalEventObject
>;

export type ImmediateWithdrawalEventFilter =
  TypedEventFilter<ImmediateWithdrawalEvent>;

export interface InterestAppliedEventObject {
  tranche: string;
  epoch: BigNumber;
  interestAmount: BigNumber;
}
export type InterestAppliedEvent = TypedEvent<
  [string, BigNumber, BigNumber],
  InterestAppliedEventObject
>;

export type InterestAppliedEventFilter = TypedEventFilter<InterestAppliedEvent>;

export interface LendingPoolStoppedEventObject {}
export type LendingPoolStoppedEvent = TypedEvent<
  [],
  LendingPoolStoppedEventObject
>;

export type LendingPoolStoppedEventFilter =
  TypedEventFilter<LendingPoolStoppedEvent>;

export interface LossReportedEventObject {
  amount: BigNumber;
}
export type LossReportedEvent = TypedEvent<
  [BigNumber],
  LossReportedEventObject
>;

export type LossReportedEventFilter = TypedEventFilter<LossReportedEvent>;

export interface OwedFundsRepaidEventObject {
  amountForUsers: BigNumber;
  amountForFees: BigNumber;
}
export type OwedFundsRepaidEvent = TypedEvent<
  [BigNumber, BigNumber],
  OwedFundsRepaidEventObject
>;

export type OwedFundsRepaidEventFilter = TypedEventFilter<OwedFundsRepaidEvent>;

export interface PaidFeesEventObject {
  feesPaid: BigNumber;
}
export type PaidFeesEvent = TypedEvent<[BigNumber], PaidFeesEventObject>;

export type PaidFeesEventFilter = TypedEventFilter<PaidFeesEvent>;

export interface RemovedTrancheInterestRateUpdateEventObject {
  tranche: string;
  applicableEpoch: BigNumber;
  arrayIndex: BigNumber;
}
export type RemovedTrancheInterestRateUpdateEvent = TypedEvent<
  [string, BigNumber, BigNumber],
  RemovedTrancheInterestRateUpdateEventObject
>;

export type RemovedTrancheInterestRateUpdateEventFilter =
  TypedEventFilter<RemovedTrancheInterestRateUpdateEvent>;

export interface TransferEventObject {
  from: string;
  to: string;
  value: BigNumber;
}
export type TransferEvent = TypedEvent<
  [string, string, BigNumber],
  TransferEventObject
>;

export type TransferEventFilter = TypedEventFilter<TransferEvent>;

export interface UpdatedDesiredDrawAmountEventObject {
  desiredDrawAmount: BigNumber;
}
export type UpdatedDesiredDrawAmountEvent = TypedEvent<
  [BigNumber],
  UpdatedDesiredDrawAmountEventObject
>;

export type UpdatedDesiredDrawAmountEventFilter =
  TypedEventFilter<UpdatedDesiredDrawAmountEvent>;

export interface UpdatedDrawRecipientEventObject {
  drawRecipient: string;
}
export type UpdatedDrawRecipientEvent = TypedEvent<
  [string],
  UpdatedDrawRecipientEventObject
>;

export type UpdatedDrawRecipientEventFilter =
  TypedEventFilter<UpdatedDrawRecipientEvent>;

export interface UpdatedMaximumDepositAmountEventObject {
  tranche: string;
  amount: BigNumber;
}
export type UpdatedMaximumDepositAmountEvent = TypedEvent<
  [string, BigNumber],
  UpdatedMaximumDepositAmountEventObject
>;

export type UpdatedMaximumDepositAmountEventFilter =
  TypedEventFilter<UpdatedMaximumDepositAmountEvent>;

export interface UpdatedMinimumDepositAmountEventObject {
  tranche: string;
  amount: BigNumber;
}
export type UpdatedMinimumDepositAmountEvent = TypedEvent<
  [string, BigNumber],
  UpdatedMinimumDepositAmountEventObject
>;

export type UpdatedMinimumDepositAmountEventFilter =
  TypedEventFilter<UpdatedMinimumDepositAmountEvent>;

export interface UpdatedMinimumExcessLiquidityPercentageEventObject {
  percentage: BigNumber;
}
export type UpdatedMinimumExcessLiquidityPercentageEvent = TypedEvent<
  [BigNumber],
  UpdatedMinimumExcessLiquidityPercentageEventObject
>;

export type UpdatedMinimumExcessLiquidityPercentageEventFilter =
  TypedEventFilter<UpdatedMinimumExcessLiquidityPercentageEvent>;

export interface UpdatedTargetExcessLiquidityPercentageEventObject {
  percentage: BigNumber;
}
export type UpdatedTargetExcessLiquidityPercentageEvent = TypedEvent<
  [BigNumber],
  UpdatedTargetExcessLiquidityPercentageEventObject
>;

export type UpdatedTargetExcessLiquidityPercentageEventFilter =
  TypedEventFilter<UpdatedTargetExcessLiquidityPercentageEvent>;

export interface UpdatedTrancheDesiredRatiosEventObject {
  ratios: BigNumber[];
}
export type UpdatedTrancheDesiredRatiosEvent = TypedEvent<
  [BigNumber[]],
  UpdatedTrancheDesiredRatiosEventObject
>;

export type UpdatedTrancheDesiredRatiosEventFilter =
  TypedEventFilter<UpdatedTrancheDesiredRatiosEvent>;

export interface UpdatedTrancheInterestRateEventObject {
  tranche: string;
  applicableEpoch: BigNumber;
  newInterestRate: BigNumber;
}
export type UpdatedTrancheInterestRateEvent = TypedEvent<
  [string, BigNumber, BigNumber],
  UpdatedTrancheInterestRateEventObject
>;

export type UpdatedTrancheInterestRateEventFilter =
  TypedEventFilter<UpdatedTrancheInterestRateEvent>;

export interface UpdatedTrancheInterestRateChangeEpochDelayEventObject {
  epochDelay: BigNumber;
}
export type UpdatedTrancheInterestRateChangeEpochDelayEvent = TypedEvent<
  [BigNumber],
  UpdatedTrancheInterestRateChangeEpochDelayEventObject
>;

export type UpdatedTrancheInterestRateChangeEpochDelayEventFilter =
  TypedEventFilter<UpdatedTrancheInterestRateChangeEpochDelayEvent>;

export interface WithdrawalAcceptedEventObject {
  user: string;
  tranche: string;
  shares: BigNumber;
  assetAmount: BigNumber;
}
export type WithdrawalAcceptedEvent = TypedEvent<
  [string, string, BigNumber, BigNumber],
  WithdrawalAcceptedEventObject
>;

export type WithdrawalAcceptedEventFilter =
  TypedEventFilter<WithdrawalAcceptedEvent>;

export interface ILendingPoolAbi extends BaseContract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  interface: ILendingPoolAbiInterface;

  queryFilter<TEvent extends TypedEvent>(
    event: TypedEventFilter<TEvent>,
    fromBlockOrBlockhash?: string | number | undefined,
    toBlock?: string | number | undefined
  ): Promise<Array<TEvent>>;

  listeners<TEvent extends TypedEvent>(
    eventFilter?: TypedEventFilter<TEvent>
  ): Array<TypedListener<TEvent>>;
  listeners(eventName?: string): Array<Listener>;
  removeAllListeners<TEvent extends TypedEvent>(
    eventFilter: TypedEventFilter<TEvent>
  ): this;
  removeAllListeners(eventName?: string): this;
  off: OnEvent<this>;
  on: OnEvent<this>;
  once: OnEvent<this>;
  removeListener: OnEvent<this>;

  functions: {
    acceptDeposit(
      tranche: string,
      user: string,
      acceptedAmount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    acceptWithdrawal(
      tranche: string,
      user: string,
      acceptedShares: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    applyInterests(
      epoch: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    approve(
      spender: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    availableFunds(overrides?: CallOverrides): Promise<[BigNumber]>;

    balanceOf(account: string, overrides?: CallOverrides): Promise<[BigNumber]>;

    calculateMaximumLossAmount(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { maximumLossAmount: BigNumber }>;

    claimRepaidLoss(
      user: string,
      tranche: string,
      lossId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    depositFirstLossCapital(
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    drawFunds(
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    feesOwedAmount(overrides?: CallOverrides): Promise<[BigNumber]>;

    forceImmediateWithdrawal(
      tranche: string,
      user: string,
      sharesToWithdraw: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    getClearingConfig(
      overrides?: CallOverrides
    ): Promise<
      [ClearingConfigurationStructOutput] & {
        clearingConfig: ClearingConfigurationStructOutput;
      }
    >;

    getLendingPoolInfo(
      overrides?: CallOverrides
    ): Promise<[LendingPoolInfoStructOutput]>;

    isLendingPoolTranche(
      tranche: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    lendingPoolTrancheCount(overrides?: CallOverrides): Promise<[BigNumber]>;

    lendingPoolTranches(overrides?: CallOverrides): Promise<[string[]]>;

    pendingPool(overrides?: CallOverrides): Promise<[string]>;

    poolConfiguration(
      overrides?: CallOverrides
    ): Promise<[PoolConfigurationStructOutput]>;

    repayLoss(
      tranche: string,
      lossId: BigNumberish,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    repayOwedFunds(
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    reportLoss(
      lossAmount: BigNumberish,
      doMintLossTokens: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    stop(
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;

    trancheConfigurationDepositLimits(
      tranche: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        minDepositAmount: BigNumber;
        maxDepositAmount: BigNumber;
      }
    >;

    trancheIndex(
      tranche: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    transfer(
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    transferFrom(
      from: string,
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    updateDesiredDrawAmount(
      desiredDrawAmount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    updateDrawRecipient(
      drawRecipient: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    updateMaximumDepositAmount(
      tranche: string,
      maximumDepositAmount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    updateMinimumDepositAmount(
      tranche: string,
      minimumDepositAmount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    updateMinimumExcessLiquidityPercentage(
      minimumExcessLiquidityPercentage: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    updateTargetExcessLiquidityPercentage(
      targetExcessLiquidityPercentage: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    updateTrancheDesiredRatios(
      ratios: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    updateTrancheInterestRate(
      tranche: string,
      interestRate: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    updateTrancheInterestRateChangeEpochDelay(
      epochDelay: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    userBalance(user: string, overrides?: CallOverrides): Promise<[BigNumber]>;

    userOwedAmount(overrides?: CallOverrides): Promise<[BigNumber]>;

    verifyClearingConfig(
      clearingConfig: ClearingConfigurationStruct,
      overrides?: CallOverrides
    ): Promise<[void]>;

    withdrawFirstLossCapital(
      withdrawAmount: BigNumberish,
      withdrawAddress: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;
  };

  acceptDeposit(
    tranche: string,
    user: string,
    acceptedAmount: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  acceptWithdrawal(
    tranche: string,
    user: string,
    acceptedShares: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  allowance(
    owner: string,
    spender: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  applyInterests(
    epoch: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  approve(
    spender: string,
    value: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  availableFunds(overrides?: CallOverrides): Promise<BigNumber>;

  balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

  calculateMaximumLossAmount(overrides?: CallOverrides): Promise<BigNumber>;

  claimRepaidLoss(
    user: string,
    tranche: string,
    lossId: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  depositFirstLossCapital(
    amount: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  drawFunds(
    amount: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  feesOwedAmount(overrides?: CallOverrides): Promise<BigNumber>;

  forceImmediateWithdrawal(
    tranche: string,
    user: string,
    sharesToWithdraw: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  getClearingConfig(
    overrides?: CallOverrides
  ): Promise<ClearingConfigurationStructOutput>;

  getLendingPoolInfo(
    overrides?: CallOverrides
  ): Promise<LendingPoolInfoStructOutput>;

  isLendingPoolTranche(
    tranche: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  lendingPoolTrancheCount(overrides?: CallOverrides): Promise<BigNumber>;

  lendingPoolTranches(overrides?: CallOverrides): Promise<string[]>;

  pendingPool(overrides?: CallOverrides): Promise<string>;

  poolConfiguration(
    overrides?: CallOverrides
  ): Promise<PoolConfigurationStructOutput>;

  repayLoss(
    tranche: string,
    lossId: BigNumberish,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  repayOwedFunds(
    amount: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  reportLoss(
    lossAmount: BigNumberish,
    doMintLossTokens: boolean,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  stop(overrides?: Overrides & { from?: string }): Promise<ContractTransaction>;

  totalSupply(overrides?: CallOverrides): Promise<BigNumber>;

  trancheConfigurationDepositLimits(
    tranche: string,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & {
      minDepositAmount: BigNumber;
      maxDepositAmount: BigNumber;
    }
  >;

  trancheIndex(tranche: string, overrides?: CallOverrides): Promise<BigNumber>;

  transfer(
    to: string,
    value: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  transferFrom(
    from: string,
    to: string,
    value: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  updateDesiredDrawAmount(
    desiredDrawAmount: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  updateDrawRecipient(
    drawRecipient: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  updateMaximumDepositAmount(
    tranche: string,
    maximumDepositAmount: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  updateMinimumDepositAmount(
    tranche: string,
    minimumDepositAmount: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  updateMinimumExcessLiquidityPercentage(
    minimumExcessLiquidityPercentage: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  updateTargetExcessLiquidityPercentage(
    targetExcessLiquidityPercentage: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  updateTrancheDesiredRatios(
    ratios: BigNumberish[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  updateTrancheInterestRate(
    tranche: string,
    interestRate: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  updateTrancheInterestRateChangeEpochDelay(
    epochDelay: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  userBalance(user: string, overrides?: CallOverrides): Promise<BigNumber>;

  userOwedAmount(overrides?: CallOverrides): Promise<BigNumber>;

  verifyClearingConfig(
    clearingConfig: ClearingConfigurationStruct,
    overrides?: CallOverrides
  ): Promise<void>;

  withdrawFirstLossCapital(
    withdrawAmount: BigNumberish,
    withdrawAddress: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  callStatic: {
    acceptDeposit(
      tranche: string,
      user: string,
      acceptedAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    acceptWithdrawal(
      tranche: string,
      user: string,
      acceptedShares: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    applyInterests(
      epoch: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    approve(
      spender: string,
      value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    availableFunds(overrides?: CallOverrides): Promise<BigNumber>;

    balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

    calculateMaximumLossAmount(overrides?: CallOverrides): Promise<BigNumber>;

    claimRepaidLoss(
      user: string,
      tranche: string,
      lossId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    depositFirstLossCapital(
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    drawFunds(amount: BigNumberish, overrides?: CallOverrides): Promise<void>;

    feesOwedAmount(overrides?: CallOverrides): Promise<BigNumber>;

    forceImmediateWithdrawal(
      tranche: string,
      user: string,
      sharesToWithdraw: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getClearingConfig(
      overrides?: CallOverrides
    ): Promise<ClearingConfigurationStructOutput>;

    getLendingPoolInfo(
      overrides?: CallOverrides
    ): Promise<LendingPoolInfoStructOutput>;

    isLendingPoolTranche(
      tranche: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    lendingPoolTrancheCount(overrides?: CallOverrides): Promise<BigNumber>;

    lendingPoolTranches(overrides?: CallOverrides): Promise<string[]>;

    pendingPool(overrides?: CallOverrides): Promise<string>;

    poolConfiguration(
      overrides?: CallOverrides
    ): Promise<PoolConfigurationStructOutput>;

    repayLoss(
      tranche: string,
      lossId: BigNumberish,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    repayOwedFunds(
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    reportLoss(
      lossAmount: BigNumberish,
      doMintLossTokens: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    stop(overrides?: CallOverrides): Promise<void>;

    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;

    trancheConfigurationDepositLimits(
      tranche: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        minDepositAmount: BigNumber;
        maxDepositAmount: BigNumber;
      }
    >;

    trancheIndex(
      tranche: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    transfer(
      to: string,
      value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    transferFrom(
      from: string,
      to: string,
      value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    updateDesiredDrawAmount(
      desiredDrawAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    updateDrawRecipient(
      drawRecipient: string,
      overrides?: CallOverrides
    ): Promise<void>;

    updateMaximumDepositAmount(
      tranche: string,
      maximumDepositAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    updateMinimumDepositAmount(
      tranche: string,
      minimumDepositAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    updateMinimumExcessLiquidityPercentage(
      minimumExcessLiquidityPercentage: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    updateTargetExcessLiquidityPercentage(
      targetExcessLiquidityPercentage: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    updateTrancheDesiredRatios(
      ratios: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    updateTrancheInterestRate(
      tranche: string,
      interestRate: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    updateTrancheInterestRateChangeEpochDelay(
      epochDelay: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    userBalance(user: string, overrides?: CallOverrides): Promise<BigNumber>;

    userOwedAmount(overrides?: CallOverrides): Promise<BigNumber>;

    verifyClearingConfig(
      clearingConfig: ClearingConfigurationStruct,
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawFirstLossCapital(
      withdrawAmount: BigNumberish,
      withdrawAddress: string,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "Approval(address,address,uint256)"(
      owner?: string | null,
      spender?: string | null,
      value?: null
    ): ApprovalEventFilter;
    Approval(
      owner?: string | null,
      spender?: string | null,
      value?: null
    ): ApprovalEventFilter;

    "DepositAccepted(address,address,uint256)"(
      user?: string | null,
      tranche?: string | null,
      amount?: null
    ): DepositAcceptedEventFilter;
    DepositAccepted(
      user?: string | null,
      tranche?: string | null,
      amount?: null
    ): DepositAcceptedEventFilter;

    "FeesOwedIncreased(uint256,uint256)"(
      epoch?: BigNumberish | null,
      feesIncreasedAmount?: null
    ): FeesOwedIncreasedEventFilter;
    FeesOwedIncreased(
      epoch?: BigNumberish | null,
      feesIncreasedAmount?: null
    ): FeesOwedIncreasedEventFilter;

    "FirstLossCapitalAdded(uint256)"(
      amountAdded?: null
    ): FirstLossCapitalAddedEventFilter;
    FirstLossCapitalAdded(amountAdded?: null): FirstLossCapitalAddedEventFilter;

    "FirstLossCapitalLossReported(uint256,uint256)"(
      lossId?: BigNumberish | null,
      amount?: null
    ): FirstLossCapitalLossReportedEventFilter;
    FirstLossCapitalLossReported(
      lossId?: BigNumberish | null,
      amount?: null
    ): FirstLossCapitalLossReportedEventFilter;

    "FirstLossCapitalWithdrawn(uint256)"(
      amountWithdrawn?: null
    ): FirstLossCapitalWithdrawnEventFilter;
    FirstLossCapitalWithdrawn(
      amountWithdrawn?: null
    ): FirstLossCapitalWithdrawnEventFilter;

    "FundsDrawn(uint256)"(amount?: null): FundsDrawnEventFilter;
    FundsDrawn(amount?: null): FundsDrawnEventFilter;

    "ImmediateWithdrawal(address,address,uint256,uint256)"(
      user?: string | null,
      tranche?: string | null,
      shares?: null,
      amount?: null
    ): ImmediateWithdrawalEventFilter;
    ImmediateWithdrawal(
      user?: string | null,
      tranche?: string | null,
      shares?: null,
      amount?: null
    ): ImmediateWithdrawalEventFilter;

    "InterestApplied(address,uint256,uint256)"(
      tranche?: string | null,
      epoch?: BigNumberish | null,
      interestAmount?: null
    ): InterestAppliedEventFilter;
    InterestApplied(
      tranche?: string | null,
      epoch?: BigNumberish | null,
      interestAmount?: null
    ): InterestAppliedEventFilter;

    "LendingPoolStopped()"(): LendingPoolStoppedEventFilter;
    LendingPoolStopped(): LendingPoolStoppedEventFilter;

    "LossReported(uint256)"(amount?: null): LossReportedEventFilter;
    LossReported(amount?: null): LossReportedEventFilter;

    "OwedFundsRepaid(uint256,uint256)"(
      amountForUsers?: null,
      amountForFees?: null
    ): OwedFundsRepaidEventFilter;
    OwedFundsRepaid(
      amountForUsers?: null,
      amountForFees?: null
    ): OwedFundsRepaidEventFilter;

    "PaidFees(uint256)"(feesPaid?: null): PaidFeesEventFilter;
    PaidFees(feesPaid?: null): PaidFeesEventFilter;

    "RemovedTrancheInterestRateUpdate(address,uint256,uint256)"(
      tranche?: string | null,
      applicableEpoch?: BigNumberish | null,
      arrayIndex?: null
    ): RemovedTrancheInterestRateUpdateEventFilter;
    RemovedTrancheInterestRateUpdate(
      tranche?: string | null,
      applicableEpoch?: BigNumberish | null,
      arrayIndex?: null
    ): RemovedTrancheInterestRateUpdateEventFilter;

    "Transfer(address,address,uint256)"(
      from?: string | null,
      to?: string | null,
      value?: null
    ): TransferEventFilter;
    Transfer(
      from?: string | null,
      to?: string | null,
      value?: null
    ): TransferEventFilter;

    "UpdatedDesiredDrawAmount(uint256)"(
      desiredDrawAmount?: null
    ): UpdatedDesiredDrawAmountEventFilter;
    UpdatedDesiredDrawAmount(
      desiredDrawAmount?: null
    ): UpdatedDesiredDrawAmountEventFilter;

    "UpdatedDrawRecipient(address)"(
      drawRecipient?: string | null
    ): UpdatedDrawRecipientEventFilter;
    UpdatedDrawRecipient(
      drawRecipient?: string | null
    ): UpdatedDrawRecipientEventFilter;

    "UpdatedMaximumDepositAmount(address,uint256)"(
      tranche?: string | null,
      amount?: null
    ): UpdatedMaximumDepositAmountEventFilter;
    UpdatedMaximumDepositAmount(
      tranche?: string | null,
      amount?: null
    ): UpdatedMaximumDepositAmountEventFilter;

    "UpdatedMinimumDepositAmount(address,uint256)"(
      tranche?: string | null,
      amount?: null
    ): UpdatedMinimumDepositAmountEventFilter;
    UpdatedMinimumDepositAmount(
      tranche?: string | null,
      amount?: null
    ): UpdatedMinimumDepositAmountEventFilter;

    "UpdatedMinimumExcessLiquidityPercentage(uint256)"(
      percentage?: null
    ): UpdatedMinimumExcessLiquidityPercentageEventFilter;
    UpdatedMinimumExcessLiquidityPercentage(
      percentage?: null
    ): UpdatedMinimumExcessLiquidityPercentageEventFilter;

    "UpdatedTargetExcessLiquidityPercentage(uint256)"(
      percentage?: null
    ): UpdatedTargetExcessLiquidityPercentageEventFilter;
    UpdatedTargetExcessLiquidityPercentage(
      percentage?: null
    ): UpdatedTargetExcessLiquidityPercentageEventFilter;

    "UpdatedTrancheDesiredRatios(uint256[])"(
      ratios?: null
    ): UpdatedTrancheDesiredRatiosEventFilter;
    UpdatedTrancheDesiredRatios(
      ratios?: null
    ): UpdatedTrancheDesiredRatiosEventFilter;

    "UpdatedTrancheInterestRate(address,uint256,uint256)"(
      tranche?: string | null,
      applicableEpoch?: BigNumberish | null,
      newInterestRate?: null
    ): UpdatedTrancheInterestRateEventFilter;
    UpdatedTrancheInterestRate(
      tranche?: string | null,
      applicableEpoch?: BigNumberish | null,
      newInterestRate?: null
    ): UpdatedTrancheInterestRateEventFilter;

    "UpdatedTrancheInterestRateChangeEpochDelay(uint256)"(
      epochDelay?: null
    ): UpdatedTrancheInterestRateChangeEpochDelayEventFilter;
    UpdatedTrancheInterestRateChangeEpochDelay(
      epochDelay?: null
    ): UpdatedTrancheInterestRateChangeEpochDelayEventFilter;

    "WithdrawalAccepted(address,address,uint256,uint256)"(
      user?: string | null,
      tranche?: string | null,
      shares?: null,
      assetAmount?: null
    ): WithdrawalAcceptedEventFilter;
    WithdrawalAccepted(
      user?: string | null,
      tranche?: string | null,
      shares?: null,
      assetAmount?: null
    ): WithdrawalAcceptedEventFilter;
  };

  estimateGas: {
    acceptDeposit(
      tranche: string,
      user: string,
      acceptedAmount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    acceptWithdrawal(
      tranche: string,
      user: string,
      acceptedShares: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    applyInterests(
      epoch: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    approve(
      spender: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    availableFunds(overrides?: CallOverrides): Promise<BigNumber>;

    balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

    calculateMaximumLossAmount(overrides?: CallOverrides): Promise<BigNumber>;

    claimRepaidLoss(
      user: string,
      tranche: string,
      lossId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    depositFirstLossCapital(
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    drawFunds(
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    feesOwedAmount(overrides?: CallOverrides): Promise<BigNumber>;

    forceImmediateWithdrawal(
      tranche: string,
      user: string,
      sharesToWithdraw: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    getClearingConfig(overrides?: CallOverrides): Promise<BigNumber>;

    getLendingPoolInfo(overrides?: CallOverrides): Promise<BigNumber>;

    isLendingPoolTranche(
      tranche: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    lendingPoolTrancheCount(overrides?: CallOverrides): Promise<BigNumber>;

    lendingPoolTranches(overrides?: CallOverrides): Promise<BigNumber>;

    pendingPool(overrides?: CallOverrides): Promise<BigNumber>;

    poolConfiguration(overrides?: CallOverrides): Promise<BigNumber>;

    repayLoss(
      tranche: string,
      lossId: BigNumberish,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    repayOwedFunds(
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    reportLoss(
      lossAmount: BigNumberish,
      doMintLossTokens: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    stop(overrides?: Overrides & { from?: string }): Promise<BigNumber>;

    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;

    trancheConfigurationDepositLimits(
      tranche: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    trancheIndex(
      tranche: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    transfer(
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    transferFrom(
      from: string,
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    updateDesiredDrawAmount(
      desiredDrawAmount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    updateDrawRecipient(
      drawRecipient: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    updateMaximumDepositAmount(
      tranche: string,
      maximumDepositAmount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    updateMinimumDepositAmount(
      tranche: string,
      minimumDepositAmount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    updateMinimumExcessLiquidityPercentage(
      minimumExcessLiquidityPercentage: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    updateTargetExcessLiquidityPercentage(
      targetExcessLiquidityPercentage: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    updateTrancheDesiredRatios(
      ratios: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    updateTrancheInterestRate(
      tranche: string,
      interestRate: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    updateTrancheInterestRateChangeEpochDelay(
      epochDelay: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    userBalance(user: string, overrides?: CallOverrides): Promise<BigNumber>;

    userOwedAmount(overrides?: CallOverrides): Promise<BigNumber>;

    verifyClearingConfig(
      clearingConfig: ClearingConfigurationStruct,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    withdrawFirstLossCapital(
      withdrawAmount: BigNumberish,
      withdrawAddress: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    acceptDeposit(
      tranche: string,
      user: string,
      acceptedAmount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    acceptWithdrawal(
      tranche: string,
      user: string,
      acceptedShares: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    applyInterests(
      epoch: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    approve(
      spender: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    availableFunds(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    balanceOf(
      account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    calculateMaximumLossAmount(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    claimRepaidLoss(
      user: string,
      tranche: string,
      lossId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    depositFirstLossCapital(
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    drawFunds(
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    feesOwedAmount(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    forceImmediateWithdrawal(
      tranche: string,
      user: string,
      sharesToWithdraw: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    getClearingConfig(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    getLendingPoolInfo(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isLendingPoolTranche(
      tranche: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    lendingPoolTrancheCount(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    lendingPoolTranches(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    pendingPool(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    poolConfiguration(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    repayLoss(
      tranche: string,
      lossId: BigNumberish,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    repayOwedFunds(
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    reportLoss(
      lossAmount: BigNumberish,
      doMintLossTokens: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    stop(
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    totalSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    trancheConfigurationDepositLimits(
      tranche: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    trancheIndex(
      tranche: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    transfer(
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    transferFrom(
      from: string,
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    updateDesiredDrawAmount(
      desiredDrawAmount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    updateDrawRecipient(
      drawRecipient: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    updateMaximumDepositAmount(
      tranche: string,
      maximumDepositAmount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    updateMinimumDepositAmount(
      tranche: string,
      minimumDepositAmount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    updateMinimumExcessLiquidityPercentage(
      minimumExcessLiquidityPercentage: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    updateTargetExcessLiquidityPercentage(
      targetExcessLiquidityPercentage: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    updateTrancheDesiredRatios(
      ratios: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    updateTrancheInterestRate(
      tranche: string,
      interestRate: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    updateTrancheInterestRateChangeEpochDelay(
      epochDelay: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    userBalance(
      user: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    userOwedAmount(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    verifyClearingConfig(
      clearingConfig: ClearingConfigurationStruct,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    withdrawFirstLossCapital(
      withdrawAmount: BigNumberish,
      withdrawAddress: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;
  };
}