@kasufinance/kasu-sdk 1.0.1

package/dist/contracts/ILendingPoolTrancheAbi.d.ts

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