/* 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 RelayerPoolInterface extends utils.Interface {
  contractName: "RelayerPool";
  functions: {
    "MIN_RELAYER_COLLATERAL()": FunctionFragment;
    "MIN_RELAYER_STAKING_TIME()": FunctionFragment;
    "MIN_STAKING_TIME()": FunctionFragment;
    "deposit(uint256)": FunctionFragment;
    "depositToken()": FunctionFragment;
    "deposits(uint256)": FunctionFragment;
    "emissionAnnualRateNumerator()": FunctionFragment;
    "getDeposit(uint256)": FunctionFragment;
    "harvestMyReward()": FunctionFragment;
    "harvestPoolReward()": FunctionFragment;
    "lastHarvestRewardTimestamp()": FunctionFragment;
    "owner()": FunctionFragment;
    "registry()": FunctionFragment;
    "relayerFeeNumerator()": FunctionFragment;
    "relayerStatus()": FunctionFragment;
    "rewardPerTokenNumerator()": FunctionFragment;
    "rewardToken()": FunctionFragment;
    "setEmissionAnnualRateNumerator(uint256)": FunctionFragment;
    "setRelayerFeeNumerator(uint256)": FunctionFragment;
    "totalDeposit()": FunctionFragment;
    "vault()": FunctionFragment;
    "withdraw(uint256,uint256)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "MIN_RELAYER_COLLATERAL",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MIN_RELAYER_STAKING_TIME",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MIN_STAKING_TIME",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "deposit",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "depositToken",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "deposits",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "emissionAnnualRateNumerator",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getDeposit",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "harvestMyReward",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "harvestPoolReward",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "lastHarvestRewardTimestamp",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(functionFragment: "registry", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "relayerFeeNumerator",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "relayerStatus",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "rewardPerTokenNumerator",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "rewardToken",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setEmissionAnnualRateNumerator",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setRelayerFeeNumerator",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "totalDeposit",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "vault", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [BigNumberish, BigNumberish]
  ): string;

  decodeFunctionResult(
    functionFragment: "MIN_RELAYER_COLLATERAL",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MIN_RELAYER_STAKING_TIME",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MIN_STAKING_TIME",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "depositToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "deposits", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "emissionAnnualRateNumerator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getDeposit", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "harvestMyReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "harvestPoolReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lastHarvestRewardTimestamp",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "registry", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "relayerFeeNumerator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "relayerStatus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "rewardPerTokenNumerator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "rewardToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setEmissionAnnualRateNumerator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRelayerFeeNumerator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalDeposit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "vault", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;

  events: {
    "DepositPut(address,uint256,uint256,uint256)": EventFragment;
    "DepositWithdrawn(address,uint256,uint256,uint256)": EventFragment;
    "EmissionAnnualRateNumeratorSet(address,uint256)": EventFragment;
    "HarvestPoolReward(address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256)": EventFragment;
    "RelayerFeeNumeratorSet(address,uint256)": EventFragment;
    "RelayerStatusSet(address,uint8)": EventFragment;
    "UserHarvestReward(address,uint256,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "DepositPut"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DepositWithdrawn"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "EmissionAnnualRateNumeratorSet"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "HarvestPoolReward"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RelayerFeeNumeratorSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RelayerStatusSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UserHarvestReward"): EventFragment;
}

export type DepositPutEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber],
  { user: string; id: BigNumber; amount: BigNumber; lockTill: BigNumber }
>;

export type DepositPutEventFilter = TypedEventFilter<DepositPutEvent>;

export type DepositWithdrawnEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber],
  { user: string; id: BigNumber; amount: BigNumber; rest: BigNumber }
>;

export type DepositWithdrawnEventFilter =
  TypedEventFilter<DepositWithdrawnEvent>;

export type EmissionAnnualRateNumeratorSetEvent = TypedEvent<
  [string, BigNumber],
  { sender: string; value: BigNumber }
>;

export type EmissionAnnualRateNumeratorSetEventFilter =
  TypedEventFilter<EmissionAnnualRateNumeratorSetEvent>;

export type HarvestPoolRewardEvent = TypedEvent<
  [
    string,
    BigNumber,
    BigNumber,
    string,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
  ],
  {
    sender: string;
    harvestForPeriod: BigNumber;
    profit: BigNumber;
    feeReceiver: string;
    fee: BigNumber;
    rewardForPool: BigNumber;
    rewardPerTokenNumeratorBefore: BigNumber;
    rewardPerTokenNumerator: BigNumber;
    totalDeposit: BigNumber;
  }
>;

export type HarvestPoolRewardEventFilter =
  TypedEventFilter<HarvestPoolRewardEvent>;

export type RelayerFeeNumeratorSetEvent = TypedEvent<
  [string, BigNumber],
  { sender: string; value: BigNumber }
>;

export type RelayerFeeNumeratorSetEventFilter =
  TypedEventFilter<RelayerFeeNumeratorSetEvent>;

export type RelayerStatusSetEvent = TypedEvent<
  [string, number],
  { sender: string; status: number }
>;

export type RelayerStatusSetEventFilter =
  TypedEventFilter<RelayerStatusSetEvent>;

export type UserHarvestRewardEvent = TypedEvent<
  [string, BigNumber, BigNumber],
  { user: string; userReward: BigNumber; userDeposit: BigNumber }
>;

export type UserHarvestRewardEventFilter =
  TypedEventFilter<UserHarvestRewardEvent>;

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

  interface: RelayerPoolInterface;

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

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

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

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

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

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

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

    "deposit(uint256)"(
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    deposits(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber] & {
        user: string;
        lockTill: BigNumber;
        amount: BigNumber;
      }
    >;

    "deposits(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber] & {
        user: string;
        lockTill: BigNumber;
        amount: BigNumber;
      }
    >;

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

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

    getDeposit(
      _depositId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber] & {
        user: string;
        amount: BigNumber;
        lockTill: BigNumber;
      }
    >;

    "getDeposit(uint256)"(
      _depositId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber] & {
        user: string;
        amount: BigNumber;
        lockTill: BigNumber;
      }
    >;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    "setEmissionAnnualRateNumerator(uint256)"(
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    "setRelayerFeeNumerator(uint256)"(
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

    withdraw(
      _depositId: BigNumberish,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "withdraw(uint256,uint256)"(
      _depositId: BigNumberish,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;
  };

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

  "MIN_RELAYER_COLLATERAL()"(overrides?: CallOverrides): Promise<BigNumber>;

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

  "MIN_RELAYER_STAKING_TIME()"(overrides?: CallOverrides): Promise<BigNumber>;

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

  "MIN_STAKING_TIME()"(overrides?: CallOverrides): Promise<BigNumber>;

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

  "deposit(uint256)"(
    _amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  "depositToken()"(overrides?: CallOverrides): Promise<string>;

  deposits(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [string, BigNumber, BigNumber] & {
      user: string;
      lockTill: BigNumber;
      amount: BigNumber;
    }
  >;

  "deposits(uint256)"(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [string, BigNumber, BigNumber] & {
      user: string;
      lockTill: BigNumber;
      amount: BigNumber;
    }
  >;

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

  "emissionAnnualRateNumerator()"(
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getDeposit(
    _depositId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [string, BigNumber, BigNumber] & {
      user: string;
      amount: BigNumber;
      lockTill: BigNumber;
    }
  >;

  "getDeposit(uint256)"(
    _depositId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [string, BigNumber, BigNumber] & {
      user: string;
      amount: BigNumber;
      lockTill: BigNumber;
    }
  >;

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

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

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

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

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

  "lastHarvestRewardTimestamp()"(overrides?: CallOverrides): Promise<BigNumber>;

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

  "owner()"(overrides?: CallOverrides): Promise<string>;

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

  "registry()"(overrides?: CallOverrides): Promise<string>;

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

  "relayerFeeNumerator()"(overrides?: CallOverrides): Promise<BigNumber>;

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

  "relayerStatus()"(overrides?: CallOverrides): Promise<number>;

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

  "rewardPerTokenNumerator()"(overrides?: CallOverrides): Promise<BigNumber>;

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

  "rewardToken()"(overrides?: CallOverrides): Promise<string>;

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

  "setEmissionAnnualRateNumerator(uint256)"(
    _value: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  "setRelayerFeeNumerator(uint256)"(
    _value: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  "totalDeposit()"(overrides?: CallOverrides): Promise<BigNumber>;

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

  "vault()"(overrides?: CallOverrides): Promise<string>;

  withdraw(
    _depositId: BigNumberish,
    _amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "withdraw(uint256,uint256)"(
    _depositId: BigNumberish,
    _amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  callStatic: {
    MIN_RELAYER_COLLATERAL(overrides?: CallOverrides): Promise<BigNumber>;

    "MIN_RELAYER_COLLATERAL()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "MIN_RELAYER_STAKING_TIME()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "MIN_STAKING_TIME()"(overrides?: CallOverrides): Promise<BigNumber>;

    deposit(_amount: BigNumberish, overrides?: CallOverrides): Promise<void>;

    "deposit(uint256)"(
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    "depositToken()"(overrides?: CallOverrides): Promise<string>;

    deposits(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber] & {
        user: string;
        lockTill: BigNumber;
        amount: BigNumber;
      }
    >;

    "deposits(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber] & {
        user: string;
        lockTill: BigNumber;
        amount: BigNumber;
      }
    >;

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

    "emissionAnnualRateNumerator()"(
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDeposit(
      _depositId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber] & {
        user: string;
        amount: BigNumber;
        lockTill: BigNumber;
      }
    >;

    "getDeposit(uint256)"(
      _depositId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber] & {
        user: string;
        amount: BigNumber;
        lockTill: BigNumber;
      }
    >;

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

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

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

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

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

    "lastHarvestRewardTimestamp()"(
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "owner()"(overrides?: CallOverrides): Promise<string>;

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

    "registry()"(overrides?: CallOverrides): Promise<string>;

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

    "relayerFeeNumerator()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "relayerStatus()"(overrides?: CallOverrides): Promise<number>;

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

    "rewardPerTokenNumerator()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "rewardToken()"(overrides?: CallOverrides): Promise<string>;

    setEmissionAnnualRateNumerator(
      _value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "setEmissionAnnualRateNumerator(uint256)"(
      _value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setRelayerFeeNumerator(
      _value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "setRelayerFeeNumerator(uint256)"(
      _value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    "totalDeposit()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "vault()"(overrides?: CallOverrides): Promise<string>;

    withdraw(
      _depositId: BigNumberish,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "withdraw(uint256,uint256)"(
      _depositId: BigNumberish,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "DepositPut(address,uint256,uint256,uint256)"(
      user?: string | null,
      id?: BigNumberish | null,
      amount?: null,
      lockTill?: null
    ): DepositPutEventFilter;
    DepositPut(
      user?: string | null,
      id?: BigNumberish | null,
      amount?: null,
      lockTill?: null
    ): DepositPutEventFilter;

    "DepositWithdrawn(address,uint256,uint256,uint256)"(
      user?: string | null,
      id?: BigNumberish | null,
      amount?: null,
      rest?: null
    ): DepositWithdrawnEventFilter;
    DepositWithdrawn(
      user?: string | null,
      id?: BigNumberish | null,
      amount?: null,
      rest?: null
    ): DepositWithdrawnEventFilter;

    "EmissionAnnualRateNumeratorSet(address,uint256)"(
      sender?: string | null,
      value?: null
    ): EmissionAnnualRateNumeratorSetEventFilter;
    EmissionAnnualRateNumeratorSet(
      sender?: string | null,
      value?: null
    ): EmissionAnnualRateNumeratorSetEventFilter;

    "HarvestPoolReward(address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256)"(
      sender?: string | null,
      harvestForPeriod?: null,
      profit?: null,
      feeReceiver?: string | null,
      fee?: null,
      rewardForPool?: null,
      rewardPerTokenNumeratorBefore?: null,
      rewardPerTokenNumerator?: null,
      totalDeposit?: null
    ): HarvestPoolRewardEventFilter;
    HarvestPoolReward(
      sender?: string | null,
      harvestForPeriod?: null,
      profit?: null,
      feeReceiver?: string | null,
      fee?: null,
      rewardForPool?: null,
      rewardPerTokenNumeratorBefore?: null,
      rewardPerTokenNumerator?: null,
      totalDeposit?: null
    ): HarvestPoolRewardEventFilter;

    "RelayerFeeNumeratorSet(address,uint256)"(
      sender?: string | null,
      value?: null
    ): RelayerFeeNumeratorSetEventFilter;
    RelayerFeeNumeratorSet(
      sender?: string | null,
      value?: null
    ): RelayerFeeNumeratorSetEventFilter;

    "RelayerStatusSet(address,uint8)"(
      sender?: string | null,
      status?: null
    ): RelayerStatusSetEventFilter;
    RelayerStatusSet(
      sender?: string | null,
      status?: null
    ): RelayerStatusSetEventFilter;

    "UserHarvestReward(address,uint256,uint256)"(
      user?: string | null,
      userReward?: null,
      userDeposit?: null
    ): UserHarvestRewardEventFilter;
    UserHarvestReward(
      user?: string | null,
      userReward?: null,
      userDeposit?: null
    ): UserHarvestRewardEventFilter;
  };

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

    "MIN_RELAYER_COLLATERAL()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "MIN_RELAYER_STAKING_TIME()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "MIN_STAKING_TIME()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "deposit(uint256)"(
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    "depositToken()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "deposits(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "emissionAnnualRateNumerator()"(
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDeposit(
      _depositId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getDeposit(uint256)"(
      _depositId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

    "lastHarvestRewardTimestamp()"(
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "owner()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "registry()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "relayerFeeNumerator()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "relayerStatus()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "rewardPerTokenNumerator()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "rewardToken()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "setEmissionAnnualRateNumerator(uint256)"(
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    "setRelayerFeeNumerator(uint256)"(
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    "totalDeposit()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "vault()"(overrides?: CallOverrides): Promise<BigNumber>;

    withdraw(
      _depositId: BigNumberish,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "withdraw(uint256,uint256)"(
      _depositId: BigNumberish,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;
  };

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

    "MIN_RELAYER_COLLATERAL()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "MIN_RELAYER_STAKING_TIME()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "MIN_STAKING_TIME()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "deposit(uint256)"(
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    "depositToken()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "deposits(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "emissionAnnualRateNumerator()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getDeposit(
      _depositId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getDeposit(uint256)"(
      _depositId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

    "lastHarvestRewardTimestamp()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "owner()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "registry()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "relayerFeeNumerator()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "relayerStatus()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "rewardPerTokenNumerator()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "rewardToken()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "setEmissionAnnualRateNumerator(uint256)"(
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    "setRelayerFeeNumerator(uint256)"(
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    "totalDeposit()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "vault()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    withdraw(
      _depositId: BigNumberish,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "withdraw(uint256,uint256)"(
      _depositId: BigNumberish,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;
  };
}