/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  Contract,
  ContractTransaction,
  Overrides,
  CallOverrides,
} from "ethers";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
import { TypedEventFilter, TypedEvent, TypedListener } from "./commons";

interface TrancheMasterInterface extends ethers.utils.Interface {
  functions: {
    "_swapFromInstrument(bool,uint256,uint256,uint256,bytes)": FunctionFragment;
    "_swapFromTranche(bool,int256,uint256,uint256,bytes)": FunctionFragment;
    "arbByPairRedeem(bool,uint256)": FunctionFragment;
    "freshTrancheNewOrder()": FunctionFragment;
    "getAMM(uint256)": FunctionFragment;
    "getDorc(uint256)": FunctionFragment;
    "getFee(uint256,uint256)": FunctionFragment;
    "getPTV(uint256,bool,uint256)": FunctionFragment;
    "getdVaultBal(uint256,address,bool,uint256)": FunctionFragment;
    "leverageSwap()": FunctionFragment;
    "redeemByDebtVault(uint256,uint256,bool,uint256)": FunctionFragment;
    "redeemFromDebtVault(uint256,uint256,uint256,bool)": FunctionFragment;
    "redeemToDebtVault(uint256,bool,uint256)": FunctionFragment;
    "routeOptimalTrade()": FunctionFragment;
    "swapFromInstrument()": FunctionFragment;
    "swapFromTranche()": FunctionFragment;
    "swapFromUnderlying(bool,uint256,uint256,uint256)": FunctionFragment;
    "swapToRatio()": FunctionFragment;
    "swapToUnderlying()": FunctionFragment;
    "unRedeemDebtVault(uint256,uint256,bool,uint256)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "_swapFromInstrument",
    values: [boolean, BigNumberish, BigNumberish, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "_swapFromTranche",
    values: [boolean, BigNumberish, BigNumberish, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "arbByPairRedeem",
    values: [boolean, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "freshTrancheNewOrder",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getAMM",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getDorc",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getFee",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getPTV",
    values: [BigNumberish, boolean, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getdVaultBal",
    values: [BigNumberish, string, boolean, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "leverageSwap",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "redeemByDebtVault",
    values: [BigNumberish, BigNumberish, boolean, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "redeemFromDebtVault",
    values: [BigNumberish, BigNumberish, BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "redeemToDebtVault",
    values: [BigNumberish, boolean, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "routeOptimalTrade",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "swapFromInstrument",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "swapFromTranche",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "swapFromUnderlying",
    values: [boolean, BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "swapToRatio",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "swapToUnderlying",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "unRedeemDebtVault",
    values: [BigNumberish, BigNumberish, boolean, BigNumberish]
  ): string;

  decodeFunctionResult(
    functionFragment: "_swapFromInstrument",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_swapFromTranche",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "arbByPairRedeem",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "freshTrancheNewOrder",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getAMM", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getDorc", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getFee", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getPTV", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getdVaultBal",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "leverageSwap",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "redeemByDebtVault",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "redeemFromDebtVault",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "redeemToDebtVault",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "routeOptimalTrade",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "swapFromInstrument",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "swapFromTranche",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "swapFromUnderlying",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "swapToRatio",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "swapToUnderlying",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unRedeemDebtVault",
    data: BytesLike
  ): Result;

  events: {};
}

export class TrancheMaster extends Contract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  listeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter?: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): Array<TypedListener<EventArgsArray, EventArgsObject>>;
  off<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  on<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  once<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeListener<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeAllListeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): this;

  listeners(eventName?: string): Array<Listener>;
  off(eventName: string, listener: Listener): this;
  on(eventName: string, listener: Listener): this;
  once(eventName: string, listener: Listener): this;
  removeListener(eventName: string, listener: Listener): this;
  removeAllListeners(eventName?: string): this;

  queryFilter<EventArgsArray extends Array<any>, EventArgsObject>(
    event: TypedEventFilter<EventArgsArray, EventArgsObject>,
    fromBlockOrBlockhash?: string | number | undefined,
    toBlock?: string | number | undefined
  ): Promise<Array<TypedEvent<EventArgsArray & EventArgsObject>>>;

  interface: TrancheMasterInterface;

  functions: {
    _swapFromInstrument(
      toJunior: boolean,
      amount: BigNumberish,
      priceLimit: BigNumberish,
      vaultId: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "_swapFromInstrument(bool,uint256,uint256,uint256,bytes)"(
      toJunior: boolean,
      amount: BigNumberish,
      priceLimit: BigNumberish,
      vaultId: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    _swapFromTranche(
      toJunior: boolean,
      amount: BigNumberish,
      priceLimit: BigNumberish,
      vaultId: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "_swapFromTranche(bool,int256,uint256,uint256,bytes)"(
      toJunior: boolean,
      amount: BigNumberish,
      priceLimit: BigNumberish,
      vaultId: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    arbByPairRedeem(
      senior: boolean,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "arbByPairRedeem(bool,uint256)"(
      senior: boolean,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    "freshTrancheNewOrder()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    getAMM(vaultId: BigNumberish, overrides?: CallOverrides): Promise<[string]>;

    "getAMM(uint256)"(
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getDorc(
      pjs: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber, BigNumber, BigNumber]>;

    "getDorc(uint256)"(
      pjs: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber, BigNumber, BigNumber]>;

    getFee(
      p1: BigNumberish,
      p2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    "getFee(uint256,uint256)"(
      p1: BigNumberish,
      p2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getPTV(
      pjs: BigNumberish,
      isSenior: boolean,
      junior_weight: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { pTv: BigNumber }>;

    "getPTV(uint256,bool,uint256)"(
      pjs: BigNumberish,
      isSenior: boolean,
      junior_weight: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { pTv: BigNumber }>;

    getdVaultBal(
      vaultId: BigNumberish,
      who: string,
      isSenior: boolean,
      pjs: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    "getdVaultBal(uint256,address,bool,uint256)"(
      vaultId: BigNumberish,
      who: string,
      isSenior: boolean,
      pjs: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    "leverageSwap()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    redeemByDebtVault(
      amount: BigNumberish,
      pjs: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "redeemByDebtVault(uint256,uint256,bool,uint256)"(
      amount: BigNumberish,
      pjs: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    redeemFromDebtVault(
      dVaultAmount: BigNumberish,
      pjs: BigNumberish,
      vaultId: BigNumberish,
      isSenior: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "redeemFromDebtVault(uint256,uint256,uint256,bool)"(
      dVaultAmount: BigNumberish,
      pjs: BigNumberish,
      vaultId: BigNumberish,
      isSenior: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    redeemToDebtVault(
      amount: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "redeemToDebtVault(uint256,bool,uint256)"(
      amount: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    "routeOptimalTrade()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    "swapFromInstrument()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    "swapFromTranche()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    swapFromUnderlying(
      wantSenior: boolean,
      amount: BigNumberish,
      vaultId: BigNumberish,
      priceLimit: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "swapFromUnderlying(bool,uint256,uint256,uint256)"(
      wantSenior: boolean,
      amount: BigNumberish,
      vaultId: BigNumberish,
      priceLimit: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    "swapToRatio()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    "swapToUnderlying()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    unRedeemDebtVault(
      amount: BigNumberish,
      pjs: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "unRedeemDebtVault(uint256,uint256,bool,uint256)"(
      amount: BigNumberish,
      pjs: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;
  };

  _swapFromInstrument(
    toJunior: boolean,
    amount: BigNumberish,
    priceLimit: BigNumberish,
    vaultId: BigNumberish,
    data: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "_swapFromInstrument(bool,uint256,uint256,uint256,bytes)"(
    toJunior: boolean,
    amount: BigNumberish,
    priceLimit: BigNumberish,
    vaultId: BigNumberish,
    data: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  _swapFromTranche(
    toJunior: boolean,
    amount: BigNumberish,
    priceLimit: BigNumberish,
    vaultId: BigNumberish,
    data: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "_swapFromTranche(bool,int256,uint256,uint256,bytes)"(
    toJunior: boolean,
    amount: BigNumberish,
    priceLimit: BigNumberish,
    vaultId: BigNumberish,
    data: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  arbByPairRedeem(
    senior: boolean,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "arbByPairRedeem(bool,uint256)"(
    senior: boolean,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  "freshTrancheNewOrder()"(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  getAMM(vaultId: BigNumberish, overrides?: CallOverrides): Promise<string>;

  "getAMM(uint256)"(
    vaultId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  getDorc(
    pjs: BigNumberish,
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber, BigNumber, BigNumber]>;

  "getDorc(uint256)"(
    pjs: BigNumberish,
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber, BigNumber, BigNumber]>;

  getFee(
    p1: BigNumberish,
    p2: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getFee(uint256,uint256)"(
    p1: BigNumberish,
    p2: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getPTV(
    pjs: BigNumberish,
    isSenior: boolean,
    junior_weight: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getPTV(uint256,bool,uint256)"(
    pjs: BigNumberish,
    isSenior: boolean,
    junior_weight: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getdVaultBal(
    vaultId: BigNumberish,
    who: string,
    isSenior: boolean,
    pjs: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getdVaultBal(uint256,address,bool,uint256)"(
    vaultId: BigNumberish,
    who: string,
    isSenior: boolean,
    pjs: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  "leverageSwap()"(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  redeemByDebtVault(
    amount: BigNumberish,
    pjs: BigNumberish,
    isSenior: boolean,
    vaultId: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "redeemByDebtVault(uint256,uint256,bool,uint256)"(
    amount: BigNumberish,
    pjs: BigNumberish,
    isSenior: boolean,
    vaultId: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  redeemFromDebtVault(
    dVaultAmount: BigNumberish,
    pjs: BigNumberish,
    vaultId: BigNumberish,
    isSenior: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "redeemFromDebtVault(uint256,uint256,uint256,bool)"(
    dVaultAmount: BigNumberish,
    pjs: BigNumberish,
    vaultId: BigNumberish,
    isSenior: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  redeemToDebtVault(
    amount: BigNumberish,
    isSenior: boolean,
    vaultId: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "redeemToDebtVault(uint256,bool,uint256)"(
    amount: BigNumberish,
    isSenior: boolean,
    vaultId: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  "routeOptimalTrade()"(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  "swapFromInstrument()"(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  "swapFromTranche()"(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  swapFromUnderlying(
    wantSenior: boolean,
    amount: BigNumberish,
    vaultId: BigNumberish,
    priceLimit: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "swapFromUnderlying(bool,uint256,uint256,uint256)"(
    wantSenior: boolean,
    amount: BigNumberish,
    vaultId: BigNumberish,
    priceLimit: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  "swapToRatio()"(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  "swapToUnderlying()"(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  unRedeemDebtVault(
    amount: BigNumberish,
    pjs: BigNumberish,
    isSenior: boolean,
    vaultId: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "unRedeemDebtVault(uint256,uint256,bool,uint256)"(
    amount: BigNumberish,
    pjs: BigNumberish,
    isSenior: boolean,
    vaultId: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  callStatic: {
    _swapFromInstrument(
      toJunior: boolean,
      amount: BigNumberish,
      priceLimit: BigNumberish,
      vaultId: BigNumberish,
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { amountIn: BigNumber; amountOut: BigNumber }
    >;

    "_swapFromInstrument(bool,uint256,uint256,uint256,bytes)"(
      toJunior: boolean,
      amount: BigNumberish,
      priceLimit: BigNumberish,
      vaultId: BigNumberish,
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { amountIn: BigNumber; amountOut: BigNumber }
    >;

    _swapFromTranche(
      toJunior: boolean,
      amount: BigNumberish,
      priceLimit: BigNumberish,
      vaultId: BigNumberish,
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { amountIn: BigNumber; amountOut: BigNumber }
    >;

    "_swapFromTranche(bool,int256,uint256,uint256,bytes)"(
      toJunior: boolean,
      amount: BigNumberish,
      priceLimit: BigNumberish,
      vaultId: BigNumberish,
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { amountIn: BigNumber; amountOut: BigNumber }
    >;

    arbByPairRedeem(
      senior: boolean,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "arbByPairRedeem(bool,uint256)"(
      senior: boolean,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    "freshTrancheNewOrder()"(overrides?: CallOverrides): Promise<void>;

    getAMM(vaultId: BigNumberish, overrides?: CallOverrides): Promise<string>;

    "getAMM(uint256)"(
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    getDorc(
      pjs: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber, BigNumber, BigNumber]>;

    "getDorc(uint256)"(
      pjs: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber, BigNumber, BigNumber]>;

    getFee(
      p1: BigNumberish,
      p2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getFee(uint256,uint256)"(
      p1: BigNumberish,
      p2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getPTV(
      pjs: BigNumberish,
      isSenior: boolean,
      junior_weight: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getPTV(uint256,bool,uint256)"(
      pjs: BigNumberish,
      isSenior: boolean,
      junior_weight: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getdVaultBal(
      vaultId: BigNumberish,
      who: string,
      isSenior: boolean,
      pjs: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getdVaultBal(uint256,address,bool,uint256)"(
      vaultId: BigNumberish,
      who: string,
      isSenior: boolean,
      pjs: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "leverageSwap()"(overrides?: CallOverrides): Promise<void>;

    redeemByDebtVault(
      amount: BigNumberish,
      pjs: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "redeemByDebtVault(uint256,uint256,bool,uint256)"(
      amount: BigNumberish,
      pjs: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    redeemFromDebtVault(
      dVaultAmount: BigNumberish,
      pjs: BigNumberish,
      vaultId: BigNumberish,
      isSenior: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "redeemFromDebtVault(uint256,uint256,uint256,bool)"(
      dVaultAmount: BigNumberish,
      pjs: BigNumberish,
      vaultId: BigNumberish,
      isSenior: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    redeemToDebtVault(
      amount: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "redeemToDebtVault(uint256,bool,uint256)"(
      amount: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "routeOptimalTrade()"(overrides?: CallOverrides): Promise<void>;

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

    "swapFromInstrument()"(overrides?: CallOverrides): Promise<void>;

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

    "swapFromTranche()"(overrides?: CallOverrides): Promise<void>;

    swapFromUnderlying(
      wantSenior: boolean,
      amount: BigNumberish,
      vaultId: BigNumberish,
      priceLimit: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "swapFromUnderlying(bool,uint256,uint256,uint256)"(
      wantSenior: boolean,
      amount: BigNumberish,
      vaultId: BigNumberish,
      priceLimit: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    "swapToRatio()"(overrides?: CallOverrides): Promise<void>;

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

    "swapToUnderlying()"(overrides?: CallOverrides): Promise<void>;

    unRedeemDebtVault(
      amount: BigNumberish,
      pjs: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "unRedeemDebtVault(uint256,uint256,bool,uint256)"(
      amount: BigNumberish,
      pjs: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {};

  estimateGas: {
    _swapFromInstrument(
      toJunior: boolean,
      amount: BigNumberish,
      priceLimit: BigNumberish,
      vaultId: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "_swapFromInstrument(bool,uint256,uint256,uint256,bytes)"(
      toJunior: boolean,
      amount: BigNumberish,
      priceLimit: BigNumberish,
      vaultId: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    _swapFromTranche(
      toJunior: boolean,
      amount: BigNumberish,
      priceLimit: BigNumberish,
      vaultId: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "_swapFromTranche(bool,int256,uint256,uint256,bytes)"(
      toJunior: boolean,
      amount: BigNumberish,
      priceLimit: BigNumberish,
      vaultId: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    arbByPairRedeem(
      senior: boolean,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "arbByPairRedeem(bool,uint256)"(
      senior: boolean,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    "freshTrancheNewOrder()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    getAMM(
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getAMM(uint256)"(
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDorc(pjs: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

    "getDorc(uint256)"(
      pjs: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getFee(
      p1: BigNumberish,
      p2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getFee(uint256,uint256)"(
      p1: BigNumberish,
      p2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getPTV(
      pjs: BigNumberish,
      isSenior: boolean,
      junior_weight: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getPTV(uint256,bool,uint256)"(
      pjs: BigNumberish,
      isSenior: boolean,
      junior_weight: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getdVaultBal(
      vaultId: BigNumberish,
      who: string,
      isSenior: boolean,
      pjs: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getdVaultBal(uint256,address,bool,uint256)"(
      vaultId: BigNumberish,
      who: string,
      isSenior: boolean,
      pjs: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "leverageSwap()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    redeemByDebtVault(
      amount: BigNumberish,
      pjs: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "redeemByDebtVault(uint256,uint256,bool,uint256)"(
      amount: BigNumberish,
      pjs: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    redeemFromDebtVault(
      dVaultAmount: BigNumberish,
      pjs: BigNumberish,
      vaultId: BigNumberish,
      isSenior: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "redeemFromDebtVault(uint256,uint256,uint256,bool)"(
      dVaultAmount: BigNumberish,
      pjs: BigNumberish,
      vaultId: BigNumberish,
      isSenior: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    redeemToDebtVault(
      amount: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "redeemToDebtVault(uint256,bool,uint256)"(
      amount: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    "routeOptimalTrade()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    "swapFromInstrument()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    "swapFromTranche()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    swapFromUnderlying(
      wantSenior: boolean,
      amount: BigNumberish,
      vaultId: BigNumberish,
      priceLimit: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "swapFromUnderlying(bool,uint256,uint256,uint256)"(
      wantSenior: boolean,
      amount: BigNumberish,
      vaultId: BigNumberish,
      priceLimit: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    "swapToRatio()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    "swapToUnderlying()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    unRedeemDebtVault(
      amount: BigNumberish,
      pjs: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "unRedeemDebtVault(uint256,uint256,bool,uint256)"(
      amount: BigNumberish,
      pjs: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    _swapFromInstrument(
      toJunior: boolean,
      amount: BigNumberish,
      priceLimit: BigNumberish,
      vaultId: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "_swapFromInstrument(bool,uint256,uint256,uint256,bytes)"(
      toJunior: boolean,
      amount: BigNumberish,
      priceLimit: BigNumberish,
      vaultId: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    _swapFromTranche(
      toJunior: boolean,
      amount: BigNumberish,
      priceLimit: BigNumberish,
      vaultId: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "_swapFromTranche(bool,int256,uint256,uint256,bytes)"(
      toJunior: boolean,
      amount: BigNumberish,
      priceLimit: BigNumberish,
      vaultId: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    arbByPairRedeem(
      senior: boolean,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "arbByPairRedeem(bool,uint256)"(
      senior: boolean,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    "freshTrancheNewOrder()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    getAMM(
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getAMM(uint256)"(
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getDorc(
      pjs: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getDorc(uint256)"(
      pjs: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getFee(
      p1: BigNumberish,
      p2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getFee(uint256,uint256)"(
      p1: BigNumberish,
      p2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getPTV(
      pjs: BigNumberish,
      isSenior: boolean,
      junior_weight: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getPTV(uint256,bool,uint256)"(
      pjs: BigNumberish,
      isSenior: boolean,
      junior_weight: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getdVaultBal(
      vaultId: BigNumberish,
      who: string,
      isSenior: boolean,
      pjs: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getdVaultBal(uint256,address,bool,uint256)"(
      vaultId: BigNumberish,
      who: string,
      isSenior: boolean,
      pjs: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "leverageSwap()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    redeemByDebtVault(
      amount: BigNumberish,
      pjs: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "redeemByDebtVault(uint256,uint256,bool,uint256)"(
      amount: BigNumberish,
      pjs: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    redeemFromDebtVault(
      dVaultAmount: BigNumberish,
      pjs: BigNumberish,
      vaultId: BigNumberish,
      isSenior: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "redeemFromDebtVault(uint256,uint256,uint256,bool)"(
      dVaultAmount: BigNumberish,
      pjs: BigNumberish,
      vaultId: BigNumberish,
      isSenior: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    redeemToDebtVault(
      amount: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "redeemToDebtVault(uint256,bool,uint256)"(
      amount: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    "routeOptimalTrade()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    "swapFromInstrument()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    "swapFromTranche()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    swapFromUnderlying(
      wantSenior: boolean,
      amount: BigNumberish,
      vaultId: BigNumberish,
      priceLimit: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "swapFromUnderlying(bool,uint256,uint256,uint256)"(
      wantSenior: boolean,
      amount: BigNumberish,
      vaultId: BigNumberish,
      priceLimit: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    "swapToRatio()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    "swapToUnderlying()"(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    unRedeemDebtVault(
      amount: BigNumberish,
      pjs: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "unRedeemDebtVault(uint256,uint256,bool,uint256)"(
      amount: BigNumberish,
      pjs: BigNumberish,
      isSenior: boolean,
      vaultId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;
  };
}