/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import type {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  PayableOverrides,
  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,
  PromiseOrValue,
} from "./common";

export type MultiCallStruct = {
  target: PromiseOrValue<string>;
  callData: PromiseOrValue<BytesLike>;
};

export type MultiCallStructOutput = [string, string] & {
  target: string;
  callData: string;
};

export interface CreditFacadeInterface extends utils.Interface {
  functions: {
    "addCollateral(address,address,uint256)": FunctionFragment;
    "approveAccountTransfer(address,bool)": FunctionFragment;
    "blacklistHelper()": FunctionFragment;
    "calcCreditAccountHealthFactor(address)": FunctionFragment;
    "calcTotalValue(address)": FunctionFragment;
    "closeCreditAccount(address,uint256,(address,bytes)[])": FunctionFragment;
    "closeCreditAccount(address,uint256,bool,(address,bytes)[])": FunctionFragment;
    "creditManager()": FunctionFragment;
    "degenNFT()": FunctionFragment;
    "expirable()": FunctionFragment;
    "getTotalBorrowedInBlock()": FunctionFragment;
    "hasOpenedCreditAccount(address)": FunctionFragment;
    "isBlacklistableUnderlying()": FunctionFragment;
    "isTokenAllowed(address)": FunctionFragment;
    "limits()": FunctionFragment;
    "liquidateCreditAccount(address,address,uint256,(address,bytes)[])": FunctionFragment;
    "liquidateCreditAccount(address,address,uint256,bool,(address,bytes)[])": FunctionFragment;
    "liquidateExpiredCreditAccount(address,address,uint256,(address,bytes)[])": FunctionFragment;
    "liquidateExpiredCreditAccount(address,address,uint256,bool,(address,bytes)[])": FunctionFragment;
    "lossParams()": FunctionFragment;
    "multicall((address,bytes)[])": FunctionFragment;
    "openCreditAccount(uint256,address,uint16,uint16)": FunctionFragment;
    "openCreditAccountMulticall(uint256,address,(address,bytes)[],uint16)": FunctionFragment;
    "params()": FunctionFragment;
    "pool()": FunctionFragment;
    "resetCumulativeLoss()": FunctionFragment;
    "setCreditAccountLimits(uint128,uint128)": FunctionFragment;
    "setEmergencyLiquidationDiscount(uint16)": FunctionFragment;
    "setExpirationDate(uint40)": FunctionFragment;
    "setIncreaseDebtForbidden(bool)": FunctionFragment;
    "setLimitPerBlock(uint128)": FunctionFragment;
    "setMaxCumulativeLoss(uint128)": FunctionFragment;
    "setTotalDebtParams(uint128,uint128)": FunctionFragment;
    "totalDebt()": FunctionFragment;
    "transferAccountOwnership(address)": FunctionFragment;
    "transfersAllowed(address,address)": FunctionFragment;
    "underlying()": FunctionFragment;
    "version()": FunctionFragment;
    "wethAddress()": FunctionFragment;
    "whitelisted()": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "addCollateral"
      | "approveAccountTransfer"
      | "blacklistHelper"
      | "calcCreditAccountHealthFactor"
      | "calcTotalValue"
      | "closeCreditAccount(address,uint256,(address,bytes)[])"
      | "closeCreditAccount(address,uint256,bool,(address,bytes)[])"
      | "creditManager"
      | "degenNFT"
      | "expirable"
      | "getTotalBorrowedInBlock"
      | "hasOpenedCreditAccount"
      | "isBlacklistableUnderlying"
      | "isTokenAllowed"
      | "limits"
      | "liquidateCreditAccount(address,address,uint256,(address,bytes)[])"
      | "liquidateCreditAccount(address,address,uint256,bool,(address,bytes)[])"
      | "liquidateExpiredCreditAccount(address,address,uint256,(address,bytes)[])"
      | "liquidateExpiredCreditAccount(address,address,uint256,bool,(address,bytes)[])"
      | "lossParams"
      | "multicall"
      | "openCreditAccount"
      | "openCreditAccountMulticall"
      | "params"
      | "pool"
      | "resetCumulativeLoss"
      | "setCreditAccountLimits"
      | "setEmergencyLiquidationDiscount"
      | "setExpirationDate"
      | "setIncreaseDebtForbidden"
      | "setLimitPerBlock"
      | "setMaxCumulativeLoss"
      | "setTotalDebtParams"
      | "totalDebt"
      | "transferAccountOwnership"
      | "transfersAllowed"
      | "underlying"
      | "version"
      | "wethAddress"
      | "whitelisted"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "addCollateral",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "approveAccountTransfer",
    values: [PromiseOrValue<string>, PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "blacklistHelper",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "calcCreditAccountHealthFactor",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "calcTotalValue",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "closeCreditAccount(address,uint256,(address,bytes)[])",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      MultiCallStruct[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "closeCreditAccount(address,uint256,bool,(address,bytes)[])",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<boolean>,
      MultiCallStruct[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "creditManager",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "degenNFT", values?: undefined): string;
  encodeFunctionData(functionFragment: "expirable", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getTotalBorrowedInBlock",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "hasOpenedCreditAccount",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "isBlacklistableUnderlying",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isTokenAllowed",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(functionFragment: "limits", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "liquidateCreditAccount(address,address,uint256,(address,bytes)[])",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      MultiCallStruct[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "liquidateCreditAccount(address,address,uint256,bool,(address,bytes)[])",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<boolean>,
      MultiCallStruct[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "liquidateExpiredCreditAccount(address,address,uint256,(address,bytes)[])",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      MultiCallStruct[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "liquidateExpiredCreditAccount(address,address,uint256,bool,(address,bytes)[])",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<boolean>,
      MultiCallStruct[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "lossParams",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "multicall",
    values: [MultiCallStruct[]]
  ): string;
  encodeFunctionData(
    functionFragment: "openCreditAccount",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "openCreditAccountMulticall",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      MultiCallStruct[],
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(functionFragment: "params", values?: undefined): string;
  encodeFunctionData(functionFragment: "pool", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "resetCumulativeLoss",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setCreditAccountLimits",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setEmergencyLiquidationDiscount",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setExpirationDate",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setIncreaseDebtForbidden",
    values: [PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "setLimitPerBlock",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setMaxCumulativeLoss",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setTotalDebtParams",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(functionFragment: "totalDebt", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "transferAccountOwnership",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "transfersAllowed",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "underlying",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "version", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "wethAddress",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "whitelisted",
    values?: undefined
  ): string;

  decodeFunctionResult(
    functionFragment: "addCollateral",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "approveAccountTransfer",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "blacklistHelper",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "calcCreditAccountHealthFactor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "calcTotalValue",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "closeCreditAccount(address,uint256,(address,bytes)[])",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "closeCreditAccount(address,uint256,bool,(address,bytes)[])",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "creditManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "degenNFT", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "expirable", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getTotalBorrowedInBlock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "hasOpenedCreditAccount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isBlacklistableUnderlying",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isTokenAllowed",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "limits", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "liquidateCreditAccount(address,address,uint256,(address,bytes)[])",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidateCreditAccount(address,address,uint256,bool,(address,bytes)[])",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidateExpiredCreditAccount(address,address,uint256,(address,bytes)[])",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidateExpiredCreditAccount(address,address,uint256,bool,(address,bytes)[])",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "lossParams", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "multicall", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "openCreditAccount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "openCreditAccountMulticall",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "params", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "pool", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "resetCumulativeLoss",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setCreditAccountLimits",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setEmergencyLiquidationDiscount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setExpirationDate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setIncreaseDebtForbidden",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setLimitPerBlock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMaxCumulativeLoss",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTotalDebtParams",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "totalDebt", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferAccountOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transfersAllowed",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "underlying", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "wethAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "whitelisted",
    data: BytesLike
  ): Result;

  events: {
    "AddCollateral(address,address,uint256)": EventFragment;
    "BlacklistHelperSet(address)": EventFragment;
    "CloseCreditAccount(address,address)": EventFragment;
    "DecreaseBorrowedAmount(address,uint256)": EventFragment;
    "IncreaseBorrowedAmount(address,uint256)": EventFragment;
    "IncurLossOnLiquidation(uint256)": EventFragment;
    "LiquidateCreditAccount(address,address,address,uint256)": EventFragment;
    "LiquidateExpiredCreditAccount(address,address,address,uint256)": EventFragment;
    "MultiCallFinished()": EventFragment;
    "MultiCallStarted(address)": EventFragment;
    "OpenCreditAccount(address,address,uint256,uint16)": EventFragment;
    "TokenDisabled(address,address)": EventFragment;
    "TokenEnabled(address,address)": EventFragment;
    "TransferAccount(address,address)": EventFragment;
    "TransferAccountAllowed(address,address,bool)": EventFragment;
    "UnderlyingSentToBlacklistHelper(address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "AddCollateral"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "BlacklistHelperSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "CloseCreditAccount"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DecreaseBorrowedAmount"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "IncreaseBorrowedAmount"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "IncurLossOnLiquidation"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LiquidateCreditAccount"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "LiquidateExpiredCreditAccount"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MultiCallFinished"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MultiCallStarted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OpenCreditAccount"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokenDisabled"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokenEnabled"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TransferAccount"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TransferAccountAllowed"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "UnderlyingSentToBlacklistHelper"
  ): EventFragment;
}

export interface AddCollateralEventObject {
  onBehalfOf: string;
  token: string;
  value: BigNumber;
}
export type AddCollateralEvent = TypedEvent<
  [string, string, BigNumber],
  AddCollateralEventObject
>;

export type AddCollateralEventFilter = TypedEventFilter<AddCollateralEvent>;

export interface BlacklistHelperSetEventObject {
  blacklistHelper: string;
}
export type BlacklistHelperSetEvent = TypedEvent<
  [string],
  BlacklistHelperSetEventObject
>;

export type BlacklistHelperSetEventFilter =
  TypedEventFilter<BlacklistHelperSetEvent>;

export interface CloseCreditAccountEventObject {
  borrower: string;
  to: string;
}
export type CloseCreditAccountEvent = TypedEvent<
  [string, string],
  CloseCreditAccountEventObject
>;

export type CloseCreditAccountEventFilter =
  TypedEventFilter<CloseCreditAccountEvent>;

export interface DecreaseBorrowedAmountEventObject {
  borrower: string;
  amount: BigNumber;
}
export type DecreaseBorrowedAmountEvent = TypedEvent<
  [string, BigNumber],
  DecreaseBorrowedAmountEventObject
>;

export type DecreaseBorrowedAmountEventFilter =
  TypedEventFilter<DecreaseBorrowedAmountEvent>;

export interface IncreaseBorrowedAmountEventObject {
  borrower: string;
  amount: BigNumber;
}
export type IncreaseBorrowedAmountEvent = TypedEvent<
  [string, BigNumber],
  IncreaseBorrowedAmountEventObject
>;

export type IncreaseBorrowedAmountEventFilter =
  TypedEventFilter<IncreaseBorrowedAmountEvent>;

export interface IncurLossOnLiquidationEventObject {
  loss: BigNumber;
}
export type IncurLossOnLiquidationEvent = TypedEvent<
  [BigNumber],
  IncurLossOnLiquidationEventObject
>;

export type IncurLossOnLiquidationEventFilter =
  TypedEventFilter<IncurLossOnLiquidationEvent>;

export interface LiquidateCreditAccountEventObject {
  borrower: string;
  liquidator: string;
  to: string;
  remainingFunds: BigNumber;
}
export type LiquidateCreditAccountEvent = TypedEvent<
  [string, string, string, BigNumber],
  LiquidateCreditAccountEventObject
>;

export type LiquidateCreditAccountEventFilter =
  TypedEventFilter<LiquidateCreditAccountEvent>;

export interface LiquidateExpiredCreditAccountEventObject {
  borrower: string;
  liquidator: string;
  to: string;
  remainingFunds: BigNumber;
}
export type LiquidateExpiredCreditAccountEvent = TypedEvent<
  [string, string, string, BigNumber],
  LiquidateExpiredCreditAccountEventObject
>;

export type LiquidateExpiredCreditAccountEventFilter =
  TypedEventFilter<LiquidateExpiredCreditAccountEvent>;

export interface MultiCallFinishedEventObject {}
export type MultiCallFinishedEvent = TypedEvent<
  [],
  MultiCallFinishedEventObject
>;

export type MultiCallFinishedEventFilter =
  TypedEventFilter<MultiCallFinishedEvent>;

export interface MultiCallStartedEventObject {
  borrower: string;
}
export type MultiCallStartedEvent = TypedEvent<
  [string],
  MultiCallStartedEventObject
>;

export type MultiCallStartedEventFilter =
  TypedEventFilter<MultiCallStartedEvent>;

export interface OpenCreditAccountEventObject {
  onBehalfOf: string;
  creditAccount: string;
  borrowAmount: BigNumber;
  referralCode: number;
}
export type OpenCreditAccountEvent = TypedEvent<
  [string, string, BigNumber, number],
  OpenCreditAccountEventObject
>;

export type OpenCreditAccountEventFilter =
  TypedEventFilter<OpenCreditAccountEvent>;

export interface TokenDisabledEventObject {
  borrower: string;
  token: string;
}
export type TokenDisabledEvent = TypedEvent<
  [string, string],
  TokenDisabledEventObject
>;

export type TokenDisabledEventFilter = TypedEventFilter<TokenDisabledEvent>;

export interface TokenEnabledEventObject {
  borrower: string;
  token: string;
}
export type TokenEnabledEvent = TypedEvent<
  [string, string],
  TokenEnabledEventObject
>;

export type TokenEnabledEventFilter = TypedEventFilter<TokenEnabledEvent>;

export interface TransferAccountEventObject {
  oldOwner: string;
  newOwner: string;
}
export type TransferAccountEvent = TypedEvent<
  [string, string],
  TransferAccountEventObject
>;

export type TransferAccountEventFilter = TypedEventFilter<TransferAccountEvent>;

export interface TransferAccountAllowedEventObject {
  from: string;
  to: string;
  state: boolean;
}
export type TransferAccountAllowedEvent = TypedEvent<
  [string, string, boolean],
  TransferAccountAllowedEventObject
>;

export type TransferAccountAllowedEventFilter =
  TypedEventFilter<TransferAccountAllowedEvent>;

export interface UnderlyingSentToBlacklistHelperEventObject {
  borrower: string;
  amount: BigNumber;
}
export type UnderlyingSentToBlacklistHelperEvent = TypedEvent<
  [string, BigNumber],
  UnderlyingSentToBlacklistHelperEventObject
>;

export type UnderlyingSentToBlacklistHelperEventFilter =
  TypedEventFilter<UnderlyingSentToBlacklistHelperEvent>;

export interface CreditFacade extends BaseContract {
  contractName: "CreditFacade";

  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  interface: CreditFacadeInterface;

  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: {
    addCollateral(
      onBehalfOf: PromiseOrValue<string>,
      token: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    approveAccountTransfer(
      from: PromiseOrValue<string>,
      state: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

    calcCreditAccountHealthFactor(
      creditAccount: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { hf: BigNumber }>;

    calcTotalValue(
      creditAccount: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber] & { total: BigNumber; twv: BigNumber }>;

    "closeCreditAccount(address,uint256,(address,bytes)[])"(
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    "closeCreditAccount(address,uint256,bool,(address,bytes)[])"(
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      arg2: PromiseOrValue<boolean>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

    expirable(overrides?: CallOverrides): Promise<[boolean]>;

    getTotalBorrowedInBlock(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        blockLastUpdate: BigNumber;
        borrowedInBlock: BigNumber;
      }
    >;

    hasOpenedCreditAccount(
      borrower: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    isBlacklistableUnderlying(overrides?: CallOverrides): Promise<[boolean]>;

    isTokenAllowed(
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean] & { allowed: boolean }>;

    limits(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        minBorrowedAmount: BigNumber;
        maxBorrowedAmount: BigNumber;
      }
    >;

    "liquidateCreditAccount(address,address,uint256,(address,bytes)[])"(
      borrower: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    "liquidateCreditAccount(address,address,uint256,bool,(address,bytes)[])"(
      borrower: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      arg3: PromiseOrValue<boolean>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    "liquidateExpiredCreditAccount(address,address,uint256,(address,bytes)[])"(
      borrower: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    "liquidateExpiredCreditAccount(address,address,uint256,bool,(address,bytes)[])"(
      borrower: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      arg3: PromiseOrValue<boolean>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    lossParams(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        currentCumulativeLoss: BigNumber;
        maxCumulativeLoss: BigNumber;
      }
    >;

    multicall(
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    openCreditAccount(
      amount: PromiseOrValue<BigNumberish>,
      onBehalfOf: PromiseOrValue<string>,
      leverageFactor: PromiseOrValue<BigNumberish>,
      referralCode: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    openCreditAccountMulticall(
      borrowedAmount: PromiseOrValue<BigNumberish>,
      onBehalfOf: PromiseOrValue<string>,
      calls: MultiCallStruct[],
      referralCode: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    params(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, boolean, number, number] & {
        maxBorrowedAmountPerBlock: BigNumber;
        isIncreaseDebtForbidden: boolean;
        expirationDate: number;
        emergencyLiquidationDiscount: number;
      }
    >;

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

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

    setCreditAccountLimits(
      _minBorrowedAmount: PromiseOrValue<BigNumberish>,
      _maxBorrowedAmount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setEmergencyLiquidationDiscount(
      newDiscount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setExpirationDate(
      newExpirationDate: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setIncreaseDebtForbidden(
      _mode: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setLimitPerBlock(
      newLimit: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setMaxCumulativeLoss(
      _maxCumulativeLoss: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setTotalDebtParams(
      newCurrentTotalDebt: PromiseOrValue<BigNumberish>,
      newLimit: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    totalDebt(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        currentTotalDebt: BigNumber;
        totalDebtLimit: BigNumber;
      }
    >;

    transferAccountOwnership(
      to: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    transfersAllowed(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

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

    whitelisted(overrides?: CallOverrides): Promise<[boolean]>;
  };

  addCollateral(
    onBehalfOf: PromiseOrValue<string>,
    token: PromiseOrValue<string>,
    amount: PromiseOrValue<BigNumberish>,
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  approveAccountTransfer(
    from: PromiseOrValue<string>,
    state: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

  calcCreditAccountHealthFactor(
    creditAccount: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  calcTotalValue(
    creditAccount: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber] & { total: BigNumber; twv: BigNumber }>;

  "closeCreditAccount(address,uint256,(address,bytes)[])"(
    to: PromiseOrValue<string>,
    skipTokenMask: PromiseOrValue<BigNumberish>,
    calls: MultiCallStruct[],
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  "closeCreditAccount(address,uint256,bool,(address,bytes)[])"(
    to: PromiseOrValue<string>,
    skipTokenMask: PromiseOrValue<BigNumberish>,
    arg2: PromiseOrValue<boolean>,
    calls: MultiCallStruct[],
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

  expirable(overrides?: CallOverrides): Promise<boolean>;

  getTotalBorrowedInBlock(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & {
      blockLastUpdate: BigNumber;
      borrowedInBlock: BigNumber;
    }
  >;

  hasOpenedCreditAccount(
    borrower: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isBlacklistableUnderlying(overrides?: CallOverrides): Promise<boolean>;

  isTokenAllowed(
    token: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  limits(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & {
      minBorrowedAmount: BigNumber;
      maxBorrowedAmount: BigNumber;
    }
  >;

  "liquidateCreditAccount(address,address,uint256,(address,bytes)[])"(
    borrower: PromiseOrValue<string>,
    to: PromiseOrValue<string>,
    skipTokenMask: PromiseOrValue<BigNumberish>,
    calls: MultiCallStruct[],
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  "liquidateCreditAccount(address,address,uint256,bool,(address,bytes)[])"(
    borrower: PromiseOrValue<string>,
    to: PromiseOrValue<string>,
    skipTokenMask: PromiseOrValue<BigNumberish>,
    arg3: PromiseOrValue<boolean>,
    calls: MultiCallStruct[],
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  "liquidateExpiredCreditAccount(address,address,uint256,(address,bytes)[])"(
    borrower: PromiseOrValue<string>,
    to: PromiseOrValue<string>,
    skipTokenMask: PromiseOrValue<BigNumberish>,
    calls: MultiCallStruct[],
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  "liquidateExpiredCreditAccount(address,address,uint256,bool,(address,bytes)[])"(
    borrower: PromiseOrValue<string>,
    to: PromiseOrValue<string>,
    skipTokenMask: PromiseOrValue<BigNumberish>,
    arg3: PromiseOrValue<boolean>,
    calls: MultiCallStruct[],
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  lossParams(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & {
      currentCumulativeLoss: BigNumber;
      maxCumulativeLoss: BigNumber;
    }
  >;

  multicall(
    calls: MultiCallStruct[],
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  openCreditAccount(
    amount: PromiseOrValue<BigNumberish>,
    onBehalfOf: PromiseOrValue<string>,
    leverageFactor: PromiseOrValue<BigNumberish>,
    referralCode: PromiseOrValue<BigNumberish>,
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  openCreditAccountMulticall(
    borrowedAmount: PromiseOrValue<BigNumberish>,
    onBehalfOf: PromiseOrValue<string>,
    calls: MultiCallStruct[],
    referralCode: PromiseOrValue<BigNumberish>,
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  params(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, boolean, number, number] & {
      maxBorrowedAmountPerBlock: BigNumber;
      isIncreaseDebtForbidden: boolean;
      expirationDate: number;
      emergencyLiquidationDiscount: number;
    }
  >;

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

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

  setCreditAccountLimits(
    _minBorrowedAmount: PromiseOrValue<BigNumberish>,
    _maxBorrowedAmount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setEmergencyLiquidationDiscount(
    newDiscount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setExpirationDate(
    newExpirationDate: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setIncreaseDebtForbidden(
    _mode: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setLimitPerBlock(
    newLimit: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setMaxCumulativeLoss(
    _maxCumulativeLoss: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setTotalDebtParams(
    newCurrentTotalDebt: PromiseOrValue<BigNumberish>,
    newLimit: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  totalDebt(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & {
      currentTotalDebt: BigNumber;
      totalDebtLimit: BigNumber;
    }
  >;

  transferAccountOwnership(
    to: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  transfersAllowed(
    arg0: PromiseOrValue<string>,
    arg1: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

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

  whitelisted(overrides?: CallOverrides): Promise<boolean>;

  callStatic: {
    addCollateral(
      onBehalfOf: PromiseOrValue<string>,
      token: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    approveAccountTransfer(
      from: PromiseOrValue<string>,
      state: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

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

    calcCreditAccountHealthFactor(
      creditAccount: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calcTotalValue(
      creditAccount: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber] & { total: BigNumber; twv: BigNumber }>;

    "closeCreditAccount(address,uint256,(address,bytes)[])"(
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      calls: MultiCallStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

    "closeCreditAccount(address,uint256,bool,(address,bytes)[])"(
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      arg2: PromiseOrValue<boolean>,
      calls: MultiCallStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    expirable(overrides?: CallOverrides): Promise<boolean>;

    getTotalBorrowedInBlock(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        blockLastUpdate: BigNumber;
        borrowedInBlock: BigNumber;
      }
    >;

    hasOpenedCreditAccount(
      borrower: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isBlacklistableUnderlying(overrides?: CallOverrides): Promise<boolean>;

    isTokenAllowed(
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    limits(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        minBorrowedAmount: BigNumber;
        maxBorrowedAmount: BigNumber;
      }
    >;

    "liquidateCreditAccount(address,address,uint256,(address,bytes)[])"(
      borrower: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      calls: MultiCallStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

    "liquidateCreditAccount(address,address,uint256,bool,(address,bytes)[])"(
      borrower: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      arg3: PromiseOrValue<boolean>,
      calls: MultiCallStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

    "liquidateExpiredCreditAccount(address,address,uint256,(address,bytes)[])"(
      borrower: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      calls: MultiCallStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

    "liquidateExpiredCreditAccount(address,address,uint256,bool,(address,bytes)[])"(
      borrower: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      arg3: PromiseOrValue<boolean>,
      calls: MultiCallStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

    lossParams(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        currentCumulativeLoss: BigNumber;
        maxCumulativeLoss: BigNumber;
      }
    >;

    multicall(
      calls: MultiCallStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

    openCreditAccount(
      amount: PromiseOrValue<BigNumberish>,
      onBehalfOf: PromiseOrValue<string>,
      leverageFactor: PromiseOrValue<BigNumberish>,
      referralCode: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    openCreditAccountMulticall(
      borrowedAmount: PromiseOrValue<BigNumberish>,
      onBehalfOf: PromiseOrValue<string>,
      calls: MultiCallStruct[],
      referralCode: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    params(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, boolean, number, number] & {
        maxBorrowedAmountPerBlock: BigNumber;
        isIncreaseDebtForbidden: boolean;
        expirationDate: number;
        emergencyLiquidationDiscount: number;
      }
    >;

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

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

    setCreditAccountLimits(
      _minBorrowedAmount: PromiseOrValue<BigNumberish>,
      _maxBorrowedAmount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setEmergencyLiquidationDiscount(
      newDiscount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setExpirationDate(
      newExpirationDate: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setIncreaseDebtForbidden(
      _mode: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

    setLimitPerBlock(
      newLimit: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setMaxCumulativeLoss(
      _maxCumulativeLoss: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setTotalDebtParams(
      newCurrentTotalDebt: PromiseOrValue<BigNumberish>,
      newLimit: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    totalDebt(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        currentTotalDebt: BigNumber;
        totalDebtLimit: BigNumber;
      }
    >;

    transferAccountOwnership(
      to: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    transfersAllowed(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

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

    whitelisted(overrides?: CallOverrides): Promise<boolean>;
  };

  filters: {
    "AddCollateral(address,address,uint256)"(
      onBehalfOf?: PromiseOrValue<string> | null,
      token?: PromiseOrValue<string> | null,
      value?: null
    ): AddCollateralEventFilter;
    AddCollateral(
      onBehalfOf?: PromiseOrValue<string> | null,
      token?: PromiseOrValue<string> | null,
      value?: null
    ): AddCollateralEventFilter;

    "BlacklistHelperSet(address)"(
      blacklistHelper?: PromiseOrValue<string> | null
    ): BlacklistHelperSetEventFilter;
    BlacklistHelperSet(
      blacklistHelper?: PromiseOrValue<string> | null
    ): BlacklistHelperSetEventFilter;

    "CloseCreditAccount(address,address)"(
      borrower?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null
    ): CloseCreditAccountEventFilter;
    CloseCreditAccount(
      borrower?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null
    ): CloseCreditAccountEventFilter;

    "DecreaseBorrowedAmount(address,uint256)"(
      borrower?: PromiseOrValue<string> | null,
      amount?: null
    ): DecreaseBorrowedAmountEventFilter;
    DecreaseBorrowedAmount(
      borrower?: PromiseOrValue<string> | null,
      amount?: null
    ): DecreaseBorrowedAmountEventFilter;

    "IncreaseBorrowedAmount(address,uint256)"(
      borrower?: PromiseOrValue<string> | null,
      amount?: null
    ): IncreaseBorrowedAmountEventFilter;
    IncreaseBorrowedAmount(
      borrower?: PromiseOrValue<string> | null,
      amount?: null
    ): IncreaseBorrowedAmountEventFilter;

    "IncurLossOnLiquidation(uint256)"(
      loss?: null
    ): IncurLossOnLiquidationEventFilter;
    IncurLossOnLiquidation(loss?: null): IncurLossOnLiquidationEventFilter;

    "LiquidateCreditAccount(address,address,address,uint256)"(
      borrower?: PromiseOrValue<string> | null,
      liquidator?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null,
      remainingFunds?: null
    ): LiquidateCreditAccountEventFilter;
    LiquidateCreditAccount(
      borrower?: PromiseOrValue<string> | null,
      liquidator?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null,
      remainingFunds?: null
    ): LiquidateCreditAccountEventFilter;

    "LiquidateExpiredCreditAccount(address,address,address,uint256)"(
      borrower?: PromiseOrValue<string> | null,
      liquidator?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null,
      remainingFunds?: null
    ): LiquidateExpiredCreditAccountEventFilter;
    LiquidateExpiredCreditAccount(
      borrower?: PromiseOrValue<string> | null,
      liquidator?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null,
      remainingFunds?: null
    ): LiquidateExpiredCreditAccountEventFilter;

    "MultiCallFinished()"(): MultiCallFinishedEventFilter;
    MultiCallFinished(): MultiCallFinishedEventFilter;

    "MultiCallStarted(address)"(
      borrower?: PromiseOrValue<string> | null
    ): MultiCallStartedEventFilter;
    MultiCallStarted(
      borrower?: PromiseOrValue<string> | null
    ): MultiCallStartedEventFilter;

    "OpenCreditAccount(address,address,uint256,uint16)"(
      onBehalfOf?: PromiseOrValue<string> | null,
      creditAccount?: PromiseOrValue<string> | null,
      borrowAmount?: null,
      referralCode?: null
    ): OpenCreditAccountEventFilter;
    OpenCreditAccount(
      onBehalfOf?: PromiseOrValue<string> | null,
      creditAccount?: PromiseOrValue<string> | null,
      borrowAmount?: null,
      referralCode?: null
    ): OpenCreditAccountEventFilter;

    "TokenDisabled(address,address)"(
      borrower?: PromiseOrValue<string> | null,
      token?: PromiseOrValue<string> | null
    ): TokenDisabledEventFilter;
    TokenDisabled(
      borrower?: PromiseOrValue<string> | null,
      token?: PromiseOrValue<string> | null
    ): TokenDisabledEventFilter;

    "TokenEnabled(address,address)"(
      borrower?: PromiseOrValue<string> | null,
      token?: PromiseOrValue<string> | null
    ): TokenEnabledEventFilter;
    TokenEnabled(
      borrower?: PromiseOrValue<string> | null,
      token?: PromiseOrValue<string> | null
    ): TokenEnabledEventFilter;

    "TransferAccount(address,address)"(
      oldOwner?: PromiseOrValue<string> | null,
      newOwner?: PromiseOrValue<string> | null
    ): TransferAccountEventFilter;
    TransferAccount(
      oldOwner?: PromiseOrValue<string> | null,
      newOwner?: PromiseOrValue<string> | null
    ): TransferAccountEventFilter;

    "TransferAccountAllowed(address,address,bool)"(
      from?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null,
      state?: null
    ): TransferAccountAllowedEventFilter;
    TransferAccountAllowed(
      from?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null,
      state?: null
    ): TransferAccountAllowedEventFilter;

    "UnderlyingSentToBlacklistHelper(address,uint256)"(
      borrower?: PromiseOrValue<string> | null,
      amount?: null
    ): UnderlyingSentToBlacklistHelperEventFilter;
    UnderlyingSentToBlacklistHelper(
      borrower?: PromiseOrValue<string> | null,
      amount?: null
    ): UnderlyingSentToBlacklistHelperEventFilter;
  };

  estimateGas: {
    addCollateral(
      onBehalfOf: PromiseOrValue<string>,
      token: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    approveAccountTransfer(
      from: PromiseOrValue<string>,
      state: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

    calcCreditAccountHealthFactor(
      creditAccount: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calcTotalValue(
      creditAccount: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "closeCreditAccount(address,uint256,(address,bytes)[])"(
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    "closeCreditAccount(address,uint256,bool,(address,bytes)[])"(
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      arg2: PromiseOrValue<boolean>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

    hasOpenedCreditAccount(
      borrower: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    isTokenAllowed(
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "liquidateCreditAccount(address,address,uint256,(address,bytes)[])"(
      borrower: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    "liquidateCreditAccount(address,address,uint256,bool,(address,bytes)[])"(
      borrower: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      arg3: PromiseOrValue<boolean>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    "liquidateExpiredCreditAccount(address,address,uint256,(address,bytes)[])"(
      borrower: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    "liquidateExpiredCreditAccount(address,address,uint256,bool,(address,bytes)[])"(
      borrower: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      arg3: PromiseOrValue<boolean>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

    multicall(
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    openCreditAccount(
      amount: PromiseOrValue<BigNumberish>,
      onBehalfOf: PromiseOrValue<string>,
      leverageFactor: PromiseOrValue<BigNumberish>,
      referralCode: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    openCreditAccountMulticall(
      borrowedAmount: PromiseOrValue<BigNumberish>,
      onBehalfOf: PromiseOrValue<string>,
      calls: MultiCallStruct[],
      referralCode: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

    setCreditAccountLimits(
      _minBorrowedAmount: PromiseOrValue<BigNumberish>,
      _maxBorrowedAmount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setEmergencyLiquidationDiscount(
      newDiscount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setExpirationDate(
      newExpirationDate: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setIncreaseDebtForbidden(
      _mode: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setLimitPerBlock(
      newLimit: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setMaxCumulativeLoss(
      _maxCumulativeLoss: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setTotalDebtParams(
      newCurrentTotalDebt: PromiseOrValue<BigNumberish>,
      newLimit: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

    transferAccountOwnership(
      to: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    transfersAllowed(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    whitelisted(overrides?: CallOverrides): Promise<BigNumber>;
  };

  populateTransaction: {
    addCollateral(
      onBehalfOf: PromiseOrValue<string>,
      token: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    approveAccountTransfer(
      from: PromiseOrValue<string>,
      state: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

    calcCreditAccountHealthFactor(
      creditAccount: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    calcTotalValue(
      creditAccount: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "closeCreditAccount(address,uint256,(address,bytes)[])"(
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    "closeCreditAccount(address,uint256,bool,(address,bytes)[])"(
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      arg2: PromiseOrValue<boolean>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    hasOpenedCreditAccount(
      borrower: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    isTokenAllowed(
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "liquidateCreditAccount(address,address,uint256,(address,bytes)[])"(
      borrower: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    "liquidateCreditAccount(address,address,uint256,bool,(address,bytes)[])"(
      borrower: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      arg3: PromiseOrValue<boolean>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    "liquidateExpiredCreditAccount(address,address,uint256,(address,bytes)[])"(
      borrower: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    "liquidateExpiredCreditAccount(address,address,uint256,bool,(address,bytes)[])"(
      borrower: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      skipTokenMask: PromiseOrValue<BigNumberish>,
      arg3: PromiseOrValue<boolean>,
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

    multicall(
      calls: MultiCallStruct[],
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    openCreditAccount(
      amount: PromiseOrValue<BigNumberish>,
      onBehalfOf: PromiseOrValue<string>,
      leverageFactor: PromiseOrValue<BigNumberish>,
      referralCode: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    openCreditAccountMulticall(
      borrowedAmount: PromiseOrValue<BigNumberish>,
      onBehalfOf: PromiseOrValue<string>,
      calls: MultiCallStruct[],
      referralCode: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

    setCreditAccountLimits(
      _minBorrowedAmount: PromiseOrValue<BigNumberish>,
      _maxBorrowedAmount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setEmergencyLiquidationDiscount(
      newDiscount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setExpirationDate(
      newExpirationDate: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setIncreaseDebtForbidden(
      _mode: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setLimitPerBlock(
      newLimit: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setMaxCumulativeLoss(
      _maxCumulativeLoss: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setTotalDebtParams(
      newCurrentTotalDebt: PromiseOrValue<BigNumberish>,
      newLimit: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

    transferAccountOwnership(
      to: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    transfersAllowed(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    whitelisted(overrides?: CallOverrides): Promise<PopulatedTransaction>;
  };
}