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

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  BaseContract,
  ContractTransaction,
  Overrides,
  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 RelayerRegistryInterface extends ethers.utils.Interface {
  functions: {
    "bulkResolve(bytes32[])": FunctionFragment;
    "burn(address,address,address)": FunctionFragment;
    "ens()": FunctionFragment;
    "feeManager()": FunctionFragment;
    "getRelayerBalance(address)": FunctionFragment;
    "getRelayerEnsHash(address)": FunctionFragment;
    "governance()": FunctionFragment;
    "initialize(bytes32)": FunctionFragment;
    "isRelayer(address)": FunctionFragment;
    "isRelayerRegistered(address,address)": FunctionFragment;
    "minStakeAmount()": FunctionFragment;
    "nullifyBalance(address)": FunctionFragment;
    "register(string,uint256,address[])": FunctionFragment;
    "registerPermit(string,uint256,address[],address,uint256,uint8,bytes32,bytes32)": FunctionFragment;
    "registerWorker(address,address)": FunctionFragment;
    "relayers(address)": FunctionFragment;
    "resolve(bytes32)": FunctionFragment;
    "setMinStakeAmount(uint256)": FunctionFragment;
    "setTornadoRouter(address)": FunctionFragment;
    "stakeToRelayer(address,uint256)": FunctionFragment;
    "stakeToRelayerPermit(address,uint256,address,uint256,uint8,bytes32,bytes32)": FunctionFragment;
    "staking()": FunctionFragment;
    "torn()": FunctionFragment;
    "tornadoRouter()": FunctionFragment;
    "unregisterWorker(address)": FunctionFragment;
    "workers(address)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "bulkResolve",
    values: [BytesLike[]]
  ): string;
  encodeFunctionData(
    functionFragment: "burn",
    values: [string, string, string]
  ): string;
  encodeFunctionData(functionFragment: "ens", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "feeManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getRelayerBalance",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getRelayerEnsHash",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "governance",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "isRelayer", values: [string]): string;
  encodeFunctionData(
    functionFragment: "isRelayerRegistered",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "minStakeAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "nullifyBalance",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "register",
    values: [string, BigNumberish, string[]]
  ): string;
  encodeFunctionData(
    functionFragment: "registerPermit",
    values: [
      string,
      BigNumberish,
      string[],
      string,
      BigNumberish,
      BigNumberish,
      BytesLike,
      BytesLike
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "registerWorker",
    values: [string, string]
  ): string;
  encodeFunctionData(functionFragment: "relayers", values: [string]): string;
  encodeFunctionData(functionFragment: "resolve", values: [BytesLike]): string;
  encodeFunctionData(
    functionFragment: "setMinStakeAmount",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setTornadoRouter",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "stakeToRelayer",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "stakeToRelayerPermit",
    values: [
      string,
      BigNumberish,
      string,
      BigNumberish,
      BigNumberish,
      BytesLike,
      BytesLike
    ]
  ): string;
  encodeFunctionData(functionFragment: "staking", values?: undefined): string;
  encodeFunctionData(functionFragment: "torn", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "tornadoRouter",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "unregisterWorker",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "workers", values: [string]): string;

  decodeFunctionResult(
    functionFragment: "bulkResolve",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "ens", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "feeManager", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getRelayerBalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRelayerEnsHash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "governance", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "isRelayer", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isRelayerRegistered",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "minStakeAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "nullifyBalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "register", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "registerPermit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "registerWorker",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "relayers", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "resolve", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setMinStakeAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTornadoRouter",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "stakeToRelayer",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "stakeToRelayerPermit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "staking", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "torn", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "tornadoRouter",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unregisterWorker",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "workers", data: BytesLike): Result;

  events: {
    "MinimumStakeAmount(uint256)": EventFragment;
    "RelayerBalanceNullified(address)": EventFragment;
    "RelayerRegistered(bytes32,string,address,uint256)": EventFragment;
    "RouterRegistered(address)": EventFragment;
    "StakeAddedToRelayer(address,uint256)": EventFragment;
    "StakeBurned(address,uint256)": EventFragment;
    "WorkerRegistered(address,address)": EventFragment;
    "WorkerUnregistered(address,address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "MinimumStakeAmount"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RelayerBalanceNullified"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RelayerRegistered"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RouterRegistered"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakeAddedToRelayer"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakeBurned"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "WorkerRegistered"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "WorkerUnregistered"): EventFragment;
}

export type MinimumStakeAmountEvent = TypedEvent<
  [BigNumber] & { minStakeAmount: BigNumber }
>;

export type RelayerBalanceNullifiedEvent = TypedEvent<
  [string] & { relayer: string }
>;

export type RelayerRegisteredEvent = TypedEvent<
  [string, string, string, BigNumber] & {
    relayer: string;
    ensName: string;
    relayerAddress: string;
    stakedAmount: BigNumber;
  }
>;

export type RouterRegisteredEvent = TypedEvent<
  [string] & { tornadoRouter: string }
>;

export type StakeAddedToRelayerEvent = TypedEvent<
  [string, BigNumber] & { relayer: string; amountStakeAdded: BigNumber }
>;

export type StakeBurnedEvent = TypedEvent<
  [string, BigNumber] & { relayer: string; amountBurned: BigNumber }
>;

export type WorkerRegisteredEvent = TypedEvent<
  [string, string] & { relayer: string; worker: string }
>;

export type WorkerUnregisteredEvent = TypedEvent<
  [string, string] & { relayer: string; worker: string }
>;

export class RelayerRegistry 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: RelayerRegistryInterface;

  functions: {
    bulkResolve(
      domains: BytesLike[],
      overrides?: CallOverrides
    ): Promise<[string[]] & { result: string[] }>;

    burn(
      sender: string,
      relayer: string,
      pool: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    getRelayerBalance(
      relayer: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getRelayerEnsHash(
      relayer: string,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

    isRelayer(toResolve: string, overrides?: CallOverrides): Promise<[boolean]>;

    isRelayerRegistered(
      relayer: string,
      toResolve: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

    register(
      ensName: string,
      stake: BigNumberish,
      workersToRegister: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    registerPermit(
      ensName: string,
      stake: BigNumberish,
      workersToRegister: string[],
      relayer: string,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    registerWorker(
      relayer: string,
      worker: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    relayers(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber, string] & { balance: BigNumber; ensHash: string }>;

    resolve(node: BytesLike, overrides?: CallOverrides): Promise<[string]>;

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

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

    stakeToRelayer(
      relayer: string,
      stake: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    stakeToRelayerPermit(
      relayer: string,
      stake: BigNumberish,
      staker: string,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

    workers(arg0: string, overrides?: CallOverrides): Promise<[string]>;
  };

  bulkResolve(
    domains: BytesLike[],
    overrides?: CallOverrides
  ): Promise<string[]>;

  burn(
    sender: string,
    relayer: string,
    pool: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  getRelayerBalance(
    relayer: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getRelayerEnsHash(
    relayer: string,
    overrides?: CallOverrides
  ): Promise<string>;

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

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

  isRelayer(toResolve: string, overrides?: CallOverrides): Promise<boolean>;

  isRelayerRegistered(
    relayer: string,
    toResolve: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

  register(
    ensName: string,
    stake: BigNumberish,
    workersToRegister: string[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  registerPermit(
    ensName: string,
    stake: BigNumberish,
    workersToRegister: string[],
    relayer: string,
    deadline: BigNumberish,
    v: BigNumberish,
    r: BytesLike,
    s: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  registerWorker(
    relayer: string,
    worker: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  relayers(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<[BigNumber, string] & { balance: BigNumber; ensHash: string }>;

  resolve(node: BytesLike, overrides?: CallOverrides): Promise<string>;

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

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

  stakeToRelayer(
    relayer: string,
    stake: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  stakeToRelayerPermit(
    relayer: string,
    stake: BigNumberish,
    staker: string,
    deadline: BigNumberish,
    v: BigNumberish,
    r: BytesLike,
    s: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

  callStatic: {
    bulkResolve(
      domains: BytesLike[],
      overrides?: CallOverrides
    ): Promise<string[]>;

    burn(
      sender: string,
      relayer: string,
      pool: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    getRelayerBalance(
      relayer: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getRelayerEnsHash(
      relayer: string,
      overrides?: CallOverrides
    ): Promise<string>;

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

    initialize(
      _tornadoRouter: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    isRelayer(toResolve: string, overrides?: CallOverrides): Promise<boolean>;

    isRelayerRegistered(
      relayer: string,
      toResolve: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    nullifyBalance(relayer: string, overrides?: CallOverrides): Promise<void>;

    register(
      ensName: string,
      stake: BigNumberish,
      workersToRegister: string[],
      overrides?: CallOverrides
    ): Promise<void>;

    registerPermit(
      ensName: string,
      stake: BigNumberish,
      workersToRegister: string[],
      relayer: string,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    registerWorker(
      relayer: string,
      worker: string,
      overrides?: CallOverrides
    ): Promise<void>;

    relayers(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber, string] & { balance: BigNumber; ensHash: string }>;

    resolve(node: BytesLike, overrides?: CallOverrides): Promise<string>;

    setMinStakeAmount(
      minAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setTornadoRouter(
      tornadoRouterAddress: string,
      overrides?: CallOverrides
    ): Promise<void>;

    stakeToRelayer(
      relayer: string,
      stake: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    stakeToRelayerPermit(
      relayer: string,
      stake: BigNumberish,
      staker: string,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    unregisterWorker(worker: string, overrides?: CallOverrides): Promise<void>;

    workers(arg0: string, overrides?: CallOverrides): Promise<string>;
  };

  filters: {
    "MinimumStakeAmount(uint256)"(
      minStakeAmount?: null
    ): TypedEventFilter<[BigNumber], { minStakeAmount: BigNumber }>;

    MinimumStakeAmount(
      minStakeAmount?: null
    ): TypedEventFilter<[BigNumber], { minStakeAmount: BigNumber }>;

    "RelayerBalanceNullified(address)"(
      relayer?: null
    ): TypedEventFilter<[string], { relayer: string }>;

    RelayerBalanceNullified(
      relayer?: null
    ): TypedEventFilter<[string], { relayer: string }>;

    "RelayerRegistered(bytes32,string,address,uint256)"(
      relayer?: null,
      ensName?: null,
      relayerAddress?: null,
      stakedAmount?: null
    ): TypedEventFilter<
      [string, string, string, BigNumber],
      {
        relayer: string;
        ensName: string;
        relayerAddress: string;
        stakedAmount: BigNumber;
      }
    >;

    RelayerRegistered(
      relayer?: null,
      ensName?: null,
      relayerAddress?: null,
      stakedAmount?: null
    ): TypedEventFilter<
      [string, string, string, BigNumber],
      {
        relayer: string;
        ensName: string;
        relayerAddress: string;
        stakedAmount: BigNumber;
      }
    >;

    "RouterRegistered(address)"(
      tornadoRouter?: null
    ): TypedEventFilter<[string], { tornadoRouter: string }>;

    RouterRegistered(
      tornadoRouter?: null
    ): TypedEventFilter<[string], { tornadoRouter: string }>;

    "StakeAddedToRelayer(address,uint256)"(
      relayer?: null,
      amountStakeAdded?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { relayer: string; amountStakeAdded: BigNumber }
    >;

    StakeAddedToRelayer(
      relayer?: null,
      amountStakeAdded?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { relayer: string; amountStakeAdded: BigNumber }
    >;

    "StakeBurned(address,uint256)"(
      relayer?: null,
      amountBurned?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { relayer: string; amountBurned: BigNumber }
    >;

    StakeBurned(
      relayer?: null,
      amountBurned?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { relayer: string; amountBurned: BigNumber }
    >;

    "WorkerRegistered(address,address)"(
      relayer?: null,
      worker?: null
    ): TypedEventFilter<[string, string], { relayer: string; worker: string }>;

    WorkerRegistered(
      relayer?: null,
      worker?: null
    ): TypedEventFilter<[string, string], { relayer: string; worker: string }>;

    "WorkerUnregistered(address,address)"(
      relayer?: null,
      worker?: null
    ): TypedEventFilter<[string, string], { relayer: string; worker: string }>;

    WorkerUnregistered(
      relayer?: null,
      worker?: null
    ): TypedEventFilter<[string, string], { relayer: string; worker: string }>;
  };

  estimateGas: {
    bulkResolve(
      domains: BytesLike[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    burn(
      sender: string,
      relayer: string,
      pool: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    getRelayerBalance(
      relayer: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getRelayerEnsHash(
      relayer: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    isRelayer(toResolve: string, overrides?: CallOverrides): Promise<BigNumber>;

    isRelayerRegistered(
      relayer: string,
      toResolve: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    register(
      ensName: string,
      stake: BigNumberish,
      workersToRegister: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    registerPermit(
      ensName: string,
      stake: BigNumberish,
      workersToRegister: string[],
      relayer: string,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    registerWorker(
      relayer: string,
      worker: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    resolve(node: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;

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

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

    stakeToRelayer(
      relayer: string,
      stake: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    stakeToRelayerPermit(
      relayer: string,
      stake: BigNumberish,
      staker: string,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

  populateTransaction: {
    bulkResolve(
      domains: BytesLike[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    burn(
      sender: string,
      relayer: string,
      pool: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    getRelayerBalance(
      relayer: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getRelayerEnsHash(
      relayer: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    isRelayer(
      toResolve: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isRelayerRegistered(
      relayer: string,
      toResolve: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    register(
      ensName: string,
      stake: BigNumberish,
      workersToRegister: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    registerPermit(
      ensName: string,
      stake: BigNumberish,
      workersToRegister: string[],
      relayer: string,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    registerWorker(
      relayer: string,
      worker: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    resolve(
      node: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    stakeToRelayer(
      relayer: string,
      stake: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    stakeToRelayerPermit(
      relayer: string,
      stake: BigNumberish,
      staker: string,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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