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 {
    type TokenOwnershipStruct = {
        addr: string;
        startTimestamp: BigNumberish;
    };
    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>;
    };
}