/* 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 type {
  TypedEventFilter,
  TypedEvent,
  TypedListener,
  OnEvent,
} from "./common";

export interface PendleYieldTokenInterface extends utils.Interface {
  contractName: "PendleYieldToken";
  functions: {
    "PT()": FunctionFragment;
    "SY()": FunctionFragment;
    "VERSION()": FunctionFragment;
    "allowance(address,address)": FunctionFragment;
    "approve(address,uint256)": FunctionFragment;
    "balanceOf(address)": FunctionFragment;
    "decimals()": FunctionFragment;
    "doCacheIndexSameBlock()": FunctionFragment;
    "expiry()": FunctionFragment;
    "factory()": FunctionFragment;
    "getPostExpiryData()": FunctionFragment;
    "getRewardTokens()": FunctionFragment;
    "isExpired()": FunctionFragment;
    "mintPY(address,address)": FunctionFragment;
    "mintPYMulti(address[],address[],uint256[])": FunctionFragment;
    "name()": FunctionFragment;
    "postExpiry()": FunctionFragment;
    "pyIndexCurrent()": FunctionFragment;
    "pyIndexLastUpdatedBlock()": FunctionFragment;
    "pyIndexStored()": FunctionFragment;
    "redeemDueInterestAndRewards(address,bool,bool)": FunctionFragment;
    "redeemInterestAndRewardsPostExpiryForTreasury()": FunctionFragment;
    "redeemPY(address)": FunctionFragment;
    "redeemPYMulti(address[],uint256[])": FunctionFragment;
    "reentrancyGuardEntered()": FunctionFragment;
    "rewardIndexesCurrent()": FunctionFragment;
    "setPostExpiryData()": FunctionFragment;
    "syReserve()": FunctionFragment;
    "symbol()": FunctionFragment;
    "totalSupply()": FunctionFragment;
    "transfer(address,uint256)": FunctionFragment;
    "transferFrom(address,address,uint256)": FunctionFragment;
    "userInterest(address)": FunctionFragment;
    "userReward(address,address)": FunctionFragment;
  };

  encodeFunctionData(functionFragment: "PT", values?: undefined): string;
  encodeFunctionData(functionFragment: "SY", values?: undefined): string;
  encodeFunctionData(functionFragment: "VERSION", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "allowance",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "approve",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "doCacheIndexSameBlock",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "expiry", values?: undefined): string;
  encodeFunctionData(functionFragment: "factory", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getPostExpiryData",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getRewardTokens",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "isExpired", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "mintPY",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "mintPYMulti",
    values: [string[], string[], BigNumberish[]]
  ): string;
  encodeFunctionData(functionFragment: "name", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "postExpiry",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "pyIndexCurrent",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "pyIndexLastUpdatedBlock",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "pyIndexStored",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "redeemDueInterestAndRewards",
    values: [string, boolean, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "redeemInterestAndRewardsPostExpiryForTreasury",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "redeemPY", values: [string]): string;
  encodeFunctionData(
    functionFragment: "redeemPYMulti",
    values: [string[], BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "reentrancyGuardEntered",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "rewardIndexesCurrent",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setPostExpiryData",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "syReserve", values?: undefined): string;
  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "totalSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transfer",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferFrom",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "userInterest",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "userReward",
    values: [string, string]
  ): string;

  decodeFunctionResult(functionFragment: "PT", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "SY", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "VERSION", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "doCacheIndexSameBlock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "expiry", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "factory", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getPostExpiryData",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRewardTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isExpired", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "mintPY", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "mintPYMulti",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "postExpiry", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "pyIndexCurrent",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "pyIndexLastUpdatedBlock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "pyIndexStored",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "redeemDueInterestAndRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "redeemInterestAndRewardsPostExpiryForTreasury",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "redeemPY", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "redeemPYMulti",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "reentrancyGuardEntered",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "rewardIndexesCurrent",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPostExpiryData",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "syReserve", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "totalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "userInterest",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "userReward", data: BytesLike): Result;

  events: {
    "Approval(address,address,uint256)": EventFragment;
    "Burn(address,address,uint256,uint256)": EventFragment;
    "CollectInterestFee(uint256)": EventFragment;
    "CollectRewardFee(address,uint256)": EventFragment;
    "Mint(address,address,address,uint256,uint256)": EventFragment;
    "NewInterestIndex(uint256)": EventFragment;
    "RedeemInterest(address,uint256)": EventFragment;
    "RedeemRewards(address,uint256[])": EventFragment;
    "Transfer(address,address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Burn"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "CollectInterestFee"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "CollectRewardFee"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Mint"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewInterestIndex"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RedeemInterest"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RedeemRewards"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
}

export type ApprovalEvent = TypedEvent<
  [string, string, BigNumber],
  { owner: string; spender: string; value: BigNumber }
>;

export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;

export type BurnEvent = TypedEvent<
  [string, string, BigNumber, BigNumber],
  {
    caller: string;
    receiver: string;
    amountPYToRedeem: BigNumber;
    amountSyOut: BigNumber;
  }
>;

export type BurnEventFilter = TypedEventFilter<BurnEvent>;

export type CollectInterestFeeEvent = TypedEvent<
  [BigNumber],
  { amountInterestFee: BigNumber }
>;

export type CollectInterestFeeEventFilter =
  TypedEventFilter<CollectInterestFeeEvent>;

export type CollectRewardFeeEvent = TypedEvent<
  [string, BigNumber],
  { rewardToken: string; amountRewardFee: BigNumber }
>;

export type CollectRewardFeeEventFilter =
  TypedEventFilter<CollectRewardFeeEvent>;

export type MintEvent = TypedEvent<
  [string, string, string, BigNumber, BigNumber],
  {
    caller: string;
    receiverPT: string;
    receiverYT: string;
    amountSyToMint: BigNumber;
    amountPYOut: BigNumber;
  }
>;

export type MintEventFilter = TypedEventFilter<MintEvent>;

export type NewInterestIndexEvent = TypedEvent<
  [BigNumber],
  { newIndex: BigNumber }
>;

export type NewInterestIndexEventFilter =
  TypedEventFilter<NewInterestIndexEvent>;

export type RedeemInterestEvent = TypedEvent<
  [string, BigNumber],
  { user: string; interestOut: BigNumber }
>;

export type RedeemInterestEventFilter = TypedEventFilter<RedeemInterestEvent>;

export type RedeemRewardsEvent = TypedEvent<
  [string, BigNumber[]],
  { user: string; amountRewardsOut: BigNumber[] }
>;

export type RedeemRewardsEventFilter = TypedEventFilter<RedeemRewardsEvent>;

export type TransferEvent = TypedEvent<
  [string, string, BigNumber],
  { from: string; to: string; value: BigNumber }
>;

export type TransferEventFilter = TypedEventFilter<TransferEvent>;

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

  interface: PendleYieldTokenInterface;

  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: {
    PT(overrides?: CallOverrides): Promise<[string]>;

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

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

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    balanceOf(account: string, overrides?: CallOverrides): Promise<[BigNumber]>;

    decimals(overrides?: CallOverrides): Promise<[number]>;

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

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

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

    getPostExpiryData(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber[], BigNumber[]] & {
        firstPYIndex: BigNumber;
        totalSyInterestForTreasury: BigNumber;
        firstRewardIndexes: BigNumber[];
        userRewardOwed: BigNumber[];
      }
    >;

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

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

    mintPY(
      receiverPT: string,
      receiverYT: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    mintPYMulti(
      receiverPTs: string[],
      receiverYTs: string[],
      amountSyToMints: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    postExpiry(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        firstPYIndex: BigNumber;
        totalSyInterestForTreasury: BigNumber;
      }
    >;

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

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

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

    redeemDueInterestAndRewards(
      user: string,
      redeemInterest: boolean,
      redeemRewards: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    redeemPYMulti(
      receivers: string[],
      amountPYToRedeems: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

    userInterest(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { index: BigNumber; accrued: BigNumber }
    >;

    userReward(
      arg0: string,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { index: BigNumber; accrued: BigNumber }
    >;
  };

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

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

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

  allowance(
    owner: string,
    spender: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

  decimals(overrides?: CallOverrides): Promise<number>;

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

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

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

  getPostExpiryData(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber[], BigNumber[]] & {
      firstPYIndex: BigNumber;
      totalSyInterestForTreasury: BigNumber;
      firstRewardIndexes: BigNumber[];
      userRewardOwed: BigNumber[];
    }
  >;

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

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

  mintPY(
    receiverPT: string,
    receiverYT: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  mintPYMulti(
    receiverPTs: string[],
    receiverYTs: string[],
    amountSyToMints: BigNumberish[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  postExpiry(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & {
      firstPYIndex: BigNumber;
      totalSyInterestForTreasury: BigNumber;
    }
  >;

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

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

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

  redeemDueInterestAndRewards(
    user: string,
    redeemInterest: boolean,
    redeemRewards: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  redeemPYMulti(
    receivers: string[],
    amountPYToRedeems: BigNumberish[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

  userInterest(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber] & { index: BigNumber; accrued: BigNumber }>;

  userReward(
    arg0: string,
    arg1: string,
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber] & { index: BigNumber; accrued: BigNumber }>;

  callStatic: {
    PT(overrides?: CallOverrides): Promise<string>;

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

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

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

    decimals(overrides?: CallOverrides): Promise<number>;

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

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

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

    getPostExpiryData(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber[], BigNumber[]] & {
        firstPYIndex: BigNumber;
        totalSyInterestForTreasury: BigNumber;
        firstRewardIndexes: BigNumber[];
        userRewardOwed: BigNumber[];
      }
    >;

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

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

    mintPY(
      receiverPT: string,
      receiverYT: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    mintPYMulti(
      receiverPTs: string[],
      receiverYTs: string[],
      amountSyToMints: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

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

    postExpiry(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        firstPYIndex: BigNumber;
        totalSyInterestForTreasury: BigNumber;
      }
    >;

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

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

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

    redeemDueInterestAndRewards(
      user: string,
      redeemInterest: boolean,
      redeemRewards: boolean,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber[]] & {
        interestOut: BigNumber;
        rewardsOut: BigNumber[];
      }
    >;

    redeemInterestAndRewardsPostExpiryForTreasury(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber[]] & {
        interestOut: BigNumber;
        rewardsOut: BigNumber[];
      }
    >;

    redeemPY(receiver: string, overrides?: CallOverrides): Promise<BigNumber>;

    redeemPYMulti(
      receivers: string[],
      amountPYToRedeems: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

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

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

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

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

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

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

    transfer(
      to: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    transferFrom(
      from: string,
      to: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    userInterest(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { index: BigNumber; accrued: BigNumber }
    >;

    userReward(
      arg0: string,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { index: BigNumber; accrued: BigNumber }
    >;
  };

  filters: {
    "Approval(address,address,uint256)"(
      owner?: string | null,
      spender?: string | null,
      value?: null
    ): ApprovalEventFilter;
    Approval(
      owner?: string | null,
      spender?: string | null,
      value?: null
    ): ApprovalEventFilter;

    "Burn(address,address,uint256,uint256)"(
      caller?: string | null,
      receiver?: string | null,
      amountPYToRedeem?: null,
      amountSyOut?: null
    ): BurnEventFilter;
    Burn(
      caller?: string | null,
      receiver?: string | null,
      amountPYToRedeem?: null,
      amountSyOut?: null
    ): BurnEventFilter;

    "CollectInterestFee(uint256)"(
      amountInterestFee?: null
    ): CollectInterestFeeEventFilter;
    CollectInterestFee(amountInterestFee?: null): CollectInterestFeeEventFilter;

    "CollectRewardFee(address,uint256)"(
      rewardToken?: string | null,
      amountRewardFee?: null
    ): CollectRewardFeeEventFilter;
    CollectRewardFee(
      rewardToken?: string | null,
      amountRewardFee?: null
    ): CollectRewardFeeEventFilter;

    "Mint(address,address,address,uint256,uint256)"(
      caller?: string | null,
      receiverPT?: string | null,
      receiverYT?: string | null,
      amountSyToMint?: null,
      amountPYOut?: null
    ): MintEventFilter;
    Mint(
      caller?: string | null,
      receiverPT?: string | null,
      receiverYT?: string | null,
      amountSyToMint?: null,
      amountPYOut?: null
    ): MintEventFilter;

    "NewInterestIndex(uint256)"(
      newIndex?: BigNumberish | null
    ): NewInterestIndexEventFilter;
    NewInterestIndex(
      newIndex?: BigNumberish | null
    ): NewInterestIndexEventFilter;

    "RedeemInterest(address,uint256)"(
      user?: string | null,
      interestOut?: null
    ): RedeemInterestEventFilter;
    RedeemInterest(
      user?: string | null,
      interestOut?: null
    ): RedeemInterestEventFilter;

    "RedeemRewards(address,uint256[])"(
      user?: string | null,
      amountRewardsOut?: null
    ): RedeemRewardsEventFilter;
    RedeemRewards(
      user?: string | null,
      amountRewardsOut?: null
    ): RedeemRewardsEventFilter;

    "Transfer(address,address,uint256)"(
      from?: string | null,
      to?: string | null,
      value?: null
    ): TransferEventFilter;
    Transfer(
      from?: string | null,
      to?: string | null,
      value?: null
    ): TransferEventFilter;
  };

  estimateGas: {
    PT(overrides?: CallOverrides): Promise<BigNumber>;

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

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

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

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

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

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

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

    mintPY(
      receiverPT: string,
      receiverYT: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    mintPYMulti(
      receiverPTs: string[],
      receiverYTs: string[],
      amountSyToMints: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

    redeemDueInterestAndRewards(
      user: string,
      redeemInterest: boolean,
      redeemRewards: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    redeemPYMulti(
      receivers: string[],
      amountPYToRedeems: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

    userReward(
      arg0: string,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    PT(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

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

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    balanceOf(
      account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

    mintPY(
      receiverPT: string,
      receiverYT: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    mintPYMulti(
      receiverPTs: string[],
      receiverYTs: string[],
      amountSyToMints: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

    redeemDueInterestAndRewards(
      user: string,
      redeemInterest: boolean,
      redeemRewards: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    redeemPYMulti(
      receivers: string[],
      amountPYToRedeems: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

    userReward(
      arg0: string,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;
  };
}