/* 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 ERC20Votes {
  export type CheckpointStruct = {
    fromBlock: BigNumberish;
    votes: BigNumberish;
  };

  export type CheckpointStructOutput = [number, BigNumber] & {
    fromBlock: number;
    votes: BigNumber;
  };
}

export declare namespace INFTWEscrow {
  export type WorldInfoStruct = {
    weight: BigNumberish;
    owner: string;
    deposit: BigNumberish;
    rentalPerDay: BigNumberish;
    minRentDays: BigNumberish;
    rentableUntil: BigNumberish;
  };

  export type WorldInfoStructOutput = [
    number,
    string,
    number,
    number,
    number,
    number
  ] & {
    weight: number;
    owner: string;
    deposit: number;
    rentalPerDay: number;
    minRentDays: number;
    rentableUntil: number;
  };
}

export interface NftwEscrowInterface extends utils.Interface {
  functions: {
    "DOMAIN_SEPARATOR()": FunctionFragment;
    "allowance(address,address)": FunctionFragment;
    "approve(address,uint256)": FunctionFragment;
    "balanceOf(address)": FunctionFragment;
    "checkUserRewards(address)": FunctionFragment;
    "checkpoints(address,uint32)": FunctionFragment;
    "claim(address)": FunctionFragment;
    "decimals()": FunctionFragment;
    "decreaseAllowance(address,uint256)": FunctionFragment;
    "delegate(address)": FunctionFragment;
    "delegateBySig(address,uint256,uint256,uint8,bytes32,bytes32)": FunctionFragment;
    "delegates(address)": FunctionFragment;
    "extendRentalPeriod(uint256,uint32)": FunctionFragment;
    "getPastTotalSupply(uint256)": FunctionFragment;
    "getPastVotes(address,uint256)": FunctionFragment;
    "getVotes(address)": FunctionFragment;
    "getWorldInfo(uint256)": FunctionFragment;
    "increaseAllowance(address,uint256)": FunctionFragment;
    "initialStake(uint256[],uint256[],address,uint16,uint16,uint16,uint32,uint32,bytes)": FunctionFragment;
    "name()": FunctionFragment;
    "nonces(address)": FunctionFragment;
    "numCheckpoints(address)": FunctionFragment;
    "onERC721Received(address,address,uint256,bytes)": FunctionFragment;
    "owner()": FunctionFragment;
    "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)": FunctionFragment;
    "removeRoutingDataIPFSHash(uint256)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "rewards(address)": FunctionFragment;
    "rewardsPerWeight()": FunctionFragment;
    "rewardsPeriod()": FunctionFragment;
    "setPredicate(address,bool)": FunctionFragment;
    "setRentalContract(address)": FunctionFragment;
    "setRewards(uint32,uint32,uint96)": FunctionFragment;
    "setRouterContract(address)": FunctionFragment;
    "setRoutingDataIPFSHash(uint256,string)": FunctionFragment;
    "setSigner(address)": FunctionFragment;
    "setWeight(uint256[],uint256[])": FunctionFragment;
    "stake(uint256[],address,uint16,uint16,uint16,uint32)": FunctionFragment;
    "supportsInterface(bytes4)": FunctionFragment;
    "symbol()": FunctionFragment;
    "totalSupply()": FunctionFragment;
    "transfer(address,uint256)": FunctionFragment;
    "transferFrom(address,address,uint256)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "unstake(uint256[],address)": FunctionFragment;
    "updateMetadata(uint256,string)": FunctionFragment;
    "updateRent(uint256[],uint16,uint16,uint16,uint32)": FunctionFragment;
    "userBridged(address)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "DOMAIN_SEPARATOR"
      | "allowance"
      | "approve"
      | "balanceOf"
      | "checkUserRewards"
      | "checkpoints"
      | "claim"
      | "decimals"
      | "decreaseAllowance"
      | "delegate"
      | "delegateBySig"
      | "delegates"
      | "extendRentalPeriod"
      | "getPastTotalSupply"
      | "getPastVotes"
      | "getVotes"
      | "getWorldInfo"
      | "increaseAllowance"
      | "initialStake"
      | "name"
      | "nonces"
      | "numCheckpoints"
      | "onERC721Received"
      | "owner"
      | "permit"
      | "removeRoutingDataIPFSHash"
      | "renounceOwnership"
      | "rewards"
      | "rewardsPerWeight"
      | "rewardsPeriod"
      | "setPredicate"
      | "setRentalContract"
      | "setRewards"
      | "setRouterContract"
      | "setRoutingDataIPFSHash"
      | "setSigner"
      | "setWeight"
      | "stake"
      | "supportsInterface"
      | "symbol"
      | "totalSupply"
      | "transfer"
      | "transferFrom"
      | "transferOwnership"
      | "unstake"
      | "updateMetadata"
      | "updateRent"
      | "userBridged"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "DOMAIN_SEPARATOR",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "allowance",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "approve",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
  encodeFunctionData(
    functionFragment: "checkUserRewards",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "checkpoints",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "claim", values: [string]): string;
  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "decreaseAllowance",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "delegate", values: [string]): string;
  encodeFunctionData(
    functionFragment: "delegateBySig",
    values: [
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BytesLike,
      BytesLike
    ]
  ): string;
  encodeFunctionData(functionFragment: "delegates", values: [string]): string;
  encodeFunctionData(
    functionFragment: "extendRentalPeriod",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getPastTotalSupply",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getPastVotes",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "getVotes", values: [string]): string;
  encodeFunctionData(
    functionFragment: "getWorldInfo",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "increaseAllowance",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "initialStake",
    values: [
      BigNumberish[],
      BigNumberish[],
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BytesLike
    ]
  ): string;
  encodeFunctionData(functionFragment: "name", values?: undefined): string;
  encodeFunctionData(functionFragment: "nonces", values: [string]): string;
  encodeFunctionData(
    functionFragment: "numCheckpoints",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "onERC721Received",
    values: [string, string, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "permit",
    values: [
      string,
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BytesLike,
      BytesLike
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "removeRoutingDataIPFSHash",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "rewards", values: [string]): string;
  encodeFunctionData(
    functionFragment: "rewardsPerWeight",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "rewardsPeriod",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setPredicate",
    values: [string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setRentalContract",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setRewards",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setRouterContract",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setRoutingDataIPFSHash",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(functionFragment: "setSigner", values: [string]): string;
  encodeFunctionData(
    functionFragment: "setWeight",
    values: [BigNumberish[], BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "stake",
    values: [
      BigNumberish[],
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "supportsInterface",
    values: [BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "totalSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transfer",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferFrom",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "unstake",
    values: [BigNumberish[], string]
  ): string;
  encodeFunctionData(
    functionFragment: "updateMetadata",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "updateRent",
    values: [
      BigNumberish[],
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(functionFragment: "userBridged", values: [string]): string;

  decodeFunctionResult(
    functionFragment: "DOMAIN_SEPARATOR",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "checkUserRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "checkpoints",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "decreaseAllowance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "delegate", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "delegateBySig",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "delegates", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "extendRentalPeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPastTotalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPastVotes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getVotes", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getWorldInfo",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "increaseAllowance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "initialStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "nonces", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "numCheckpoints",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "onERC721Received",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "permit", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "removeRoutingDataIPFSHash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "rewards", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "rewardsPerWeight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "rewardsPeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPredicate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRentalContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setRewards", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setRouterContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRoutingDataIPFSHash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setSigner", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "setWeight", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "supportsInterface",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "totalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unstake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "updateMetadata",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "updateRent", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "userBridged",
    data: BytesLike
  ): Result;

  events: {
    "Approval(address,address,uint256)": EventFragment;
    "DelegateChanged(address,address,address)": EventFragment;
    "DelegateVotesChanged(address,uint256,uint256)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "RewardClaimed(address,uint256)": EventFragment;
    "RewardsPerWeightUpdated(uint256)": EventFragment;
    "RewardsSet(uint32,uint32,uint256)": EventFragment;
    "RewardsUpdated(uint32,uint32,uint256)": EventFragment;
    "Transfer(address,address,uint256)": EventFragment;
    "UserRewardsUpdated(address,uint256,uint256)": EventFragment;
    "WeightUpdated(address,bool,uint256,uint256)": EventFragment;
    "WorldStaked(uint256,address)": EventFragment;
    "WorldUnstaked(uint256,address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DelegateChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DelegateVotesChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewardClaimed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewardsPerWeightUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewardsSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewardsUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UserRewardsUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "WeightUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "WorldStaked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "WorldUnstaked"): EventFragment;
}

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

export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;

export interface DelegateChangedEventObject {
  delegator: string;
  fromDelegate: string;
  toDelegate: string;
}
export type DelegateChangedEvent = TypedEvent<
  [string, string, string],
  DelegateChangedEventObject
>;

export type DelegateChangedEventFilter = TypedEventFilter<DelegateChangedEvent>;

export interface DelegateVotesChangedEventObject {
  delegate: string;
  previousBalance: BigNumber;
  newBalance: BigNumber;
}
export type DelegateVotesChangedEvent = TypedEvent<
  [string, BigNumber, BigNumber],
  DelegateVotesChangedEventObject
>;

export type DelegateVotesChangedEventFilter =
  TypedEventFilter<DelegateVotesChangedEvent>;

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

export type OwnershipTransferredEventFilter =
  TypedEventFilter<OwnershipTransferredEvent>;

export interface RewardClaimedEventObject {
  receiver: string;
  claimed: BigNumber;
}
export type RewardClaimedEvent = TypedEvent<
  [string, BigNumber],
  RewardClaimedEventObject
>;

export type RewardClaimedEventFilter = TypedEventFilter<RewardClaimedEvent>;

export interface RewardsPerWeightUpdatedEventObject {
  accumulated: BigNumber;
}
export type RewardsPerWeightUpdatedEvent = TypedEvent<
  [BigNumber],
  RewardsPerWeightUpdatedEventObject
>;

export type RewardsPerWeightUpdatedEventFilter =
  TypedEventFilter<RewardsPerWeightUpdatedEvent>;

export interface RewardsSetEventObject {
  start: number;
  end: number;
  rate: BigNumber;
}
export type RewardsSetEvent = TypedEvent<
  [number, number, BigNumber],
  RewardsSetEventObject
>;

export type RewardsSetEventFilter = TypedEventFilter<RewardsSetEvent>;

export interface RewardsUpdatedEventObject {
  start: number;
  end: number;
  rate: BigNumber;
}
export type RewardsUpdatedEvent = TypedEvent<
  [number, number, BigNumber],
  RewardsUpdatedEventObject
>;

export type RewardsUpdatedEventFilter = TypedEventFilter<RewardsUpdatedEvent>;

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

export type TransferEventFilter = TypedEventFilter<TransferEvent>;

export interface UserRewardsUpdatedEventObject {
  user: string;
  userRewards: BigNumber;
  paidRewardPerWeight: BigNumber;
}
export type UserRewardsUpdatedEvent = TypedEvent<
  [string, BigNumber, BigNumber],
  UserRewardsUpdatedEventObject
>;

export type UserRewardsUpdatedEventFilter =
  TypedEventFilter<UserRewardsUpdatedEvent>;

export interface WeightUpdatedEventObject {
  user: string;
  increase: boolean;
  weight: BigNumber;
  timestamp: BigNumber;
}
export type WeightUpdatedEvent = TypedEvent<
  [string, boolean, BigNumber, BigNumber],
  WeightUpdatedEventObject
>;

export type WeightUpdatedEventFilter = TypedEventFilter<WeightUpdatedEvent>;

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

export type WorldStakedEventFilter = TypedEventFilter<WorldStakedEvent>;

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

export type WorldUnstakedEventFilter = TypedEventFilter<WorldUnstakedEvent>;

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

  interface: NftwEscrowInterface;

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

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

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

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

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

    checkpoints(
      account: string,
      pos: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[ERC20Votes.CheckpointStructOutput]>;

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

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    delegateBySig(
      delegatee: string,
      nonce: BigNumberish,
      expiry: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

    getPastTotalSupply(
      blockNumber: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

    getWorldInfo(
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[INFTWEscrow.WorldInfoStructOutput]>;

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    initialStake(
      tokenIds: BigNumberish[],
      weights: BigNumberish[],
      stakeTo: string,
      _deposit: BigNumberish,
      _rentalPerDay: BigNumberish,
      _minRentDays: BigNumberish,
      _rentableUntil: BigNumberish,
      _maxTimestamp: BigNumberish,
      _signature: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

    numCheckpoints(
      account: string,
      overrides?: CallOverrides
    ): Promise<[number]>;

    onERC721Received(
      operator: string,
      from: string,
      tokenId: BigNumberish,
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

    permit(
      owner: string,
      spender: string,
      value: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

    rewards(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [number, BigNumber, BigNumber] & {
        stakedWeight: number;
        accumulated: BigNumber;
        checkpoint: BigNumber;
      }
    >;

    rewardsPerWeight(
      overrides?: CallOverrides
    ): Promise<
      [number, BigNumber, number, BigNumber] & {
        totalWeight: number;
        accumulated: BigNumber;
        lastUpdated: number;
        rate: BigNumber;
      }
    >;

    rewardsPeriod(
      overrides?: CallOverrides
    ): Promise<[number, number] & { start: number; end: number }>;

    setPredicate(
      _contract: string,
      _allow: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    setRewards(
      start: BigNumberish,
      end: BigNumberish,
      rate: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

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

    stake(
      tokenIds: BigNumberish[],
      stakeTo: string,
      _deposit: BigNumberish,
      _rentalPerDay: BigNumberish,
      _minRentDays: BigNumberish,
      _rentableUntil: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    supportsInterface(
      interfaceId: BytesLike,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

    totalSupply(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { supply: BigNumber }>;

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

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

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

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

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

    updateRent(
      tokenIds: BigNumberish[],
      _deposit: BigNumberish,
      _rentalPerDay: BigNumberish,
      _minRentDays: BigNumberish,
      _rentableUntil: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

  checkpoints(
    account: string,
    pos: BigNumberish,
    overrides?: CallOverrides
  ): Promise<ERC20Votes.CheckpointStructOutput>;

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

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

  decreaseAllowance(
    spender: string,
    subtractedValue: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  delegateBySig(
    delegatee: string,
    nonce: BigNumberish,
    expiry: BigNumberish,
    v: BigNumberish,
    r: BytesLike,
    s: BytesLike,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

  getPastTotalSupply(
    blockNumber: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getPastVotes(
    account: string,
    blockNumber: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  getWorldInfo(
    tokenId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<INFTWEscrow.WorldInfoStructOutput>;

  increaseAllowance(
    spender: string,
    addedValue: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  initialStake(
    tokenIds: BigNumberish[],
    weights: BigNumberish[],
    stakeTo: string,
    _deposit: BigNumberish,
    _rentalPerDay: BigNumberish,
    _minRentDays: BigNumberish,
    _rentableUntil: BigNumberish,
    _maxTimestamp: BigNumberish,
    _signature: BytesLike,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

  numCheckpoints(account: string, overrides?: CallOverrides): Promise<number>;

  onERC721Received(
    operator: string,
    from: string,
    tokenId: BigNumberish,
    data: BytesLike,
    overrides?: CallOverrides
  ): Promise<string>;

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

  permit(
    owner: string,
    spender: string,
    value: BigNumberish,
    deadline: BigNumberish,
    v: BigNumberish,
    r: BytesLike,
    s: BytesLike,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

  rewards(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<
    [number, BigNumber, BigNumber] & {
      stakedWeight: number;
      accumulated: BigNumber;
      checkpoint: BigNumber;
    }
  >;

  rewardsPerWeight(
    overrides?: CallOverrides
  ): Promise<
    [number, BigNumber, number, BigNumber] & {
      totalWeight: number;
      accumulated: BigNumber;
      lastUpdated: number;
      rate: BigNumber;
    }
  >;

  rewardsPeriod(
    overrides?: CallOverrides
  ): Promise<[number, number] & { start: number; end: number }>;

  setPredicate(
    _contract: string,
    _allow: boolean,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  setRewards(
    start: BigNumberish,
    end: BigNumberish,
    rate: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

  stake(
    tokenIds: BigNumberish[],
    stakeTo: string,
    _deposit: BigNumberish,
    _rentalPerDay: BigNumberish,
    _minRentDays: BigNumberish,
    _rentableUntil: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  supportsInterface(
    interfaceId: BytesLike,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

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

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

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

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

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

  updateRent(
    tokenIds: BigNumberish[],
    _deposit: BigNumberish,
    _rentalPerDay: BigNumberish,
    _minRentDays: BigNumberish,
    _rentableUntil: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

    checkpoints(
      account: string,
      pos: BigNumberish,
      overrides?: CallOverrides
    ): Promise<ERC20Votes.CheckpointStructOutput>;

    claim(to: string, overrides?: CallOverrides): Promise<void>;

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    delegate(delegatee: string, overrides?: CallOverrides): Promise<void>;

    delegateBySig(
      delegatee: string,
      nonce: BigNumberish,
      expiry: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    getPastTotalSupply(
      blockNumber: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getPastVotes(
      account: string,
      blockNumber: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getWorldInfo(
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<INFTWEscrow.WorldInfoStructOutput>;

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    initialStake(
      tokenIds: BigNumberish[],
      weights: BigNumberish[],
      stakeTo: string,
      _deposit: BigNumberish,
      _rentalPerDay: BigNumberish,
      _minRentDays: BigNumberish,
      _rentableUntil: BigNumberish,
      _maxTimestamp: BigNumberish,
      _signature: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    numCheckpoints(account: string, overrides?: CallOverrides): Promise<number>;

    onERC721Received(
      operator: string,
      from: string,
      tokenId: BigNumberish,
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

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

    permit(
      owner: string,
      spender: string,
      value: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    rewards(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [number, BigNumber, BigNumber] & {
        stakedWeight: number;
        accumulated: BigNumber;
        checkpoint: BigNumber;
      }
    >;

    rewardsPerWeight(
      overrides?: CallOverrides
    ): Promise<
      [number, BigNumber, number, BigNumber] & {
        totalWeight: number;
        accumulated: BigNumber;
        lastUpdated: number;
        rate: BigNumber;
      }
    >;

    rewardsPeriod(
      overrides?: CallOverrides
    ): Promise<[number, number] & { start: number; end: number }>;

    setPredicate(
      _contract: string,
      _allow: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setRentalContract(
      _contract: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setRewards(
      start: BigNumberish,
      end: BigNumberish,
      rate: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setRouterContract(
      _contract: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setRoutingDataIPFSHash(
      tokenId: BigNumberish,
      _ipfsHash: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setSigner(_signer: string, overrides?: CallOverrides): Promise<void>;

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

    stake(
      tokenIds: BigNumberish[],
      stakeTo: string,
      _deposit: BigNumberish,
      _rentalPerDay: BigNumberish,
      _minRentDays: BigNumberish,
      _rentableUntil: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    supportsInterface(
      interfaceId: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

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

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

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

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

    updateMetadata(
      tokenId: BigNumberish,
      _tokenMetadataIPFSHash: string,
      overrides?: CallOverrides
    ): Promise<void>;

    updateRent(
      tokenIds: BigNumberish[],
      _deposit: BigNumberish,
      _rentalPerDay: BigNumberish,
      _minRentDays: BigNumberish,
      _rentableUntil: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    "DelegateChanged(address,address,address)"(
      delegator?: string | null,
      fromDelegate?: string | null,
      toDelegate?: string | null
    ): DelegateChangedEventFilter;
    DelegateChanged(
      delegator?: string | null,
      fromDelegate?: string | null,
      toDelegate?: string | null
    ): DelegateChangedEventFilter;

    "DelegateVotesChanged(address,uint256,uint256)"(
      delegate?: string | null,
      previousBalance?: null,
      newBalance?: null
    ): DelegateVotesChangedEventFilter;
    DelegateVotesChanged(
      delegate?: string | null,
      previousBalance?: null,
      newBalance?: null
    ): DelegateVotesChangedEventFilter;

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

    "RewardClaimed(address,uint256)"(
      receiver?: null,
      claimed?: null
    ): RewardClaimedEventFilter;
    RewardClaimed(receiver?: null, claimed?: null): RewardClaimedEventFilter;

    "RewardsPerWeightUpdated(uint256)"(
      accumulated?: null
    ): RewardsPerWeightUpdatedEventFilter;
    RewardsPerWeightUpdated(
      accumulated?: null
    ): RewardsPerWeightUpdatedEventFilter;

    "RewardsSet(uint32,uint32,uint256)"(
      start?: null,
      end?: null,
      rate?: null
    ): RewardsSetEventFilter;
    RewardsSet(start?: null, end?: null, rate?: null): RewardsSetEventFilter;

    "RewardsUpdated(uint32,uint32,uint256)"(
      start?: null,
      end?: null,
      rate?: null
    ): RewardsUpdatedEventFilter;
    RewardsUpdated(
      start?: null,
      end?: null,
      rate?: null
    ): RewardsUpdatedEventFilter;

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

    "UserRewardsUpdated(address,uint256,uint256)"(
      user?: null,
      userRewards?: null,
      paidRewardPerWeight?: null
    ): UserRewardsUpdatedEventFilter;
    UserRewardsUpdated(
      user?: null,
      userRewards?: null,
      paidRewardPerWeight?: null
    ): UserRewardsUpdatedEventFilter;

    "WeightUpdated(address,bool,uint256,uint256)"(
      user?: string | null,
      increase?: null,
      weight?: null,
      timestamp?: null
    ): WeightUpdatedEventFilter;
    WeightUpdated(
      user?: string | null,
      increase?: null,
      weight?: null,
      timestamp?: null
    ): WeightUpdatedEventFilter;

    "WorldStaked(uint256,address)"(
      tokenId?: BigNumberish | null,
      user?: string | null
    ): WorldStakedEventFilter;
    WorldStaked(
      tokenId?: BigNumberish | null,
      user?: string | null
    ): WorldStakedEventFilter;

    "WorldUnstaked(uint256,address)"(
      tokenId?: BigNumberish | null,
      user?: string | null
    ): WorldUnstakedEventFilter;
    WorldUnstaked(
      tokenId?: BigNumberish | null,
      user?: string | null
    ): WorldUnstakedEventFilter;
  };

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

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

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

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

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

    checkpoints(
      account: string,
      pos: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    delegateBySig(
      delegatee: string,
      nonce: BigNumberish,
      expiry: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

    getPastTotalSupply(
      blockNumber: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getPastVotes(
      account: string,
      blockNumber: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    initialStake(
      tokenIds: BigNumberish[],
      weights: BigNumberish[],
      stakeTo: string,
      _deposit: BigNumberish,
      _rentalPerDay: BigNumberish,
      _minRentDays: BigNumberish,
      _rentableUntil: BigNumberish,
      _maxTimestamp: BigNumberish,
      _signature: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

    onERC721Received(
      operator: string,
      from: string,
      tokenId: BigNumberish,
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    permit(
      owner: string,
      spender: string,
      value: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

    setPredicate(
      _contract: string,
      _allow: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    setRewards(
      start: BigNumberish,
      end: BigNumberish,
      rate: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

    stake(
      tokenIds: BigNumberish[],
      stakeTo: string,
      _deposit: BigNumberish,
      _rentalPerDay: BigNumberish,
      _minRentDays: BigNumberish,
      _rentableUntil: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    supportsInterface(
      interfaceId: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    updateRent(
      tokenIds: BigNumberish[],
      _deposit: BigNumberish,
      _rentalPerDay: BigNumberish,
      _minRentDays: BigNumberish,
      _rentableUntil: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

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

    checkpoints(
      account: string,
      pos: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    delegateBySig(
      delegatee: string,
      nonce: BigNumberish,
      expiry: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

    getPastTotalSupply(
      blockNumber: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getPastVotes(
      account: string,
      blockNumber: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    initialStake(
      tokenIds: BigNumberish[],
      weights: BigNumberish[],
      stakeTo: string,
      _deposit: BigNumberish,
      _rentalPerDay: BigNumberish,
      _minRentDays: BigNumberish,
      _rentableUntil: BigNumberish,
      _maxTimestamp: BigNumberish,
      _signature: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

    onERC721Received(
      operator: string,
      from: string,
      tokenId: BigNumberish,
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    permit(
      owner: string,
      spender: string,
      value: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

    setPredicate(
      _contract: string,
      _allow: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    setRewards(
      start: BigNumberish,
      end: BigNumberish,
      rate: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    stake(
      tokenIds: BigNumberish[],
      stakeTo: string,
      _deposit: BigNumberish,
      _rentalPerDay: BigNumberish,
      _minRentDays: BigNumberish,
      _rentableUntil: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    supportsInterface(
      interfaceId: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

    updateRent(
      tokenIds: BigNumberish[],
      _deposit: BigNumberish,
      _rentalPerDay: BigNumberish,
      _minRentDays: BigNumberish,
      _rentableUntil: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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