/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  Contract,
  ContractTransaction,
  Overrides,
  PayableOverrides,
  CallOverrides,
} from "ethers";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
import { TypedEventFilter, TypedEvent, TypedListener } from "./commons";

interface TurboFilInterface extends ethers.utils.Interface {
  functions: {
    "DEFAULT_ADMIN_ROLE()": FunctionFragment;
    "MAINTAIN_ROLE()": FunctionFragment;
    "SECTOR_ROLE()": FunctionFragment;
    "SEED_ROLE()": FunctionFragment;
    "VERIFY_ROLE()": FunctionFragment;
    "depositRequirement()": FunctionFragment;
    "getRoleAdmin(bytes32)": FunctionFragment;
    "grantRole(bytes32,address)": FunctionFragment;
    "hasRole(bytes32,address)": FunctionFragment;
    "hasVerifyRole(address)": FunctionFragment;
    "lockPeriod()": FunctionFragment;
    "renounceRole(bytes32,address)": FunctionFragment;
    "revokeRole(bytes32,address)": FunctionFragment;
    "sectorAtIndex(uint256)": FunctionFragment;
    "sectorReward()": FunctionFragment;
    "sectorWithAfid(bytes28)": FunctionFragment;
    "seedReward()": FunctionFragment;
    "seedUsed(bytes28)": FunctionFragment;
    "setLockPeriod(uint256)": FunctionFragment;
    "setSectorReward(uint256)": FunctionFragment;
    "setSeedReward(uint256)": FunctionFragment;
    "setSubmitProofTimeout(uint256)": FunctionFragment;
    "setVerifyProofTimeout(uint256)": FunctionFragment;
    "setVerifyReward(uint256)": FunctionFragment;
    "setVerifyThreshold(uint256)": FunctionFragment;
    "submitProofTimeout()": FunctionFragment;
    "submitSector(address,bytes28)": FunctionFragment;
    "submitSeed(bytes28)": FunctionFragment;
    "supportsInterface(bytes4)": FunctionFragment;
    "verifyProofTimeout()": FunctionFragment;
    "verifyReward()": FunctionFragment;
    "verifyThreshold()": FunctionFragment;
    "withdraw()": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "DEFAULT_ADMIN_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MAINTAIN_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "SECTOR_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "SEED_ROLE", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "VERIFY_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "depositRequirement",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getRoleAdmin",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "grantRole",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "hasRole",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "hasVerifyRole",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "lockPeriod",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "renounceRole",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "revokeRole",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "sectorAtIndex",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "sectorReward",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "sectorWithAfid",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "seedReward",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "seedUsed", values: [BytesLike]): string;
  encodeFunctionData(
    functionFragment: "setLockPeriod",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setSectorReward",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setSeedReward",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setSubmitProofTimeout",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setVerifyProofTimeout",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setVerifyReward",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setVerifyThreshold",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "submitProofTimeout",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "submitSector",
    values: [string, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "submitSeed",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "supportsInterface",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "verifyProofTimeout",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "verifyReward",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "verifyThreshold",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "withdraw", values?: undefined): string;

  decodeFunctionResult(
    functionFragment: "DEFAULT_ADMIN_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MAINTAIN_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "SECTOR_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "SEED_ROLE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "VERIFY_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "depositRequirement",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRoleAdmin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "grantRole", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "hasVerifyRole",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "lockPeriod", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "renounceRole",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "sectorAtIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "sectorReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "sectorWithAfid",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "seedReward", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "seedUsed", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setLockPeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setSectorReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setSeedReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setSubmitProofTimeout",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setVerifyProofTimeout",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setVerifyReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setVerifyThreshold",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "submitProofTimeout",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "submitSector",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "submitSeed", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "supportsInterface",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "verifyProofTimeout",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "verifyReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "verifyThreshold",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;

  events: {
    "RoleAdminChanged(bytes32,bytes32,bytes32)": EventFragment;
    "RoleGranted(bytes32,address,address)": EventFragment;
    "RoleRevoked(bytes32,address,address)": EventFragment;
    "SectorSubmission(address,bytes28,address)": EventFragment;
    "VerificationTask(bytes28,bytes28,address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "RoleAdminChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RoleGranted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RoleRevoked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SectorSubmission"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "VerificationTask"): EventFragment;
}

export class TurboFil extends Contract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  listeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter?: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): Array<TypedListener<EventArgsArray, EventArgsObject>>;
  off<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  on<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  once<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeListener<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeAllListeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): this;

