@kasufinance/kasu-sdk 1.0.1

package/dist/contracts/ILendingPoolAbi.d.ts

@@ -0,0 +1,968 @@
+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>;
+    };
+}