/* 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";

export type CollectionSecurityPolicyStruct = {
  transferSecurityLevel: BigNumberish;
  operatorWhitelistId: BigNumberish;
  permittedContractReceiversId: BigNumberish;
};

export type CollectionSecurityPolicyStructOutput = [
  number,
  BigNumber,
  BigNumber
] & {
  transferSecurityLevel: number;
  operatorWhitelistId: BigNumber;
  permittedContractReceiversId: BigNumber;
};

export declare namespace IERC721A {
  export type TokenOwnershipStruct = {
    addr: string;
    startTimestamp: BigNumberish;
    burned: boolean;
    extraData: BigNumberish;
  };

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

export declare namespace IERC721M {
  export type MintStageInfoStruct = {
    price: BigNumberish;
    mintFee: BigNumberish;
    walletLimit: BigNumberish;
    merkleRoot: BytesLike;
    maxStageSupply: BigNumberish;
    startTimeUnixSeconds: BigNumberish;
    endTimeUnixSeconds: BigNumberish;
  };

  export type MintStageInfoStructOutput = [
    BigNumber,
    BigNumber,
    number,
    string,
    number,
    BigNumber,
    BigNumber
  ] & {
    price: BigNumber;
    mintFee: BigNumber;
    walletLimit: number;
    merkleRoot: string;
    maxStageSupply: number;
    startTimeUnixSeconds: BigNumber;
    endTimeUnixSeconds: BigNumber;
  };
}

export interface IKasuNFTsAbiInterface extends utils.Interface {
  functions: {
    "DEFAULT_OPERATOR_WHITELIST_ID()": FunctionFragment;
    "DEFAULT_TRANSFER_SECURITY_LEVEL()": FunctionFragment;
    "DEFAULT_TRANSFER_VALIDATOR()": FunctionFragment;
    "FUND_RECEIVER()": FunctionFragment;
    "approve(address,uint256)": FunctionFragment;
    "assertValidCosign(address,uint32,uint64,bytes)": FunctionFragment;
    "balanceOf(address)": FunctionFragment;
    "contractURI()": FunctionFragment;
    "crossmint(uint32,address,bytes32[],uint64,bytes)": FunctionFragment;
    "explicitOwnershipOf(uint256)": FunctionFragment;
    "explicitOwnershipsOf(uint256[])": FunctionFragment;
    "getActiveStageFromTimestamp(uint64)": FunctionFragment;
    "getApproved(uint256)": FunctionFragment;
    "getCosignDigest(address,uint32,uint64)": FunctionFragment;
    "getCosignNonce(address)": FunctionFragment;
    "getGlobalWalletLimit()": FunctionFragment;
    "getMaxMintableSupply()": FunctionFragment;
    "getMintCurrency()": FunctionFragment;
    "getMintable()": FunctionFragment;
    "getNumberStages()": FunctionFragment;
    "getPermittedContractReceivers()": FunctionFragment;
    "getSecurityPolicy()": FunctionFragment;
    "getStageInfo(uint256)": FunctionFragment;
    "getTransferValidator()": FunctionFragment;
    "getWhitelistedOperators()": FunctionFragment;
    "isApprovedForAll(address,address)": FunctionFragment;
    "isContractReceiverPermitted(address)": FunctionFragment;
    "isOperatorWhitelisted(address)": FunctionFragment;
    "isTransferAllowed(address,address,address)": FunctionFragment;
    "mint(uint32,bytes32[],uint64,bytes)": FunctionFragment;
    "mintWithLimit(uint32,uint32,bytes32[],uint64,bytes)": FunctionFragment;
    "name()": FunctionFragment;
    "owner()": FunctionFragment;
    "ownerMint(uint32,address)": FunctionFragment;
    "ownerOf(uint256)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "royaltyInfo(uint256,uint256)": FunctionFragment;
    "safeTransferFrom(address,address,uint256)": FunctionFragment;
    "safeTransferFrom(address,address,uint256,bytes)": FunctionFragment;
    "setApprovalForAll(address,bool)": FunctionFragment;
    "setBaseURI(string)": FunctionFragment;
    "setContractURI(string)": FunctionFragment;
    "setCosigner(address)": FunctionFragment;
    "setCrossmintAddress(address)": FunctionFragment;
    "setDefaultRoyalty(address,uint96)": FunctionFragment;
    "setGlobalWalletLimit(uint256)": FunctionFragment;
    "setMaxMintableSupply(uint256)": FunctionFragment;
    "setMintable(bool)": FunctionFragment;
    "setStages((uint80,uint80,uint32,bytes32,uint24,uint64,uint64)[])": FunctionFragment;
    "setTimestampExpirySeconds(uint64)": FunctionFragment;
    "setToCustomSecurityPolicy(uint8,uint120,uint120)": FunctionFragment;
    "setToCustomValidatorAndSecurityPolicy(address,uint8,uint120,uint120)": FunctionFragment;
    "setToDefaultSecurityPolicy()": FunctionFragment;
    "setTokenRoyalty(uint256,address,uint96)": FunctionFragment;
    "setTokenURISuffix(string)": FunctionFragment;
    "setTransferValidator(address)": FunctionFragment;
    "supportsInterface(bytes4)": FunctionFragment;
    "symbol()": FunctionFragment;
    "tokenURI(uint256)": FunctionFragment;
    "tokensOfOwner(address)": FunctionFragment;
    "tokensOfOwnerIn(address,uint256,uint256)": FunctionFragment;
    "totalMintedByAddress(address)": FunctionFragment;
    "totalSupply()": FunctionFragment;
    "transferFrom(address,address,uint256)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "withdraw()": FunctionFragment;
    "withdrawERC20()": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "DEFAULT_OPERATOR_WHITELIST_ID"
      | "DEFAULT_TRANSFER_SECURITY_LEVEL"
      | "DEFAULT_TRANSFER_VALIDATOR"
      | "FUND_RECEIVER"
      | "approve"
      | "assertValidCosign"
      | "balanceOf"
      | "contractURI"
      | "crossmint"
      | "explicitOwnershipOf"
      | "explicitOwnershipsOf"
      | "getActiveStageFromTimestamp"
      | "getApproved"
      | "getCosignDigest"
      | "getCosignNonce"
      | "getGlobalWalletLimit"
      | "getMaxMintableSupply"
      | "getMintCurrency"
      | "getMintable"
      | "getNumberStages"
      | "getPermittedContractReceivers"
      | "getSecurityPolicy"
      | "getStageInfo"
      | "getTransferValidator"
      | "getWhitelistedOperators"
      | "isApprovedForAll"
      | "isContractReceiverPermitted"
      | "isOperatorWhitelisted"
      | "isTransferAllowed"
      | "mint"
      | "mintWithLimit"
      | "name"
      | "owner"
      | "ownerMint"
      | "ownerOf"
      | "renounceOwnership"
      | "royaltyInfo"
      | "safeTransferFrom(address,address,uint256)"
      | "safeTransferFrom(address,address,uint256,bytes)"
      | "setApprovalForAll"
      | "setBaseURI"
      | "setContractURI"
      | "setCosigner"
      | "setCrossmintAddress"
      | "setDefaultRoyalty"
      | "setGlobalWalletLimit"
      | "setMaxMintableSupply"
      | "setMintable"
      | "setStages"
      | "setTimestampExpirySeconds"
      | "setToCustomSecurityPolicy"
      | "setToCustomValidatorAndSecurityPolicy"
      | "setToDefaultSecurityPolicy"
      | "setTokenRoyalty"
      | "setTokenURISuffix"
      | "setTransferValidator"
      | "supportsInterface"
      | "symbol"
      | "tokenURI"
      | "tokensOfOwner"
      | "tokensOfOwnerIn"
      | "totalMintedByAddress"
      | "totalSupply"
      | "transferFrom"
      | "transferOwnership"
      | "withdraw"
      | "withdrawERC20"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "DEFAULT_OPERATOR_WHITELIST_ID",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "DEFAULT_TRANSFER_SECURITY_LEVEL",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "DEFAULT_TRANSFER_VALIDATOR",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "FUND_RECEIVER",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "approve",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "assertValidCosign",
    values: [string, BigNumberish, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
  encodeFunctionData(
    functionFragment: "contractURI",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "crossmint",
    values: [BigNumberish, string, BytesLike[], BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "explicitOwnershipOf",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "explicitOwnershipsOf",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "getActiveStageFromTimestamp",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getApproved",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getCosignDigest",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getCosignNonce",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getGlobalWalletLimit",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getMaxMintableSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getMintCurrency",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getMintable",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getNumberStages",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getPermittedContractReceivers",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getSecurityPolicy",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getStageInfo",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getTransferValidator",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getWhitelistedOperators",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isApprovedForAll",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "isContractReceiverPermitted",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "isOperatorWhitelisted",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "isTransferAllowed",
    values: [string, string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "mint",
    values: [BigNumberish, BytesLike[], BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "mintWithLimit",
    values: [BigNumberish, BigNumberish, BytesLike[], BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "name", values?: undefined): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "ownerMint",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "ownerOf",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    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: "setContractURI",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "setCosigner", values: [string]): string;
  encodeFunctionData(
    functionFragment: "setCrossmintAddress",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setDefaultRoyalty",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setGlobalWalletLimit",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setMaxMintableSupply",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setMintable",
    values: [boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setStages",
    values: [IERC721M.MintStageInfoStruct[]]
  ): string;
  encodeFunctionData(
    functionFragment: "setTimestampExpirySeconds",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setToCustomSecurityPolicy",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setToCustomValidatorAndSecurityPolicy",
    values: [string, BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setToDefaultSecurityPolicy",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setTokenRoyalty",
    values: [BigNumberish, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setTokenURISuffix",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setTransferValidator",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "supportsInterface",
    values: [BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "tokenURI",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "tokensOfOwner",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "tokensOfOwnerIn",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "totalMintedByAddress",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "totalSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transferFrom",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "withdraw", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "withdrawERC20",
    values?: undefined
  ): string;

  decodeFunctionResult(
    functionFragment: "DEFAULT_OPERATOR_WHITELIST_ID",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "DEFAULT_TRANSFER_SECURITY_LEVEL",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "DEFAULT_TRANSFER_VALIDATOR",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "FUND_RECEIVER",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "assertValidCosign",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "contractURI",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "crossmint", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "explicitOwnershipOf",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "explicitOwnershipsOf",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getActiveStageFromTimestamp",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getApproved",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getCosignDigest",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getCosignNonce",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getGlobalWalletLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getMaxMintableSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getMintCurrency",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getMintable",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getNumberStages",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPermittedContractReceivers",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getSecurityPolicy",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getStageInfo",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTransferValidator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getWhitelistedOperators",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isApprovedForAll",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isContractReceiverPermitted",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isOperatorWhitelisted",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isTransferAllowed",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "mintWithLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "ownerMint", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "ownerOf", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    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: "setContractURI",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setCosigner",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setCrossmintAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDefaultRoyalty",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setGlobalWalletLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMaxMintableSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMintable",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setStages", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setTimestampExpirySeconds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setToCustomSecurityPolicy",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setToCustomValidatorAndSecurityPolicy",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setToDefaultSecurityPolicy",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTokenRoyalty",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTokenURISuffix",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTransferValidator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "supportsInterface",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "tokenURI", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "tokensOfOwner",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "tokensOfOwnerIn",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalMintedByAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "withdrawERC20",
    data: BytesLike
  ): Result;

  events: {
    "Approval(address,address,uint256)": EventFragment;
    "ApprovalForAll(address,address,bool)": EventFragment;
    "ConsecutiveTransfer(uint256,uint256,address,address)": EventFragment;
    "DefaultRoyaltySet(address,uint96)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "SetActiveStage(uint256)": EventFragment;
    "SetBaseURI(string)": EventFragment;
    "SetCosigner(address)": EventFragment;
    "SetCrossmintAddress(address)": EventFragment;
    "SetGlobalWalletLimit(uint256)": EventFragment;
    "SetMaxMintableSupply(uint256)": EventFragment;
    "SetMintCurrency(address)": EventFragment;
    "SetMintable(bool)": EventFragment;
    "SetTimestampExpirySeconds(uint64)": EventFragment;
    "TokenRoyaltySet(uint256,address,uint96)": EventFragment;
    "Transfer(address,address,uint256)": EventFragment;
    "TransferValidatorUpdated(address,address)": EventFragment;
    "UpdateStage(uint256,uint80,uint80,uint32,bytes32,uint24,uint64,uint64)": EventFragment;
    "Withdraw(uint256)": EventFragment;
    "WithdrawERC20(address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ApprovalForAll"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ConsecutiveTransfer"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DefaultRoyaltySet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetActiveStage"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetBaseURI"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetCosigner"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetCrossmintAddress"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetGlobalWalletLimit"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetMaxMintableSupply"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetMintCurrency"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetMintable"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetTimestampExpirySeconds"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokenRoyaltySet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TransferValidatorUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UpdateStage"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "WithdrawERC20"): 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 ConsecutiveTransferEventObject {
  fromTokenId: BigNumber;
  toTokenId: BigNumber;
  from: string;
  to: string;
}
export type ConsecutiveTransferEvent = TypedEvent<
  [BigNumber, BigNumber, string, string],
  ConsecutiveTransferEventObject
>;

export type ConsecutiveTransferEventFilter =
  TypedEventFilter<ConsecutiveTransferEvent>;

export interface DefaultRoyaltySetEventObject {
  receiver: string;
  feeNumerator: BigNumber;
}
export type DefaultRoyaltySetEvent = TypedEvent<
  [string, BigNumber],
  DefaultRoyaltySetEventObject
>;

export type DefaultRoyaltySetEventFilter =
  TypedEventFilter<DefaultRoyaltySetEvent>;

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

export type OwnershipTransferredEventFilter =
  TypedEventFilter<OwnershipTransferredEvent>;

export interface SetActiveStageEventObject {
  activeStage: BigNumber;
}
export type SetActiveStageEvent = TypedEvent<
  [BigNumber],
  SetActiveStageEventObject
>;

export type SetActiveStageEventFilter = TypedEventFilter<SetActiveStageEvent>;

export interface SetBaseURIEventObject {
  baseURI: string;
}
export type SetBaseURIEvent = TypedEvent<[string], SetBaseURIEventObject>;

export type SetBaseURIEventFilter = TypedEventFilter<SetBaseURIEvent>;

export interface SetCosignerEventObject {
  cosigner: string;
}
export type SetCosignerEvent = TypedEvent<[string], SetCosignerEventObject>;

export type SetCosignerEventFilter = TypedEventFilter<SetCosignerEvent>;

export interface SetCrossmintAddressEventObject {
  crossmintAddress: string;
}
export type SetCrossmintAddressEvent = TypedEvent<
  [string],
  SetCrossmintAddressEventObject
>;

export type SetCrossmintAddressEventFilter =
  TypedEventFilter<SetCrossmintAddressEvent>;

export interface SetGlobalWalletLimitEventObject {
  globalWalletLimit: BigNumber;
}
export type SetGlobalWalletLimitEvent = TypedEvent<
  [BigNumber],
  SetGlobalWalletLimitEventObject
>;

export type SetGlobalWalletLimitEventFilter =
  TypedEventFilter<SetGlobalWalletLimitEvent>;

export interface SetMaxMintableSupplyEventObject {
  maxMintableSupply: BigNumber;
}
export type SetMaxMintableSupplyEvent = TypedEvent<
  [BigNumber],
  SetMaxMintableSupplyEventObject
>;

export type SetMaxMintableSupplyEventFilter =
  TypedEventFilter<SetMaxMintableSupplyEvent>;

export interface SetMintCurrencyEventObject {
  mintCurrency: string;
}
export type SetMintCurrencyEvent = TypedEvent<
  [string],
  SetMintCurrencyEventObject
>;

export type SetMintCurrencyEventFilter = TypedEventFilter<SetMintCurrencyEvent>;

export interface SetMintableEventObject {
  mintable: boolean;
}
export type SetMintableEvent = TypedEvent<[boolean], SetMintableEventObject>;

export type SetMintableEventFilter = TypedEventFilter<SetMintableEvent>;

export interface SetTimestampExpirySecondsEventObject {
  expiry: BigNumber;
}
export type SetTimestampExpirySecondsEvent = TypedEvent<
  [BigNumber],
  SetTimestampExpirySecondsEventObject
>;

export type SetTimestampExpirySecondsEventFilter =
  TypedEventFilter<SetTimestampExpirySecondsEvent>;

export interface TokenRoyaltySetEventObject {
  tokenId: BigNumber;
  receiver: string;
  feeNumerator: BigNumber;
}
export type TokenRoyaltySetEvent = TypedEvent<
  [BigNumber, string, BigNumber],
  TokenRoyaltySetEventObject
>;

export type TokenRoyaltySetEventFilter = TypedEventFilter<TokenRoyaltySetEvent>;

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

export type TransferEventFilter = TypedEventFilter<TransferEvent>;

export interface TransferValidatorUpdatedEventObject {
  oldValidator: string;
  newValidator: string;
}
export type TransferValidatorUpdatedEvent = TypedEvent<
  [string, string],
  TransferValidatorUpdatedEventObject
>;

export type TransferValidatorUpdatedEventFilter =
  TypedEventFilter<TransferValidatorUpdatedEvent>;

export interface UpdateStageEventObject {
  stage: BigNumber;
  price: BigNumber;
  mintFee: BigNumber;
  walletLimit: number;
  merkleRoot: string;
  maxStageSupply: number;
  startTimeUnixSeconds: BigNumber;
  endTimeUnixSeconds: BigNumber;
}
export type UpdateStageEvent = TypedEvent<
  [
    BigNumber,
    BigNumber,
    BigNumber,
    number,
    string,
    number,
    BigNumber,
    BigNumber
  ],
  UpdateStageEventObject
>;

export type UpdateStageEventFilter = TypedEventFilter<UpdateStageEvent>;

export interface WithdrawEventObject {
  value: BigNumber;
}
export type WithdrawEvent = TypedEvent<[BigNumber], WithdrawEventObject>;

export type WithdrawEventFilter = TypedEventFilter<WithdrawEvent>;

export interface WithdrawERC20EventObject {
  mintCurrency: string;
  value: BigNumber;
}
export type WithdrawERC20Event = TypedEvent<
  [string, BigNumber],
  WithdrawERC20EventObject
>;

export type WithdrawERC20EventFilter = TypedEventFilter<WithdrawERC20Event>;

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

  interface: IKasuNFTsAbiInterface;

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

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

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

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

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

    assertValidCosign(
      minter: string,
      qty: BigNumberish,
      timestamp: BigNumberish,
      signature: BytesLike,
      overrides?: CallOverrides
    ): Promise<[void]>;

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

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

    crossmint(
      qty: BigNumberish,
      to: string,
      proof: BytesLike[],
      timestamp: BigNumberish,
      signature: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    explicitOwnershipsOf(
      tokenIds: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<[IERC721A.TokenOwnershipStructOutput[]]>;

    getActiveStageFromTimestamp(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    getCosignDigest(
      minter: string,
      qty: BigNumberish,
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getCosignNonce(
      minter: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

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

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

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

    getSecurityPolicy(
      overrides?: CallOverrides
    ): Promise<[CollectionSecurityPolicyStructOutput]>;

    getStageInfo(
      index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[IERC721M.MintStageInfoStructOutput, number, BigNumber]>;

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

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

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

    isContractReceiverPermitted(
      receiver: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

    isTransferAllowed(
      caller: string,
      from: string,
      to: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    mint(
      qty: BigNumberish,
      proof: BytesLike[],
      timestamp: BigNumberish,
      signature: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<ContractTransaction>;

    mintWithLimit(
      qty: BigNumberish,
      limit: BigNumberish,
      proof: BytesLike[],
      timestamp: BigNumberish,
      signature: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    setStages(
      newStages: IERC721M.MintStageInfoStruct[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    setToCustomSecurityPolicy(
      level: BigNumberish,
      operatorWhitelistId: BigNumberish,
      permittedContractReceiversAllowlistId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    setToCustomValidatorAndSecurityPolicy(
      validator: string,
      level: BigNumberish,
      operatorWhitelistId: BigNumberish,
      permittedContractReceiversAllowlistId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

    tokensOfOwnerIn(
      owner: string,
      start: BigNumberish,
      stop: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber[]]>;

    totalMintedByAddress(
      a: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

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

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

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

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

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

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

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

  assertValidCosign(
    minter: string,
    qty: BigNumberish,
    timestamp: BigNumberish,
    signature: BytesLike,
    overrides?: CallOverrides
  ): Promise<void>;

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

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

  crossmint(
    qty: BigNumberish,
    to: string,
    proof: BytesLike[],
    timestamp: BigNumberish,
    signature: BytesLike,
    overrides?: PayableOverrides & { from?: string }
  ): Promise<ContractTransaction>;

  explicitOwnershipOf(
    tokenId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<IERC721A.TokenOwnershipStructOutput>;

  explicitOwnershipsOf(
    tokenIds: BigNumberish[],
    overrides?: CallOverrides
  ): Promise<IERC721A.TokenOwnershipStructOutput[]>;

  getActiveStageFromTimestamp(
    timestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  getCosignDigest(
    minter: string,
    qty: BigNumberish,
    timestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  getCosignNonce(minter: string, overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

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

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

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

  getSecurityPolicy(
    overrides?: CallOverrides
  ): Promise<CollectionSecurityPolicyStructOutput>;

  getStageInfo(
    index: BigNumberish,
    overrides?: CallOverrides
  ): Promise<[IERC721M.MintStageInfoStructOutput, number, BigNumber]>;

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

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

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

  isContractReceiverPermitted(
    receiver: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

  isTransferAllowed(
    caller: string,
    from: string,
    to: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  mint(
    qty: BigNumberish,
    proof: BytesLike[],
    timestamp: BigNumberish,
    signature: BytesLike,
    overrides?: PayableOverrides & { from?: string }
  ): Promise<ContractTransaction>;

  mintWithLimit(
    qty: BigNumberish,
    limit: BigNumberish,
    proof: BytesLike[],
    timestamp: BigNumberish,
    signature: BytesLike,
    overrides?: PayableOverrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  setStages(
    newStages: IERC721M.MintStageInfoStruct[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  setToCustomSecurityPolicy(
    level: BigNumberish,
    operatorWhitelistId: BigNumberish,
    permittedContractReceiversAllowlistId: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  setToCustomValidatorAndSecurityPolicy(
    validator: string,
    level: BigNumberish,
    operatorWhitelistId: BigNumberish,
    permittedContractReceiversAllowlistId: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

  tokensOfOwnerIn(
    owner: string,
    start: BigNumberish,
    stop: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber[]>;

  totalMintedByAddress(
    a: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

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

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

  callStatic: {
    DEFAULT_OPERATOR_WHITELIST_ID(
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    assertValidCosign(
      minter: string,
      qty: BigNumberish,
      timestamp: BigNumberish,
      signature: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    crossmint(
      qty: BigNumberish,
      to: string,
      proof: BytesLike[],
      timestamp: BigNumberish,
      signature: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    explicitOwnershipOf(
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<IERC721A.TokenOwnershipStructOutput>;

    explicitOwnershipsOf(
      tokenIds: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<IERC721A.TokenOwnershipStructOutput[]>;

    getActiveStageFromTimestamp(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getCosignDigest(
      minter: string,
      qty: BigNumberish,
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    getCosignNonce(
      minter: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

    getSecurityPolicy(
      overrides?: CallOverrides
    ): Promise<CollectionSecurityPolicyStructOutput>;

    getStageInfo(
      index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[IERC721M.MintStageInfoStructOutput, number, BigNumber]>;

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

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

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

    isContractReceiverPermitted(
      receiver: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    isTransferAllowed(
      caller: string,
      from: string,
      to: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    mint(
      qty: BigNumberish,
      proof: BytesLike[],
      timestamp: BigNumberish,
      signature: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    mintWithLimit(
      qty: BigNumberish,
      limit: BigNumberish,
      proof: BytesLike[],
      timestamp: BigNumberish,
      signature: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    ownerMint(
      qty: BigNumberish,
      to: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    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>;

    setContractURI(uri: string, overrides?: CallOverrides): Promise<void>;

    setCosigner(cosigner: string, overrides?: CallOverrides): Promise<void>;

    setCrossmintAddress(
      crossmintAddress: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setDefaultRoyalty(
      receiver: string,
      feeNumerator: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setGlobalWalletLimit(
      globalWalletLimit: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setMaxMintableSupply(
      maxMintableSupply: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setMintable(mintable: boolean, overrides?: CallOverrides): Promise<void>;

    setStages(
      newStages: IERC721M.MintStageInfoStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

    setTimestampExpirySeconds(
      expiry: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setToCustomSecurityPolicy(
      level: BigNumberish,
      operatorWhitelistId: BigNumberish,
      permittedContractReceiversAllowlistId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setToCustomValidatorAndSecurityPolicy(
      validator: string,
      level: BigNumberish,
      operatorWhitelistId: BigNumberish,
      permittedContractReceiversAllowlistId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    setTokenRoyalty(
      tokenId: BigNumberish,
      receiver: string,
      feeNumerator: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setTokenURISuffix(suffix: string, overrides?: CallOverrides): Promise<void>;

    setTransferValidator(
      transferValidator_: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    tokensOfOwnerIn(
      owner: string,
      start: BigNumberish,
      stop: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

    totalMintedByAddress(
      a: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    withdrawERC20(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;

    "ConsecutiveTransfer(uint256,uint256,address,address)"(
      fromTokenId?: BigNumberish | null,
      toTokenId?: null,
      from?: string | null,
      to?: string | null
    ): ConsecutiveTransferEventFilter;
    ConsecutiveTransfer(
      fromTokenId?: BigNumberish | null,
      toTokenId?: null,
      from?: string | null,
      to?: string | null
    ): ConsecutiveTransferEventFilter;

    "DefaultRoyaltySet(address,uint96)"(
      receiver?: string | null,
      feeNumerator?: null
    ): DefaultRoyaltySetEventFilter;
    DefaultRoyaltySet(
      receiver?: string | null,
      feeNumerator?: null
    ): DefaultRoyaltySetEventFilter;

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

    "SetActiveStage(uint256)"(activeStage?: null): SetActiveStageEventFilter;
    SetActiveStage(activeStage?: null): SetActiveStageEventFilter;

    "SetBaseURI(string)"(baseURI?: null): SetBaseURIEventFilter;
    SetBaseURI(baseURI?: null): SetBaseURIEventFilter;

    "SetCosigner(address)"(cosigner?: null): SetCosignerEventFilter;
    SetCosigner(cosigner?: null): SetCosignerEventFilter;

    "SetCrossmintAddress(address)"(
      crossmintAddress?: null
    ): SetCrossmintAddressEventFilter;
    SetCrossmintAddress(
      crossmintAddress?: null
    ): SetCrossmintAddressEventFilter;

    "SetGlobalWalletLimit(uint256)"(
      globalWalletLimit?: null
    ): SetGlobalWalletLimitEventFilter;
    SetGlobalWalletLimit(
      globalWalletLimit?: null
    ): SetGlobalWalletLimitEventFilter;

    "SetMaxMintableSupply(uint256)"(
      maxMintableSupply?: null
    ): SetMaxMintableSupplyEventFilter;
    SetMaxMintableSupply(
      maxMintableSupply?: null
    ): SetMaxMintableSupplyEventFilter;

    "SetMintCurrency(address)"(mintCurrency?: null): SetMintCurrencyEventFilter;
    SetMintCurrency(mintCurrency?: null): SetMintCurrencyEventFilter;

    "SetMintable(bool)"(mintable?: null): SetMintableEventFilter;
    SetMintable(mintable?: null): SetMintableEventFilter;

    "SetTimestampExpirySeconds(uint64)"(
      expiry?: null
    ): SetTimestampExpirySecondsEventFilter;
    SetTimestampExpirySeconds(
      expiry?: null
    ): SetTimestampExpirySecondsEventFilter;

    "TokenRoyaltySet(uint256,address,uint96)"(
      tokenId?: BigNumberish | null,
      receiver?: string | null,
      feeNumerator?: null
    ): TokenRoyaltySetEventFilter;
    TokenRoyaltySet(
      tokenId?: BigNumberish | null,
      receiver?: string | null,
      feeNumerator?: null
    ): TokenRoyaltySetEventFilter;

    "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;

    "TransferValidatorUpdated(address,address)"(
      oldValidator?: null,
      newValidator?: null
    ): TransferValidatorUpdatedEventFilter;
    TransferValidatorUpdated(
      oldValidator?: null,
      newValidator?: null
    ): TransferValidatorUpdatedEventFilter;

    "UpdateStage(uint256,uint80,uint80,uint32,bytes32,uint24,uint64,uint64)"(
      stage?: null,
      price?: null,
      mintFee?: null,
      walletLimit?: null,
      merkleRoot?: null,
      maxStageSupply?: null,
      startTimeUnixSeconds?: null,
      endTimeUnixSeconds?: null
    ): UpdateStageEventFilter;
    UpdateStage(
      stage?: null,
      price?: null,
      mintFee?: null,
      walletLimit?: null,
      merkleRoot?: null,
      maxStageSupply?: null,
      startTimeUnixSeconds?: null,
      endTimeUnixSeconds?: null
    ): UpdateStageEventFilter;

    "Withdraw(uint256)"(value?: null): WithdrawEventFilter;
    Withdraw(value?: null): WithdrawEventFilter;

    "WithdrawERC20(address,uint256)"(
      mintCurrency?: null,
      value?: null
    ): WithdrawERC20EventFilter;
    WithdrawERC20(mintCurrency?: null, value?: null): WithdrawERC20EventFilter;
  };

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

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

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

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

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

    assertValidCosign(
      minter: string,
      qty: BigNumberish,
      timestamp: BigNumberish,
      signature: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    crossmint(
      qty: BigNumberish,
      to: string,
      proof: BytesLike[],
      timestamp: BigNumberish,
      signature: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<BigNumber>;

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

    explicitOwnershipsOf(
      tokenIds: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getActiveStageFromTimestamp(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getCosignDigest(
      minter: string,
      qty: BigNumberish,
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getCosignNonce(
      minter: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

    isContractReceiverPermitted(
      receiver: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    isTransferAllowed(
      caller: string,
      from: string,
      to: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    mint(
      qty: BigNumberish,
      proof: BytesLike[],
      timestamp: BigNumberish,
      signature: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<BigNumber>;

    mintWithLimit(
      qty: BigNumberish,
      limit: BigNumberish,
      proof: BytesLike[],
      timestamp: BigNumberish,
      signature: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    setStages(
      newStages: IERC721M.MintStageInfoStruct[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    setToCustomSecurityPolicy(
      level: BigNumberish,
      operatorWhitelistId: BigNumberish,
      permittedContractReceiversAllowlistId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setToCustomValidatorAndSecurityPolicy(
      validator: string,
      level: BigNumberish,
      operatorWhitelistId: BigNumberish,
      permittedContractReceiversAllowlistId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

    tokensOfOwnerIn(
      owner: string,
      start: BigNumberish,
      stop: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    totalMintedByAddress(
      a: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

    assertValidCosign(
      minter: string,
      qty: BigNumberish,
      timestamp: BigNumberish,
      signature: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    crossmint(
      qty: BigNumberish,
      to: string,
      proof: BytesLike[],
      timestamp: BigNumberish,
      signature: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    explicitOwnershipsOf(
      tokenIds: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getActiveStageFromTimestamp(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    getCosignDigest(
      minter: string,
      qty: BigNumberish,
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getCosignNonce(
      minter: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

    isContractReceiverPermitted(
      receiver: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    isTransferAllowed(
      caller: string,
      from: string,
      to: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    mint(
      qty: BigNumberish,
      proof: BytesLike[],
      timestamp: BigNumberish,
      signature: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    mintWithLimit(
      qty: BigNumberish,
      limit: BigNumberish,
      proof: BytesLike[],
      timestamp: BigNumberish,
      signature: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    setStages(
      newStages: IERC721M.MintStageInfoStruct[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    setToCustomSecurityPolicy(
      level: BigNumberish,
      operatorWhitelistId: BigNumberish,
      permittedContractReceiversAllowlistId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    setToCustomValidatorAndSecurityPolicy(
      validator: string,
      level: BigNumberish,
      operatorWhitelistId: BigNumberish,
      permittedContractReceiversAllowlistId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

    tokensOfOwnerIn(
      owner: string,
      start: BigNumberish,
      stop: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    totalMintedByAddress(
      a: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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