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

export interface MtgStakingInterface extends utils.Interface {
  functions: {
    "Arcada()": FunctionFragment;
    "ArcadaAddress()": FunctionFragment;
    "DAY()": FunctionFragment;
    "GAMER_RATE()": FunctionFragment;
    "LOCKIN_PERIODS()": FunctionFragment;
    "MTG()": FunctionFragment;
    "MTGAddress()": FunctionFragment;
    "ROYAL_GAMER_RATE()": FunctionFragment;
    "START()": FunctionFragment;
    "batchClaim(uint256[])": FunctionFragment;
    "batchStake(uint256[])": FunctionFragment;
    "batchUnstake(uint256[])": FunctionFragment;
    "emergencyUnstake(uint256)": FunctionFragment;
    "emergencyUnstakeByOwner(uint256[])": FunctionFragment;
    "emergencyUnstakePaused()": FunctionFragment;
    "getPendingRewards(uint256)": FunctionFragment;
    "getStakingRecords(address)": FunctionFragment;
    "numOfTokenStaked(address)": FunctionFragment;
    "onERC721Received(address,address,uint256,bytes)": FunctionFragment;
    "owner()": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "setArcadaContract(address)": FunctionFragment;
    "setEmergencyUnstakePaused(bool)": FunctionFragment;
    "setGamerRewardRate(uint256)": FunctionFragment;
    "setMTGNFTContract(address)": FunctionFragment;
    "setRoyalGamerRewardRate(uint256)": FunctionFragment;
    "stakingRecords(uint256)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "Arcada"
      | "ArcadaAddress"
      | "DAY"
      | "GAMER_RATE"
      | "LOCKIN_PERIODS"
      | "MTG"
      | "MTGAddress"
      | "ROYAL_GAMER_RATE"
      | "START"
      | "batchClaim"
      | "batchStake"
      | "batchUnstake"
      | "emergencyUnstake"
      | "emergencyUnstakeByOwner"
      | "emergencyUnstakePaused"
      | "getPendingRewards"
      | "getStakingRecords"
      | "numOfTokenStaked"
      | "onERC721Received"
      | "owner"
      | "renounceOwnership"
      | "setArcadaContract"
      | "setEmergencyUnstakePaused"
      | "setGamerRewardRate"
      | "setMTGNFTContract"
      | "setRoyalGamerRewardRate"
      | "stakingRecords"
      | "transferOwnership"
  ): FunctionFragment;

