/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import type {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  PayableOverrides,
  PopulatedTransaction,
  Signer,
  utils,
} from "ethers";
import type {
  FunctionFragment,
  Result,
  EventFragment,
} from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type {
  TypedEventFilter,
  TypedEvent,
  TypedListener,
  OnEvent,
} from "./common.js";

export interface IdolMarketplaceInterface extends utils.Interface {
  functions: {
    "ROYALTY_BPS()": FunctionFragment;
    "acceptBidForGod(uint256,uint256)": FunctionFragment;
    "addExtraReward(address)": FunctionFragment;
    "buyGod(uint256)": FunctionFragment;
    "claimEthRewards(address)": FunctionFragment;
    "claimExtraRewards(address)": FunctionFragment;
    "clearExtraRewards()": FunctionFragment;
    "cumulativeETH()": FunctionFragment;
    "decreaseVirtueStake(uint256)": FunctionFragment;
    "distributeRewards()": FunctionFragment;
    "enterBidForGod(uint256)": FunctionFragment;
    "extraRewards(uint256)": FunctionFragment;
    "extraRewardsLength()": FunctionFragment;
    "getPendingETHGain(address)": FunctionFragment;
    "getTotalVirtueStake()": FunctionFragment;
    "getUserVirtueStake(address)": FunctionFragment;
    "godBids(uint256)": FunctionFragment;
    "godListings(uint256)": FunctionFragment;
    "idolMain()": FunctionFragment;
    "increaseVirtueStake(uint256)": FunctionFragment;
    "mintContractAddress()": FunctionFragment;
    "owner()": FunctionFragment;
    "pendingWithdrawals(address)": FunctionFragment;
    "postGodListing(uint256,uint256)": FunctionFragment;
    "postGodListingForAddress(uint256,uint256,address)": FunctionFragment;
    "removeGodListing(uint256)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "setVirtueTokenAddr(address)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "virtueToken()": FunctionFragment;
    "withdrawBidForGod(uint256)": FunctionFragment;
    "withdrawPendingFunds()": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "ROYALTY_BPS"
      | "acceptBidForGod"
      | "addExtraReward"
      | "buyGod"
      | "claimEthRewards"
      | "claimExtraRewards"
      | "clearExtraRewards"
      | "cumulativeETH"
      | "decreaseVirtueStake"
      | "distributeRewards"
      | "enterBidForGod"
      | "extraRewards"
      | "extraRewardsLength"
      | "getPendingETHGain"
      | "getTotalVirtueStake"
      | "getUserVirtueStake"
      | "godBids"
      | "godListings"
      | "idolMain"
      | "increaseVirtueStake"
      | "mintContractAddress"
      | "owner"
      | "pendingWithdrawals"
      | "postGodListing"
      | "postGodListingForAddress"
      | "removeGodListing"
      | "renounceOwnership"
      | "setVirtueTokenAddr"
      | "transferOwnership"
      | "virtueToken"
      | "withdrawBidForGod"
      | "withdrawPendingFunds"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "ROYALTY_BPS",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "acceptBidForGod",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "addExtraReward",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "buyGod",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "claimEthRewards",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "claimExtraRewards",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "clearExtraRewards",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "cumulativeETH",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "decreaseVirtueStake",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "distributeRewards",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "enterBidForGod",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "extraRewards",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "extraRewardsLength",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getPendingETHGain",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getTotalVirtueStake",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getUserVirtueStake",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "godBids",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "godListings",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "idolMain", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "increaseVirtueStake",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "mintContractAddress",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "pendingWithdrawals",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "postGodListing",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "postGodListingForAddress",
    values: [BigNumberish, BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "removeGodListing",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setVirtueTokenAddr",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "virtueToken",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawBidForGod",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawPendingFunds",
    values?: undefined
  ): string;

  decodeFunctionResult(
    functionFragment: "ROYALTY_BPS",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "acceptBidForGod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "addExtraReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "buyGod", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "claimEthRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimExtraRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "clearExtraRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "cumulativeETH",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "decreaseVirtueStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "distributeRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "enterBidForGod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "extraRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "extraRewardsLength",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPendingETHGain",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTotalVirtueStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getUserVirtueStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "godBids", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "godListings",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "idolMain", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "increaseVirtueStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "mintContractAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "pendingWithdrawals",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "postGodListing",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "postGodListingForAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "removeGodListing",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setVirtueTokenAddr",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "virtueToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawBidForGod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawPendingFunds",
    data: BytesLike
  ): Result;

  events: {
    "GodBidEntered(uint256,uint256,address)": EventFragment;
    "GodBidWithdrawn(uint256,uint256,address)": EventFragment;
    "GodBought(uint256,uint256,address,address,uint256)": EventFragment;
    "GodListed(uint256,uint256,address)": EventFragment;
    "GodUnlisted(uint256)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "GodBidEntered"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "GodBidWithdrawn"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "GodBought"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "GodListed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "GodUnlisted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
}

export interface GodBidEnteredEventObject {
  _godId: BigNumber;
  _value: BigNumber;
  _fromAddress: string;
}
export type GodBidEnteredEvent = TypedEvent<
  [BigNumber, BigNumber, string],
  GodBidEnteredEventObject
>;

export type GodBidEnteredEventFilter = TypedEventFilter<GodBidEnteredEvent>;

export interface GodBidWithdrawnEventObject {
  _godId: BigNumber;
  _value: BigNumber;
  _fromAddress: string;
}
export type GodBidWithdrawnEvent = TypedEvent<
  [BigNumber, BigNumber, string],
  GodBidWithdrawnEventObject
>;

export type GodBidWithdrawnEventFilter = TypedEventFilter<GodBidWithdrawnEvent>;

export interface GodBoughtEventObject {
  _godId: BigNumber;
  _value: BigNumber;
  _fromAddress: string;
  _toAddress: string;
  cumulativeETH: BigNumber;
}
export type GodBoughtEvent = TypedEvent<
  [BigNumber, BigNumber, string, string, BigNumber],
  GodBoughtEventObject
>;

export type GodBoughtEventFilter = TypedEventFilter<GodBoughtEvent>;

export interface GodListedEventObject {
  _godId: BigNumber;
  _minValue: BigNumber;
  _toAddress: string;
}
export type GodListedEvent = TypedEvent<
  [BigNumber, BigNumber, string],
  GodListedEventObject
>;

export type GodListedEventFilter = TypedEventFilter<GodListedEvent>;

export interface GodUnlistedEventObject {
  _godId: BigNumber;
}
export type GodUnlistedEvent = TypedEvent<[BigNumber], GodUnlistedEventObject>;

export type GodUnlistedEventFilter = TypedEventFilter<GodUnlistedEvent>;

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

export type OwnershipTransferredEventFilter =
  TypedEventFilter<OwnershipTransferredEvent>;

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

  interface: IdolMarketplaceInterface;

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

    acceptBidForGod(
      _godId: BigNumberish,
      _minPrice: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    buyGod(
      _godId: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

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

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

    distributeRewards(
      overrides?: PayableOverrides & { from?: string }
    ): Promise<ContractTransaction>;

    enterBidForGod(
      _godId: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

    getPendingETHGain(
      _user: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    getUserVirtueStake(
      _user: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    godBids(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string, BigNumber] & { bidder: string; value: BigNumber }>;

    godListings(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, string] & {
        seller: string;
        minValue: BigNumber;
        onlySellTo: string;
      }
    >;

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

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

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

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

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

    postGodListing(
      _godId: BigNumberish,
      _salePriceInWei: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    postGodListingForAddress(
      _godId: BigNumberish,
      _salePriceInWei: BigNumberish,
      _toAddress: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

  acceptBidForGod(
    _godId: BigNumberish,
    _minPrice: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  buyGod(
    _godId: BigNumberish,
    overrides?: PayableOverrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

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

  distributeRewards(
    overrides?: PayableOverrides & { from?: string }
  ): Promise<ContractTransaction>;

  enterBidForGod(
    _godId: BigNumberish,
    overrides?: PayableOverrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

  getPendingETHGain(
    _user: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  getUserVirtueStake(
    _user: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  godBids(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<[string, BigNumber] & { bidder: string; value: BigNumber }>;

  godListings(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [string, BigNumber, string] & {
      seller: string;
      minValue: BigNumber;
      onlySellTo: string;
    }
  >;

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

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

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

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

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

  postGodListing(
    _godId: BigNumberish,
    _salePriceInWei: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  postGodListingForAddress(
    _godId: BigNumberish,
    _salePriceInWei: BigNumberish,
    _toAddress: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

    acceptBidForGod(
      _godId: BigNumberish,
      _minPrice: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    addExtraReward(
      _rewardContractAddress: string,
      overrides?: CallOverrides
    ): Promise<void>;

    buyGod(_godId: BigNumberish, overrides?: CallOverrides): Promise<void>;

    claimEthRewards(_user: string, overrides?: CallOverrides): Promise<void>;

    claimExtraRewards(_user: string, overrides?: CallOverrides): Promise<void>;

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

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

    decreaseVirtueStake(
      _virtueTokenAmt: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    enterBidForGod(
      _godId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    getPendingETHGain(
      _user: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getUserVirtueStake(
      _user: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    godBids(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string, BigNumber] & { bidder: string; value: BigNumber }>;

    godListings(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, string] & {
        seller: string;
        minValue: BigNumber;
        onlySellTo: string;
      }
    >;

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

    increaseVirtueStake(
      _virtueTokenAmt: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    postGodListing(
      _godId: BigNumberish,
      _salePriceInWei: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    postGodListingForAddress(
      _godId: BigNumberish,
      _salePriceInWei: BigNumberish,
      _toAddress: string,
      overrides?: CallOverrides
    ): Promise<void>;

    removeGodListing(
      _godId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    setVirtueTokenAddr(
      _virtueTokenAddr: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    withdrawBidForGod(
      _godId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

  filters: {
    "GodBidEntered(uint256,uint256,address)"(
      _godId?: BigNumberish | null,
      _value?: null,
      _fromAddress?: string | null
    ): GodBidEnteredEventFilter;
    GodBidEntered(
      _godId?: BigNumberish | null,
      _value?: null,
      _fromAddress?: string | null
    ): GodBidEnteredEventFilter;

    "GodBidWithdrawn(uint256,uint256,address)"(
      _godId?: BigNumberish | null,
      _value?: null,
      _fromAddress?: string | null
    ): GodBidWithdrawnEventFilter;
    GodBidWithdrawn(
      _godId?: BigNumberish | null,
      _value?: null,
      _fromAddress?: string | null
    ): GodBidWithdrawnEventFilter;

    "GodBought(uint256,uint256,address,address,uint256)"(
      _godId?: BigNumberish | null,
      _value?: null,
      _fromAddress?: string | null,
      _toAddress?: string | null,
      cumulativeETH?: null
    ): GodBoughtEventFilter;
    GodBought(
      _godId?: BigNumberish | null,
      _value?: null,
      _fromAddress?: string | null,
      _toAddress?: string | null,
      cumulativeETH?: null
    ): GodBoughtEventFilter;

    "GodListed(uint256,uint256,address)"(
      _godId?: BigNumberish | null,
      _minValue?: null,
      _toAddress?: string | null
    ): GodListedEventFilter;
    GodListed(
      _godId?: BigNumberish | null,
      _minValue?: null,
      _toAddress?: string | null
    ): GodListedEventFilter;

    "GodUnlisted(uint256)"(
      _godId?: BigNumberish | null
    ): GodUnlistedEventFilter;
    GodUnlisted(_godId?: BigNumberish | null): GodUnlistedEventFilter;

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

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

    acceptBidForGod(
      _godId: BigNumberish,
      _minPrice: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    buyGod(
      _godId: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

    distributeRewards(
      overrides?: PayableOverrides & { from?: string }
    ): Promise<BigNumber>;

    enterBidForGod(
      _godId: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<BigNumber>;

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

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

    getPendingETHGain(
      _user: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getUserVirtueStake(
      _user: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    postGodListing(
      _godId: BigNumberish,
      _salePriceInWei: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    postGodListingForAddress(
      _godId: BigNumberish,
      _salePriceInWei: BigNumberish,
      _toAddress: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

    acceptBidForGod(
      _godId: BigNumberish,
      _minPrice: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    buyGod(
      _godId: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

    distributeRewards(
      overrides?: PayableOverrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    enterBidForGod(
      _godId: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

    getPendingETHGain(
      _user: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    getUserVirtueStake(
      _user: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

    postGodListing(
      _godId: BigNumberish,
      _salePriceInWei: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    postGodListingForAddress(
      _godId: BigNumberish,
      _salePriceInWei: BigNumberish,
      _toAddress: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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