  listeners(eventName?: string): Array<Listener>;
  off(eventName: string, listener: Listener): this;
  on(eventName: string, listener: Listener): this;
  once(eventName: string, listener: Listener): this;
  removeListener(eventName: string, listener: Listener): this;
  removeAllListeners(eventName?: string): this;

  queryFilter<EventArgsArray extends Array<any>, EventArgsObject>(
    event: TypedEventFilter<EventArgsArray, EventArgsObject>,
    fromBlockOrBlockhash?: string | number | undefined,
    toBlock?: string | number | undefined
  ): Promise<Array<TypedEvent<EventArgsArray & EventArgsObject>>>;

  interface: TurboFilInterface;

  functions: {
    DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<[string]>;

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

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

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

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

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

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

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

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

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

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

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

    getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<[string]>;

    "getRoleAdmin(bytes32)"(
      role: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string]>;

    grantRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "grantRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    hasRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    "hasRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    hasVerifyRole(addr_: string, overrides?: CallOverrides): Promise<[boolean]>;

    "hasVerifyRole(address)"(
      addr_: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

    renounceRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "renounceRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    revokeRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "revokeRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    sectorAtIndex(
      index_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

    "sectorAtIndex(uint256)"(
      index_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

    sectorWithAfid(
      afid_: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string]>;

    "sectorWithAfid(bytes28)"(
      afid_: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

    seedUsed(seed_: BytesLike, overrides?: CallOverrides): Promise<[boolean]>;

    "seedUsed(bytes28)"(
      seed_: BytesLike,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    setLockPeriod(
      lockPeriod_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "setLockPeriod(uint256)"(
      lockPeriod_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setSectorReward(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "setSectorReward(uint256)"(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setSeedReward(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "setSeedReward(uint256)"(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setSubmitProofTimeout(
      timeout_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "setSubmitProofTimeout(uint256)"(
      timeout_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setVerifyProofTimeout(
      timeout_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "setVerifyProofTimeout(uint256)"(
      timeout_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setVerifyReward(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "setVerifyReward(uint256)"(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setVerifyThreshold(
      threshold_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "setVerifyThreshold(uint256)"(
      threshold_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    submitSector(
      owner_: string,
      afid_: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "submitSector(address,bytes28)"(
      owner_: string,
      afid_: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    submitSeed(
      seed_: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "submitSeed(bytes28)"(
      seed_: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

  "DEFAULT_ADMIN_ROLE()"(overrides?: CallOverrides): Promise<string>;

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

  "MAINTAIN_ROLE()"(overrides?: CallOverrides): Promise<string>;

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

  "SECTOR_ROLE()"(overrides?: CallOverrides): Promise<string>;

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

  "SEED_ROLE()"(overrides?: CallOverrides): Promise<string>;

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

  "VERIFY_ROLE()"(overrides?: CallOverrides): Promise<string>;

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

  "depositRequirement()"(overrides?: CallOverrides): Promise<BigNumber>;

  getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<string>;

  "getRoleAdmin(bytes32)"(
    role: BytesLike,
    overrides?: CallOverrides
  ): Promise<string>;

  grantRole(
    role: BytesLike,
    account: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "grantRole(bytes32,address)"(
    role: BytesLike,
    account: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  hasRole(
    role: BytesLike,
    account: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  "hasRole(bytes32,address)"(
    role: BytesLike,
    account: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  hasVerifyRole(addr_: string, overrides?: CallOverrides): Promise<boolean>;

  "hasVerifyRole(address)"(
    addr_: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

  "lockPeriod()"(overrides?: CallOverrides): Promise<BigNumber>;

  renounceRole(
    role: BytesLike,
    account: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "renounceRole(bytes32,address)"(
    role: BytesLike,
    account: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  revokeRole(
    role: BytesLike,
    account: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "revokeRole(bytes32,address)"(
    role: BytesLike,
    account: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  sectorAtIndex(
    index_: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  "sectorAtIndex(uint256)"(
    index_: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

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

  "sectorReward()"(overrides?: CallOverrides): Promise<BigNumber>;

  sectorWithAfid(afid_: BytesLike, overrides?: CallOverrides): Promise<string>;

  "sectorWithAfid(bytes28)"(
    afid_: BytesLike,
    overrides?: CallOverrides
  ): Promise<string>;

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

  "seedReward()"(overrides?: CallOverrides): Promise<BigNumber>;

  seedUsed(seed_: BytesLike, overrides?: CallOverrides): Promise<boolean>;

  "seedUsed(bytes28)"(
    seed_: BytesLike,
    overrides?: CallOverrides
  ): Promise<boolean>;

  setLockPeriod(
    lockPeriod_: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "setLockPeriod(uint256)"(
    lockPeriod_: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setSectorReward(
    reward_: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "setSectorReward(uint256)"(
    reward_: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setSeedReward(
    reward_: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "setSeedReward(uint256)"(
    reward_: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setSubmitProofTimeout(
    timeout_: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "setSubmitProofTimeout(uint256)"(
    timeout_: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setVerifyProofTimeout(
    timeout_: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "setVerifyProofTimeout(uint256)"(
    timeout_: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setVerifyReward(
    reward_: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "setVerifyReward(uint256)"(
    reward_: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setVerifyThreshold(
    threshold_: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "setVerifyThreshold(uint256)"(
    threshold_: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  "submitProofTimeout()"(overrides?: CallOverrides): Promise<BigNumber>;

  submitSector(
    owner_: string,
    afid_: BytesLike,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "submitSector(address,bytes28)"(
    owner_: string,
    afid_: BytesLike,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  submitSeed(
    seed_: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "submitSeed(bytes28)"(
    seed_: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

  "verifyProofTimeout()"(overrides?: CallOverrides): Promise<BigNumber>;

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

  "verifyReward()"(overrides?: CallOverrides): Promise<BigNumber>;

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

  "verifyThreshold()"(overrides?: CallOverrides): Promise<BigNumber>;

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

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

  callStatic: {
    DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;

    "DEFAULT_ADMIN_ROLE()"(overrides?: CallOverrides): Promise<string>;

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

    "MAINTAIN_ROLE()"(overrides?: CallOverrides): Promise<string>;

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

    "SECTOR_ROLE()"(overrides?: CallOverrides): Promise<string>;

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

    "SEED_ROLE()"(overrides?: CallOverrides): Promise<string>;

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

    "VERIFY_ROLE()"(overrides?: CallOverrides): Promise<string>;

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

    "depositRequirement()"(overrides?: CallOverrides): Promise<BigNumber>;

    getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<string>;

    "getRoleAdmin(bytes32)"(
      role: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

    grantRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "grantRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<void>;

    hasRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    "hasRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    hasVerifyRole(addr_: string, overrides?: CallOverrides): Promise<boolean>;

    "hasVerifyRole(address)"(
      addr_: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    "lockPeriod()"(overrides?: CallOverrides): Promise<BigNumber>;

    renounceRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "renounceRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<void>;

    revokeRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "revokeRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<void>;

    sectorAtIndex(
      index_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    "sectorAtIndex(uint256)"(
      index_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

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

    "sectorReward()"(overrides?: CallOverrides): Promise<BigNumber>;

    sectorWithAfid(
      afid_: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

    "sectorWithAfid(bytes28)"(
      afid_: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

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

    "seedReward()"(overrides?: CallOverrides): Promise<BigNumber>;

    seedUsed(seed_: BytesLike, overrides?: CallOverrides): Promise<boolean>;

    "seedUsed(bytes28)"(
      seed_: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

    setLockPeriod(
      lockPeriod_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "setLockPeriod(uint256)"(
      lockPeriod_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setSectorReward(
      reward_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "setSectorReward(uint256)"(
      reward_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setSeedReward(
      reward_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "setSeedReward(uint256)"(
      reward_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setSubmitProofTimeout(
      timeout_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "setSubmitProofTimeout(uint256)"(
      timeout_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setVerifyProofTimeout(
      timeout_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "setVerifyProofTimeout(uint256)"(
      timeout_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setVerifyReward(
      reward_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "setVerifyReward(uint256)"(
      reward_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setVerifyThreshold(
      threshold_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "setVerifyThreshold(uint256)"(
      threshold_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    "submitProofTimeout()"(overrides?: CallOverrides): Promise<BigNumber>;

    submitSector(
      owner_: string,
      afid_: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    "submitSector(address,bytes28)"(
      owner_: string,
      afid_: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    submitSeed(seed_: BytesLike, overrides?: CallOverrides): Promise<void>;

    "submitSeed(bytes28)"(
      seed_: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    "verifyProofTimeout()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "verifyReward()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "verifyThreshold()"(overrides?: CallOverrides): Promise<BigNumber>;

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

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

  filters: {
    RoleAdminChanged(
      role: BytesLike | null,
      previousAdminRole: BytesLike | null,
      newAdminRole: BytesLike | null
    ): TypedEventFilter<
      [string, string, string],
      { role: string; previousAdminRole: string; newAdminRole: string }
    >;

    RoleGranted(
      role: BytesLike | null,
      account: string | null,
      sender: string | null
    ): TypedEventFilter<
      [string, string, string],
      { role: string; account: string; sender: string }
    >;

    RoleRevoked(
      role: BytesLike | null,
      account: string | null,
      sender: string | null
    ): TypedEventFilter<
      [string, string, string],
      { role: string; account: string; sender: string }
    >;

    SectorSubmission(
      owner: null,
      afid: null,
      sector: null
    ): TypedEventFilter<
      [string, string, string],
      { owner: string; afid: string; sector: string }
    >;

    VerificationTask(
      sector_afid: BytesLike | null,
      seed: null,
      verification: null
    ): TypedEventFilter<
      [string, string, string],
      { sector_afid: string; seed: string; verification: string }
    >;
  };

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

    "DEFAULT_ADMIN_ROLE()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "MAINTAIN_ROLE()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "SECTOR_ROLE()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "SEED_ROLE()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "VERIFY_ROLE()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "depositRequirement()"(overrides?: CallOverrides): Promise<BigNumber>;

    getRoleAdmin(
      role: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getRoleAdmin(bytes32)"(
      role: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    grantRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "grantRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    hasRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "hasRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    hasVerifyRole(addr_: string, overrides?: CallOverrides): Promise<BigNumber>;

    "hasVerifyRole(address)"(
      addr_: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "lockPeriod()"(overrides?: CallOverrides): Promise<BigNumber>;

    renounceRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "renounceRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    revokeRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "revokeRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    sectorAtIndex(
      index_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "sectorAtIndex(uint256)"(
      index_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "sectorReward()"(overrides?: CallOverrides): Promise<BigNumber>;

    sectorWithAfid(
      afid_: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "sectorWithAfid(bytes28)"(
      afid_: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "seedReward()"(overrides?: CallOverrides): Promise<BigNumber>;

    seedUsed(seed_: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;

    "seedUsed(bytes28)"(
      seed_: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    setLockPeriod(
      lockPeriod_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "setLockPeriod(uint256)"(
      lockPeriod_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setSectorReward(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "setSectorReward(uint256)"(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setSeedReward(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "setSeedReward(uint256)"(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setSubmitProofTimeout(
      timeout_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "setSubmitProofTimeout(uint256)"(
      timeout_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setVerifyProofTimeout(
      timeout_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "setVerifyProofTimeout(uint256)"(
      timeout_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setVerifyReward(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "setVerifyReward(uint256)"(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setVerifyThreshold(
      threshold_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "setVerifyThreshold(uint256)"(
      threshold_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    "submitProofTimeout()"(overrides?: CallOverrides): Promise<BigNumber>;

    submitSector(
      owner_: string,
      afid_: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "submitSector(address,bytes28)"(
      owner_: string,
      afid_: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    submitSeed(
      seed_: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "submitSeed(bytes28)"(
      seed_: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

    "verifyProofTimeout()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "verifyReward()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "verifyThreshold()"(overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

    "DEFAULT_ADMIN_ROLE()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "MAINTAIN_ROLE()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "SECTOR_ROLE()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "SEED_ROLE()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "VERIFY_ROLE()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "depositRequirement()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getRoleAdmin(
      role: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getRoleAdmin(bytes32)"(
      role: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    grantRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "grantRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    hasRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "hasRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    hasVerifyRole(
      addr_: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "hasVerifyRole(address)"(
      addr_: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "lockPeriod()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    renounceRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "renounceRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    revokeRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "revokeRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    sectorAtIndex(
      index_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "sectorAtIndex(uint256)"(
      index_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "sectorReward()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    sectorWithAfid(
      afid_: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "sectorWithAfid(bytes28)"(
      afid_: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "seedReward()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    seedUsed(
      seed_: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "seedUsed(bytes28)"(
      seed_: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    setLockPeriod(
      lockPeriod_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "setLockPeriod(uint256)"(
      lockPeriod_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setSectorReward(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "setSectorReward(uint256)"(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setSeedReward(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "setSeedReward(uint256)"(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setSubmitProofTimeout(
      timeout_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "setSubmitProofTimeout(uint256)"(
      timeout_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setVerifyProofTimeout(
      timeout_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "setVerifyProofTimeout(uint256)"(
      timeout_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setVerifyReward(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "setVerifyReward(uint256)"(
      reward_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setVerifyThreshold(
      threshold_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "setVerifyThreshold(uint256)"(
      threshold_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    "submitProofTimeout()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    submitSector(
      owner_: string,
      afid_: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "submitSector(address,bytes28)"(
      owner_: string,
      afid_: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    submitSeed(
      seed_: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "submitSeed(bytes28)"(
      seed_: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

    "verifyProofTimeout()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "verifyReward()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "verifyThreshold()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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