@kasufinance/kasu-sdk 1.0.1

package/src/contracts/ILendingPoolTrancheAbi.ts

@@ -0,0 +1,1911 @@
+/* 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 LossDetailsStruct = {
+  lossAmount: BigNumberish;
+  usersCount: BigNumberish;
+  usersMintedCount: BigNumberish;
+  recoveredAmount: BigNumberish;
+  totalLossShares: BigNumberish;
+};
+
+export type LossDetailsStructOutput = [
+  BigNumber,
+  BigNumber,
+  BigNumber,
+  BigNumber,
+  BigNumber
+] & {
+  lossAmount: BigNumber;
+  usersCount: BigNumber;
+  usersMintedCount: BigNumber;
+  recoveredAmount: BigNumber;
+  totalLossShares: BigNumber;
+};
+
+export interface ILendingPoolTrancheAbiInterface extends utils.Interface {
+  functions: {
+    "allowance(address,address)": FunctionFragment;
+    "approve(address,uint256)": FunctionFragment;
+    "asset()": FunctionFragment;
+    "balanceOf(address,uint256)": FunctionFragment;
+    "balanceOf(address)": FunctionFragment;
+    "balanceOfBatch(address[],uint256[])": FunctionFragment;
+    "batchMintLossTokens(uint256,uint256)": FunctionFragment;
+    "calculateMaximumLossAmount()": FunctionFragment;
+    "claimRepaidLoss(address,uint256)": FunctionFragment;
+    "convertToAssets(uint256)": FunctionFragment;
+    "convertToShares(uint256)": FunctionFragment;
+    "decimals()": FunctionFragment;
+    "deposit(uint256,address)": FunctionFragment;
+    "isApprovedForAll(address,address)": FunctionFragment;
+    "isLossMintingComplete(uint256)": FunctionFragment;
+    "lossDetails(uint256)": FunctionFragment;
+    "maxDeposit(address)": FunctionFragment;
+    "maxMint(address)": FunctionFragment;
+    "maxRedeem(address)": FunctionFragment;
+    "maxWithdraw(address)": FunctionFragment;
+    "minimumAssetAmountLeftAfterLoss()": FunctionFragment;
+    "mint(uint256,address)": FunctionFragment;
+    "name()": FunctionFragment;
+    "previewDeposit(uint256)": FunctionFragment;
+    "previewMint(uint256)": FunctionFragment;
+    "previewRedeem(uint256)": FunctionFragment;
+    "previewWithdraw(uint256)": FunctionFragment;
+    "redeem(uint256,address,address)": FunctionFragment;
+    "registerTrancheLoss(uint256,uint256,bool)": FunctionFragment;
+    "removeUserActiveShares(address,uint256)": FunctionFragment;
+    "repayLoss(uint256,uint256)": FunctionFragment;
+    "safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)": FunctionFragment;
+    "safeTransferFrom(address,address,uint256,uint256,bytes)": FunctionFragment;
+    "setApprovalForAll(address,bool)": FunctionFragment;
+    "supportsInterface(bytes4)": FunctionFragment;
+    "symbol()": FunctionFragment;
+    "totalAssets()": FunctionFragment;
+    "totalSupply()": FunctionFragment;
+    "transfer(address,uint256)": FunctionFragment;
+    "transferFrom(address,address,uint256)": FunctionFragment;
+    "userActiveAssets(address)": FunctionFragment;
+    "userClaimableLoss(address,uint256)": FunctionFragment;
+    "userClaimedLosses(address,uint256)": FunctionFragment;
+    "withdraw(uint256,address,address)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "allowance"
+      | "approve"
+      | "asset"
+      | "balanceOf(address,uint256)"
+      | "balanceOf(address)"
+      | "balanceOfBatch"
+      | "batchMintLossTokens"
+      | "calculateMaximumLossAmount"
+      | "claimRepaidLoss"
+      | "convertToAssets"
+      | "convertToShares"
+      | "decimals"
+      | "deposit"
+      | "isApprovedForAll"
+      | "isLossMintingComplete"
+      | "lossDetails"
+      | "maxDeposit"
+      | "maxMint"
+      | "maxRedeem"
+      | "maxWithdraw"
+      | "minimumAssetAmountLeftAfterLoss"
+      | "mint"
+      | "name"
+      | "previewDeposit"
+      | "previewMint"
+      | "previewRedeem"
+      | "previewWithdraw"
+      | "redeem"
+      | "registerTrancheLoss"
+      | "removeUserActiveShares"
+      | "repayLoss"
+      | "safeBatchTransferFrom"
+      | "safeTransferFrom"
+      | "setApprovalForAll"
+      | "supportsInterface"
+      | "symbol"
+      | "totalAssets"
+      | "totalSupply"
+      | "transfer"
+      | "transferFrom"
+      | "userActiveAssets"
+      | "userClaimableLoss"
+      | "userClaimedLosses"
+      | "withdraw"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "allowance",
+    values: [string, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "approve",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(functionFragment: "asset", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "balanceOf(address,uint256)",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "balanceOf(address)",
+    values: [string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "balanceOfBatch",
+    values: [string[], BigNumberish[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "batchMintLossTokens",
+    values: [BigNumberish, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "calculateMaximumLossAmount",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "claimRepaidLoss",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "convertToAssets",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "convertToShares",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "deposit",
+    values: [BigNumberish, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isApprovedForAll",
+    values: [string, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isLossMintingComplete",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "lossDetails",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(functionFragment: "maxDeposit", values: [string]): string;
+  encodeFunctionData(functionFragment: "maxMint", values: [string]): string;
+  encodeFunctionData(functionFragment: "maxRedeem", values: [string]): string;
+  encodeFunctionData(functionFragment: "maxWithdraw", values: [string]): string;
+  encodeFunctionData(
+    functionFragment: "minimumAssetAmountLeftAfterLoss",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "mint",
+    values: [BigNumberish, string]
+  ): string;
+  encodeFunctionData(functionFragment: "name", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "previewDeposit",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "previewMint",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "previewRedeem",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "previewWithdraw",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "redeem",
+    values: [BigNumberish, string, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "registerTrancheLoss",
+    values: [BigNumberish, BigNumberish, boolean]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removeUserActiveShares",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "repayLoss",
+    values: [BigNumberish, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "safeBatchTransferFrom",
+    values: [string, string, BigNumberish[], BigNumberish[], BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "safeTransferFrom",
+    values: [string, string, BigNumberish, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setApprovalForAll",
+    values: [string, boolean]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "supportsInterface",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "totalAssets",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalSupply",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "transfer",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "transferFrom",
+    values: [string, string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "userActiveAssets",
+    values: [string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "userClaimableLoss",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "userClaimedLosses",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "withdraw",
+    values: [BigNumberish, string, string]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "asset", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "balanceOf(address,uint256)",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "balanceOf(address)",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "balanceOfBatch",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "batchMintLossTokens",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "calculateMaximumLossAmount",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "claimRepaidLoss",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "convertToAssets",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "convertToShares",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "isApprovedForAll",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "isLossMintingComplete",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "lossDetails",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "maxDeposit", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "maxMint", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "maxRedeem", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "maxWithdraw",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "minimumAssetAmountLeftAfterLoss",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "previewDeposit",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "previewMint",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "previewRedeem",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "previewWithdraw",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "redeem", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "registerTrancheLoss",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "removeUserActiveShares",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "repayLoss", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "safeBatchTransferFrom",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "safeTransferFrom",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setApprovalForAll",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "supportsInterface",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "totalAssets",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "totalSupply",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "transferFrom",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "userActiveAssets",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "userClaimableLoss",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "userClaimedLosses",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
+
+  events: {
+    "Approval(address,address,uint256)": EventFragment;
+    "ApprovalForAll(address,address,bool)": EventFragment;
+    "Deposit(address,address,uint256,uint256)": EventFragment;
+    "LossClaimed(address,uint256,uint256)": EventFragment;
+    "LossMintingComplete(uint256)": EventFragment;
+    "LossRegistered(uint256,uint256,uint256)": EventFragment;
+    "LossReturned(uint256,uint256)": EventFragment;
+    "MintedLossTokensToUsers(uint256,uint256)": EventFragment;
+    "Transfer(address,address,uint256)": EventFragment;
+    "TransferBatch(address,address,address,uint256[],uint256[])": EventFragment;
+    "TransferSingle(address,address,address,uint256,uint256)": EventFragment;
+    "URI(string,uint256)": EventFragment;
+    "Withdraw(address,address,address,uint256,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "ApprovalForAll"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "LossClaimed"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "LossMintingComplete"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "LossRegistered"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "LossReturned"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "MintedLossTokensToUsers"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "TransferBatch"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "TransferSingle"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "URI"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "Withdraw"): 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 ApprovalForAllEventObject {
+  account: string;
+  operator: string;
+  approved: boolean;
+}
+export type ApprovalForAllEvent = TypedEvent<
+  [string, string, boolean],
+  ApprovalForAllEventObject
+>;
+
+export type ApprovalForAllEventFilter = TypedEventFilter<ApprovalForAllEvent>;
+
+export interface DepositEventObject {
+  sender: string;
+  owner: string;
+  assets: BigNumber;
+  shares: BigNumber;
+}
+export type DepositEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber],
+  DepositEventObject
+>;
+
+export type DepositEventFilter = TypedEventFilter<DepositEvent>;
+
+export interface LossClaimedEventObject {
+  user: string;
+  lossId: BigNumber;
+  amount: BigNumber;
+}
+export type LossClaimedEvent = TypedEvent<
+  [string, BigNumber, BigNumber],
+  LossClaimedEventObject
+>;
+
+export type LossClaimedEventFilter = TypedEventFilter<LossClaimedEvent>;
+
+export interface LossMintingCompleteEventObject {
+  lossId: BigNumber;
+}
+export type LossMintingCompleteEvent = TypedEvent<
+  [BigNumber],
+  LossMintingCompleteEventObject
+>;
+
+export type LossMintingCompleteEventFilter =
+  TypedEventFilter<LossMintingCompleteEvent>;
+
+export interface LossRegisteredEventObject {
+  lossId: BigNumber;
+  lossAmount: BigNumber;
+  usersCount: BigNumber;
+}
+export type LossRegisteredEvent = TypedEvent<
+  [BigNumber, BigNumber, BigNumber],
+  LossRegisteredEventObject
+>;
+
+export type LossRegisteredEventFilter = TypedEventFilter<LossRegisteredEvent>;
+
+export interface LossReturnedEventObject {
+  lossId: BigNumber;
+  amount: BigNumber;
+}
+export type LossReturnedEvent = TypedEvent<
+  [BigNumber, BigNumber],
+  LossReturnedEventObject
+>;
+
+export type LossReturnedEventFilter = TypedEventFilter<LossReturnedEvent>;
+
+export interface MintedLossTokensToUsersEventObject {
+  lossId: BigNumber;
+  batchCount: BigNumber;
+}
+export type MintedLossTokensToUsersEvent = TypedEvent<
+  [BigNumber, BigNumber],
+  MintedLossTokensToUsersEventObject
+>;
+
+export type MintedLossTokensToUsersEventFilter =
+  TypedEventFilter<MintedLossTokensToUsersEvent>;
+
+export interface TransferEventObject {
+  from: string;
+  to: string;
+  value: BigNumber;
+}
+export type TransferEvent = TypedEvent<
+  [string, string, BigNumber],
+  TransferEventObject
+>;
+
+export type TransferEventFilter = TypedEventFilter<TransferEvent>;
+
+export interface TransferBatchEventObject {
+  operator: string;
+  from: string;
+  to: string;
+  ids: BigNumber[];
+  values: BigNumber[];
+}
+export type TransferBatchEvent = TypedEvent<
+  [string, string, string, BigNumber[], BigNumber[]],
+  TransferBatchEventObject
+>;
+
+export type TransferBatchEventFilter = TypedEventFilter<TransferBatchEvent>;
+
+export interface TransferSingleEventObject {
+  operator: string;
+  from: string;
+  to: string;
+  id: BigNumber;
+  value: BigNumber;
+}
+export type TransferSingleEvent = TypedEvent<
+  [string, string, string, BigNumber, BigNumber],
+  TransferSingleEventObject
+>;
+
+export type TransferSingleEventFilter = TypedEventFilter<TransferSingleEvent>;
+
+export interface URIEventObject {
+  value: string;
+  id: BigNumber;
+}
+export type URIEvent = TypedEvent<[string, BigNumber], URIEventObject>;
+
+export type URIEventFilter = TypedEventFilter<URIEvent>;
+
+export interface WithdrawEventObject {
+  sender: string;
+  receiver: string;
+  owner: string;
+  assets: BigNumber;
+  shares: BigNumber;
+}
+export type WithdrawEvent = TypedEvent<
+  [string, string, string, BigNumber, BigNumber],
+  WithdrawEventObject
+>;
+
+export type WithdrawEventFilter = TypedEventFilter<WithdrawEvent>;
+
+export interface ILendingPoolTrancheAbi extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: ILendingPoolTrancheAbiInterface;
+
+  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: {
+    allowance(
+      owner: string,
+      spender: string,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    approve(
+      spender: string,
+      value: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<ContractTransaction>;
+
+    asset(
+      overrides?: CallOverrides
+    ): Promise<[string] & { assetTokenAddress: string }>;
+
+    "balanceOf(address,uint256)"(
+      account: string,
+      id: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    "balanceOf(address)"(
+      account: string,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    balanceOfBatch(
+      accounts: string[],
+      ids: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<[BigNumber[]]>;
+
+    batchMintLossTokens(
+      lossId: BigNumberish,
+      batchSize: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<ContractTransaction>;
+
+    calculateMaximumLossAmount(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    claimRepaidLoss(
+      user: string,
+      lossId: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<ContractTransaction>;
+
+    convertToAssets(
+      shares: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { assets: BigNumber }>;
+
+    convertToShares(
+      assets: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { shares: BigNumber }>;
+
+    decimals(overrides?: CallOverrides): Promise<[number]>;
+
+    deposit(
+      assets: BigNumberish,
+      receiver: string,
+      overrides?: Overrides & { from?: string }
+    ): Promise<ContractTransaction>;
+
+    isApprovedForAll(
+      account: string,
+      operator: string,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+
+    isLossMintingComplete(
+      lossId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+
+    lossDetails(
+      lossId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[LossDetailsStructOutput]>;
+
+    maxDeposit(
+      receiver: string,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { maxAssets: BigNumber }>;
+
+    maxMint(
+      receiver: string,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { maxShares: BigNumber }>;
+
+    maxRedeem(
+      owner: string,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { maxShares: BigNumber }>;
+
+    maxWithdraw(
+      owner: string,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { maxAssets: BigNumber }>;
+
+    minimumAssetAmountLeftAfterLoss(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    mint(
+      shares: BigNumberish,
+      receiver: string,
+      overrides?: Overrides & { from?: string }
+    ): Promise<ContractTransaction>;
+
+    name(overrides?: CallOverrides): Promise<[string]>;
+
+    previewDeposit(
+      assets: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { shares: BigNumber }>;
+
+    previewMint(
+      shares: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { assets: BigNumber }>;
+
+    previewRedeem(
+      shares: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { assets: BigNumber }>;
+
+    previewWithdraw(
+      assets: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { shares: BigNumber }>;
+
+    redeem(
+      shares: BigNumberish,
+      receiver: string,
+      owner: string,
+      overrides?: Overrides & { from?: string }
+    ): Promise<ContractTransaction>;
+
+    registerTrancheLoss(
+      lossId: BigNumberish,
+      lossAmount: BigNumberish,
+      doMintLossTokens: boolean,
+      overrides?: Overrides & { from?: string }
+    ): Promise<ContractTransaction>;
+
+    removeUserActiveShares(
+      user: string,
+      shares: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<ContractTransaction>;
+
+    repayLoss(
+      lossId: BigNumberish,
+      amount: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<ContractTransaction>;
+
+    safeBatchTransferFrom(
+      from: string,
+      to: string,
+      ids: BigNumberish[],
+      values: BigNumberish[],
+      data: BytesLike,
+      overrides?: Overrides & { from?: string }
+    ): Promise<ContractTransaction>;
+
+    safeTransferFrom(
+      from: string,
+      to: string,
+      id: BigNumberish,
+      value: BigNumberish,
+      data: BytesLike,
+      overrides?: Overrides & { from?: string }
+    ): Promise<ContractTransaction>;
+
+    setApprovalForAll(
+      operator: string,
+      approved: boolean,
+      overrides?: Overrides & { from?: string }
+    ): Promise<ContractTransaction>;
+
+    supportsInterface(
+      interfaceId: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+
+    symbol(overrides?: CallOverrides): Promise<[string]>;
+
+    totalAssets(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { totalManagedAssets: BigNumber }>;
+
+    totalSupply(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>;
+
+    userActiveAssets(
+      user: string,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    userClaimableLoss(
+      user: string,
+      lossId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { claimableAmount: BigNumber }>;
+
+    userClaimedLosses(
+      user: string,
+      lossId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { claimedAmount: BigNumber }>;
+
+    withdraw(
+      assets: BigNumberish,
+      receiver: string,
+      owner: string,
+      overrides?: Overrides & { from?: string }
+    ): Promise<ContractTransaction>;
+  };
+
+  allowance(
+    owner: string,
+    spender: string,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  approve(
+    spender: string,
+    value: BigNumberish,
+    overrides?: Overrides & { from?: string }
+  ): Promise<ContractTransaction>;
+
+  asset(overrides?: CallOverrides): Promise<string>;
+
+  "balanceOf(address,uint256)"(
+    account: string,
+    id: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  "balanceOf(address)"(
+    account: string,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  balanceOfBatch(
+    accounts: string[],
+    ids: BigNumberish[],
+    overrides?: CallOverrides
+  ): Promise<BigNumber[]>;
+
+  batchMintLossTokens(
+    lossId: BigNumberish,
+    batchSize: BigNumberish,
+    overrides?: Overrides & { from?: string }
+  ): Promise<ContractTransaction>;
+
+  calculateMaximumLossAmount(overrides?: CallOverrides): Promise<BigNumber>;
+
+  claimRepaidLoss(
+    user: string,
+    lossId: BigNumberish,
+    overrides?: Overrides & { from?: string }
+  ): Promise<ContractTransaction>;
+
+  convertToAssets(
+    shares: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  convertToShares(
+    assets: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  decimals(overrides?: CallOverrides): Promise<number>;
+
+  deposit(
+    assets: BigNumberish,
+    receiver: string,
+    overrides?: Overrides & { from?: string }
+  ): Promise<ContractTransaction>;
+
+  isApprovedForAll(
+    account: string,
+    operator: string,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  isLossMintingComplete(
+    lossId: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  lossDetails(
+    lossId: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<LossDetailsStructOutput>;
+
+  maxDeposit(receiver: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+  maxMint(receiver: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+  maxRedeem(owner: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+  maxWithdraw(owner: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+  minimumAssetAmountLeftAfterLoss(
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  mint(
+    shares: BigNumberish,
+    receiver: string,
+    overrides?: Overrides & { from?: string }
+  ): Promise<ContractTransaction>;
+
+  name(overrides?: CallOverrides): Promise<string>;
+
+  previewDeposit(
+    assets: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  previewMint(
+    shares: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  previewRedeem(
+    shares: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  previewWithdraw(
+    assets: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  redeem(
+    shares: BigNumberish,
+    receiver: string,
+    owner: string,
+    overrides?: Overrides & { from?: string }
+  ): Promise<ContractTransaction>;
+
+  registerTrancheLoss(
+    lossId: BigNumberish,
+    lossAmount: BigNumberish,
+    doMintLossTokens: boolean,
+    overrides?: Overrides & { from?: string }
+  ): Promise<ContractTransaction>;
+
+  removeUserActiveShares(
+    user: string,
+    shares: BigNumberish,
+    overrides?: Overrides & { from?: string }
+  ): Promise<ContractTransaction>;
+
+  repayLoss(
+    lossId: BigNumberish,
+    amount: BigNumberish,
+    overrides?: Overrides & { from?: string }
+  ): Promise<ContractTransaction>;
+
+  safeBatchTransferFrom(
+    from: string,
+    to: string,
+    ids: BigNumberish[],
+    values: BigNumberish[],
+    data: BytesLike,
+    overrides?: Overrides & { from?: string }
+  ): Promise<ContractTransaction>;
+
+  safeTransferFrom(
+    from: string,
+    to: string,
+    id: BigNumberish,
+    value: BigNumberish,
+    data: BytesLike,
+    overrides?: Overrides & { from?: string }
+  ): Promise<ContractTransaction>;
+
+  setApprovalForAll(
+    operator: string,
+    approved: boolean,
+    overrides?: Overrides & { from?: string }
+  ): Promise<ContractTransaction>;
+
+  supportsInterface(
+    interfaceId: BytesLike,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  symbol(overrides?: CallOverrides): Promise<string>;
+
+  totalAssets(overrides?: CallOverrides): Promise<BigNumber>;
+
+  totalSupply(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>;
+
+  userActiveAssets(user: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+  userClaimableLoss(
+    user: string,
+    lossId: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  userClaimedLosses(
+    user: string,
+    lossId: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  withdraw(
+    assets: BigNumberish,
+    receiver: string,
+    owner: string,
+    overrides?: Overrides & { from?: string }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    allowance(
+      owner: string,
+      spender: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    approve(
+      spender: string,
+      value: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    asset(overrides?: CallOverrides): Promise<string>;
+
+    "balanceOf(address,uint256)"(
+      account: string,
+      id: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "balanceOf(address)"(
+      account: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    balanceOfBatch(
+      accounts: string[],
+      ids: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber[]>;
+
+    batchMintLossTokens(
+      lossId: BigNumberish,
+      batchSize: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    calculateMaximumLossAmount(overrides?: CallOverrides): Promise<BigNumber>;
+
+    claimRepaidLoss(
+      user: string,
+      lossId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    convertToAssets(
+      shares: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    convertToShares(
+      assets: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    decimals(overrides?: CallOverrides): Promise<number>;
+
+    deposit(
+      assets: BigNumberish,
+      receiver: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    isApprovedForAll(
+      account: string,
+      operator: string,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    isLossMintingComplete(
+      lossId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    lossDetails(
+      lossId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<LossDetailsStructOutput>;
+
+    maxDeposit(receiver: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+    maxMint(receiver: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+    maxRedeem(owner: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+    maxWithdraw(owner: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+    minimumAssetAmountLeftAfterLoss(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    mint(
+      shares: BigNumberish,
+      receiver: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    name(overrides?: CallOverrides): Promise<string>;
+
+    previewDeposit(
+      assets: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    previewMint(
+      shares: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    previewRedeem(
+      shares: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    previewWithdraw(
+      assets: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    redeem(
+      shares: BigNumberish,
+      receiver: string,
+      owner: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    registerTrancheLoss(
+      lossId: BigNumberish,
+      lossAmount: BigNumberish,
+      doMintLossTokens: boolean,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    removeUserActiveShares(
+      user: string,
+      shares: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    repayLoss(
+      lossId: BigNumberish,
+      amount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    safeBatchTransferFrom(
+      from: string,
+      to: string,
+      ids: BigNumberish[],
+      values: BigNumberish[],
+      data: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    safeTransferFrom(
+      from: string,
+      to: string,
+      id: BigNumberish,
+      value: BigNumberish,
+      data: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    setApprovalForAll(
+      operator: string,
+      approved: boolean,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    supportsInterface(
+      interfaceId: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    symbol(overrides?: CallOverrides): Promise<string>;
+
+    totalAssets(overrides?: CallOverrides): Promise<BigNumber>;
+
+    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+
+    transfer(
+      to: string,
+      value: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    transferFrom(
+      from: string,
+      to: string,
+      value: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    userActiveAssets(
+      user: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    userClaimableLoss(
+      user: string,
+      lossId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    userClaimedLosses(
+      user: string,
+      lossId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    withdraw(
+      assets: BigNumberish,
+      receiver: string,
+      owner: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  filters: {
+    "Approval(address,address,uint256)"(
+      owner?: string | null,
+      spender?: string | null,
+      value?: null
+    ): ApprovalEventFilter;
+    Approval(
+      owner?: string | null,
+      spender?: string | null,
+      value?: null
+    ): ApprovalEventFilter;
+
+    "ApprovalForAll(address,address,bool)"(
+      account?: string | null,
+      operator?: string | null,
+      approved?: null
+    ): ApprovalForAllEventFilter;
+    ApprovalForAll(
+      account?: string | null,
+      operator?: string | null,
+      approved?: null
+    ): ApprovalForAllEventFilter;
+
+    "Deposit(address,address,uint256,uint256)"(
+      sender?: string | null,
+      owner?: string | null,
+      assets?: null,
+      shares?: null
+    ): DepositEventFilter;
+    Deposit(
+      sender?: string | null,
+      owner?: string | null,
+      assets?: null,
+      shares?: null
+    ): DepositEventFilter;
+
+    "LossClaimed(address,uint256,uint256)"(
+      user?: string | null,
+      lossId?: BigNumberish | null,
+      amount?: null
+    ): LossClaimedEventFilter;
+    LossClaimed(
+      user?: string | null,
+      lossId?: BigNumberish | null,
+      amount?: null
+    ): LossClaimedEventFilter;
+
+    "LossMintingComplete(uint256)"(
+      lossId?: BigNumberish | null
+    ): LossMintingCompleteEventFilter;
+    LossMintingComplete(
+      lossId?: BigNumberish | null
+    ): LossMintingCompleteEventFilter;
+
+    "LossRegistered(uint256,uint256,uint256)"(
+      lossId?: BigNumberish | null,
+      lossAmount?: null,
+      usersCount?: null
+    ): LossRegisteredEventFilter;
+    LossRegistered(
+      lossId?: BigNumberish | null,
+      lossAmount?: null,
+      usersCount?: null
+    ): LossRegisteredEventFilter;
+
+    "LossReturned(uint256,uint256)"(
+      lossId?: BigNumberish | null,
+      amount?: null
+    ): LossReturnedEventFilter;
+    LossReturned(
+      lossId?: BigNumberish | null,
+      amount?: null
+    ): LossReturnedEventFilter;
+
+    "MintedLossTokensToUsers(uint256,uint256)"(
+      lossId?: BigNumberish | null,
+      batchCount?: null
+    ): MintedLossTokensToUsersEventFilter;
+    MintedLossTokensToUsers(
+      lossId?: BigNumberish | null,
+      batchCount?: null
+    ): MintedLossTokensToUsersEventFilter;
+
+    "Transfer(address,address,uint256)"(
+      from?: string | null,
+      to?: string | null,
+      value?: null
+    ): TransferEventFilter;
+    Transfer(
+      from?: string | null,
+      to?: string | null,
+      value?: null
+    ): TransferEventFilter;
+
+    "TransferBatch(address,address,address,uint256[],uint256[])"(
+      operator?: string | null,
+      from?: string | null,
+      to?: string | null,
+      ids?: null,
+      values?: null
+    ): TransferBatchEventFilter;
+    TransferBatch(
+      operator?: string | null,
+      from?: string | null,
+      to?: string | null,
+      ids?: null,
+      values?: null
+    ): TransferBatchEventFilter;
+
+    "TransferSingle(address,address,address,uint256,uint256)"(
+      operator?: string | null,
+      from?: string | null,
+      to?: string | null,
+      id?: null,
+      value?: null
+    ): TransferSingleEventFilter;
+    TransferSingle(
+      operator?: string | null,
+      from?: string | null,
+      to?: string | null,
+      id?: null,
+      value?: null
+    ): TransferSingleEventFilter;
+
+    "URI(string,uint256)"(
+      value?: null,
+      id?: BigNumberish | null
+    ): URIEventFilter;
+    URI(value?: null, id?: BigNumberish | null): URIEventFilter;
+
+    "Withdraw(address,address,address,uint256,uint256)"(
+      sender?: string | null,
+      receiver?: string | null,
+      owner?: string | null,
+      assets?: null,
+      shares?: null
+    ): WithdrawEventFilter;
+    Withdraw(
+      sender?: string | null,
+      receiver?: string | null,
+      owner?: string | null,
+      assets?: null,
+      shares?: null
+    ): WithdrawEventFilter;
+  };
+
+  estimateGas: {
+    allowance(
+      owner: string,
+      spender: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    approve(
+      spender: string,
+      value: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<BigNumber>;
+
+    asset(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "balanceOf(address,uint256)"(
+      account: string,
+      id: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "balanceOf(address)"(
+      account: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    balanceOfBatch(
+      accounts: string[],
+      ids: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    batchMintLossTokens(
+      lossId: BigNumberish,
+      batchSize: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<BigNumber>;
+
+    calculateMaximumLossAmount(overrides?: CallOverrides): Promise<BigNumber>;
+
+    claimRepaidLoss(
+      user: string,
+      lossId: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<BigNumber>;
+
+    convertToAssets(
+      shares: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    convertToShares(
+      assets: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    decimals(overrides?: CallOverrides): Promise<BigNumber>;
+
+    deposit(
+      assets: BigNumberish,
+      receiver: string,
+      overrides?: Overrides & { from?: string }
+    ): Promise<BigNumber>;
+
+    isApprovedForAll(
+      account: string,
+      operator: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    isLossMintingComplete(
+      lossId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    lossDetails(
+      lossId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    maxDeposit(receiver: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+    maxMint(receiver: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+    maxRedeem(owner: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+    maxWithdraw(owner: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+    minimumAssetAmountLeftAfterLoss(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    mint(
+      shares: BigNumberish,
+      receiver: string,
+      overrides?: Overrides & { from?: string }
+    ): Promise<BigNumber>;
+
+    name(overrides?: CallOverrides): Promise<BigNumber>;
+
+    previewDeposit(
+      assets: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    previewMint(
+      shares: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    previewRedeem(
+      shares: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    previewWithdraw(
+      assets: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    redeem(
+      shares: BigNumberish,
+      receiver: string,
+      owner: string,
+      overrides?: Overrides & { from?: string }
+    ): Promise<BigNumber>;
+
+    registerTrancheLoss(
+      lossId: BigNumberish,
+      lossAmount: BigNumberish,
+      doMintLossTokens: boolean,
+      overrides?: Overrides & { from?: string }
+    ): Promise<BigNumber>;
+
+    removeUserActiveShares(
+      user: string,
+      shares: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<BigNumber>;
+
+    repayLoss(
+      lossId: BigNumberish,
+      amount: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<BigNumber>;
+
+    safeBatchTransferFrom(
+      from: string,
+      to: string,
+      ids: BigNumberish[],
+      values: BigNumberish[],
+      data: BytesLike,
+      overrides?: Overrides & { from?: string }
+    ): Promise<BigNumber>;
+
+    safeTransferFrom(
+      from: string,
+      to: string,
+      id: BigNumberish,
+      value: BigNumberish,
+      data: BytesLike,
+      overrides?: Overrides & { from?: string }
+    ): Promise<BigNumber>;
+
+    setApprovalForAll(
+      operator: string,
+      approved: boolean,
+      overrides?: Overrides & { from?: string }
+    ): Promise<BigNumber>;
+
+    supportsInterface(
+      interfaceId: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    symbol(overrides?: CallOverrides): Promise<BigNumber>;
+
+    totalAssets(overrides?: CallOverrides): Promise<BigNumber>;
+
+    totalSupply(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>;
+
+    userActiveAssets(
+      user: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    userClaimableLoss(
+      user: string,
+      lossId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    userClaimedLosses(
+      user: string,
+      lossId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    withdraw(
+      assets: BigNumberish,
+      receiver: string,
+      owner: string,
+      overrides?: Overrides & { from?: string }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    allowance(
+      owner: string,
+      spender: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    approve(
+      spender: string,
+      value: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<PopulatedTransaction>;
+
+    asset(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "balanceOf(address,uint256)"(
+      account: string,
+      id: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "balanceOf(address)"(
+      account: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    balanceOfBatch(
+      accounts: string[],
+      ids: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    batchMintLossTokens(
+      lossId: BigNumberish,
+      batchSize: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<PopulatedTransaction>;
+
+    calculateMaximumLossAmount(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    claimRepaidLoss(
+      user: string,
+      lossId: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<PopulatedTransaction>;
+
+    convertToAssets(
+      shares: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    convertToShares(
+      assets: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    decimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    deposit(
+      assets: BigNumberish,
+      receiver: string,
+      overrides?: Overrides & { from?: string }
+    ): Promise<PopulatedTransaction>;
+
+    isApprovedForAll(
+      account: string,
+      operator: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    isLossMintingComplete(
+      lossId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    lossDetails(
+      lossId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    maxDeposit(
+      receiver: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    maxMint(
+      receiver: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    maxRedeem(
+      owner: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    maxWithdraw(
+      owner: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    minimumAssetAmountLeftAfterLoss(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    mint(
+      shares: BigNumberish,
+      receiver: string,
+      overrides?: Overrides & { from?: string }
+    ): Promise<PopulatedTransaction>;
+
+    name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    previewDeposit(
+      assets: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    previewMint(
+      shares: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    previewRedeem(
+      shares: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    previewWithdraw(
+      assets: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    redeem(
+      shares: BigNumberish,
+      receiver: string,
+      owner: string,
+      overrides?: Overrides & { from?: string }
+    ): Promise<PopulatedTransaction>;
+
+    registerTrancheLoss(
+      lossId: BigNumberish,
+      lossAmount: BigNumberish,
+      doMintLossTokens: boolean,
+      overrides?: Overrides & { from?: string }
+    ): Promise<PopulatedTransaction>;
+
+    removeUserActiveShares(
+      user: string,
+      shares: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<PopulatedTransaction>;
+
+    repayLoss(
+      lossId: BigNumberish,
+      amount: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<PopulatedTransaction>;
+
+    safeBatchTransferFrom(
+      from: string,
+      to: string,
+      ids: BigNumberish[],
+      values: BigNumberish[],
+      data: BytesLike,
+      overrides?: Overrides & { from?: string }
+    ): Promise<PopulatedTransaction>;
+
+    safeTransferFrom(
+      from: string,
+      to: string,
+      id: BigNumberish,
+      value: BigNumberish,
+      data: BytesLike,
+      overrides?: Overrides & { from?: string }
+    ): Promise<PopulatedTransaction>;
+
+    setApprovalForAll(
+      operator: string,
+      approved: boolean,
+      overrides?: Overrides & { from?: string }
+    ): Promise<PopulatedTransaction>;
+
+    supportsInterface(
+      interfaceId: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    symbol(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    totalAssets(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    totalSupply(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>;
+
+    userActiveAssets(
+      user: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    userClaimableLoss(
+      user: string,
+      lossId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    userClaimedLosses(
+      user: string,
+      lossId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    withdraw(
+      assets: BigNumberish,
+      receiver: string,
+      owner: string,
+      overrides?: Overrides & { from?: string }
+    ): Promise<PopulatedTransaction>;
+  };
+}