/* 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 OilV2 {
  export type HabibiStruct = {
    stakedTimestamp: BigNumberish;
    tokenId: BigNumberish;
  };

  export type HabibiStructOutput = [BigNumber, BigNumber] & {
    stakedTimestamp: BigNumber;
    tokenId: BigNumber;
  };

  export type StakerStruct = {
    habibiz: OilV2.HabibiStruct[];
    lastClaim: BigNumberish;
  };

  export type StakerStructOutput = [OilV2.HabibiStructOutput[], BigNumber] & {
    habibiz: OilV2.HabibiStructOutput[];
    lastClaim: BigNumber;
  };

  export type RoyalStruct = {
    stakedTimestamp: BigNumberish;
    tokenId: BigNumberish;
  };

  export type RoyalStructOutput = [BigNumber, BigNumber] & {
    stakedTimestamp: BigNumber;
    tokenId: BigNumber;
  };

  export type RoyalStakerStruct = { royals: OilV2.RoyalStruct[] };

  export type RoyalStakerStructOutput = [OilV2.RoyalStructOutput[]] & {
    royals: OilV2.RoyalStructOutput[];
  };
}

export interface HabibizStakingInterface extends utils.Interface {
  functions: {
    "RoyalsUnFrozen(uint256)": FunctionFragment;
    "allStakedOfStaker(address)": FunctionFragment;
    "allowance(address,address)": FunctionFragment;
    "approve(address,uint256)": FunctionFragment;
    "approveRescue(address,bool,bool)": FunctionFragment;
    "balanceOf(address)": FunctionFragment;
    "baseTax()": FunctionFragment;
    "blockList(address)": FunctionFragment;
    "blockOrUnblockAddresses(address[],bool[])": FunctionFragment;
    "burn(address,uint256)": FunctionFragment;
    "calculateOilRewards(address)": FunctionFragment;
    "cancelSwap(uint256)": FunctionFragment;
    "changeUnFreezePrice(uint256)": FunctionFragment;
    "changeUnFreezeTimer(uint256)": FunctionFragment;
    "claim()": FunctionFragment;
    "claimedRoyals(uint256)": FunctionFragment;
    "claims(uint256)": FunctionFragment;
    "decimals()": FunctionFragment;
    "doubleBaseTimestamp()": FunctionFragment;
    "escrowedOil(uint256)": FunctionFragment;
    "excludeFromFees(address[],bool[])": FunctionFragment;
    "excludedFromFees(address)": FunctionFragment;
    "freeze(address,uint256[],uint256)": FunctionFragment;
    "frozenHabibiz(uint256)": FunctionFragment;
    "getRoyalsBase(address)": FunctionFragment;
    "getUnfrozen(uint256)": FunctionFragment;
    "habibi()": FunctionFragment;
    "habibizOfStaker(address)": FunctionFragment;
    "holderBonusPercentage(address)": FunctionFragment;
    "impl_()": FunctionFragment;
    "initialize(address,address)": FunctionFragment;
    "isMinter(address)": FunctionFragment;
    "isOwnedByStaker(address,uint256,bool)": FunctionFragment;
    "lastUnstakedTimestamp(address)": FunctionFragment;
    "minSwap()": FunctionFragment;
    "mint(address,uint256)": FunctionFragment;
    "name()": FunctionFragment;
    "onERC721Received(address,address,uint256,bytes)": FunctionFragment;
    "ownerOfRoyal(uint256)": FunctionFragment;
    "paused()": FunctionFragment;
    "rescue(address,address,uint256[],uint256[])": FunctionFragment;
    "revokeRescue(address,bool)": FunctionFragment;
    "royalSwaps(uint256)": FunctionFragment;
    "royals()": FunctionFragment;
    "royalsHabibiRatio()": FunctionFragment;
    "royalsOfStaker(address)": FunctionFragment;
    "ruler()": FunctionFragment;
    "sellFee()": FunctionFragment;
    "setHabibiAddress(address)": FunctionFragment;
    "setMinter(address,bool)": FunctionFragment;
    "setPairs(address,address)": FunctionFragment;
    "setPaused(bool)": FunctionFragment;
    "setRoyalOwner(address,address,uint256,bool)": FunctionFragment;
    "setRoyalSwapCost(uint256)": FunctionFragment;
    "setRoyalsAddress(address)": FunctionFragment;
    "setRoyalsHabibiRatio(uint256)": FunctionFragment;
    "setRuler(address)": FunctionFragment;
    "setSellFee(uint256)": FunctionFragment;
    "setStakedTransferFor(address,address)": FunctionFragment;
    "setSushiswapPair(address)": FunctionFragment;
    "setSushiswapV2Router(address)": FunctionFragment;
    "setSwappingActive(bool)": FunctionFragment;
    "setUnfreezeMerkleRoot(bytes32)": FunctionFragment;
    "setUniPair(address)": FunctionFragment;
    "setUniswapV2Router(address)": FunctionFragment;
    "setV2Routers(address,address)": FunctionFragment;
    "stake(uint256[],uint256[])": FunctionFragment;
    "stakeAll()": FunctionFragment;
    "stakedTransfer()": FunctionFragment;
    "staker(address)": FunctionFragment;
    "startingTime()": FunctionFragment;
    "sushiswapPair()": FunctionFragment;
    "sushiswapV2Router()": FunctionFragment;
    "swapRoyals(uint256,uint256)": FunctionFragment;
    "swapRoyalsCost()": FunctionFragment;
    "swapping()": FunctionFragment;
    "swappingActive()": FunctionFragment;
    "symbol()": FunctionFragment;
    "toggleUnfreeze()": FunctionFragment;
    "totalSupply()": FunctionFragment;
    "transfer(address,uint256)": FunctionFragment;
    "transferFrom(address,address,uint256)": FunctionFragment;
    "treasury()": FunctionFragment;
    "unFreeze(uint256,uint256,bytes32[])": FunctionFragment;
    "unFreezeActive()": FunctionFragment;
    "unFreezeMerkleRoot()": FunctionFragment;
    "unFreezeOilCost()": FunctionFragment;
    "unFreezeTimer()": FunctionFragment;
    "unclaimedRoyals()": FunctionFragment;
    "uniPair()": FunctionFragment;
    "uniswapV2Router()": FunctionFragment;
    "unstakeAll()": FunctionFragment;
    "unstakeAllHabibiz()": FunctionFragment;
    "unstakeAllRoyals()": FunctionFragment;
    "unstakeHabibizByIds(uint256[])": FunctionFragment;
    "unstakeRoyalsByIds(uint256[])": FunctionFragment;
    "weth()": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "RoyalsUnFrozen"
      | "allStakedOfStaker"
      | "allowance"
      | "approve"
      | "approveRescue"
      | "balanceOf"
      | "baseTax"
      | "blockList"
      | "blockOrUnblockAddresses"
      | "burn"
      | "calculateOilRewards"
      | "cancelSwap"
      | "changeUnFreezePrice"
      | "changeUnFreezeTimer"
      | "claim"
      | "claimedRoyals"
      | "claims"
      | "decimals"
      | "doubleBaseTimestamp"
      | "escrowedOil"
      | "excludeFromFees"
      | "excludedFromFees"
      | "freeze"
      | "frozenHabibiz"
      | "getRoyalsBase"
      | "getUnfrozen"
      | "habibi"
      | "habibizOfStaker"
      | "holderBonusPercentage"
      | "impl_"
      | "initialize"
      | "isMinter"
      | "isOwnedByStaker"
      | "lastUnstakedTimestamp"
      | "minSwap"
      | "mint"
      | "name"
      | "onERC721Received"
      | "ownerOfRoyal"
      | "paused"
      | "rescue"
      | "revokeRescue"
      | "royalSwaps"
      | "royals"
      | "royalsHabibiRatio"
      | "royalsOfStaker"
      | "ruler"
      | "sellFee"
      | "setHabibiAddress"
      | "setMinter"
      | "setPairs"
      | "setPaused"
      | "setRoyalOwner"
      | "setRoyalSwapCost"
      | "setRoyalsAddress"
      | "setRoyalsHabibiRatio"
      | "setRuler"
      | "setSellFee"
      | "setStakedTransferFor"
      | "setSushiswapPair"
      | "setSushiswapV2Router"
      | "setSwappingActive"
      | "setUnfreezeMerkleRoot"
      | "setUniPair"
      | "setUniswapV2Router"
      | "setV2Routers"
      | "stake"
      | "stakeAll"
      | "stakedTransfer"
      | "staker"
      | "startingTime"
      | "sushiswapPair"
      | "sushiswapV2Router"
      | "swapRoyals"
      | "swapRoyalsCost"
      | "swapping"
      | "swappingActive"
      | "symbol"
      | "toggleUnfreeze"
      | "totalSupply"
      | "transfer"
      | "transferFrom"
      | "treasury"
      | "unFreeze"
      | "unFreezeActive"
      | "unFreezeMerkleRoot"
      | "unFreezeOilCost"
      | "unFreezeTimer"
      | "unclaimedRoyals"
      | "uniPair"
      | "uniswapV2Router"
      | "unstakeAll"
      | "unstakeAllHabibiz"
      | "unstakeAllRoyals"
      | "unstakeHabibizByIds"
      | "unstakeRoyalsByIds"
      | "weth"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "RoyalsUnFrozen",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "allStakedOfStaker",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "allowance",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "approve",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "approveRescue",
    values: [string, boolean, boolean]
  ): string;
  encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
  encodeFunctionData(functionFragment: "baseTax", values?: undefined): string;
  encodeFunctionData(functionFragment: "blockList", values: [string]): string;
  encodeFunctionData(
    functionFragment: "blockOrUnblockAddresses",
    values: [string[], boolean[]]
  ): string;
  encodeFunctionData(
    functionFragment: "burn",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "calculateOilRewards",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "cancelSwap",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "changeUnFreezePrice",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "changeUnFreezeTimer",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "claim", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "claimedRoyals",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "claims",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "doubleBaseTimestamp",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "escrowedOil",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "excludeFromFees",
    values: [string[], boolean[]]
  ): string;
  encodeFunctionData(
    functionFragment: "excludedFromFees",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "freeze",
    values: [string, BigNumberish[], BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "frozenHabibiz",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getRoyalsBase",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getUnfrozen",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "habibi", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "habibizOfStaker",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "holderBonusPercentage",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "impl_", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [string, string]
  ): string;
  encodeFunctionData(functionFragment: "isMinter", values: [string]): string;
  encodeFunctionData(
    functionFragment: "isOwnedByStaker",
    values: [string, BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "lastUnstakedTimestamp",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "minSwap", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "mint",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "name", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "onERC721Received",
    values: [string, string, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "ownerOfRoyal",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "paused", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "rescue",
    values: [string, string, BigNumberish[], BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "revokeRescue",
    values: [string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "royalSwaps",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "royals", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "royalsHabibiRatio",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "royalsOfStaker",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "ruler", values?: undefined): string;
  encodeFunctionData(functionFragment: "sellFee", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "setHabibiAddress",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setMinter",
    values: [string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setPairs",
    values: [string, string]
  ): string;
  encodeFunctionData(functionFragment: "setPaused", values: [boolean]): string;
  encodeFunctionData(
    functionFragment: "setRoyalOwner",
    values: [string, string, BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setRoyalSwapCost",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setRoyalsAddress",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setRoyalsHabibiRatio",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "setRuler", values: [string]): string;
  encodeFunctionData(
    functionFragment: "setSellFee",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setStakedTransferFor",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "setSushiswapPair",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setSushiswapV2Router",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setSwappingActive",
    values: [boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setUnfreezeMerkleRoot",
    values: [BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "setUniPair", values: [string]): string;
  encodeFunctionData(
    functionFragment: "setUniswapV2Router",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setV2Routers",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "stake",
    values: [BigNumberish[], BigNumberish[]]
  ): string;
  encodeFunctionData(functionFragment: "stakeAll", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "stakedTransfer",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "staker", values: [string]): string;
  encodeFunctionData(
    functionFragment: "startingTime",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "sushiswapPair",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "sushiswapV2Router",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "swapRoyals",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "swapRoyalsCost",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "swapping", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "swappingActive",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "toggleUnfreeze",
    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: "treasury", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "unFreeze",
    values: [BigNumberish, BigNumberish, BytesLike[]]
  ): string;
  encodeFunctionData(
    functionFragment: "unFreezeActive",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "unFreezeMerkleRoot",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "unFreezeOilCost",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "unFreezeTimer",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "unclaimedRoyals",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "uniPair", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "uniswapV2Router",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "unstakeAll",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "unstakeAllHabibiz",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "unstakeAllRoyals",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "unstakeHabibizByIds",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "unstakeRoyalsByIds",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(functionFragment: "weth", values?: undefined): string;

  decodeFunctionResult(
    functionFragment: "RoyalsUnFrozen",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "allStakedOfStaker",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "approveRescue",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "baseTax", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "blockList", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "blockOrUnblockAddresses",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "calculateOilRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "cancelSwap", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "changeUnFreezePrice",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "changeUnFreezeTimer",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "claimedRoyals",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "claims", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "doubleBaseTimestamp",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "escrowedOil",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "excludeFromFees",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "excludedFromFees",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "freeze", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "frozenHabibiz",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRoyalsBase",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getUnfrozen",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "habibi", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "habibizOfStaker",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "holderBonusPercentage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "impl_", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "isMinter", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isOwnedByStaker",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lastUnstakedTimestamp",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "minSwap", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "onERC721Received",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "ownerOfRoyal",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "rescue", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "revokeRescue",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "royalSwaps", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "royals", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "royalsHabibiRatio",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "royalsOfStaker",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "ruler", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "sellFee", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setHabibiAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setMinter", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "setPairs", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "setPaused", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setRoyalOwner",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRoyalSwapCost",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRoyalsAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRoyalsHabibiRatio",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setRuler", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "setSellFee", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setStakedTransferFor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setSushiswapPair",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setSushiswapV2Router",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setSwappingActive",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setUnfreezeMerkleRoot",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setUniPair", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setUniswapV2Router",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setV2Routers",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stakeAll", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "stakedTransfer",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "staker", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "startingTime",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "sushiswapPair",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "sushiswapV2Router",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "swapRoyals", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "swapRoyalsCost",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "swapping", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "swappingActive",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "toggleUnfreeze",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "treasury", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "unFreeze", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "unFreezeActive",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unFreezeMerkleRoot",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unFreezeOilCost",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unFreezeTimer",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unclaimedRoyals",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "uniPair", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "uniswapV2Router",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unstakeAll", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "unstakeAllHabibiz",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unstakeAllRoyals",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unstakeHabibizByIds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unstakeRoyalsByIds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "weth", data: BytesLike): Result;

  events: {
    "Approval(address,address,uint256)": EventFragment;
    "Transfer(address,address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Transfer"): 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 TransferEventObject {
  from: string;
  to: string;
  value: BigNumber;
}
export type TransferEvent = TypedEvent<
  [string, string, BigNumber],
  TransferEventObject
>;

export type TransferEventFilter = TypedEventFilter<TransferEvent>;

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

  interface: HabibizStakingInterface;

  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: {
    RoyalsUnFrozen(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        lastClaim: BigNumber;
        eligbleClaimTimestamp: BigNumber;
      }
    >;

    allStakedOfStaker(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber[], BigNumber[]]>;

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

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

    approveRescue(
      revoker_: string,
      confirm_: boolean,
      rescueableByAdmin_: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

    blockList(arg0: string, overrides?: CallOverrides): Promise<[boolean]>;

    blockOrUnblockAddresses(
      addresses_: string[],
      blocked_: boolean[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    calculateOilRewards(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { oilAmount: BigNumber }>;

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

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

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

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

    claimedRoyals(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

    claims(arg0: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;

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

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

    escrowedOil(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    excludeFromFees(
      addresses_: string[],
      excluded_: boolean[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    excludedFromFees(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    freeze(
      staker_: string,
      habibizIds_: BigNumberish[],
      royalId_: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    frozenHabibiz(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getRoyalsBase(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { base: BigNumber }>;

    getUnfrozen(
      royalId_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber[]] & { unFrozenIds_: BigNumber[] }>;

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

    habibizOfStaker(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber[]]>;

    holderBonusPercentage(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    initialize(
      habibi_: string,
      treasury_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    isMinter(arg0: string, overrides?: CallOverrides): Promise<[boolean]>;

    isOwnedByStaker(
      staker_: string,
      tokenId_: BigNumberish,
      isRoyal_: boolean,
      overrides?: CallOverrides
    ): Promise<[BigNumber, boolean]>;

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

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

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

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

    onERC721Received(
      operator: string,
      from: string,
      tokenId: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    ownerOfRoyal(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

    rescue(
      staker_: string,
      to_: string,
      habibiIds_: BigNumberish[],
      royalIds_: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    revokeRescue(
      rescueable_: string,
      confirm_: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    royalSwaps(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

    royalsOfStaker(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber[]]>;

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

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

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

    setMinter(
      minter_: string,
      canMint_: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    setPairs(
      uniPair_: string,
      sushiswapPair_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    setRoyalOwner(
      staker_: string,
      previousStaker_: string,
      royalId_: BigNumberish,
      force_: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

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

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

    setStakedTransferFor(
      staker_: string,
      newAddress_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

    setUnfreezeMerkleRoot(
      root_: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

    setV2Routers(
      uniswapRouter_: string,
      sushiswapRouter_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

    staker(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<[OilV2.StakerStructOutput, OilV2.RoyalStakerStructOutput]>;

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

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

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

    swapRoyals(
      myRoyalId_: BigNumberish,
      theirRoyalId_: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

    unFreeze(
      royalId_: BigNumberish,
      habibiz_: BigNumberish,
      proof_: BytesLike[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

  RoyalsUnFrozen(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & {
      lastClaim: BigNumber;
      eligbleClaimTimestamp: BigNumber;
    }
  >;

  allStakedOfStaker(
    staker_: string,
    overrides?: CallOverrides
  ): Promise<[BigNumber[], BigNumber[]]>;

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

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

  approveRescue(
    revoker_: string,
    confirm_: boolean,
    rescueableByAdmin_: boolean,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

  blockList(arg0: string, overrides?: CallOverrides): Promise<boolean>;

  blockOrUnblockAddresses(
    addresses_: string[],
    blocked_: boolean[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  calculateOilRewards(
    staker_: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

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

  claimedRoyals(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;

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

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

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

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

  excludeFromFees(
    addresses_: string[],
    excluded_: boolean[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  excludedFromFees(arg0: string, overrides?: CallOverrides): Promise<boolean>;

  freeze(
    staker_: string,
    habibizIds_: BigNumberish[],
    royalId_: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  getRoyalsBase(staker_: string, overrides?: CallOverrides): Promise<BigNumber>;

  getUnfrozen(
    royalId_: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber[]>;

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

  habibizOfStaker(
    staker_: string,
    overrides?: CallOverrides
  ): Promise<BigNumber[]>;

  holderBonusPercentage(
    staker_: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  initialize(
    habibi_: string,
    treasury_: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  isMinter(arg0: string, overrides?: CallOverrides): Promise<boolean>;

  isOwnedByStaker(
    staker_: string,
    tokenId_: BigNumberish,
    isRoyal_: boolean,
    overrides?: CallOverrides
  ): Promise<[BigNumber, boolean]>;

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

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

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

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

  onERC721Received(
    operator: string,
    from: string,
    tokenId: BigNumberish,
    data: BytesLike,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  ownerOfRoyal(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;

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

  rescue(
    staker_: string,
    to_: string,
    habibiIds_: BigNumberish[],
    royalIds_: BigNumberish[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  revokeRescue(
    rescueable_: string,
    confirm_: boolean,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

  royalsOfStaker(
    staker_: string,
    overrides?: CallOverrides
  ): Promise<BigNumber[]>;

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

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

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

  setMinter(
    minter_: string,
    canMint_: boolean,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  setPairs(
    uniPair_: string,
    sushiswapPair_: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  setRoyalOwner(
    staker_: string,
    previousStaker_: string,
    royalId_: BigNumberish,
    force_: boolean,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

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

  setStakedTransferFor(
    staker_: string,
    newAddress_: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

  setUnfreezeMerkleRoot(
    root_: BytesLike,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

  setV2Routers(
    uniswapRouter_: string,
    sushiswapRouter_: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

  staker(
    staker_: string,
    overrides?: CallOverrides
  ): Promise<[OilV2.StakerStructOutput, OilV2.RoyalStakerStructOutput]>;

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

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

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

  swapRoyals(
    myRoyalId_: BigNumberish,
    theirRoyalId_: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

  unFreeze(
    royalId_: BigNumberish,
    habibiz_: BigNumberish,
    proof_: BytesLike[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

  callStatic: {
    RoyalsUnFrozen(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        lastClaim: BigNumber;
        eligbleClaimTimestamp: BigNumber;
      }
    >;

    allStakedOfStaker(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber[], BigNumber[]]>;

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

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

    approveRescue(
      revoker_: string,
      confirm_: boolean,
      rescueableByAdmin_: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    blockList(arg0: string, overrides?: CallOverrides): Promise<boolean>;

    blockOrUnblockAddresses(
      addresses_: string[],
      blocked_: boolean[],
      overrides?: CallOverrides
    ): Promise<void>;

    burn(
      from: string,
      value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    calculateOilRewards(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    cancelSwap(
      myRoyalId_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    changeUnFreezePrice(
      cost_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    changeUnFreezeTimer(
      newtime_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    claimedRoyals(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

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

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

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

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

    excludeFromFees(
      addresses_: string[],
      excluded_: boolean[],
      overrides?: CallOverrides
    ): Promise<void>;

    excludedFromFees(arg0: string, overrides?: CallOverrides): Promise<boolean>;

    freeze(
      staker_: string,
      habibizIds_: BigNumberish[],
      royalId_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    getRoyalsBase(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getUnfrozen(
      royalId_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

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

    habibizOfStaker(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

    holderBonusPercentage(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    initialize(
      habibi_: string,
      treasury_: string,
      overrides?: CallOverrides
    ): Promise<void>;

    isMinter(arg0: string, overrides?: CallOverrides): Promise<boolean>;

    isOwnedByStaker(
      staker_: string,
      tokenId_: BigNumberish,
      isRoyal_: boolean,
      overrides?: CallOverrides
    ): Promise<[BigNumber, boolean]>;

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

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

    mint(
      to: string,
      value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    ownerOfRoyal(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

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

    rescue(
      staker_: string,
      to_: string,
      habibiIds_: BigNumberish[],
      royalIds_: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    revokeRescue(
      rescueable_: string,
      confirm_: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    royalsOfStaker(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

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

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

    setHabibiAddress(
      habibiAddress_: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setMinter(
      minter_: string,
      canMint_: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setPairs(
      uniPair_: string,
      sushiswapPair_: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setPaused(paused_: boolean, overrides?: CallOverrides): Promise<void>;

    setRoyalOwner(
      staker_: string,
      previousStaker_: string,
      royalId_: BigNumberish,
      force_: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setRoyalSwapCost(
      cost_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setRoyalsAddress(
      royalsAddress_: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setRoyalsHabibiRatio(
      ratio_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setRuler(ruler_: string, overrides?: CallOverrides): Promise<void>;

    setSellFee(fee_: BigNumberish, overrides?: CallOverrides): Promise<void>;

    setStakedTransferFor(
      staker_: string,
      newAddress_: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setSushiswapPair(
      sushiswapPair_: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setSushiswapV2Router(
      router_: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setSwappingActive(
      active_: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setUnfreezeMerkleRoot(
      root_: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    setUniPair(uniPair_: string, overrides?: CallOverrides): Promise<void>;

    setUniswapV2Router(
      router_: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setV2Routers(
      uniswapRouter_: string,
      sushiswapRouter_: string,
      overrides?: CallOverrides
    ): Promise<void>;

    stake(
      habibiz_: BigNumberish[],
      royals_: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    staker(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<[OilV2.StakerStructOutput, OilV2.RoyalStakerStructOutput]>;

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

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

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

    swapRoyals(
      myRoyalId_: BigNumberish,
      theirRoyalId_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

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

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

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

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

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

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

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

    unFreeze(
      royalId_: BigNumberish,
      habibiz_: BigNumberish,
      proof_: BytesLike[],
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

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

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

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

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

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

    unstakeHabibizByIds(
      tokenIds_: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    unstakeRoyalsByIds(
      tokenIds_: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

  estimateGas: {
    RoyalsUnFrozen(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    allStakedOfStaker(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    approveRescue(
      revoker_: string,
      confirm_: boolean,
      rescueableByAdmin_: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

    blockOrUnblockAddresses(
      addresses_: string[],
      blocked_: boolean[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    calculateOilRewards(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

    excludeFromFees(
      addresses_: string[],
      excluded_: boolean[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    freeze(
      staker_: string,
      habibizIds_: BigNumberish[],
      royalId_: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    getRoyalsBase(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getUnfrozen(
      royalId_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    habibizOfStaker(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    holderBonusPercentage(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    initialize(
      habibi_: string,
      treasury_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    isOwnedByStaker(
      staker_: string,
      tokenId_: BigNumberish,
      isRoyal_: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    onERC721Received(
      operator: string,
      from: string,
      tokenId: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

    rescue(
      staker_: string,
      to_: string,
      habibiIds_: BigNumberish[],
      royalIds_: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    revokeRescue(
      rescueable_: string,
      confirm_: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

    royalsOfStaker(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    setMinter(
      minter_: string,
      canMint_: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setPairs(
      uniPair_: string,
      sushiswapPair_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    setRoyalOwner(
      staker_: string,
      previousStaker_: string,
      royalId_: BigNumberish,
      force_: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

    setStakedTransferFor(
      staker_: string,
      newAddress_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

    setUnfreezeMerkleRoot(
      root_: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

    setV2Routers(
      uniswapRouter_: string,
      sushiswapRouter_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    swapRoyals(
      myRoyalId_: BigNumberish,
      theirRoyalId_: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

    unFreeze(
      royalId_: BigNumberish,
      habibiz_: BigNumberish,
      proof_: BytesLike[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

  populateTransaction: {
    RoyalsUnFrozen(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    allStakedOfStaker(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    approveRescue(
      revoker_: string,
      confirm_: boolean,
      rescueableByAdmin_: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

    blockOrUnblockAddresses(
      addresses_: string[],
      blocked_: boolean[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    calculateOilRewards(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

    excludeFromFees(
      addresses_: string[],
      excluded_: boolean[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    freeze(
      staker_: string,
      habibizIds_: BigNumberish[],
      royalId_: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    getRoyalsBase(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getUnfrozen(
      royalId_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    habibizOfStaker(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    holderBonusPercentage(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    initialize(
      habibi_: string,
      treasury_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    isOwnedByStaker(
      staker_: string,
      tokenId_: BigNumberish,
      isRoyal_: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    onERC721Received(
      operator: string,
      from: string,
      tokenId: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

    rescue(
      staker_: string,
      to_: string,
      habibiIds_: BigNumberish[],
      royalIds_: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    revokeRescue(
      rescueable_: string,
      confirm_: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

    royalsOfStaker(
      staker_: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    setMinter(
      minter_: string,
      canMint_: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    setPairs(
      uniPair_: string,
      sushiswapPair_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    setRoyalOwner(
      staker_: string,
      previousStaker_: string,
      royalId_: BigNumberish,
      force_: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

    setStakedTransferFor(
      staker_: string,
      newAddress_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

    setUnfreezeMerkleRoot(
      root_: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

    setV2Routers(
      uniswapRouter_: string,
      sushiswapRouter_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

    swapRoyals(
      myRoyalId_: BigNumberish,
      theirRoyalId_: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

    unFreeze(
      royalId_: BigNumberish,
      habibiz_: BigNumberish,
      proof_: BytesLike[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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