/* 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 } from "@ethersproject/abi";
import { Listener, Provider } from "@ethersproject/providers";
import { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";

export type RedeemOptsStruct = {
  redeemToUnderlying: boolean;
  transferfCash: boolean;
  receiver: string;
  maxImpliedRate: BigNumberish;
};

export type RedeemOptsStructOutput = [boolean, boolean, string, number] & {
  redeemToUnderlying: boolean;
  transferfCash: boolean;
  receiver: string;
  maxImpliedRate: number;
};

export interface IWrappedfCashInterface extends utils.Interface {
  functions: {
    "getAssetToken()": FunctionFragment;
    "getCurrencyId()": FunctionFragment;
    "getDecodedID()": FunctionFragment;
    "getMarketIndex()": FunctionFragment;
    "getMaturity()": FunctionFragment;
    "getUnderlyingToken()": FunctionFragment;
    "getfCashId()": FunctionFragment;
    "hasMatured()": FunctionFragment;
    "initialize(uint16,uint40)": FunctionFragment;
    "mintViaAsset(uint256,uint88,address,uint32)": FunctionFragment;
    "mintViaUnderlying(uint256,uint88,address,uint32)": FunctionFragment;
    "redeem(uint256,(bool,bool,address,uint32))": FunctionFragment;
    "redeemToAsset(uint256,address,uint32)": FunctionFragment;
    "redeemToUnderlying(uint256,address,uint32)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "getAssetToken",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getCurrencyId",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getDecodedID",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getMarketIndex",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getMaturity",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getUnderlyingToken",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getfCashId",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "hasMatured",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "mintViaAsset",
    values: [BigNumberish, BigNumberish, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "mintViaUnderlying",
    values: [BigNumberish, BigNumberish, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "redeem",
    values: [BigNumberish, RedeemOptsStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "redeemToAsset",
    values: [BigNumberish, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "redeemToUnderlying",
    values: [BigNumberish, string, BigNumberish]
  ): string;

  decodeFunctionResult(
    functionFragment: "getAssetToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getCurrencyId",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDecodedID",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getMarketIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getMaturity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getUnderlyingToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getfCashId", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "hasMatured", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "mintViaAsset",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "mintViaUnderlying",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "redeem", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "redeemToAsset",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "redeemToUnderlying",
    data: BytesLike
  ): Result;

  events: {};
}

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

  interface: IWrappedfCashInterface;

  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: {
    getAssetToken(
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, number] & {
        assetToken: string;
        assetPrecision: BigNumber;
        tokenType: number;
      }
    >;

    getCurrencyId(
      overrides?: CallOverrides
    ): Promise<[number] & { currencyId: number }>;

    getDecodedID(
      overrides?: CallOverrides
    ): Promise<[number, number] & { currencyId: number; maturity: number }>;

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

    getMaturity(
      overrides?: CallOverrides
    ): Promise<[number] & { maturity: number }>;

    getUnderlyingToken(
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber] & {
        underlyingToken: string;
        underlyingPrecision: BigNumber;
      }
    >;

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

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

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

    mintViaAsset(
      depositAmountExternal: BigNumberish,
      fCashAmount: BigNumberish,
      receiver: string,
      minImpliedRate: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    mintViaUnderlying(
      depositAmountExternal: BigNumberish,
      fCashAmount: BigNumberish,
      receiver: string,
      minImpliedRate: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

  getAssetToken(
    overrides?: CallOverrides
  ): Promise<
    [string, BigNumber, number] & {
      assetToken: string;
      assetPrecision: BigNumber;
      tokenType: number;
    }
  >;

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

  getDecodedID(
    overrides?: CallOverrides
  ): Promise<[number, number] & { currencyId: number; maturity: number }>;

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

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

  getUnderlyingToken(
    overrides?: CallOverrides
  ): Promise<
    [string, BigNumber] & {
      underlyingToken: string;
      underlyingPrecision: BigNumber;
    }
  >;

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

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

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

  mintViaAsset(
    depositAmountExternal: BigNumberish,
    fCashAmount: BigNumberish,
    receiver: string,
    minImpliedRate: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  mintViaUnderlying(
    depositAmountExternal: BigNumberish,
    fCashAmount: BigNumberish,
    receiver: string,
    minImpliedRate: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

  callStatic: {
    getAssetToken(
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, number] & {
        assetToken: string;
        assetPrecision: BigNumber;
        tokenType: number;
      }
    >;

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

    getDecodedID(
      overrides?: CallOverrides
    ): Promise<[number, number] & { currencyId: number; maturity: number }>;

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

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

    getUnderlyingToken(
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber] & {
        underlyingToken: string;
        underlyingPrecision: BigNumber;
      }
    >;

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

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

    initialize(
      currencyId: BigNumberish,
      maturity: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    mintViaAsset(
      depositAmountExternal: BigNumberish,
      fCashAmount: BigNumberish,
      receiver: string,
      minImpliedRate: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    mintViaUnderlying(
      depositAmountExternal: BigNumberish,
      fCashAmount: BigNumberish,
      receiver: string,
      minImpliedRate: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    redeem(
      amount: BigNumberish,
      data: RedeemOptsStruct,
      overrides?: CallOverrides
    ): Promise<void>;

    redeemToAsset(
      amount: BigNumberish,
      receiver: string,
      maxImpliedRate: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    redeemToUnderlying(
      amount: BigNumberish,
      receiver: string,
      maxImpliedRate: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {};

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

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

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

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

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

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

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

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

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

    mintViaAsset(
      depositAmountExternal: BigNumberish,
      fCashAmount: BigNumberish,
      receiver: string,
      minImpliedRate: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    mintViaUnderlying(
      depositAmountExternal: BigNumberish,
      fCashAmount: BigNumberish,
      receiver: string,
      minImpliedRate: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

    mintViaAsset(
      depositAmountExternal: BigNumberish,
      fCashAmount: BigNumberish,
      receiver: string,
      minImpliedRate: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    mintViaUnderlying(
      depositAmountExternal: BigNumberish,
      fCashAmount: BigNumberish,
      receiver: string,
      minImpliedRate: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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