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

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

interface MultiSigWalletInterface extends ethers.utils.Interface {
  functions: {
    "owners(uint256)": FunctionFragment;
    "removeOwner(address)": FunctionFragment;
    "revokeConfirmation(uint256)": FunctionFragment;
    "isOwner(address)": FunctionFragment;
    "confirmations(uint256,address)": FunctionFragment;
    "getTransactionCount(bool,bool)": FunctionFragment;
    "addOwner(address)": FunctionFragment;
    "isConfirmed(uint256)": FunctionFragment;
    "getConfirmationCount(uint256)": FunctionFragment;
    "transactions(uint256)": FunctionFragment;
    "getOwners()": FunctionFragment;
    "getTransactionIds(uint256,uint256,bool,bool)": FunctionFragment;
    "getConfirmations(uint256)": FunctionFragment;
    "transactionCount()": FunctionFragment;
    "changeRequirement(uint256)": FunctionFragment;
    "confirmTransaction(uint256)": FunctionFragment;
    "submitTransaction(address,uint256,bytes)": FunctionFragment;
    "MAX_OWNER_COUNT()": FunctionFragment;
    "required()": FunctionFragment;
    "replaceOwner(address,address)": FunctionFragment;
    "executeTransaction(uint256)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "owners",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "removeOwner", values: [string]): string;
  encodeFunctionData(
    functionFragment: "revokeConfirmation",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "isOwner", values: [string]): string;
  encodeFunctionData(
    functionFragment: "confirmations",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "getTransactionCount",
    values: [boolean, boolean]
  ): string;
  encodeFunctionData(functionFragment: "addOwner", values: [string]): string;
  encodeFunctionData(
    functionFragment: "isConfirmed",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getConfirmationCount",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transactions",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "getOwners", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getTransactionIds",
    values: [BigNumberish, BigNumberish, boolean, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "getConfirmations",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transactionCount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "changeRequirement",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "confirmTransaction",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "submitTransaction",
    values: [string, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "MAX_OWNER_COUNT",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "required", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "replaceOwner",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "executeTransaction",
    values: [BigNumberish]
  ): string;

  decodeFunctionResult(functionFragment: "owners", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "removeOwner",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "revokeConfirmation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isOwner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "confirmations",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTransactionCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "addOwner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isConfirmed",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getConfirmationCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transactions",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getOwners", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getTransactionIds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getConfirmations",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transactionCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "changeRequirement",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "confirmTransaction",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "submitTransaction",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MAX_OWNER_COUNT",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "required", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "replaceOwner",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "executeTransaction",
    data: BytesLike
  ): Result;

  events: {
    "Confirmation(address,uint256)": EventFragment;
    "Revocation(address,uint256)": EventFragment;
    "Submission(uint256)": EventFragment;
    "Execution(uint256)": EventFragment;
    "ExecutionFailure(uint256)": EventFragment;
    "Deposit(address,uint256)": EventFragment;
    "OwnerAddition(address)": EventFragment;
    "OwnerRemoval(address)": EventFragment;
    "RequirementChange(uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Confirmation"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Revocation"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Submission"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Execution"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ExecutionFailure"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnerAddition"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnerRemoval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RequirementChange"): EventFragment;
}

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

  on(event: EventFilter | string, listener: Listener): this;
  once(event: EventFilter | string, listener: Listener): this;
  addListener(eventName: EventFilter | string, listener: Listener): this;
  removeAllListeners(eventName: EventFilter | string): this;
  removeListener(eventName: any, listener: Listener): this;

  interface: MultiSigWalletInterface;

  functions: {
    owners(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      0: string;
    }>;

    "owners(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      0: string;
    }>;

    removeOwner(
      owner: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "removeOwner(address)"(
      owner: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    revokeConfirmation(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "revokeConfirmation(uint256)"(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    isOwner(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<{
      0: boolean;
    }>;

    "isOwner(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<{
      0: boolean;
    }>;

    confirmations(
      arg0: BigNumberish,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<{
      0: boolean;
    }>;

    "confirmations(uint256,address)"(
      arg0: BigNumberish,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<{
      0: boolean;
    }>;

    getTransactionCount(
      pending: boolean,
      executed: boolean,
      overrides?: CallOverrides
    ): Promise<{
      count: BigNumber;
      0: BigNumber;
    }>;

    "getTransactionCount(bool,bool)"(
      pending: boolean,
      executed: boolean,
      overrides?: CallOverrides
    ): Promise<{
      count: BigNumber;
      0: BigNumber;
    }>;

    addOwner(
      owner: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "addOwner(address)"(
      owner: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    isConfirmed(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      0: boolean;
    }>;

    "isConfirmed(uint256)"(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      0: boolean;
    }>;

    getConfirmationCount(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      count: BigNumber;
      0: BigNumber;
    }>;

    "getConfirmationCount(uint256)"(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      count: BigNumber;
      0: BigNumber;
    }>;

    transactions(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      destination: string;
      value: BigNumber;
      data: string;
      executed: boolean;
      0: string;
      1: BigNumber;
      2: string;
      3: boolean;
    }>;

    "transactions(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      destination: string;
      value: BigNumber;
      data: string;
      executed: boolean;
      0: string;
      1: BigNumber;
      2: string;
      3: boolean;
    }>;

    getOwners(
      overrides?: CallOverrides
    ): Promise<{
      0: string[];
    }>;

    "getOwners()"(
      overrides?: CallOverrides
    ): Promise<{
      0: string[];
    }>;

    getTransactionIds(
      from: BigNumberish,
      to: BigNumberish,
      pending: boolean,
      executed: boolean,
      overrides?: CallOverrides
    ): Promise<{
      _transactionIds: BigNumber[];
      0: BigNumber[];
    }>;

    "getTransactionIds(uint256,uint256,bool,bool)"(
      from: BigNumberish,
      to: BigNumberish,
      pending: boolean,
      executed: boolean,
      overrides?: CallOverrides
    ): Promise<{
      _transactionIds: BigNumber[];
      0: BigNumber[];
    }>;

    getConfirmations(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      _confirmations: string[];
      0: string[];
    }>;

    "getConfirmations(uint256)"(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      _confirmations: string[];
      0: string[];
    }>;

    transactionCount(
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    "transactionCount()"(
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    changeRequirement(
      _required: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "changeRequirement(uint256)"(
      _required: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    confirmTransaction(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "confirmTransaction(uint256)"(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    submitTransaction(
      destination: string,
      value: BigNumberish,
      data: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "submitTransaction(address,uint256,bytes)"(
      destination: string,
      value: BigNumberish,
      data: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    MAX_OWNER_COUNT(
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    "MAX_OWNER_COUNT()"(
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    required(
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    "required()"(
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    replaceOwner(
      owner: string,
      newOwner: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "replaceOwner(address,address)"(
      owner: string,
      newOwner: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    executeTransaction(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "executeTransaction(uint256)"(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;
  };

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

  "owners(uint256)"(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  removeOwner(
    owner: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "removeOwner(address)"(
    owner: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  revokeConfirmation(
    transactionId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "revokeConfirmation(uint256)"(
    transactionId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

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

  "isOwner(address)"(arg0: string, overrides?: CallOverrides): Promise<boolean>;

  confirmations(
    arg0: BigNumberish,
    arg1: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  "confirmations(uint256,address)"(
    arg0: BigNumberish,
    arg1: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  getTransactionCount(
    pending: boolean,
    executed: boolean,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getTransactionCount(bool,bool)"(
    pending: boolean,
    executed: boolean,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  addOwner(owner: string, overrides?: Overrides): Promise<ContractTransaction>;

  "addOwner(address)"(
    owner: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  isConfirmed(
    transactionId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

  "isConfirmed(uint256)"(
    transactionId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

  getConfirmationCount(
    transactionId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getConfirmationCount(uint256)"(
    transactionId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  transactions(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<{
    destination: string;
    value: BigNumber;
    data: string;
    executed: boolean;
    0: string;
    1: BigNumber;
    2: string;
    3: boolean;
  }>;

  "transactions(uint256)"(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<{
    destination: string;
    value: BigNumber;
    data: string;
    executed: boolean;
    0: string;
    1: BigNumber;
    2: string;
    3: boolean;
  }>;

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

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

  getTransactionIds(
    from: BigNumberish,
    to: BigNumberish,
    pending: boolean,
    executed: boolean,
    overrides?: CallOverrides
  ): Promise<BigNumber[]>;

  "getTransactionIds(uint256,uint256,bool,bool)"(
    from: BigNumberish,
    to: BigNumberish,
    pending: boolean,
    executed: boolean,
    overrides?: CallOverrides
  ): Promise<BigNumber[]>;

  getConfirmations(
    transactionId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string[]>;

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

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

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

  changeRequirement(
    _required: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "changeRequirement(uint256)"(
    _required: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  confirmTransaction(
    transactionId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "confirmTransaction(uint256)"(
    transactionId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  submitTransaction(
    destination: string,
    value: BigNumberish,
    data: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "submitTransaction(address,uint256,bytes)"(
    destination: string,
    value: BigNumberish,
    data: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

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

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

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

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

  replaceOwner(
    owner: string,
    newOwner: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "replaceOwner(address,address)"(
    owner: string,
    newOwner: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  executeTransaction(
    transactionId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "executeTransaction(uint256)"(
    transactionId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  callStatic: {
    owners(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;

    "owners(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

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

    "removeOwner(address)"(
      owner: string,
      overrides?: CallOverrides
    ): Promise<void>;

    revokeConfirmation(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "revokeConfirmation(uint256)"(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    "isOwner(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    confirmations(
      arg0: BigNumberish,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    "confirmations(uint256,address)"(
      arg0: BigNumberish,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    getTransactionCount(
      pending: boolean,
      executed: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getTransactionCount(bool,bool)"(
      pending: boolean,
      executed: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "addOwner(address)"(
      owner: string,
      overrides?: CallOverrides
    ): Promise<void>;

    isConfirmed(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    "isConfirmed(uint256)"(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    getConfirmationCount(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getConfirmationCount(uint256)"(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    transactions(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      destination: string;
      value: BigNumber;
      data: string;
      executed: boolean;
      0: string;
      1: BigNumber;
      2: string;
      3: boolean;
    }>;

    "transactions(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      destination: string;
      value: BigNumber;
      data: string;
      executed: boolean;
      0: string;
      1: BigNumber;
      2: string;
      3: boolean;
    }>;

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

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

    getTransactionIds(
      from: BigNumberish,
      to: BigNumberish,
      pending: boolean,
      executed: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

    "getTransactionIds(uint256,uint256,bool,bool)"(
      from: BigNumberish,
      to: BigNumberish,
      pending: boolean,
      executed: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

    getConfirmations(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string[]>;

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

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

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

    changeRequirement(
      _required: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "changeRequirement(uint256)"(
      _required: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    confirmTransaction(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "confirmTransaction(uint256)"(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    submitTransaction(
      destination: string,
      value: BigNumberish,
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "submitTransaction(address,uint256,bytes)"(
      destination: string,
      value: BigNumberish,
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

    "replaceOwner(address,address)"(
      owner: string,
      newOwner: string,
      overrides?: CallOverrides
    ): Promise<void>;

    executeTransaction(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "executeTransaction(uint256)"(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    Confirmation(
      sender: string | null,
      transactionId: BigNumberish | null
    ): EventFilter;

    Revocation(
      sender: string | null,
      transactionId: BigNumberish | null
    ): EventFilter;

    Submission(transactionId: BigNumberish | null): EventFilter;

    Execution(transactionId: BigNumberish | null): EventFilter;

    ExecutionFailure(transactionId: BigNumberish | null): EventFilter;

    Deposit(sender: string | null, value: null): EventFilter;

    OwnerAddition(owner: string | null): EventFilter;

    OwnerRemoval(owner: string | null): EventFilter;

    RequirementChange(required: null): EventFilter;
  };

  estimateGas: {
    owners(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

    "owners(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    removeOwner(owner: string, overrides?: Overrides): Promise<BigNumber>;

    "removeOwner(address)"(
      owner: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    revokeConfirmation(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "revokeConfirmation(uint256)"(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

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

    "isOwner(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    confirmations(
      arg0: BigNumberish,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "confirmations(uint256,address)"(
      arg0: BigNumberish,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getTransactionCount(
      pending: boolean,
      executed: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getTransactionCount(bool,bool)"(
      pending: boolean,
      executed: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    addOwner(owner: string, overrides?: Overrides): Promise<BigNumber>;

    "addOwner(address)"(
      owner: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    isConfirmed(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "isConfirmed(uint256)"(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getConfirmationCount(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getConfirmationCount(uint256)"(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "transactions(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getTransactionIds(
      from: BigNumberish,
      to: BigNumberish,
      pending: boolean,
      executed: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getTransactionIds(uint256,uint256,bool,bool)"(
      from: BigNumberish,
      to: BigNumberish,
      pending: boolean,
      executed: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getConfirmations(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getConfirmations(uint256)"(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    changeRequirement(
      _required: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "changeRequirement(uint256)"(
      _required: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    confirmTransaction(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "confirmTransaction(uint256)"(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    submitTransaction(
      destination: string,
      value: BigNumberish,
      data: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "submitTransaction(address,uint256,bytes)"(
      destination: string,
      value: BigNumberish,
      data: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;

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

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

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

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

    replaceOwner(
      owner: string,
      newOwner: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "replaceOwner(address,address)"(
      owner: string,
      newOwner: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    executeTransaction(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "executeTransaction(uint256)"(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    owners(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "owners(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    removeOwner(
      owner: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "removeOwner(address)"(
      owner: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    revokeConfirmation(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "revokeConfirmation(uint256)"(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

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

    "isOwner(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    confirmations(
      arg0: BigNumberish,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "confirmations(uint256,address)"(
      arg0: BigNumberish,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getTransactionCount(
      pending: boolean,
      executed: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getTransactionCount(bool,bool)"(
      pending: boolean,
      executed: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    addOwner(
      owner: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "addOwner(address)"(
      owner: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    isConfirmed(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "isConfirmed(uint256)"(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getConfirmationCount(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getConfirmationCount(uint256)"(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "transactions(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    getTransactionIds(
      from: BigNumberish,
      to: BigNumberish,
      pending: boolean,
      executed: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getTransactionIds(uint256,uint256,bool,bool)"(
      from: BigNumberish,
      to: BigNumberish,
      pending: boolean,
      executed: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getConfirmations(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getConfirmations(uint256)"(
      transactionId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    changeRequirement(
      _required: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "changeRequirement(uint256)"(
      _required: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    confirmTransaction(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "confirmTransaction(uint256)"(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    submitTransaction(
      destination: string,
      value: BigNumberish,
      data: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "submitTransaction(address,uint256,bytes)"(
      destination: string,
      value: BigNumberish,
      data: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    replaceOwner(
      owner: string,
      newOwner: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "replaceOwner(address,address)"(
      owner: string,
      newOwner: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    executeTransaction(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "executeTransaction(uint256)"(
      transactionId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;
  };
}
