/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import type {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  PayableOverrides,
  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 ERC721A {
  export type TokenOwnershipStruct = {
    addr: string;
    startTimestamp: BigNumberish;
  };

  export type TokenOwnershipStructOutput = [string, BigNumber] & {
    addr: string;
    startTimestamp: BigNumber;
  };
}

export interface SupremeKong2StakingInterface extends utils.Interface {
  functions: {
    "_paidMutantBananaIds(uint256)": FunctionFragment;
    "_redeemedBananaIds(uint256)": FunctionFragment;
    "_redeemedKongIds(uint256)": FunctionFragment;
    "_redeemedMutantBananaIds(uint256)": FunctionFragment;
    "_usedNonces(string)": FunctionFragment;
    "approve(address,uint256)": FunctionFragment;
    "balanceOf(address)": FunctionFragment;
    "baseURI()": FunctionFragment;
    "batchStakeNFT(uint256[])": FunctionFragment;
    "batchUnstakeNFT()": FunctionFragment;
    "freeMint(address)": FunctionFragment;
    "freemintSupply()": FunctionFragment;
    "getApproved(uint256)": FunctionFragment;
    "getOwnershipData(uint256)": FunctionFragment;
    "hashTransaction(address,uint256,string)": FunctionFragment;
    "hiddenURI()": FunctionFragment;
    "isApprovedForAll(address,address)": FunctionFragment;
    "matchSigner(bytes32,bytes)": FunctionFragment;
    "maxSupply()": FunctionFragment;
    "mintEnabled()": FunctionFragment;
    "mutantMint(address,uint256)": FunctionFragment;
    "mutantMintAndStake(address,uint256)": FunctionFragment;
    "mutantSupply()": FunctionFragment;
    "name()": FunctionFragment;
    "nextOwnerToExplicitlySet()": FunctionFragment;
    "onERC721Received(address,address,uint256,bytes)": FunctionFragment;
    "owner()": FunctionFragment;
    "ownerOf(uint256)": FunctionFragment;
    "price()": FunctionFragment;
    "publicLimit()": FunctionFragment;
    "publicMint(address,uint256)": FunctionFragment;
    "publicMintAndStake(address,uint256)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "revealed()": FunctionFragment;
    "royaltyInfo(uint256,uint256)": FunctionFragment;
    "safeTransferFrom(address,address,uint256)": FunctionFragment;
    "safeTransferFrom(address,address,uint256,bytes)": FunctionFragment;
    "setApprovalForAll(address,bool)": FunctionFragment;
    "setBaseURI(string)": FunctionFragment;
    "setFreemintSupply(uint256)": FunctionFragment;
    "setHiddenURI(string)": FunctionFragment;
    "setMutantSupply(uint256)": FunctionFragment;
    "setOwnersExplicit(uint256)": FunctionFragment;
    "setRoyaltyInfo(address,uint96)": FunctionFragment;
    "setWhitelistSupply(uint256)": FunctionFragment;
    "stakeNFT(uint256)": FunctionFragment;
    "stakePrice()": FunctionFragment;
    "stakedNfts(address)": FunctionFragment;
    "supportsInterface(bytes4)": FunctionFragment;
    "symbol()": FunctionFragment;
    "teamMint(address,uint256)": FunctionFragment;
    "teamSupply()": FunctionFragment;
    "toggleMinting()": FunctionFragment;
    "toggleRevealed()": FunctionFragment;
    "tokenByIndex(uint256)": FunctionFragment;
    "tokenOfOwnerByIndex(address,uint256)": FunctionFragment;
    "tokenURI(uint256)": FunctionFragment;
    "totalSupply()": FunctionFragment;
    "transferFrom(address,address,uint256)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "unstakeNFT(uint256)": FunctionFragment;
    "whitelistMint(address,uint256,string,bytes32,bytes)": FunctionFragment;
    "whitelistMintAndStake(address,uint256,string,bytes32,bytes)": FunctionFragment;
    "whitelistSupply()": FunctionFragment;
    "withdraw()": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "_paidMutantBananaIds"
      | "_redeemedBananaIds"
      | "_redeemedKongIds"
      | "_redeemedMutantBananaIds"
      | "_usedNonces"
      | "approve"
      | "balanceOf"
      | "baseURI"
      | "batchStakeNFT"
      | "batchUnstakeNFT"
      | "freeMint"
      | "freemintSupply"
      | "getApproved"
      | "getOwnershipData"
      | "hashTransaction"
      | "hiddenURI"
      | "isApprovedForAll"
      | "matchSigner"
      | "maxSupply"
      | "mintEnabled"
      | "mutantMint"
      | "mutantMintAndStake"
      | "mutantSupply"
      | "name"
      | "nextOwnerToExplicitlySet"
      | "onERC721Received"
      | "owner"
      | "ownerOf"
      | "price"
      | "publicLimit"
      | "publicMint"
      | "publicMintAndStake"
      | "renounceOwnership"
      | "revealed"
      | "royaltyInfo"
      | "safeTransferFrom(address,address,uint256)"
      | "safeTransferFrom(address,address,uint256,bytes)"
      | "setApprovalForAll"
      | "setBaseURI"
      | "setFreemintSupply"
      | "setHiddenURI"
      | "setMutantSupply"
      | "setOwnersExplicit"
      | "setRoyaltyInfo"
      | "setWhitelistSupply"
      | "stakeNFT"
      | "stakePrice"
      | "stakedNfts"
      | "supportsInterface"
      | "symbol"
      | "teamMint"
      | "teamSupply"
      | "toggleMinting"
      | "toggleRevealed"
      | "tokenByIndex"
      | "tokenOfOwnerByIndex"
      | "tokenURI"
      | "totalSupply"
      | "transferFrom"
      | "transferOwnership"
      | "unstakeNFT"
      | "whitelistMint"
      | "whitelistMintAndStake"
      | "whitelistSupply"
      | "withdraw"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "_paidMutantBananaIds",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "_redeemedBananaIds",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "_redeemedKongIds",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "_redeemedMutantBananaIds",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "_usedNonces", values: [string]): string;
  encodeFunctionData(
    functionFragment: "approve",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
  encodeFunctionData(functionFragment: "baseURI", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "batchStakeNFT",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "batchUnstakeNFT",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "freeMint", values: [string]): string;
  encodeFunctionData(
    functionFragment: "freemintSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getApproved",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getOwnershipData",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "hashTransaction",
    values: [string, BigNumberish, string]
  ): string;
  encodeFunctionData(functionFragment: "hiddenURI", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "isApprovedForAll",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "matchSigner",
    values: [BytesLike, BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "maxSupply", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "mintEnabled",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "mutantMint",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "mutantMintAndStake",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "mutantSupply",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "name", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "nextOwnerToExplicitlySet",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "onERC721Received",
    values: [string, string, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "ownerOf",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "price", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "publicLimit",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "publicMint",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "publicMintAndStake",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "revealed", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "royaltyInfo",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "safeTransferFrom(address,address,uint256)",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "safeTransferFrom(address,address,uint256,bytes)",
    values: [string, string, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "setApprovalForAll",
    values: [string, boolean]
  ): string;
  encodeFunctionData(functionFragment: "setBaseURI", values: [string]): string;
  encodeFunctionData(
    functionFragment: "setFreemintSupply",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setHiddenURI",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setMutantSupply",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setOwnersExplicit",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setRoyaltyInfo",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setWhitelistSupply",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "stakeNFT",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "stakePrice",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "stakedNfts", values: [string]): string;
  encodeFunctionData(
    functionFragment: "supportsInterface",
    values: [BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "teamMint",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "teamSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "toggleMinting",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "toggleRevealed",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "tokenByIndex",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "tokenOfOwnerByIndex",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "tokenURI",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "totalSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transferFrom",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "unstakeNFT",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "whitelistMint",
    values: [string, BigNumberish, string, BytesLike, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "whitelistMintAndStake",
    values: [string, BigNumberish, string, BytesLike, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "whitelistSupply",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "withdraw", values?: undefined): string;

  decodeFunctionResult(
    functionFragment: "_paidMutantBananaIds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_redeemedBananaIds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_redeemedKongIds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_redeemedMutantBananaIds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_usedNonces",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "baseURI", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "batchStakeNFT",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "batchUnstakeNFT",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "freeMint", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "freemintSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getApproved",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getOwnershipData",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "hashTransaction",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "hiddenURI", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isApprovedForAll",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "matchSigner",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "maxSupply", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "mintEnabled",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "mutantMint", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "mutantMintAndStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "mutantSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "nextOwnerToExplicitlySet",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "onERC721Received",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "ownerOf", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "price", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "publicLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "publicMint", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "publicMintAndStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "revealed", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "royaltyInfo",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "safeTransferFrom(address,address,uint256)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "safeTransferFrom(address,address,uint256,bytes)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setApprovalForAll",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setBaseURI", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setFreemintSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setHiddenURI",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMutantSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setOwnersExplicit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRoyaltyInfo",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setWhitelistSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "stakeNFT", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stakePrice", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stakedNfts", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "supportsInterface",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "teamMint", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "teamSupply", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "toggleMinting",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "toggleRevealed",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "tokenByIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "tokenOfOwnerByIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "tokenURI", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "totalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unstakeNFT", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "whitelistMint",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "whitelistMintAndStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "whitelistSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;

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

  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ApprovalForAll"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
}

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

export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;

export interface ApprovalForAllEventObject {
  owner: string;
  operator: string;
  approved: boolean;
}
export type ApprovalForAllEvent = TypedEvent<
  [string, string, boolean],
  ApprovalForAllEventObject
>;

export type ApprovalForAllEventFilter = TypedEventFilter<ApprovalForAllEvent>;

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

export type OwnershipTransferredEventFilter =
  TypedEventFilter<OwnershipTransferredEvent>;

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

export type TransferEventFilter = TypedEventFilter<TransferEvent>;

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

  interface: SupremeKong2StakingInterface;

  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: {
    _paidMutantBananaIds(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    _redeemedBananaIds(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    _redeemedKongIds(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    _redeemedMutantBananaIds(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

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

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

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

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

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

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

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

    getOwnershipData(
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[ERC721A.TokenOwnershipStructOutput]>;

    hashTransaction(
      sender: string,
      amount: BigNumberish,
      nonce: string,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

    isApprovedForAll(
      owner: string,
      operator: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    matchSigner(
      hash: BytesLike,
      signature: BytesLike,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

    mutantMint(
      to: string,
      numberOfTokens: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<ContractTransaction>;

    mutantMintAndStake(
      to: string,
      numberOfTokens: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

    onERC721Received(
      arg0: string,
      arg1: string,
      arg2: BigNumberish,
      arg3: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

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

    publicMint(
      to: string,
      numberOfTokens: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<ContractTransaction>;

    publicMintAndStake(
      to: string,
      numberOfTokens: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

    royaltyInfo(
      _tokenId: BigNumberish,
      _salePrice: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string, BigNumber]>;

    "safeTransferFrom(address,address,uint256)"(
      from: string,
      to: string,
      tokenId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    "safeTransferFrom(address,address,uint256,bytes)"(
      from: string,
      to: string,
      tokenId: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

    setRoyaltyInfo(
      receiver: string,
      numerator: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

    stakedNfts(
      _owner: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber[]]>;

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

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

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

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

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

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

    tokenByIndex(
      index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

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

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

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

    whitelistMint(
      to: string,
      numberOfTokens: BigNumberish,
      nonce: string,
      hash: BytesLike,
      signature: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<ContractTransaction>;

    whitelistMintAndStake(
      to: string,
      numberOfTokens: BigNumberish,
      nonce: string,
      hash: BytesLike,
      signature: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

  _paidMutantBananaIds(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

  _redeemedBananaIds(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

  _redeemedKongIds(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

  _redeemedMutantBananaIds(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

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

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

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

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

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

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

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

  getOwnershipData(
    tokenId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<ERC721A.TokenOwnershipStructOutput>;

  hashTransaction(
    sender: string,
    amount: BigNumberish,
    nonce: string,
    overrides?: CallOverrides
  ): Promise<string>;

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

  isApprovedForAll(
    owner: string,
    operator: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  matchSigner(
    hash: BytesLike,
    signature: BytesLike,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

  mutantMint(
    to: string,
    numberOfTokens: BigNumberish,
    overrides?: PayableOverrides & { from?: string }
  ): Promise<ContractTransaction>;

  mutantMintAndStake(
    to: string,
    numberOfTokens: BigNumberish,
    overrides?: PayableOverrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

  onERC721Received(
    arg0: string,
    arg1: string,
    arg2: BigNumberish,
    arg3: BytesLike,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

  publicMint(
    to: string,
    numberOfTokens: BigNumberish,
    overrides?: PayableOverrides & { from?: string }
  ): Promise<ContractTransaction>;

  publicMintAndStake(
    to: string,
    numberOfTokens: BigNumberish,
    overrides?: PayableOverrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

  royaltyInfo(
    _tokenId: BigNumberish,
    _salePrice: BigNumberish,
    overrides?: CallOverrides
  ): Promise<[string, BigNumber]>;

  "safeTransferFrom(address,address,uint256)"(
    from: string,
    to: string,
    tokenId: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  "safeTransferFrom(address,address,uint256,bytes)"(
    from: string,
    to: string,
    tokenId: BigNumberish,
    _data: BytesLike,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

  setRoyaltyInfo(
    receiver: string,
    numerator: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

  stakedNfts(_owner: string, overrides?: CallOverrides): Promise<BigNumber[]>;

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

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

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

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

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

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

  tokenByIndex(
    index: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  tokenOfOwnerByIndex(
    owner: string,
    index: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

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

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

  whitelistMint(
    to: string,
    numberOfTokens: BigNumberish,
    nonce: string,
    hash: BytesLike,
    signature: BytesLike,
    overrides?: PayableOverrides & { from?: string }
  ): Promise<ContractTransaction>;

  whitelistMintAndStake(
    to: string,
    numberOfTokens: BigNumberish,
    nonce: string,
    hash: BytesLike,
    signature: BytesLike,
    overrides?: PayableOverrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

  callStatic: {
    _paidMutantBananaIds(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    _redeemedBananaIds(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    _redeemedKongIds(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    _redeemedMutantBananaIds(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    approve(
      to: string,
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    batchStakeNFT(
      _tokenIds: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    getOwnershipData(
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<ERC721A.TokenOwnershipStructOutput>;

    hashTransaction(
      sender: string,
      amount: BigNumberish,
      nonce: string,
      overrides?: CallOverrides
    ): Promise<string>;

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

    isApprovedForAll(
      owner: string,
      operator: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    matchSigner(
      hash: BytesLike,
      signature: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

    mutantMint(
      to: string,
      numberOfTokens: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    mutantMintAndStake(
      to: string,
      numberOfTokens: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

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

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

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

    publicMint(
      to: string,
      numberOfTokens: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    publicMintAndStake(
      to: string,
      numberOfTokens: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    royaltyInfo(
      _tokenId: BigNumberish,
      _salePrice: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string, BigNumber]>;

    "safeTransferFrom(address,address,uint256)"(
      from: string,
      to: string,
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "safeTransferFrom(address,address,uint256,bytes)"(
      from: string,
      to: string,
      tokenId: BigNumberish,
      _data: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    setApprovalForAll(
      operator: string,
      approved: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setBaseURI(baseURI_: string, overrides?: CallOverrides): Promise<void>;

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

    setHiddenURI(hiddenURI_: string, overrides?: CallOverrides): Promise<void>;

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

    setOwnersExplicit(
      quantity: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setRoyaltyInfo(
      receiver: string,
      numerator: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    stakeNFT(_tokenId: BigNumberish, overrides?: CallOverrides): Promise<void>;

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

    stakedNfts(_owner: string, overrides?: CallOverrides): Promise<BigNumber[]>;

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

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

    teamMint(
      to: string,
      numberOfTokens: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    tokenByIndex(
      index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    tokenOfOwnerByIndex(
      owner: string,
      index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    unstakeNFT(
      _tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    whitelistMint(
      to: string,
      numberOfTokens: BigNumberish,
      nonce: string,
      hash: BytesLike,
      signature: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    whitelistMintAndStake(
      to: string,
      numberOfTokens: BigNumberish,
      nonce: string,
      hash: BytesLike,
      signature: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

    withdraw(overrides?: CallOverrides): Promise<void>;
  };

  filters: {
    "Approval(address,address,uint256)"(
      owner?: string | null,
      approved?: string | null,
      tokenId?: BigNumberish | null
    ): ApprovalEventFilter;
    Approval(
      owner?: string | null,
      approved?: string | null,
      tokenId?: BigNumberish | null
    ): ApprovalEventFilter;

    "ApprovalForAll(address,address,bool)"(
      owner?: string | null,
      operator?: string | null,
      approved?: null
    ): ApprovalForAllEventFilter;
    ApprovalForAll(
      owner?: string | null,
      operator?: string | null,
      approved?: null
    ): ApprovalForAllEventFilter;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    hashTransaction(
      sender: string,
      amount: BigNumberish,
      nonce: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    matchSigner(
      hash: BytesLike,
      signature: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    mutantMint(
      to: string,
      numberOfTokens: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<BigNumber>;

    mutantMintAndStake(
      to: string,
      numberOfTokens: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

    onERC721Received(
      arg0: string,
      arg1: string,
      arg2: BigNumberish,
      arg3: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

    publicMint(
      to: string,
      numberOfTokens: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<BigNumber>;

    publicMintAndStake(
      to: string,
      numberOfTokens: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<BigNumber>;

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

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

    royaltyInfo(
      _tokenId: BigNumberish,
      _salePrice: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "safeTransferFrom(address,address,uint256)"(
      from: string,
      to: string,
      tokenId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    "safeTransferFrom(address,address,uint256,bytes)"(
      from: string,
      to: string,
      tokenId: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

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

    setRoyaltyInfo(
      receiver: string,
      numerator: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

    stakedNfts(_owner: string, overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

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

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

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

    tokenByIndex(
      index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    tokenOfOwnerByIndex(
      owner: string,
      index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

    whitelistMint(
      to: string,
      numberOfTokens: BigNumberish,
      nonce: string,
      hash: BytesLike,
      signature: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<BigNumber>;

    whitelistMintAndStake(
      to: string,
      numberOfTokens: BigNumberish,
      nonce: string,
      hash: BytesLike,
      signature: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    hashTransaction(
      sender: string,
      amount: BigNumberish,
      nonce: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    matchSigner(
      hash: BytesLike,
      signature: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    mutantMint(
      to: string,
      numberOfTokens: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    mutantMintAndStake(
      to: string,
      numberOfTokens: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

    onERC721Received(
      arg0: string,
      arg1: string,
      arg2: BigNumberish,
      arg3: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    publicMint(
      to: string,
      numberOfTokens: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    publicMintAndStake(
      to: string,
      numberOfTokens: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

    royaltyInfo(
      _tokenId: BigNumberish,
      _salePrice: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "safeTransferFrom(address,address,uint256)"(
      from: string,
      to: string,
      tokenId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    "safeTransferFrom(address,address,uint256,bytes)"(
      from: string,
      to: string,
      tokenId: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

    setRoyaltyInfo(
      receiver: string,
      numerator: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

    stakedNfts(
      _owner: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

    tokenByIndex(
      index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    tokenOfOwnerByIndex(
      owner: string,
      index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

    whitelistMint(
      to: string,
      numberOfTokens: BigNumberish,
      nonce: string,
      hash: BytesLike,
      signature: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    whitelistMintAndStake(
      to: string,
      numberOfTokens: BigNumberish,
      nonce: string,
      hash: BytesLike,
      signature: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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