  encodeFunctionData(functionFragment: "Arcada", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "ArcadaAddress",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "DAY", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "GAMER_RATE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "LOCKIN_PERIODS",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "MTG", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "MTGAddress",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "ROYAL_GAMER_RATE",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "START", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "batchClaim",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "batchStake",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "batchUnstake",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "emergencyUnstake",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "emergencyUnstakeByOwner",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "emergencyUnstakePaused",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getPendingRewards",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getStakingRecords",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "numOfTokenStaked",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "onERC721Received",
    values: [string, string, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setArcadaContract",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setEmergencyUnstakePaused",
    values: [boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setGamerRewardRate",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setMTGNFTContract",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setRoyalGamerRewardRate",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "stakingRecords",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;

  decodeFunctionResult(functionFragment: "Arcada", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "ArcadaAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "DAY", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "GAMER_RATE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "LOCKIN_PERIODS",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "MTG", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "MTGAddress", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "ROYAL_GAMER_RATE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "START", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "batchClaim", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "batchStake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "batchUnstake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "emergencyUnstake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "emergencyUnstakeByOwner",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "emergencyUnstakePaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPendingRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getStakingRecords",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "numOfTokenStaked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "onERC721Received",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setArcadaContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setEmergencyUnstakePaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setGamerRewardRate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMTGNFTContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRoyalGamerRewardRate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "stakingRecords",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;

  events: {
    "Claimed(address,uint256)": EventFragment;
    "EmergencyUnstake(address,uint256)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "Staked(address,uint256)": EventFragment;
    "Unstaked(address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Claimed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "EmergencyUnstake"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Staked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Unstaked"): EventFragment;
}

export interface ClaimedEventObject {
  owner: string;
  rewards: BigNumber;
}
export type ClaimedEvent = TypedEvent<[string, BigNumber], ClaimedEventObject>;

export type ClaimedEventFilter = TypedEventFilter<ClaimedEvent>;

export interface EmergencyUnstakeEventObject {
  user: string;
  tokenId: BigNumber;
}
export type EmergencyUnstakeEvent = TypedEvent<
  [string, BigNumber],
  EmergencyUnstakeEventObject
>;

export type EmergencyUnstakeEventFilter =
  TypedEventFilter<EmergencyUnstakeEvent>;

export interface OwnershipTransferredEventObject {
  previousOwner: string;
  newOwner: string;
}
export type OwnershipTransferredEvent = TypedEvent<
  [string, string],
  OwnershipTransferredEventObject
>;

export type OwnershipTransferredEventFilter =
  TypedEventFilter<OwnershipTransferredEvent>;

export interface StakedEventObject {
  owner: string;
  amount: BigNumber;
}
export type StakedEvent = TypedEvent<[string, BigNumber], StakedEventObject>;

export type StakedEventFilter = TypedEventFilter<StakedEvent>;

export interface UnstakedEventObject {
  owner: string;
  amount: BigNumber;
}
export type UnstakedEvent = TypedEvent<
  [string, BigNumber],
  UnstakedEventObject
>;

export type UnstakedEventFilter = TypedEventFilter<UnstakedEvent>;

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

  interface: MtgStakingInterface;

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

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

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

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

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

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

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

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

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

    batchClaim(
      tokenIds: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    batchStake(
      tokenIds: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    batchUnstake(
      tokenIds: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    emergencyUnstake(
      tokenId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    emergencyUnstakeByOwner(
      tokenIds: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    getPendingRewards(
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getStakingRecords(
      user: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber[], BigNumber[], BigNumber[]]>;

    numOfTokenStaked(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

    setArcadaContract(
      operator: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    setEmergencyUnstakePaused(
      paused: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    setGamerRewardRate(
      rewardPerDay: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    setMTGNFTContract(
      operator: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    setRoyalGamerRewardRate(
      rewardPerDay: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    stakingRecords(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber, BigNumber] & {
        tokenOwner: string;
        tokenId: BigNumber;
        lockInEndAt: BigNumber;
        stakedAt: BigNumber;
      }
    >;

    transferOwnership(
      newOwner: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;
  };

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

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

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

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

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

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

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

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

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

  batchClaim(
    tokenIds: BigNumberish[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  batchStake(
    tokenIds: BigNumberish[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  batchUnstake(
    tokenIds: BigNumberish[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  emergencyUnstake(
    tokenId: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  emergencyUnstakeByOwner(
    tokenIds: BigNumberish[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  getPendingRewards(
    tokenId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getStakingRecords(
    user: string,
    overrides?: CallOverrides
  ): Promise<[BigNumber[], BigNumber[], BigNumber[]]>;

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

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

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

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

  setArcadaContract(
    operator: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  setEmergencyUnstakePaused(
    paused: boolean,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  setGamerRewardRate(
    rewardPerDay: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  setMTGNFTContract(
    operator: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  setRoyalGamerRewardRate(
    rewardPerDay: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  stakingRecords(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [string, BigNumber, BigNumber, BigNumber] & {
      tokenOwner: string;
      tokenId: BigNumber;
      lockInEndAt: BigNumber;
      stakedAt: BigNumber;
    }
  >;

  transferOwnership(
    newOwner: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

    batchClaim(
      tokenIds: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    batchStake(
      tokenIds: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    batchUnstake(
      tokenIds: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    emergencyUnstake(
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    emergencyUnstakeByOwner(
      tokenIds: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

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

    getPendingRewards(
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStakingRecords(
      user: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber[], BigNumber[], BigNumber[]]>;

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

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

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

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

    setArcadaContract(
      operator: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setEmergencyUnstakePaused(
      paused: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setGamerRewardRate(
      rewardPerDay: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setMTGNFTContract(
      operator: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setRoyalGamerRewardRate(
      rewardPerDay: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    stakingRecords(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber, BigNumber] & {
        tokenOwner: string;
        tokenId: BigNumber;
        lockInEndAt: BigNumber;
        stakedAt: BigNumber;
      }
    >;

    transferOwnership(
      newOwner: string,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "Claimed(address,uint256)"(
      owner?: null,
      rewards?: null
    ): ClaimedEventFilter;
    Claimed(owner?: null, rewards?: null): ClaimedEventFilter;

    "EmergencyUnstake(address,uint256)"(
      user?: string | null,
      tokenId?: null
    ): EmergencyUnstakeEventFilter;
    EmergencyUnstake(
      user?: string | null,
      tokenId?: null
    ): EmergencyUnstakeEventFilter;

    "OwnershipTransferred(address,address)"(
      previousOwner?: string | null,
      newOwner?: string | null
    ): OwnershipTransferredEventFilter;
    OwnershipTransferred(
      previousOwner?: string | null,
      newOwner?: string | null
    ): OwnershipTransferredEventFilter;

    "Staked(address,uint256)"(owner?: null, amount?: null): StakedEventFilter;
    Staked(owner?: null, amount?: null): StakedEventFilter;

    "Unstaked(address,uint256)"(
      owner?: null,
      amount?: null
    ): UnstakedEventFilter;
    Unstaked(owner?: null, amount?: null): UnstakedEventFilter;
  };

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

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

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

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

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

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

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

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

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

    batchClaim(
      tokenIds: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    batchStake(
      tokenIds: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    batchUnstake(
      tokenIds: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    emergencyUnstake(
      tokenId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    emergencyUnstakeByOwner(
      tokenIds: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    getPendingRewards(
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStakingRecords(
      user: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    setArcadaContract(
      operator: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setEmergencyUnstakePaused(
      paused: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setGamerRewardRate(
      rewardPerDay: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setMTGNFTContract(
      operator: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setRoyalGamerRewardRate(
      rewardPerDay: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    transferOwnership(
      newOwner: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;
  };

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

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

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

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

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

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

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

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

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

    batchClaim(
      tokenIds: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    batchStake(
      tokenIds: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    batchUnstake(
      tokenIds: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    emergencyUnstake(
      tokenId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    emergencyUnstakeByOwner(
      tokenIds: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    getPendingRewards(
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getStakingRecords(
      user: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    setArcadaContract(
      operator: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    setEmergencyUnstakePaused(
      paused: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    setGamerRewardRate(
      rewardPerDay: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    setMTGNFTContract(
      operator: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    setRoyalGamerRewardRate(
      rewardPerDay: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    transferOwnership(
      newOwner: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;
  };
}