@collabland/staking-contracts/src/types/RivalBearsStaking.ts

Staking contracts supported by Collab.Land

/* 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 declare namespace Interface_Rival_Bears_Staking {
  export type UserStakeStruct = {
    nft: string;
    tokenId: BigNumberish;
    timestamp: BigNumberish;
    lastHarvest: BigNumberish;
    lastHarvestStakingSeasonIndex: BigNumberish;
  };

  export type UserStakeStructOutput = [
    string,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
  ] & {
    nft: string;
    tokenId: BigNumber;
    timestamp: BigNumber;
    lastHarvest: BigNumber;
    lastHarvestStakingSeasonIndex: BigNumber;
  };
}

export interface RivalBearsStakingInterface extends utils.Interface {
  functions: {
    "beginNewStakingSeason(address,uint256,uint256)": FunctionFragment;
    "emergencyUnstake(uint256)": FunctionFragment;
    "endStakingSeason(address)": FunctionFragment;
    "harvestAllStakes()": FunctionFragment;
    "harvestStake(uint256)": FunctionFragment;
    "redeem(uint256)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "setRedeemFunction(string)": FunctionFragment;
    "setRedeemLocation(address)": FunctionFragment;
    "setStakingPercentMultiplier(address,uint256,uint256)": FunctionFragment;
    "setStakingPercentMultiplierMultiple(address[],uint256[],uint256[])": FunctionFragment;
    "setTokenStakingDisabled(address,uint256,bool)": FunctionFragment;
    "setTokenStakingDisabledMultiple(address[],uint256[],bool)": FunctionFragment;
    "stake(address,uint256)": FunctionFragment;
    "stakeMultiple(address[],uint256[])": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "transferOwnershipRedeemLocation(address)": FunctionFragment;
    "unstake(uint256)": FunctionFragment;
    "unstakeMultiple(uint256[])": FunctionFragment;
    "updateStakingSeasonEndTime(address,uint256)": FunctionFragment;
    "getAccumulatedHarvestedPoints()": FunctionFragment;
    "getAccumulatedRedeemedPoints()": FunctionFragment;
    "getAllowednfts()": FunctionFragment;
    "getAllStakers()": FunctionFragment;
    "getCurrentStakingSeasonEndTime(address)": FunctionFragment;
    "getEarnedPointsFromStake(address,uint256)": FunctionFragment;
    "getRedeemFunction()": FunctionFragment;
    "getRedeemLocation()": FunctionFragment;
    "getStaker(address,uint256)": FunctionFragment;
    "getStakerAccumulatedHarvestedPoints(address)": FunctionFragment;
    "getStakerAccumulatedRedeemedPoints(address)": FunctionFragment;
    "getStakerUnharvestedPoints(address)": FunctionFragment;
    "getStakes(address)": FunctionFragment;
    "getStakingPercentMultiplier(address,uint256,uint256)": FunctionFragment;
    "getStakingPercentMultiplierMultiple(address[],uint256[],uint256[])": FunctionFragment;
    "getStakingSeason(address)": FunctionFragment;
    "getStakingSeasonEndTime(address,uint256)": FunctionFragment;
    "getTotalStaked()": FunctionFragment;
    "owner()": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "beginNewStakingSeason"
      | "emergencyUnstake"
      | "endStakingSeason"
      | "harvestAllStakes"
      | "harvestStake"
      | "redeem"
      | "renounceOwnership"
      | "setRedeemFunction"
      | "setRedeemLocation"
      | "setStakingPercentMultiplier"
      | "setStakingPercentMultiplierMultiple"
      | "setTokenStakingDisabled"
      | "setTokenStakingDisabledMultiple"
      | "stake"
      | "stakeMultiple"
      | "transferOwnership"
      | "transferOwnershipRedeemLocation"
      | "unstake"
      | "unstakeMultiple"
      | "updateStakingSeasonEndTime"
      | "getAccumulatedHarvestedPoints"
      | "getAccumulatedRedeemedPoints"
      | "getAllowednfts"
      | "getAllStakers"
      | "getCurrentStakingSeasonEndTime"
      | "getEarnedPointsFromStake"
      | "getRedeemFunction"
      | "getRedeemLocation"
      | "getStaker"
      | "getStakerAccumulatedHarvestedPoints"
      | "getStakerAccumulatedRedeemedPoints"
      | "getStakerUnharvestedPoints"
      | "getStakes"
      | "getStakingPercentMultiplier"
      | "getStakingPercentMultiplierMultiple"
      | "getStakingSeason"
      | "getStakingSeasonEndTime"
      | "getTotalStaked"
      | "owner"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "beginNewStakingSeason",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "emergencyUnstake",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "endStakingSeason",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "harvestAllStakes",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "harvestStake",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "redeem",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setRedeemFunction",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setRedeemLocation",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setStakingPercentMultiplier",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setStakingPercentMultiplierMultiple",
    values: [string[], BigNumberish[], BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "setTokenStakingDisabled",
    values: [string, BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setTokenStakingDisabledMultiple",
    values: [string[], BigNumberish[], boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "stake",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "stakeMultiple",
    values: [string[], BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnershipRedeemLocation",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "unstake",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "unstakeMultiple",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "updateStakingSeasonEndTime",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getAccumulatedHarvestedPoints",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getAccumulatedRedeemedPoints",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getAllowednfts",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getAllStakers",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getCurrentStakingSeasonEndTime",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getEarnedPointsFromStake",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getRedeemFunction",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getRedeemLocation",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getStaker",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getStakerAccumulatedHarvestedPoints",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getStakerAccumulatedRedeemedPoints",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getStakerUnharvestedPoints",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "getStakes", values: [string]): string;
  encodeFunctionData(
    functionFragment: "getStakingPercentMultiplier",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getStakingPercentMultiplierMultiple",
    values: [string[], BigNumberish[], BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "getStakingSeason",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getStakingSeasonEndTime",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getTotalStaked",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;

  decodeFunctionResult(
    functionFragment: "beginNewStakingSeason",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "emergencyUnstake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "endStakingSeason",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "harvestAllStakes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "harvestStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "redeem", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRedeemFunction",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRedeemLocation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setStakingPercentMultiplier",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setStakingPercentMultiplierMultiple",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTokenStakingDisabled",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTokenStakingDisabledMultiple",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "stakeMultiple",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnershipRedeemLocation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unstake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "unstakeMultiple",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateStakingSeasonEndTime",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getAccumulatedHarvestedPoints",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getAccumulatedRedeemedPoints",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getAllowednfts",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getAllStakers",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getCurrentStakingSeasonEndTime",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getEarnedPointsFromStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRedeemFunction",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRedeemLocation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getStaker", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getStakerAccumulatedHarvestedPoints",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getStakerAccumulatedRedeemedPoints",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getStakerUnharvestedPoints",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getStakes", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getStakingPercentMultiplier",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getStakingPercentMultiplierMultiple",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getStakingSeason",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getStakingSeasonEndTime",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTotalStaked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;

  events: {
    "BeginStakingSeason(address,uint256,uint256)": EventFragment;
    "DisableStaking(address,uint256)": EventFragment;
    "EnableStaking(address,uint256)": EventFragment;
    "Harvest(address,uint256)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "Redeem(address,uint256,address)": EventFragment;
    "SetRedeemLocation(address)": EventFragment;
    "SetStakingPercentMultiplier(address,uint256,uint256,uint256)": EventFragment;
    "Stake(address,address,uint256)": EventFragment;
    "Unstake(address,address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "BeginStakingSeason"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DisableStaking"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "EnableStaking"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Harvest"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Redeem"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetRedeemLocation"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "SetStakingPercentMultiplier"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Stake"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Unstake"): EventFragment;
}

export interface BeginStakingSeasonEventObject {
  nft: string;
  dailyPoints: BigNumber;
  endTime: BigNumber;
}
export type BeginStakingSeasonEvent = TypedEvent<
  [string, BigNumber, BigNumber],
  BeginStakingSeasonEventObject
>;

export type BeginStakingSeasonEventFilter =
  TypedEventFilter<BeginStakingSeasonEvent>;

export interface DisableStakingEventObject {
  nft: string;
  tokenId: BigNumber;
}
export type DisableStakingEvent = TypedEvent<
  [string, BigNumber],
  DisableStakingEventObject
>;

export type DisableStakingEventFilter = TypedEventFilter<DisableStakingEvent>;

export interface EnableStakingEventObject {
  nft: string;
  tokenId: BigNumber;
}
export type EnableStakingEvent = TypedEvent<
  [string, BigNumber],
  EnableStakingEventObject
>;

export type EnableStakingEventFilter = TypedEventFilter<EnableStakingEvent>;

export interface HarvestEventObject {
  staker: string;
  points: BigNumber;
}
export type HarvestEvent = TypedEvent<[string, BigNumber], HarvestEventObject>;

export type HarvestEventFilter = TypedEventFilter<HarvestEvent>;

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

export type OwnershipTransferredEventFilter =
  TypedEventFilter<OwnershipTransferredEvent>;

export interface RedeemEventObject {
  staker: string;
  points: BigNumber;
  redeemLocation: string;
}
export type RedeemEvent = TypedEvent<
  [string, BigNumber, string],
  RedeemEventObject
>;

export type RedeemEventFilter = TypedEventFilter<RedeemEvent>;

export interface SetRedeemLocationEventObject {
  location: string;
}
export type SetRedeemLocationEvent = TypedEvent<
  [string],
  SetRedeemLocationEventObject
>;

export type SetRedeemLocationEventFilter =
  TypedEventFilter<SetRedeemLocationEvent>;

export interface SetStakingPercentMultiplierEventObject {
  nft: string;
  tokenId: BigNumber;
  stakingSeason: BigNumber;
  multiplier: BigNumber;
}
export type SetStakingPercentMultiplierEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber],
  SetStakingPercentMultiplierEventObject
>;

export type SetStakingPercentMultiplierEventFilter =
  TypedEventFilter<SetStakingPercentMultiplierEvent>;

export interface StakeEventObject {
  staker: string;
  nft: string;
  tokenId: BigNumber;
}
export type StakeEvent = TypedEvent<
  [string, string, BigNumber],
  StakeEventObject
>;

export type StakeEventFilter = TypedEventFilter<StakeEvent>;

export interface UnstakeEventObject {
  staker: string;
  nft: string;
  tokenId: BigNumber;
}
export type UnstakeEvent = TypedEvent<
  [string, string, BigNumber],
  UnstakeEventObject
>;

export type UnstakeEventFilter = TypedEventFilter<UnstakeEvent>;

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

  interface: RivalBearsStakingInterface;

  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: {
    beginNewStakingSeason(
      nft: string,
      dailyPoints: BigNumberish,
      endTime: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

    setStakingPercentMultiplierMultiple(
      nft: string[],
      tokenId: BigNumberish[],
      stakingPercentMultiplier: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    setTokenStakingDisabled(
      nft: string,
      tokenId: BigNumberish,
      disabled: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    setTokenStakingDisabledMultiple(
      nft: string[],
      tokenId: BigNumberish[],
      disabled: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

    updateStakingSeasonEndTime(
      nft: string,
      endTime: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

    getAllStakers(
      overrides?: CallOverrides
    ): Promise<[string[]] & { staker: string[] }>;

    getCurrentStakingSeasonEndTime(
      nft: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getEarnedPointsFromStake(
      staker: string,
      stakingIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

    getStaker(
      nft: string,
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string] & { staker: string }>;

    getStakerAccumulatedHarvestedPoints(
      staker: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getStakerAccumulatedRedeemedPoints(
      staker: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getStakerUnharvestedPoints(
      staker: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getStakes(
      staker: string,
      overrides?: CallOverrides
    ): Promise<[Interface_Rival_Bears_Staking.UserStakeStructOutput[]]>;

    getStakingPercentMultiplier(
      nft: string,
      tokenId: BigNumberish,
      stakingSeasonIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getStakingPercentMultiplierMultiple(
      nft: string[],
      tokenId: BigNumberish[],
      stakingSeasonIndex: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<[BigNumber[]]>;

    getStakingSeason(
      nft: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getStakingSeasonEndTime(
      nft: string,
      stakingSeasonIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

  beginNewStakingSeason(
    nft: string,
    dailyPoints: BigNumberish,
    endTime: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

  setStakingPercentMultiplierMultiple(
    nft: string[],
    tokenId: BigNumberish[],
    stakingPercentMultiplier: BigNumberish[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  setTokenStakingDisabled(
    nft: string,
    tokenId: BigNumberish,
    disabled: boolean,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  setTokenStakingDisabledMultiple(
    nft: string[],
    tokenId: BigNumberish[],
    disabled: boolean,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

  updateStakingSeasonEndTime(
    nft: string,
    endTime: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

  getCurrentStakingSeasonEndTime(
    nft: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getEarnedPointsFromStake(
    staker: string,
    stakingIndex: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

  getStaker(
    nft: string,
    tokenId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  getStakerAccumulatedHarvestedPoints(
    staker: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getStakerAccumulatedRedeemedPoints(
    staker: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getStakerUnharvestedPoints(
    staker: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getStakes(
    staker: string,
    overrides?: CallOverrides
  ): Promise<Interface_Rival_Bears_Staking.UserStakeStructOutput[]>;

  getStakingPercentMultiplier(
    nft: string,
    tokenId: BigNumberish,
    stakingSeasonIndex: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getStakingPercentMultiplierMultiple(
    nft: string[],
    tokenId: BigNumberish[],
    stakingSeasonIndex: BigNumberish[],
    overrides?: CallOverrides
  ): Promise<BigNumber[]>;

  getStakingSeason(nft: string, overrides?: CallOverrides): Promise<BigNumber>;

  getStakingSeasonEndTime(
    nft: string,
    stakingSeasonIndex: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

  callStatic: {
    beginNewStakingSeason(
      nft: string,
      dailyPoints: BigNumberish,
      endTime: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    endStakingSeason(nft: string, overrides?: CallOverrides): Promise<void>;

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

    harvestStake(
      stakingIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    redeem(_points: BigNumberish, overrides?: CallOverrides): Promise<void>;

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

    setRedeemFunction(
      _redeemFunction: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setRedeemLocation(
      _redeemLocation: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setStakingPercentMultiplier(
      nft: string,
      tokenId: BigNumberish,
      stakingPercentMultiplier: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setStakingPercentMultiplierMultiple(
      nft: string[],
      tokenId: BigNumberish[],
      stakingPercentMultiplier: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    setTokenStakingDisabled(
      nft: string,
      tokenId: BigNumberish,
      disabled: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setTokenStakingDisabledMultiple(
      nft: string[],
      tokenId: BigNumberish[],
      disabled: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    stake(
      nft: string,
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    stakeMultiple(
      nft: string[],
      tokenId: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    unstake(
      stakingIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    unstakeMultiple(
      stakingIndex: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    updateStakingSeasonEndTime(
      nft: string,
      endTime: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    getCurrentStakingSeasonEndTime(
      nft: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getEarnedPointsFromStake(
      staker: string,
      stakingIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getStaker(
      nft: string,
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    getStakerAccumulatedHarvestedPoints(
      staker: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStakerAccumulatedRedeemedPoints(
      staker: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStakerUnharvestedPoints(
      staker: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStakes(
      staker: string,
      overrides?: CallOverrides
    ): Promise<Interface_Rival_Bears_Staking.UserStakeStructOutput[]>;

    getStakingPercentMultiplier(
      nft: string,
      tokenId: BigNumberish,
      stakingSeasonIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStakingPercentMultiplierMultiple(
      nft: string[],
      tokenId: BigNumberish[],
      stakingSeasonIndex: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

    getStakingSeason(
      nft: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStakingSeasonEndTime(
      nft: string,
      stakingSeasonIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

  filters: {
    "BeginStakingSeason(address,uint256,uint256)"(
      nft?: string | null,
      dailyPoints?: null,
      endTime?: null
    ): BeginStakingSeasonEventFilter;
    BeginStakingSeason(
      nft?: string | null,
      dailyPoints?: null,
      endTime?: null
    ): BeginStakingSeasonEventFilter;

    "DisableStaking(address,uint256)"(
      nft?: string | null,
      tokenId?: BigNumberish | null
    ): DisableStakingEventFilter;
    DisableStaking(
      nft?: string | null,
      tokenId?: BigNumberish | null
    ): DisableStakingEventFilter;

    "EnableStaking(address,uint256)"(
      nft?: string | null,
      tokenId?: BigNumberish | null
    ): EnableStakingEventFilter;
    EnableStaking(
      nft?: string | null,
      tokenId?: BigNumberish | null
    ): EnableStakingEventFilter;

    "Harvest(address,uint256)"(
      staker?: string | null,
      points?: null
    ): HarvestEventFilter;
    Harvest(staker?: string | null, points?: null): HarvestEventFilter;

    "OwnershipTransferred(address,address)"(
      oldOwner?: null,
      newOwner?: null
    ): OwnershipTransferredEventFilter;
    OwnershipTransferred(
      oldOwner?: null,
      newOwner?: null
    ): OwnershipTransferredEventFilter;

    "Redeem(address,uint256,address)"(
      staker?: string | null,
      points?: null,
      redeemLocation?: string | null
    ): RedeemEventFilter;
    Redeem(
      staker?: string | null,
      points?: null,
      redeemLocation?: string | null
    ): RedeemEventFilter;

    "SetRedeemLocation(address)"(location?: null): SetRedeemLocationEventFilter;
    SetRedeemLocation(location?: null): SetRedeemLocationEventFilter;

    "SetStakingPercentMultiplier(address,uint256,uint256,uint256)"(
      nft?: string | null,
      tokenId?: BigNumberish | null,
      stakingSeason?: BigNumberish | null,
      multiplier?: null
    ): SetStakingPercentMultiplierEventFilter;
    SetStakingPercentMultiplier(
      nft?: string | null,
      tokenId?: BigNumberish | null,
      stakingSeason?: BigNumberish | null,
      multiplier?: null
    ): SetStakingPercentMultiplierEventFilter;

    "Stake(address,address,uint256)"(
      staker?: string | null,
      nft?: string | null,
      tokenId?: BigNumberish | null
    ): StakeEventFilter;
    Stake(
      staker?: string | null,
      nft?: string | null,
      tokenId?: BigNumberish | null
    ): StakeEventFilter;

    "Unstake(address,address,uint256)"(
      staker?: string | null,
      nft?: string | null,
      tokenId?: BigNumberish | null
    ): UnstakeEventFilter;
    Unstake(
      staker?: string | null,
      nft?: string | null,
      tokenId?: BigNumberish | null
    ): UnstakeEventFilter;
  };

  estimateGas: {
    beginNewStakingSeason(
      nft: string,
      dailyPoints: BigNumberish,
      endTime: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

    setStakingPercentMultiplierMultiple(
      nft: string[],
      tokenId: BigNumberish[],
      stakingPercentMultiplier: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setTokenStakingDisabled(
      nft: string,
      tokenId: BigNumberish,
      disabled: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setTokenStakingDisabledMultiple(
      nft: string[],
      tokenId: BigNumberish[],
      disabled: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

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

    updateStakingSeasonEndTime(
      nft: string,
      endTime: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

    getCurrentStakingSeasonEndTime(
      nft: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getEarnedPointsFromStake(
      staker: string,
      stakingIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getStaker(
      nft: string,
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStakerAccumulatedHarvestedPoints(
      staker: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStakerAccumulatedRedeemedPoints(
      staker: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStakerUnharvestedPoints(
      staker: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStakes(staker: string, overrides?: CallOverrides): Promise<BigNumber>;

    getStakingPercentMultiplier(
      nft: string,
      tokenId: BigNumberish,
      stakingSeasonIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStakingPercentMultiplierMultiple(
      nft: string[],
      tokenId: BigNumberish[],
      stakingSeasonIndex: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStakingSeason(
      nft: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStakingSeasonEndTime(
      nft: string,
      stakingSeasonIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

  populateTransaction: {
    beginNewStakingSeason(
      nft: string,
      dailyPoints: BigNumberish,
      endTime: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

    setStakingPercentMultiplierMultiple(
      nft: string[],
      tokenId: BigNumberish[],
      stakingPercentMultiplier: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    setTokenStakingDisabled(
      nft: string,
      tokenId: BigNumberish,
      disabled: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    setTokenStakingDisabledMultiple(
      nft: string[],
      tokenId: BigNumberish[],
      disabled: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

    updateStakingSeasonEndTime(
      nft: string,
      endTime: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    getCurrentStakingSeasonEndTime(
      nft: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getEarnedPointsFromStake(
      staker: string,
      stakingIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    getStaker(
      nft: string,
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getStakerAccumulatedHarvestedPoints(
      staker: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getStakerAccumulatedRedeemedPoints(
      staker: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getStakerUnharvestedPoints(
      staker: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getStakes(
      staker: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getStakingPercentMultiplier(
      nft: string,
      tokenId: BigNumberish,
      stakingSeasonIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getStakingPercentMultiplierMultiple(
      nft: string[],
      tokenId: BigNumberish[],
      stakingSeasonIndex: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getStakingSeason(
      nft: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getStakingSeasonEndTime(
      nft: string,
      stakingSeasonIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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