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

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  BaseContract,
  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 IKeep3rV1Interface extends ethers.utils.Interface {
  functions: {
    "BASE()": FunctionFragment;
    "BOND()": FunctionFragment;
    "DELEGATION_TYPEHASH()": FunctionFragment;
    "DOMAINSEPARATOR()": FunctionFragment;
    "DOMAIN_TYPEHASH()": FunctionFragment;
    "ETH()": FunctionFragment;
    "FEE()": FunctionFragment;
    "KPRH()": FunctionFragment;
    "LIQUIDITYBOND()": FunctionFragment;
    "PERMIT_TYPEHASH()": FunctionFragment;
    "UNBOND()": FunctionFragment;
    "acceptGovernance()": FunctionFragment;
    "activate(address)": FunctionFragment;
    "addCredit(address,address,uint256)": FunctionFragment;
    "addCreditETH(address)": FunctionFragment;
    "addJob(address)": FunctionFragment;
    "addKPRCredit(address,uint256)": FunctionFragment;
    "addLiquidityToJob(address,address,uint256)": FunctionFragment;
    "addVotes(address,uint256)": FunctionFragment;
    "allowance(address,address)": FunctionFragment;
    "applyCreditToJob(address,address,address)": FunctionFragment;
    "approve(address,uint256)": FunctionFragment;
    "approveLiquidity(address)": FunctionFragment;
    "balanceOf(address)": FunctionFragment;
    "blacklist(address)": FunctionFragment;
    "bond(address,uint256)": FunctionFragment;
    "bondings(address,address)": FunctionFragment;
    "bonds(address,address)": FunctionFragment;
    "burn(uint256)": FunctionFragment;
    "canWithdrawAfter(address,address)": FunctionFragment;
    "checkpoints(address,uint32)": FunctionFragment;
    "credits(address,address)": FunctionFragment;
    "decimals()": FunctionFragment;
    "delegates(address)": FunctionFragment;
    "dispute(address)": FunctionFragment;
    "disputes(address)": FunctionFragment;
    "firstSeen(address)": FunctionFragment;
    "getCurrentVotes(address)": FunctionFragment;
    "getJobs()": FunctionFragment;
    "getKeepers()": FunctionFragment;
    "governance()": FunctionFragment;
    "isBondedKeeper(address,address,uint256,uint256,uint256)": FunctionFragment;
    "isKeeper(address)": FunctionFragment;
    "isMinKeeper(address,uint256,uint256,uint256)": FunctionFragment;
    "jobList(uint256)": FunctionFragment;
    "jobProposalDelay(address)": FunctionFragment;
    "jobs(address)": FunctionFragment;
    "keeperList(uint256)": FunctionFragment;
    "keepers(address)": FunctionFragment;
    "lastJob(address)": FunctionFragment;
    "liquidityAccepted(address)": FunctionFragment;
    "liquidityAmount(address,address,address)": FunctionFragment;
    "liquidityAmountsUnbonding(address,address,address)": FunctionFragment;
    "liquidityApplied(address,address,address)": FunctionFragment;
    "liquidityPairs(uint256)": FunctionFragment;
    "liquidityProvided(address,address,address)": FunctionFragment;
    "liquidityUnbonding(address,address,address)": FunctionFragment;
    "mint(uint256)": FunctionFragment;
    "name()": FunctionFragment;
    "nonces(address)": FunctionFragment;
    "numCheckpoints(address)": FunctionFragment;
    "pairs()": FunctionFragment;
    "pendingGovernance()": FunctionFragment;
    "pendingUnbonds(address,address)": FunctionFragment;
    "pendingbonds(address,address)": FunctionFragment;
    "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)": FunctionFragment;
    "receipt(address,address,uint256)": FunctionFragment;
    "receiptETH(address,uint256)": FunctionFragment;
    "removeJob(address)": FunctionFragment;
    "removeLiquidityFromJob(address,address)": FunctionFragment;
    "removeVotes(address,uint256)": FunctionFragment;
    "resolve(address)": FunctionFragment;
    "revoke(address)": FunctionFragment;
    "revokeLiquidity(address)": FunctionFragment;
    "setGovernance(address)": FunctionFragment;
    "setKeep3rHelper(address)": FunctionFragment;
    "slash(address,address,uint256)": FunctionFragment;
    "symbol()": FunctionFragment;
    "totalSupply()": FunctionFragment;
    "transfer(address,uint256)": FunctionFragment;
    "transferFrom(address,address,uint256)": FunctionFragment;
    "unbond(address,uint256)": FunctionFragment;
    "unbondLiquidityFromJob(address,address,uint256)": FunctionFragment;
    "votes(address)": FunctionFragment;
    "withdraw(address)": FunctionFragment;
    "workCompleted(address)": FunctionFragment;
    "worked(address)": FunctionFragment;
  };

  encodeFunctionData(functionFragment: "BASE", values?: undefined): string;
  encodeFunctionData(functionFragment: "BOND", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "DELEGATION_TYPEHASH",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "DOMAINSEPARATOR",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "DOMAIN_TYPEHASH",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "ETH", values?: undefined): string;
  encodeFunctionData(functionFragment: "FEE", values?: undefined): string;
  encodeFunctionData(functionFragment: "KPRH", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "LIQUIDITYBOND",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "PERMIT_TYPEHASH",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "UNBOND", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "acceptGovernance",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "activate", values: [string]): string;
  encodeFunctionData(
    functionFragment: "addCredit",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "addCreditETH",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "addJob", values: [string]): string;
  encodeFunctionData(
    functionFragment: "addKPRCredit",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "addLiquidityToJob",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "addVotes",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "allowance",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "applyCreditToJob",
    values: [string, string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "approve",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "approveLiquidity",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
  encodeFunctionData(functionFragment: "blacklist", values: [string]): string;
  encodeFunctionData(
    functionFragment: "bond",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "bondings",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "bonds",
    values: [string, string]
  ): string;
  encodeFunctionData(functionFragment: "burn", values: [BigNumberish]): string;
  encodeFunctionData(
    functionFragment: "canWithdrawAfter",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "checkpoints",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "credits",
    values: [string, string]
  ): string;
  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
  encodeFunctionData(functionFragment: "delegates", values: [string]): string;
  encodeFunctionData(functionFragment: "dispute", values: [string]): string;
  encodeFunctionData(functionFragment: "disputes", values: [string]): string;
  encodeFunctionData(functionFragment: "firstSeen", values: [string]): string;
  encodeFunctionData(
    functionFragment: "getCurrentVotes",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "getJobs", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getKeepers",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "governance",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isBondedKeeper",
    values: [string, string, BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "isKeeper", values: [string]): string;
  encodeFunctionData(
    functionFragment: "isMinKeeper",
    values: [string, BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "jobList",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "jobProposalDelay",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "jobs", values: [string]): string;
  encodeFunctionData(
    functionFragment: "keeperList",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "keepers", values: [string]): string;
  encodeFunctionData(functionFragment: "lastJob", values: [string]): string;
  encodeFunctionData(
    functionFragment: "liquidityAccepted",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "liquidityAmount",
    values: [string, string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "liquidityAmountsUnbonding",
    values: [string, string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "liquidityApplied",
    values: [string, string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "liquidityPairs",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "liquidityProvided",
    values: [string, string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "liquidityUnbonding",
    values: [string, string, string]
  ): string;
  encodeFunctionData(functionFragment: "mint", values: [BigNumberish]): string;
  encodeFunctionData(functionFragment: "name", values?: undefined): string;
  encodeFunctionData(functionFragment: "nonces", values: [string]): string;
  encodeFunctionData(
    functionFragment: "numCheckpoints",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "pairs", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "pendingGovernance",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "pendingUnbonds",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "pendingbonds",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "permit",
    values: [
      string,
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BytesLike,
      BytesLike
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "receipt",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "receiptETH",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "removeJob", values: [string]): string;
  encodeFunctionData(
    functionFragment: "removeLiquidityFromJob",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "removeVotes",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "resolve", values: [string]): string;
  encodeFunctionData(functionFragment: "revoke", values: [string]): string;
  encodeFunctionData(
    functionFragment: "revokeLiquidity",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setGovernance",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setKeep3rHelper",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "slash",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "totalSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transfer",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferFrom",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "unbond",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "unbondLiquidityFromJob",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "votes", values: [string]): string;
  encodeFunctionData(functionFragment: "withdraw", values: [string]): string;
  encodeFunctionData(
    functionFragment: "workCompleted",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "worked", values: [string]): string;

  decodeFunctionResult(functionFragment: "BASE", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "BOND", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "DELEGATION_TYPEHASH",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "DOMAINSEPARATOR",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "DOMAIN_TYPEHASH",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "ETH", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "FEE", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "KPRH", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "LIQUIDITYBOND",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "PERMIT_TYPEHASH",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "UNBOND", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "acceptGovernance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "activate", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "addCredit", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "addCreditETH",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "addJob", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "addKPRCredit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "addLiquidityToJob",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "addVotes", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "applyCreditToJob",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "approveLiquidity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "blacklist", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "bond", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "bondings", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "bonds", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "canWithdrawAfter",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "checkpoints",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "credits", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "delegates", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "dispute", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "disputes", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "firstSeen", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getCurrentVotes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getJobs", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getKeepers", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "governance", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isBondedKeeper",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isKeeper", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isMinKeeper",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "jobList", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "jobProposalDelay",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "jobs", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "keeperList", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "keepers", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "lastJob", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "liquidityAccepted",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidityAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidityAmountsUnbonding",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidityApplied",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidityPairs",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidityProvided",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidityUnbonding",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "nonces", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "numCheckpoints",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "pairs", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "pendingGovernance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "pendingUnbonds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "pendingbonds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "permit", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "receipt", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "receiptETH", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "removeJob", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "removeLiquidityFromJob",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "removeVotes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "resolve", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "revoke", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "revokeLiquidity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setGovernance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setKeep3rHelper",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "slash", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "totalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unbond", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "unbondLiquidityFromJob",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "votes", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "workCompleted",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "worked", data: BytesLike): Result;

  events: {
    "ApplyCredit(address,address,address,uint256,uint256)": EventFragment;
    "Approval(address,address,uint256)": EventFragment;
    "DelegateChanged(address,address,address)": EventFragment;
    "DelegateVotesChanged(address,uint256,uint256)": EventFragment;
    "JobAdded(address,uint256,address)": EventFragment;
    "JobRemoved(address,uint256,address)": EventFragment;
    "KeeperBonded(address,uint256,uint256,uint256)": EventFragment;
    "KeeperBonding(address,uint256,uint256,uint256)": EventFragment;
    "KeeperDispute(address,uint256)": EventFragment;
    "KeeperResolved(address,uint256)": EventFragment;
    "KeeperSlashed(address,address,uint256,uint256)": EventFragment;
    "KeeperUnbonding(address,uint256,uint256,uint256)": EventFragment;
    "KeeperUnbound(address,uint256,uint256,uint256)": EventFragment;
    "KeeperWorked(address,address,address,uint256,uint256)": EventFragment;
    "RemoveJob(address,address,address,uint256,uint256)": EventFragment;
    "SubmitJob(address,address,address,uint256,uint256)": EventFragment;
    "TokenCreditAddition(address,address,address,uint256,uint256)": EventFragment;
    "Transfer(address,address,uint256)": EventFragment;
    "UnbondJob(address,address,address,uint256,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "ApplyCredit"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DelegateChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DelegateVotesChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "JobAdded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "JobRemoved"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "KeeperBonded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "KeeperBonding"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "KeeperDispute"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "KeeperResolved"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "KeeperSlashed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "KeeperUnbonding"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "KeeperUnbound"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "KeeperWorked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RemoveJob"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SubmitJob"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokenCreditAddition"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UnbondJob"): EventFragment;
}

export class IKeep3rV1 extends BaseContract {
  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: IKeep3rV1Interface;

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

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

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

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

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

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

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

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

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

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

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

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

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

    addCredit(
      _credit: string,
      _job: string,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    addCreditETH(
      _job: string,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    addLiquidityToJob(
      _liquidity: string,
      _job: string,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    applyCreditToJob(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    blacklist(_keeper: string, overrides?: CallOverrides): Promise<[boolean]>;

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

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

    bonds(
      _keeper: string,
      _bonding: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

    checkpoints(
      _account: string,
      _checkpoint: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[[number, BigNumber] & { fromBlock: number; votes: BigNumber }]>;

    credits(
      _job: string,
      _credit: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    delegates(_delegator: string, overrides?: CallOverrides): Promise<[string]>;

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

    disputes(_keeper: string, overrides?: CallOverrides): Promise<[boolean]>;

    firstSeen(_keeper: string, overrides?: CallOverrides): Promise<[BigNumber]>;

    getCurrentVotes(
      _account: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

    isBondedKeeper(
      _keeper: string,
      _bond: string,
      _minBond: BigNumberish,
      _earned: BigNumberish,
      _age: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    isMinKeeper(
      _keeper: string,
      _minBond: BigNumberish,
      _earned: BigNumberish,
      _age: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    jobList(_index: BigNumberish, overrides?: CallOverrides): Promise<[string]>;

    jobProposalDelay(
      _job: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    jobs(_job: string, overrides?: CallOverrides): Promise<[boolean]>;

    keeperList(
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

    keepers(_keeper: string, overrides?: CallOverrides): Promise<[boolean]>;

    lastJob(_keeper: string, overrides?: CallOverrides): Promise<[BigNumber]>;

    liquidityAccepted(
      _liquidity: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    liquidityAmount(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    liquidityAmountsUnbonding(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    liquidityApplied(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    liquidityPairs(
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

    liquidityProvided(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    liquidityUnbonding(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

    numCheckpoints(
      _account: string,
      overrides?: CallOverrides
    ): Promise<[number]>;

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

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

    pendingUnbonds(
      _keeper: string,
      _bonding: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    pendingbonds(
      _keeper: string,
      _bonding: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    permit(
      _owner: string,
      _spender: string,
      _amount: BigNumberish,
      _deadline: BigNumberish,
      _v: BigNumberish,
      _r: BytesLike,
      _s: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    receipt(
      _credit: string,
      _keeper: string,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    removeLiquidityFromJob(
      _liquidity: string,
      _job: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

    slash(
      _bonded: string,
      _keeper: string,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    transfer(
      recipient: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    transferFrom(
      sender: string,
      recipient: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    unbondLiquidityFromJob(
      _liquidity: string,
      _job: string,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    votes(_delegator: string, overrides?: CallOverrides): Promise<[BigNumber]>;

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

    workCompleted(
      _keeper: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  addCredit(
    _credit: string,
    _job: string,
    _amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  addCreditETH(
    _job: string,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  addLiquidityToJob(
    _liquidity: string,
    _job: string,
    _amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  applyCreditToJob(
    _provider: string,
    _liquidity: string,
    _job: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  approve(
    spender: string,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  blacklist(_keeper: string, overrides?: CallOverrides): Promise<boolean>;

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

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

  bonds(
    _keeper: string,
    _bonding: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

  checkpoints(
    _account: string,
    _checkpoint: BigNumberish,
    overrides?: CallOverrides
  ): Promise<[number, BigNumber] & { fromBlock: number; votes: BigNumber }>;

  credits(
    _job: string,
    _credit: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  delegates(_delegator: string, overrides?: CallOverrides): Promise<string>;

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

  disputes(_keeper: string, overrides?: CallOverrides): Promise<boolean>;

  firstSeen(_keeper: string, overrides?: CallOverrides): Promise<BigNumber>;

  getCurrentVotes(
    _account: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

  isBondedKeeper(
    _keeper: string,
    _bond: string,
    _minBond: BigNumberish,
    _earned: BigNumberish,
    _age: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  isMinKeeper(
    _keeper: string,
    _minBond: BigNumberish,
    _earned: BigNumberish,
    _age: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  jobList(_index: BigNumberish, overrides?: CallOverrides): Promise<string>;

  jobProposalDelay(_job: string, overrides?: CallOverrides): Promise<BigNumber>;

  jobs(_job: string, overrides?: CallOverrides): Promise<boolean>;

  keeperList(_index: BigNumberish, overrides?: CallOverrides): Promise<string>;

  keepers(_keeper: string, overrides?: CallOverrides): Promise<boolean>;

  lastJob(_keeper: string, overrides?: CallOverrides): Promise<BigNumber>;

  liquidityAccepted(
    _liquidity: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  liquidityAmount(
    _provider: string,
    _liquidity: string,
    _job: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  liquidityAmountsUnbonding(
    _provider: string,
    _liquidity: string,
    _job: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  liquidityApplied(
    _provider: string,
    _liquidity: string,
    _job: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  liquidityPairs(
    _index: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  liquidityProvided(
    _provider: string,
    _liquidity: string,
    _job: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  liquidityUnbonding(
    _provider: string,
    _liquidity: string,
    _job: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

  numCheckpoints(_account: string, overrides?: CallOverrides): Promise<number>;

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

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

  pendingUnbonds(
    _keeper: string,
    _bonding: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  pendingbonds(
    _keeper: string,
    _bonding: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  permit(
    _owner: string,
    _spender: string,
    _amount: BigNumberish,
    _deadline: BigNumberish,
    _v: BigNumberish,
    _r: BytesLike,
    _s: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  receipt(
    _credit: string,
    _keeper: string,
    _amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  removeLiquidityFromJob(
    _liquidity: string,
    _job: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

  slash(
    _bonded: string,
    _keeper: string,
    _amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  transfer(
    recipient: string,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  transferFrom(
    sender: string,
    recipient: string,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  unbondLiquidityFromJob(
    _liquidity: string,
    _job: string,
    _amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  votes(_delegator: string, overrides?: CallOverrides): Promise<BigNumber>;

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

  workCompleted(_keeper: string, overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

    activate(_bonding: string, overrides?: CallOverrides): Promise<void>;

    addCredit(
      _credit: string,
      _job: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    addCreditETH(_job: string, overrides?: CallOverrides): Promise<void>;

    addJob(_job: string, overrides?: CallOverrides): Promise<void>;

    addKPRCredit(
      _job: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    addLiquidityToJob(
      _liquidity: string,
      _job: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    addVotes(
      _voter: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    applyCreditToJob(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<void>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    approveLiquidity(
      _liquidity: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

    blacklist(_keeper: string, overrides?: CallOverrides): Promise<boolean>;

    bond(
      _bonding: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    bonds(
      _keeper: string,
      _bonding: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    checkpoints(
      _account: string,
      _checkpoint: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number, BigNumber] & { fromBlock: number; votes: BigNumber }>;

    credits(
      _job: string,
      _credit: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    delegates(_delegator: string, overrides?: CallOverrides): Promise<string>;

    dispute(_keeper: string, overrides?: CallOverrides): Promise<void>;

    disputes(_keeper: string, overrides?: CallOverrides): Promise<boolean>;

    firstSeen(_keeper: string, overrides?: CallOverrides): Promise<BigNumber>;

    getCurrentVotes(
      _account: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    isBondedKeeper(
      _keeper: string,
      _bond: string,
      _minBond: BigNumberish,
      _earned: BigNumberish,
      _age: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isKeeper(_keeper: string, overrides?: CallOverrides): Promise<boolean>;

    isMinKeeper(
      _keeper: string,
      _minBond: BigNumberish,
      _earned: BigNumberish,
      _age: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    jobList(_index: BigNumberish, overrides?: CallOverrides): Promise<string>;

    jobProposalDelay(
      _job: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    jobs(_job: string, overrides?: CallOverrides): Promise<boolean>;

    keeperList(
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    keepers(_keeper: string, overrides?: CallOverrides): Promise<boolean>;

    lastJob(_keeper: string, overrides?: CallOverrides): Promise<BigNumber>;

    liquidityAccepted(
      _liquidity: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    liquidityAmount(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    liquidityAmountsUnbonding(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    liquidityApplied(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    liquidityPairs(
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    liquidityProvided(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    liquidityUnbonding(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    numCheckpoints(
      _account: string,
      overrides?: CallOverrides
    ): Promise<number>;

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

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

    pendingUnbonds(
      _keeper: string,
      _bonding: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    pendingbonds(
      _keeper: string,
      _bonding: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    permit(
      _owner: string,
      _spender: string,
      _amount: BigNumberish,
      _deadline: BigNumberish,
      _v: BigNumberish,
      _r: BytesLike,
      _s: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    receipt(
      _credit: string,
      _keeper: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    receiptETH(
      _keeper: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    removeJob(_job: string, overrides?: CallOverrides): Promise<void>;

    removeLiquidityFromJob(
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<void>;

    removeVotes(
      _voter: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    resolve(_keeper: string, overrides?: CallOverrides): Promise<void>;

    revoke(_keeper: string, overrides?: CallOverrides): Promise<void>;

    revokeLiquidity(
      _liquidity: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setGovernance(
      _governance: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setKeep3rHelper(
      _keep3rHelper: string,
      overrides?: CallOverrides
    ): Promise<void>;

    slash(
      _bonded: string,
      _keeper: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    transfer(
      recipient: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    transferFrom(
      sender: string,
      recipient: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    unbond(
      _bonding: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    unbondLiquidityFromJob(
      _liquidity: string,
      _job: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    votes(_delegator: string, overrides?: CallOverrides): Promise<BigNumber>;

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

    workCompleted(
      _keeper: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    worked(_keeper: string, overrides?: CallOverrides): Promise<void>;
  };

  filters: {
    ApplyCredit(
      _job?: string | null,
      _liquidity?: string | null,
      _provider?: string | null,
      _block?: null,
      _credit?: null
    ): TypedEventFilter<
      [string, string, string, BigNumber, BigNumber],
      {
        _job: string;
        _liquidity: string;
        _provider: string;
        _block: BigNumber;
        _credit: BigNumber;
      }
    >;

    Approval(
      owner?: string | null,
      spender?: string | null,
      value?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { owner: string; spender: string; value: BigNumber }
    >;

    DelegateChanged(
      _delegator?: string | null,
      _fromDelegate?: string | null,
      _toDelegate?: string | null
    ): TypedEventFilter<
      [string, string, string],
      { _delegator: string; _fromDelegate: string; _toDelegate: string }
    >;

    DelegateVotesChanged(
      _delegate?: string | null,
      _previousBalance?: null,
      _newBalance?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { _delegate: string; _previousBalance: BigNumber; _newBalance: BigNumber }
    >;

    JobAdded(
      _job?: string | null,
      _block?: null,
      _governance?: null
    ): TypedEventFilter<
      [string, BigNumber, string],
      { _job: string; _block: BigNumber; _governance: string }
    >;

    JobRemoved(
      _job?: string | null,
      _block?: null,
      _governance?: null
    ): TypedEventFilter<
      [string, BigNumber, string],
      { _job: string; _block: BigNumber; _governance: string }
    >;

    KeeperBonded(
      _keeper?: string | null,
      _block?: null,
      _activated?: null,
      _bond?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber],
      {
        _keeper: string;
        _block: BigNumber;
        _activated: BigNumber;
        _bond: BigNumber;
      }
    >;

    KeeperBonding(
      _keeper?: string | null,
      _block?: null,
      _active?: null,
      _bond?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber],
      {
        _keeper: string;
        _block: BigNumber;
        _active: BigNumber;
        _bond: BigNumber;
      }
    >;

    KeeperDispute(
      _keeper?: string | null,
      _block?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { _keeper: string; _block: BigNumber }
    >;

    KeeperResolved(
      _keeper?: string | null,
      _block?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { _keeper: string; _block: BigNumber }
    >;

    KeeperSlashed(
      _keeper?: string | null,
      _slasher?: string | null,
      _block?: null,
      _slash?: null
    ): TypedEventFilter<
      [string, string, BigNumber, BigNumber],
      {
        _keeper: string;
        _slasher: string;
        _block: BigNumber;
        _slash: BigNumber;
      }
    >;

    KeeperUnbonding(
      _keeper?: string | null,
      _block?: null,
      _deactive?: null,
      _bond?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber],
      {
        _keeper: string;
        _block: BigNumber;
        _deactive: BigNumber;
        _bond: BigNumber;
      }
    >;

    KeeperUnbound(
      _keeper?: string | null,
      _block?: null,
      _deactivated?: null,
      _bond?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber],
      {
        _keeper: string;
        _block: BigNumber;
        _deactivated: BigNumber;
        _bond: BigNumber;
      }
    >;

    KeeperWorked(
      _credit?: string | null,
      _job?: string | null,
      _keeper?: string | null,
      _block?: null,
      _amount?: null
    ): TypedEventFilter<
      [string, string, string, BigNumber, BigNumber],
      {
        _credit: string;
        _job: string;
        _keeper: string;
        _block: BigNumber;
        _amount: BigNumber;
      }
    >;

    RemoveJob(
      _job?: string | null,
      _liquidity?: string | null,
      _provider?: string | null,
      _block?: null,
      _credit?: null
    ): TypedEventFilter<
      [string, string, string, BigNumber, BigNumber],
      {
        _job: string;
        _liquidity: string;
        _provider: string;
        _block: BigNumber;
        _credit: BigNumber;
      }
    >;

    SubmitJob(
      _job?: string | null,
      _liquidity?: string | null,
      _provider?: string | null,
      _block?: null,
      _credit?: null
    ): TypedEventFilter<
      [string, string, string, BigNumber, BigNumber],
      {
        _job: string;
        _liquidity: string;
        _provider: string;
        _block: BigNumber;
        _credit: BigNumber;
      }
    >;

    TokenCreditAddition(
      _credit?: string | null,
      _job?: string | null,
      _creditor?: string | null,
      _block?: null,
      _amount?: null
    ): TypedEventFilter<
      [string, string, string, BigNumber, BigNumber],
      {
        _credit: string;
        _job: string;
        _creditor: string;
        _block: BigNumber;
        _amount: BigNumber;
      }
    >;

    Transfer(
      from?: string | null,
      to?: string | null,
      value?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { from: string; to: string; value: BigNumber }
    >;

    UnbondJob(
      _job?: string | null,
      _liquidity?: string | null,
      _provider?: string | null,
      _block?: null,
      _credit?: null
    ): TypedEventFilter<
      [string, string, string, BigNumber, BigNumber],
      {
        _job: string;
        _liquidity: string;
        _provider: string;
        _block: BigNumber;
        _credit: BigNumber;
      }
    >;
  };

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

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

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

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

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

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

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

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

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

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

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

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

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

    addCredit(
      _credit: string,
      _job: string,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    addCreditETH(
      _job: string,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    addLiquidityToJob(
      _liquidity: string,
      _job: string,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    applyCreditToJob(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    blacklist(_keeper: string, overrides?: CallOverrides): Promise<BigNumber>;

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

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

    bonds(
      _keeper: string,
      _bonding: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    checkpoints(
      _account: string,
      _checkpoint: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    credits(
      _job: string,
      _credit: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    delegates(
      _delegator: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    disputes(_keeper: string, overrides?: CallOverrides): Promise<BigNumber>;

    firstSeen(_keeper: string, overrides?: CallOverrides): Promise<BigNumber>;

    getCurrentVotes(
      _account: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    isBondedKeeper(
      _keeper: string,
      _bond: string,
      _minBond: BigNumberish,
      _earned: BigNumberish,
      _age: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    isMinKeeper(
      _keeper: string,
      _minBond: BigNumberish,
      _earned: BigNumberish,
      _age: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    jobList(
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    jobProposalDelay(
      _job: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    jobs(_job: string, overrides?: CallOverrides): Promise<BigNumber>;

    keeperList(
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    keepers(_keeper: string, overrides?: CallOverrides): Promise<BigNumber>;

    lastJob(_keeper: string, overrides?: CallOverrides): Promise<BigNumber>;

    liquidityAccepted(
      _liquidity: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    liquidityAmount(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    liquidityAmountsUnbonding(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    liquidityApplied(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    liquidityPairs(
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    liquidityProvided(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    liquidityUnbonding(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    numCheckpoints(
      _account: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    pendingUnbonds(
      _keeper: string,
      _bonding: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    pendingbonds(
      _keeper: string,
      _bonding: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    permit(
      _owner: string,
      _spender: string,
      _amount: BigNumberish,
      _deadline: BigNumberish,
      _v: BigNumberish,
      _r: BytesLike,
      _s: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    receipt(
      _credit: string,
      _keeper: string,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    removeLiquidityFromJob(
      _liquidity: string,
      _job: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

    slash(
      _bonded: string,
      _keeper: string,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    transfer(
      recipient: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    transferFrom(
      sender: string,
      recipient: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    unbondLiquidityFromJob(
      _liquidity: string,
      _job: string,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    votes(_delegator: string, overrides?: CallOverrides): Promise<BigNumber>;

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

    workCompleted(
      _keeper: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    addCredit(
      _credit: string,
      _job: string,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    addCreditETH(
      _job: string,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    addLiquidityToJob(
      _liquidity: string,
      _job: string,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    applyCreditToJob(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    blacklist(
      _keeper: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    bonds(
      _keeper: string,
      _bonding: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    checkpoints(
      _account: string,
      _checkpoint: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    credits(
      _job: string,
      _credit: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    delegates(
      _delegator: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    disputes(
      _keeper: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    firstSeen(
      _keeper: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getCurrentVotes(
      _account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    isBondedKeeper(
      _keeper: string,
      _bond: string,
      _minBond: BigNumberish,
      _earned: BigNumberish,
      _age: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    isMinKeeper(
      _keeper: string,
      _minBond: BigNumberish,
      _earned: BigNumberish,
      _age: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    jobList(
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    jobProposalDelay(
      _job: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    jobs(
      _job: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    keeperList(
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    keepers(
      _keeper: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    lastJob(
      _keeper: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    liquidityAccepted(
      _liquidity: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    liquidityAmount(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    liquidityAmountsUnbonding(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    liquidityApplied(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    liquidityPairs(
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    liquidityProvided(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    liquidityUnbonding(
      _provider: string,
      _liquidity: string,
      _job: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    numCheckpoints(
      _account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    pendingUnbonds(
      _keeper: string,
      _bonding: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    pendingbonds(
      _keeper: string,
      _bonding: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    permit(
      _owner: string,
      _spender: string,
      _amount: BigNumberish,
      _deadline: BigNumberish,
      _v: BigNumberish,
      _r: BytesLike,
      _s: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    receipt(
      _credit: string,
      _keeper: string,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    removeLiquidityFromJob(
      _liquidity: string,
      _job: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

    slash(
      _bonded: string,
      _keeper: string,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    transfer(
      recipient: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    transferFrom(
      sender: string,
      recipient: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    unbondLiquidityFromJob(
      _liquidity: string,
      _job: string,
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    votes(
      _delegator: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    workCompleted(
      _keeper: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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