/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  PopulatedTransaction,
  Signer,
  utils,
} from "ethers";
import { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
import { Listener, Provider } from "@ethersproject/providers";
import { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";

export interface PendleDataInterface extends utils.Interface {
  functions: {
    "addForge(bytes32,address)": FunctionFragment;
    "addMarket(bytes32,address,address,address)": FunctionFragment;
    "addMarketFactory(bytes32,address)": FunctionFragment;
    "allMarkets(uint256)": FunctionFragment;
    "allMarketsLength()": FunctionFragment;
    "curveShiftBlockDelta()": FunctionFragment;
    "expiryDivisor()": FunctionFragment;
    "forgeFee()": FunctionFragment;
    "getForgeAddress(bytes32)": FunctionFragment;
    "getMarket(bytes32,address,address)": FunctionFragment;
    "getMarketByIndex(uint256)": FunctionFragment;
    "getMarketFactoryAddress(bytes32)": FunctionFragment;
    "getMarketFromKey(address,address,bytes32)": FunctionFragment;
    "getPendleYieldTokens(bytes32,address,uint256)": FunctionFragment;
    "governanceManager()": FunctionFragment;
    "initialize(address)": FunctionFragment;
    "interestUpdateRateDeltaForMarket()": FunctionFragment;
    "isMarket(address)": FunctionFragment;
    "isValidOT(bytes32,address,uint256)": FunctionFragment;
    "isValidXYT(bytes32,address,uint256)": FunctionFragment;
    "isXyt(address)": FunctionFragment;
    "lockDenominator()": FunctionFragment;
    "lockNumerator()": FunctionFragment;
    "otTokens(bytes32,address,uint256)": FunctionFragment;
    "pausingManager()": FunctionFragment;
    "protocolSwapFee()": FunctionFragment;
    "router()": FunctionFragment;
    "setCurveShiftBlockDelta(uint256)": FunctionFragment;
    "setExpiryDivisor(uint256)": FunctionFragment;
    "setForgeFactoryValidity(bytes32,bytes32,bool)": FunctionFragment;
    "setForgeFee(uint256)": FunctionFragment;
    "setInterestUpdateRateDeltaForMarket(uint256)": FunctionFragment;
    "setLockParams(uint256,uint256)": FunctionFragment;
    "setMarketFees(uint256,uint256)": FunctionFragment;
    "setTreasury(address)": FunctionFragment;
    "storeTokens(bytes32,address,address,address,uint256)": FunctionFragment;
    "swapFee()": FunctionFragment;
    "treasury()": FunctionFragment;
    "validForgeFactoryPair(bytes32,bytes32)": FunctionFragment;
    "xytTokens(bytes32,address,uint256)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "addForge",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "addMarket",
    values: [BytesLike, string, string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "addMarketFactory",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "allMarkets",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "allMarketsLength",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "curveShiftBlockDelta",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "expiryDivisor",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "forgeFee", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getForgeAddress",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "getMarket",
    values: [BytesLike, string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "getMarketByIndex",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getMarketFactoryAddress",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "getMarketFromKey",
    values: [string, string, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "getPendleYieldTokens",
    values: [BytesLike, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "governanceManager",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "initialize", values: [string]): string;
  encodeFunctionData(
    functionFragment: "interestUpdateRateDeltaForMarket",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "isMarket", values: [string]): string;
  encodeFunctionData(
    functionFragment: "isValidOT",
    values: [BytesLike, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "isValidXYT",
    values: [BytesLike, string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "isXyt", values: [string]): string;
  encodeFunctionData(
    functionFragment: "lockDenominator",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "lockNumerator",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "otTokens",
    values: [BytesLike, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "pausingManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "protocolSwapFee",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "router", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "setCurveShiftBlockDelta",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setExpiryDivisor",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setForgeFactoryValidity",
    values: [BytesLike, BytesLike, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setForgeFee",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setInterestUpdateRateDeltaForMarket",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setLockParams",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setMarketFees",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "setTreasury", values: [string]): string;
  encodeFunctionData(
    functionFragment: "storeTokens",
    values: [BytesLike, string, string, string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "swapFee", values?: undefined): string;
  encodeFunctionData(functionFragment: "treasury", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "validForgeFactoryPair",
    values: [BytesLike, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "xytTokens",
    values: [BytesLike, string, BigNumberish]
  ): string;

  decodeFunctionResult(functionFragment: "addForge", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "addMarket", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "addMarketFactory",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "allMarkets", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "allMarketsLength",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "curveShiftBlockDelta",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "expiryDivisor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "forgeFee", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getForgeAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getMarket", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getMarketByIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getMarketFactoryAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getMarketFromKey",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPendleYieldTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "governanceManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "interestUpdateRateDeltaForMarket",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isMarket", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "isValidOT", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "isValidXYT", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "isXyt", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "lockDenominator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lockNumerator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "otTokens", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "pausingManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "protocolSwapFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "router", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setCurveShiftBlockDelta",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setExpiryDivisor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setForgeFactoryValidity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setForgeFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setInterestUpdateRateDeltaForMarket",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setLockParams",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMarketFees",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTreasury",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "storeTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "swapFee", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "treasury", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "validForgeFactoryPair",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "xytTokens", data: BytesLike): Result;

  events: {
    "CurveShiftBlockDeltaSet(uint256)": EventFragment;
    "ExpiryDivisorSet(uint256)": EventFragment;
    "ForgeAdded(bytes32,address)": EventFragment;
    "ForgeFactoryValiditySet(bytes32,bytes32,bool)": EventFragment;
    "ForgeFeeSet(uint256)": EventFragment;
    "InterestUpdateRateDeltaForMarketSet(uint256)": EventFragment;
    "LockParamsSet(uint256,uint256)": EventFragment;
    "MarketFeesSet(uint256,uint256)": EventFragment;
    "MarketPairAdded(address,address,address)": EventFragment;
    "NewMarketFactory(bytes32,address)": EventFragment;
    "TreasurySet(address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "CurveShiftBlockDeltaSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ExpiryDivisorSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ForgeAdded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ForgeFactoryValiditySet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ForgeFeeSet"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "InterestUpdateRateDeltaForMarketSet"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LockParamsSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MarketFeesSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MarketPairAdded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewMarketFactory"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TreasurySet"): EventFragment;
}

export type CurveShiftBlockDeltaSetEvent = TypedEvent<
  [BigNumber],
  { _blockDelta: BigNumber }
>;

export type CurveShiftBlockDeltaSetEventFilter =
  TypedEventFilter<CurveShiftBlockDeltaSetEvent>;

export type ExpiryDivisorSetEvent = TypedEvent<
  [BigNumber],
  { expiryDivisor: BigNumber }
>;

export type ExpiryDivisorSetEventFilter =
  TypedEventFilter<ExpiryDivisorSetEvent>;

export type ForgeAddedEvent = TypedEvent<
  [string, string],
  { forgeId: string; forgeAddress: string }
>;

export type ForgeAddedEventFilter = TypedEventFilter<ForgeAddedEvent>;

export type ForgeFactoryValiditySetEvent = TypedEvent<
  [string, string, boolean],
  { _forgeId: string; _marketFactoryId: string; _valid: boolean }
>;

export type ForgeFactoryValiditySetEventFilter =
  TypedEventFilter<ForgeFactoryValiditySetEvent>;

export type ForgeFeeSetEvent = TypedEvent<[BigNumber], { forgeFee: BigNumber }>;

export type ForgeFeeSetEventFilter = TypedEventFilter<ForgeFeeSetEvent>;

export type InterestUpdateRateDeltaForMarketSetEvent = TypedEvent<
  [BigNumber],
  { interestUpdateRateDeltaForMarket: BigNumber }
>;

export type InterestUpdateRateDeltaForMarketSetEventFilter =
  TypedEventFilter<InterestUpdateRateDeltaForMarketSetEvent>;

export type LockParamsSetEvent = TypedEvent<
  [BigNumber, BigNumber],
  { lockNumerator: BigNumber; lockDenominator: BigNumber }
>;

export type LockParamsSetEventFilter = TypedEventFilter<LockParamsSetEvent>;

export type MarketFeesSetEvent = TypedEvent<
  [BigNumber, BigNumber],
  { _swapFee: BigNumber; _protocolSwapFee: BigNumber }
>;

export type MarketFeesSetEventFilter = TypedEventFilter<MarketFeesSetEvent>;

export type MarketPairAddedEvent = TypedEvent<
  [string, string, string],
  { market: string; xyt: string; token: string }
>;

export type MarketPairAddedEventFilter = TypedEventFilter<MarketPairAddedEvent>;

export type NewMarketFactoryEvent = TypedEvent<
  [string, string],
  { marketFactoryId: string; marketFactoryAddress: string }
>;

export type NewMarketFactoryEventFilter =
  TypedEventFilter<NewMarketFactoryEvent>;

export type TreasurySetEvent = TypedEvent<[string], { treasury: string }>;

export type TreasurySetEventFilter = TypedEventFilter<TreasurySetEvent>;

export interface PendleData extends BaseContract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  interface: PendleDataInterface;

  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: {
    addForge(
      _forgeId: BytesLike,
      _forgeAddress: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    addMarket(
      _marketFactoryId: BytesLike,
      _xyt: string,
      _token: string,
      _market: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    addMarketFactory(
      _marketFactoryId: BytesLike,
      _marketFactoryAddress: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    allMarkets(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

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

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

    getForgeAddress(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getMarket(
      arg0: BytesLike,
      arg1: string,
      arg2: string,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getMarketByIndex(
      index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string] & { market: string }>;

    getMarketFactoryAddress(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getMarketFromKey(
      _tokenIn: string,
      _tokenOut: string,
      _marketFactoryId: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string] & { market: string }>;

    getPendleYieldTokens(
      _forgeId: BytesLike,
      _underlyingAsset: string,
      _expiry: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string, string] & { ot: string; xyt: string }>;

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

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

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

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

    isValidOT(
      _forgeId: BytesLike,
      _underlyingAsset: string,
      _expiry: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    isValidXYT(
      _forgeId: BytesLike,
      _underlyingAsset: string,
      _expiry: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

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

    otTokens(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

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

    setCurveShiftBlockDelta(
      _blockDelta: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setExpiryDivisor(
      _expiryDivisor: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setForgeFactoryValidity(
      _forgeId: BytesLike,
      _marketFactoryId: BytesLike,
      _valid: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setForgeFee(
      _forgeFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setInterestUpdateRateDeltaForMarket(
      _interestUpdateRateDeltaForMarket: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setLockParams(
      _lockNumerator: BigNumberish,
      _lockDenominator: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setMarketFees(
      _swapFee: BigNumberish,
      _protocolSwapFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    storeTokens(
      _forgeId: BytesLike,
      _ot: string,
      _xyt: string,
      _underlyingAsset: string,
      _expiry: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    validForgeFactoryPair(
      arg0: BytesLike,
      arg1: BytesLike,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    xytTokens(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;
  };

  addForge(
    _forgeId: BytesLike,
    _forgeAddress: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  addMarket(
    _marketFactoryId: BytesLike,
    _xyt: string,
    _token: string,
    _market: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  addMarketFactory(
    _marketFactoryId: BytesLike,
    _marketFactoryAddress: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  allMarkets(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;

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

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

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

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

  getForgeAddress(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;

  getMarket(
    arg0: BytesLike,
    arg1: string,
    arg2: string,
    overrides?: CallOverrides
  ): Promise<string>;

  getMarketByIndex(
    index: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  getMarketFactoryAddress(
    arg0: BytesLike,
    overrides?: CallOverrides
  ): Promise<string>;

  getMarketFromKey(
    _tokenIn: string,
    _tokenOut: string,
    _marketFactoryId: BytesLike,
    overrides?: CallOverrides
  ): Promise<string>;

  getPendleYieldTokens(
    _forgeId: BytesLike,
    _underlyingAsset: string,
    _expiry: BigNumberish,
    overrides?: CallOverrides
  ): Promise<[string, string] & { ot: string; xyt: string }>;

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

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

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

  isMarket(arg0: string, overrides?: CallOverrides): Promise<boolean>;

  isValidOT(
    _forgeId: BytesLike,
    _underlyingAsset: string,
    _expiry: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isValidXYT(
    _forgeId: BytesLike,
    _underlyingAsset: string,
    _expiry: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isXyt(arg0: string, overrides?: CallOverrides): Promise<boolean>;

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

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

  otTokens(
    arg0: BytesLike,
    arg1: string,
    arg2: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

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

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

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

  setCurveShiftBlockDelta(
    _blockDelta: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setExpiryDivisor(
    _expiryDivisor: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setForgeFactoryValidity(
    _forgeId: BytesLike,
    _marketFactoryId: BytesLike,
    _valid: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setForgeFee(
    _forgeFee: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setInterestUpdateRateDeltaForMarket(
    _interestUpdateRateDeltaForMarket: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setLockParams(
    _lockNumerator: BigNumberish,
    _lockDenominator: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setMarketFees(
    _swapFee: BigNumberish,
    _protocolSwapFee: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  storeTokens(
    _forgeId: BytesLike,
    _ot: string,
    _xyt: string,
    _underlyingAsset: string,
    _expiry: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  validForgeFactoryPair(
    arg0: BytesLike,
    arg1: BytesLike,
    overrides?: CallOverrides
  ): Promise<boolean>;

  xytTokens(
    arg0: BytesLike,
    arg1: string,
    arg2: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  callStatic: {
    addForge(
      _forgeId: BytesLike,
      _forgeAddress: string,
      overrides?: CallOverrides
    ): Promise<void>;

    addMarket(
      _marketFactoryId: BytesLike,
      _xyt: string,
      _token: string,
      _market: string,
      overrides?: CallOverrides
    ): Promise<void>;

    addMarketFactory(
      _marketFactoryId: BytesLike,
      _marketFactoryAddress: string,
      overrides?: CallOverrides
    ): Promise<void>;

    allMarkets(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;

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

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

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

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

    getForgeAddress(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

    getMarket(
      arg0: BytesLike,
      arg1: string,
      arg2: string,
      overrides?: CallOverrides
    ): Promise<string>;

    getMarketByIndex(
      index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    getMarketFactoryAddress(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

    getMarketFromKey(
      _tokenIn: string,
      _tokenOut: string,
      _marketFactoryId: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

    getPendleYieldTokens(
      _forgeId: BytesLike,
      _underlyingAsset: string,
      _expiry: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string, string] & { ot: string; xyt: string }>;

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

    initialize(_router: string, overrides?: CallOverrides): Promise<void>;

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

    isMarket(arg0: string, overrides?: CallOverrides): Promise<boolean>;

    isValidOT(
      _forgeId: BytesLike,
      _underlyingAsset: string,
      _expiry: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isValidXYT(
      _forgeId: BytesLike,
      _underlyingAsset: string,
      _expiry: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isXyt(arg0: string, overrides?: CallOverrides): Promise<boolean>;

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

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

    otTokens(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

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

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

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

    setCurveShiftBlockDelta(
      _blockDelta: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setExpiryDivisor(
      _expiryDivisor: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setForgeFactoryValidity(
      _forgeId: BytesLike,
      _marketFactoryId: BytesLike,
      _valid: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setForgeFee(
      _forgeFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setInterestUpdateRateDeltaForMarket(
      _interestUpdateRateDeltaForMarket: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setLockParams(
      _lockNumerator: BigNumberish,
      _lockDenominator: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setMarketFees(
      _swapFee: BigNumberish,
      _protocolSwapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setTreasury(_treasury: string, overrides?: CallOverrides): Promise<void>;

    storeTokens(
      _forgeId: BytesLike,
      _ot: string,
      _xyt: string,
      _underlyingAsset: string,
      _expiry: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    validForgeFactoryPair(
      arg0: BytesLike,
      arg1: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

    xytTokens(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;
  };

  filters: {
    "CurveShiftBlockDeltaSet(uint256)"(
      _blockDelta?: null
    ): CurveShiftBlockDeltaSetEventFilter;
    CurveShiftBlockDeltaSet(
      _blockDelta?: null
    ): CurveShiftBlockDeltaSetEventFilter;

    "ExpiryDivisorSet(uint256)"(
      expiryDivisor?: null
    ): ExpiryDivisorSetEventFilter;
    ExpiryDivisorSet(expiryDivisor?: null): ExpiryDivisorSetEventFilter;

    "ForgeAdded(bytes32,address)"(
      forgeId?: BytesLike | null,
      forgeAddress?: string | null
    ): ForgeAddedEventFilter;
    ForgeAdded(
      forgeId?: BytesLike | null,
      forgeAddress?: string | null
    ): ForgeAddedEventFilter;

    "ForgeFactoryValiditySet(bytes32,bytes32,bool)"(
      _forgeId?: null,
      _marketFactoryId?: null,
      _valid?: null
    ): ForgeFactoryValiditySetEventFilter;
    ForgeFactoryValiditySet(
      _forgeId?: null,
      _marketFactoryId?: null,
      _valid?: null
    ): ForgeFactoryValiditySetEventFilter;

    "ForgeFeeSet(uint256)"(forgeFee?: null): ForgeFeeSetEventFilter;
    ForgeFeeSet(forgeFee?: null): ForgeFeeSetEventFilter;

    "InterestUpdateRateDeltaForMarketSet(uint256)"(
      interestUpdateRateDeltaForMarket?: null
    ): InterestUpdateRateDeltaForMarketSetEventFilter;
    InterestUpdateRateDeltaForMarketSet(
      interestUpdateRateDeltaForMarket?: null
    ): InterestUpdateRateDeltaForMarketSetEventFilter;

    "LockParamsSet(uint256,uint256)"(
      lockNumerator?: null,
      lockDenominator?: null
    ): LockParamsSetEventFilter;
    LockParamsSet(
      lockNumerator?: null,
      lockDenominator?: null
    ): LockParamsSetEventFilter;

    "MarketFeesSet(uint256,uint256)"(
      _swapFee?: null,
      _protocolSwapFee?: null
    ): MarketFeesSetEventFilter;
    MarketFeesSet(
      _swapFee?: null,
      _protocolSwapFee?: null
    ): MarketFeesSetEventFilter;

    "MarketPairAdded(address,address,address)"(
      market?: string | null,
      xyt?: string | null,
      token?: string | null
    ): MarketPairAddedEventFilter;
    MarketPairAdded(
      market?: string | null,
      xyt?: string | null,
      token?: string | null
    ): MarketPairAddedEventFilter;

    "NewMarketFactory(bytes32,address)"(
      marketFactoryId?: BytesLike | null,
      marketFactoryAddress?: string | null
    ): NewMarketFactoryEventFilter;
    NewMarketFactory(
      marketFactoryId?: BytesLike | null,
      marketFactoryAddress?: string | null
    ): NewMarketFactoryEventFilter;

    "TreasurySet(address)"(treasury?: null): TreasurySetEventFilter;
    TreasurySet(treasury?: null): TreasurySetEventFilter;
  };

  estimateGas: {
    addForge(
      _forgeId: BytesLike,
      _forgeAddress: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    addMarket(
      _marketFactoryId: BytesLike,
      _xyt: string,
      _token: string,
      _market: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    addMarketFactory(
      _marketFactoryId: BytesLike,
      _marketFactoryAddress: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    allMarkets(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    getForgeAddress(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getMarket(
      arg0: BytesLike,
      arg1: string,
      arg2: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getMarketByIndex(
      index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getMarketFactoryAddress(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getMarketFromKey(
      _tokenIn: string,
      _tokenOut: string,
      _marketFactoryId: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getPendleYieldTokens(
      _forgeId: BytesLike,
      _underlyingAsset: string,
      _expiry: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    isMarket(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;

    isValidOT(
      _forgeId: BytesLike,
      _underlyingAsset: string,
      _expiry: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isValidXYT(
      _forgeId: BytesLike,
      _underlyingAsset: string,
      _expiry: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isXyt(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;

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

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

    otTokens(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    setCurveShiftBlockDelta(
      _blockDelta: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setExpiryDivisor(
      _expiryDivisor: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setForgeFactoryValidity(
      _forgeId: BytesLike,
      _marketFactoryId: BytesLike,
      _valid: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setForgeFee(
      _forgeFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setInterestUpdateRateDeltaForMarket(
      _interestUpdateRateDeltaForMarket: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setLockParams(
      _lockNumerator: BigNumberish,
      _lockDenominator: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setMarketFees(
      _swapFee: BigNumberish,
      _protocolSwapFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    storeTokens(
      _forgeId: BytesLike,
      _ot: string,
      _xyt: string,
      _underlyingAsset: string,
      _expiry: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    validForgeFactoryPair(
      arg0: BytesLike,
      arg1: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    xytTokens(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    addForge(
      _forgeId: BytesLike,
      _forgeAddress: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    addMarket(
      _marketFactoryId: BytesLike,
      _xyt: string,
      _token: string,
      _market: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    addMarketFactory(
      _marketFactoryId: BytesLike,
      _marketFactoryAddress: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    allMarkets(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    getForgeAddress(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getMarket(
      arg0: BytesLike,
      arg1: string,
      arg2: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getMarketByIndex(
      index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getMarketFactoryAddress(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getMarketFromKey(
      _tokenIn: string,
      _tokenOut: string,
      _marketFactoryId: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getPendleYieldTokens(
      _forgeId: BytesLike,
      _underlyingAsset: string,
      _expiry: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    isMarket(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isValidOT(
      _forgeId: BytesLike,
      _underlyingAsset: string,
      _expiry: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isValidXYT(
      _forgeId: BytesLike,
      _underlyingAsset: string,
      _expiry: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isXyt(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    otTokens(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    setCurveShiftBlockDelta(
      _blockDelta: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setExpiryDivisor(
      _expiryDivisor: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setForgeFactoryValidity(
      _forgeId: BytesLike,
      _marketFactoryId: BytesLike,
      _valid: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setForgeFee(
      _forgeFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setInterestUpdateRateDeltaForMarket(
      _interestUpdateRateDeltaForMarket: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setLockParams(
      _lockNumerator: BigNumberish,
      _lockDenominator: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setMarketFees(
      _swapFee: BigNumberish,
      _protocolSwapFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    storeTokens(
      _forgeId: BytesLike,
      _ot: string,
      _xyt: string,
      _underlyingAsset: string,
      _expiry: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    validForgeFactoryPair(
      arg0: BytesLike,
      arg1: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    xytTokens(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;
  };
}