/* 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>;
  };
}