/* 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 AmbBridgeInterface extends ethers.utils.Interface {
  functions: {
    "transactionHash()": FunctionFragment;
    "numMessagesSigned(bytes32)": FunctionFragment;
    "confirmInformation(bytes32,bool,bytes)": FunctionFragment;
    "sourceChainId()": FunctionFragment;
    "_sendMessage(address,bytes,uint256,uint256)": FunctionFragment;
    "signature(bytes32,uint256)": FunctionFragment;
    "initialize(uint256,uint256,address,uint256,uint256,uint256,address)": FunctionFragment;
    "isInitialized()": FunctionFragment;
    "requiredBlockConfirmations()": FunctionFragment;
    "getMinimumGasUsage(bytes)": FunctionFragment;
    "failedMessageReceiver(bytes32)": FunctionFragment;
    "getBridgeMode()": FunctionFragment;
    "setChainIds(uint256,uint256)": FunctionFragment;
    "message(bytes32)": FunctionFragment;
    "failedMessageSender(bytes32)": FunctionFragment;
    "allowReentrantRequests()": FunctionFragment;
    "requireToGetInformation(bytes32,bytes)": FunctionFragment;
    "submitSignature(bytes,bytes)": FunctionFragment;
    "messageId()": FunctionFragment;
    "numAffirmationsSigned(bytes32)": FunctionFragment;
    "affirmationsSigned(bytes32)": FunctionFragment;
    "setMaxGasPerTx(uint256)": FunctionFragment;
    "requiredSignatures()": FunctionFragment;
    "owner()": FunctionFragment;
    "messagesSigned(bytes32)": FunctionFragment;
    "requireToConfirmMessage(address,bytes,uint256)": FunctionFragment;
    "validatorContract()": FunctionFragment;
    "deployedAtBlock()": FunctionFragment;
    "getBridgeInterfacesVersion()": FunctionFragment;
    "messageSourceChainId()": FunctionFragment;
    "setRequiredBlockConfirmations(uint256)": FunctionFragment;
    "destinationChainId()": FunctionFragment;
    "setGasPrice(uint256)": FunctionFragment;
    "setAllowReentrantRequests(bool)": FunctionFragment;
    "enableAsyncRequestSelector(bytes32,bool)": FunctionFragment;
    "messageCallStatus(bytes32)": FunctionFragment;
    "messageSender()": FunctionFragment;
    "decimalShift()": FunctionFragment;
    "requireToPassMessage(address,bytes,uint256)": FunctionFragment;
    "failedMessageDataHash(bytes32)": FunctionFragment;
    "maxGasPerTx()": FunctionFragment;
    "executeAffirmation(bytes)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "isAsyncRequestSelectorEnabled(bytes32)": FunctionFragment;
    "gasPrice()": FunctionFragment;
    "isAlreadyProcessed(uint256)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "transactionHash",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "numMessagesSigned",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "confirmInformation",
    values: [BytesLike, boolean, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "sourceChainId",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "_sendMessage",
    values: [string, BytesLike, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "signature",
    values: [BytesLike, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [
      BigNumberish,
      BigNumberish,
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      string
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "isInitialized",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "requiredBlockConfirmations",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getMinimumGasUsage",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "failedMessageReceiver",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "getBridgeMode",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setChainIds",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "message", values: [BytesLike]): string;
  encodeFunctionData(
    functionFragment: "failedMessageSender",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "allowReentrantRequests",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "requireToGetInformation",
    values: [BytesLike, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "submitSignature",
    values: [BytesLike, BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "messageId", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "numAffirmationsSigned",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "affirmationsSigned",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "setMaxGasPerTx",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "requiredSignatures",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "messagesSigned",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "requireToConfirmMessage",
    values: [string, BytesLike, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "validatorContract",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "deployedAtBlock",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getBridgeInterfacesVersion",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "messageSourceChainId",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setRequiredBlockConfirmations",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "destinationChainId",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setGasPrice",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setAllowReentrantRequests",
    values: [boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "enableAsyncRequestSelector",
    values: [BytesLike, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "messageCallStatus",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "messageSender",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "decimalShift",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "requireToPassMessage",
    values: [string, BytesLike, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "failedMessageDataHash",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "maxGasPerTx",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "executeAffirmation",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "isAsyncRequestSelectorEnabled",
    values: [BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "gasPrice", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "isAlreadyProcessed",
    values: [BigNumberish]
  ): string;

  decodeFunctionResult(
    functionFragment: "transactionHash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "numMessagesSigned",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "confirmInformation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "sourceChainId",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_sendMessage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "signature", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isInitialized",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "requiredBlockConfirmations",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getMinimumGasUsage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "failedMessageReceiver",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getBridgeMode",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setChainIds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "message", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "failedMessageSender",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "allowReentrantRequests",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "requireToGetInformation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "submitSignature",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "messageId", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "numAffirmationsSigned",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "affirmationsSigned",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMaxGasPerTx",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "requiredSignatures",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "messagesSigned",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "requireToConfirmMessage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "validatorContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "deployedAtBlock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getBridgeInterfacesVersion",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "messageSourceChainId",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRequiredBlockConfirmations",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "destinationChainId",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setGasPrice",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setAllowReentrantRequests",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "enableAsyncRequestSelector",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "messageCallStatus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "messageSender",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "decimalShift",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "requireToPassMessage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "failedMessageDataHash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "maxGasPerTx",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "executeAffirmation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isAsyncRequestSelectorEnabled",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "gasPrice", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isAlreadyProcessed",
    data: BytesLike
  ): Result;

  events: {
    "UserRequestForSignature(bytes32,bytes)": EventFragment;
    "AffirmationCompleted(address,address,bytes32,bool)": EventFragment;
    "UserRequestForInformation(bytes32,bytes32,address,bytes)": EventFragment;
    "SignedForInformation(address,bytes32)": EventFragment;
    "InformationRetrieved(bytes32,bool,bool)": EventFragment;
    "EnabledAsyncRequestSelector(bytes32,bool)": EventFragment;
    "SignedForUserRequest(address,bytes32)": EventFragment;
    "SignedForAffirmation(address,bytes32)": EventFragment;
    "CollectedSignatures(address,bytes32,uint256)": EventFragment;
    "GasPriceChanged(uint256)": EventFragment;
    "RequiredBlockConfirmationChanged(uint256)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "UserRequestForSignature"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "AffirmationCompleted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UserRequestForInformation"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SignedForInformation"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "InformationRetrieved"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "EnabledAsyncRequestSelector"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SignedForUserRequest"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SignedForAffirmation"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "CollectedSignatures"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "GasPriceChanged"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "RequiredBlockConfirmationChanged"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
}

export type UserRequestForSignatureEvent = TypedEvent<
  [string, string] & { messageId: string; encodedData: string }
>;

export type AffirmationCompletedEvent = TypedEvent<
  [string, string, string, boolean] & {
    sender: string;
    executor: string;
    messageId: string;
    status: boolean;
  }
>;

export type UserRequestForInformationEvent = TypedEvent<
  [string, string, string, string] & {
    messageId: string;
    requestSelector: string;
    sender: string;
    data: string;
  }
>;

export type SignedForInformationEvent = TypedEvent<
  [string, string] & { signer: string; messageId: string }
>;

export type InformationRetrievedEvent = TypedEvent<
  [string, boolean, boolean] & {
    messageId: string;
    status: boolean;
    callbackStatus: boolean;
  }
>;

export type EnabledAsyncRequestSelectorEvent = TypedEvent<
  [string, boolean] & { requestSelector: string; enable: boolean }
>;

export type SignedForUserRequestEvent = TypedEvent<
  [string, string] & { signer: string; messageHash: string }
>;

export type SignedForAffirmationEvent = TypedEvent<
  [string, string] & { signer: string; messageHash: string }
>;

export type CollectedSignaturesEvent = TypedEvent<
  [string, string, BigNumber] & {
    authorityResponsibleForRelay: string;
    messageHash: string;
    NumberOfCollectedSignatures: BigNumber;
  }
>;

export type GasPriceChangedEvent = TypedEvent<
  [BigNumber] & { gasPrice: BigNumber }
>;

export type RequiredBlockConfirmationChangedEvent = TypedEvent<
  [BigNumber] & { requiredBlockConfirmations: BigNumber }
>;

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

export class AmbBridge 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: AmbBridgeInterface;

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

    numMessagesSigned(
      _message: BytesLike,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    confirmInformation(
      _messageId: BytesLike,
      _status: boolean,
      _result: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    _sendMessage(
      _contract: string,
      _data: BytesLike,
      _gas: BigNumberish,
      _dataType: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    initialize(
      _sourceChainId: BigNumberish,
      _destinationChainId: BigNumberish,
      _validatorContract: string,
      _maxGasPerTx: BigNumberish,
      _gasPrice: BigNumberish,
      _requiredBlockConfirmations: BigNumberish,
      _owner: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    isInitialized(overrides?: CallOverrides): Promise<[boolean]>;

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

    getMinimumGasUsage(
      _data: BytesLike,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { gas: BigNumber }>;

    failedMessageReceiver(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getBridgeMode(
      overrides?: CallOverrides
    ): Promise<[string] & { _data: string }>;

    setChainIds(
      _sourceChainId: BigNumberish,
      _destinationChainId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    message(_hash: BytesLike, overrides?: CallOverrides): Promise<[string]>;

    failedMessageSender(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string]>;

    allowReentrantRequests(overrides?: CallOverrides): Promise<[boolean]>;

    requireToGetInformation(
      _requestSelector: BytesLike,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    submitSignature(
      signature: BytesLike,
      message: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    messageId(overrides?: CallOverrides): Promise<[string] & { id: string }>;

    numAffirmationsSigned(
      _hash: BytesLike,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    affirmationsSigned(
      _hash: BytesLike,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

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

    messagesSigned(
      _message: BytesLike,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    requireToConfirmMessage(
      _contract: string,
      _data: BytesLike,
      _gas: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    getBridgeInterfacesVersion(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        major: BigNumber;
        minor: BigNumber;
        patch: BigNumber;
      }
    >;

    messageSourceChainId(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { id: BigNumber }>;

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

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

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

    setAllowReentrantRequests(
      _enable: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    enableAsyncRequestSelector(
      _requestSelector: BytesLike,
      _enable: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    messageCallStatus(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    messageSender(
      overrides?: CallOverrides
    ): Promise<[string] & { sender: string }>;

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

    requireToPassMessage(
      _contract: string,
      _data: BytesLike,
      _gas: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    failedMessageDataHash(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

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

    isAsyncRequestSelectorEnabled(
      _requestSelector: BytesLike,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

    isAlreadyProcessed(
      _number: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean]>;
  };

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

  numMessagesSigned(
    _message: BytesLike,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  confirmInformation(
    _messageId: BytesLike,
    _status: boolean,
    _result: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  _sendMessage(
    _contract: string,
    _data: BytesLike,
    _gas: BigNumberish,
    _dataType: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  signature(
    _hash: BytesLike,
    _index: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  initialize(
    _sourceChainId: BigNumberish,
    _destinationChainId: BigNumberish,
    _validatorContract: string,
    _maxGasPerTx: BigNumberish,
    _gasPrice: BigNumberish,
    _requiredBlockConfirmations: BigNumberish,
    _owner: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  isInitialized(overrides?: CallOverrides): Promise<boolean>;

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

  getMinimumGasUsage(
    _data: BytesLike,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  failedMessageReceiver(
    _messageId: BytesLike,
    overrides?: CallOverrides
  ): Promise<string>;

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

  setChainIds(
    _sourceChainId: BigNumberish,
    _destinationChainId: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  message(_hash: BytesLike, overrides?: CallOverrides): Promise<string>;

  failedMessageSender(
    _messageId: BytesLike,
    overrides?: CallOverrides
  ): Promise<string>;

  allowReentrantRequests(overrides?: CallOverrides): Promise<boolean>;

  requireToGetInformation(
    _requestSelector: BytesLike,
    _data: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  submitSignature(
    signature: BytesLike,
    message: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  numAffirmationsSigned(
    _hash: BytesLike,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  affirmationsSigned(
    _hash: BytesLike,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

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

  messagesSigned(
    _message: BytesLike,
    overrides?: CallOverrides
  ): Promise<boolean>;

  requireToConfirmMessage(
    _contract: string,
    _data: BytesLike,
    _gas: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  getBridgeInterfacesVersion(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber] & {
      major: BigNumber;
      minor: BigNumber;
      patch: BigNumber;
    }
  >;

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

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

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

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

  setAllowReentrantRequests(
    _enable: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  enableAsyncRequestSelector(
    _requestSelector: BytesLike,
    _enable: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  messageCallStatus(
    _messageId: BytesLike,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

  requireToPassMessage(
    _contract: string,
    _data: BytesLike,
    _gas: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  failedMessageDataHash(
    _messageId: BytesLike,
    overrides?: CallOverrides
  ): Promise<string>;

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

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

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

  isAsyncRequestSelectorEnabled(
    _requestSelector: BytesLike,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

  isAlreadyProcessed(
    _number: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

    numMessagesSigned(
      _message: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    confirmInformation(
      _messageId: BytesLike,
      _status: boolean,
      _result: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

    _sendMessage(
      _contract: string,
      _data: BytesLike,
      _gas: BigNumberish,
      _dataType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    signature(
      _hash: BytesLike,
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    initialize(
      _sourceChainId: BigNumberish,
      _destinationChainId: BigNumberish,
      _validatorContract: string,
      _maxGasPerTx: BigNumberish,
      _gasPrice: BigNumberish,
      _requiredBlockConfirmations: BigNumberish,
      _owner: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isInitialized(overrides?: CallOverrides): Promise<boolean>;

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

    getMinimumGasUsage(
      _data: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    failedMessageReceiver(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

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

    setChainIds(
      _sourceChainId: BigNumberish,
      _destinationChainId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    message(_hash: BytesLike, overrides?: CallOverrides): Promise<string>;

    failedMessageSender(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

    allowReentrantRequests(overrides?: CallOverrides): Promise<boolean>;

    requireToGetInformation(
      _requestSelector: BytesLike,
      _data: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

    submitSignature(
      signature: BytesLike,
      message: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

    numAffirmationsSigned(
      _hash: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    affirmationsSigned(
      _hash: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

    setMaxGasPerTx(
      _maxGasPerTx: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    messagesSigned(
      _message: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

    requireToConfirmMessage(
      _contract: string,
      _data: BytesLike,
      _gas: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

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

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

    getBridgeInterfacesVersion(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        major: BigNumber;
        minor: BigNumber;
        patch: BigNumber;
      }
    >;

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

    setRequiredBlockConfirmations(
      _blockConfirmations: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    setGasPrice(
      _gasPrice: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setAllowReentrantRequests(
      _enable: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    enableAsyncRequestSelector(
      _requestSelector: BytesLike,
      _enable: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    messageCallStatus(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

    requireToPassMessage(
      _contract: string,
      _data: BytesLike,
      _gas: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    failedMessageDataHash(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

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

    executeAffirmation(
      message: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

    isAsyncRequestSelectorEnabled(
      _requestSelector: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    isAlreadyProcessed(
      _number: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;
  };

  filters: {
    "UserRequestForSignature(bytes32,bytes)"(
      messageId?: BytesLike | null,
      encodedData?: null
    ): TypedEventFilter<
      [string, string],
      { messageId: string; encodedData: string }
    >;

    UserRequestForSignature(
      messageId?: BytesLike | null,
      encodedData?: null
    ): TypedEventFilter<
      [string, string],
      { messageId: string; encodedData: string }
    >;

    "AffirmationCompleted(address,address,bytes32,bool)"(
      sender?: string | null,
      executor?: string | null,
      messageId?: BytesLike | null,
      status?: null
    ): TypedEventFilter<
      [string, string, string, boolean],
      { sender: string; executor: string; messageId: string; status: boolean }
    >;

    AffirmationCompleted(
      sender?: string | null,
      executor?: string | null,
      messageId?: BytesLike | null,
      status?: null
    ): TypedEventFilter<
      [string, string, string, boolean],
      { sender: string; executor: string; messageId: string; status: boolean }
    >;

    "UserRequestForInformation(bytes32,bytes32,address,bytes)"(
      messageId?: BytesLike | null,
      requestSelector?: BytesLike | null,
      sender?: string | null,
      data?: null
    ): TypedEventFilter<
      [string, string, string, string],
      {
        messageId: string;
        requestSelector: string;
        sender: string;
        data: string;
      }
    >;

    UserRequestForInformation(
      messageId?: BytesLike | null,
      requestSelector?: BytesLike | null,
      sender?: string | null,
      data?: null
    ): TypedEventFilter<
      [string, string, string, string],
      {
        messageId: string;
        requestSelector: string;
        sender: string;
        data: string;
      }
    >;

    "SignedForInformation(address,bytes32)"(
      signer?: string | null,
      messageId?: BytesLike | null
    ): TypedEventFilter<
      [string, string],
      { signer: string; messageId: string }
    >;

    SignedForInformation(
      signer?: string | null,
      messageId?: BytesLike | null
    ): TypedEventFilter<
      [string, string],
      { signer: string; messageId: string }
    >;

    "InformationRetrieved(bytes32,bool,bool)"(
      messageId?: BytesLike | null,
      status?: null,
      callbackStatus?: null
    ): TypedEventFilter<
      [string, boolean, boolean],
      { messageId: string; status: boolean; callbackStatus: boolean }
    >;

    InformationRetrieved(
      messageId?: BytesLike | null,
      status?: null,
      callbackStatus?: null
    ): TypedEventFilter<
      [string, boolean, boolean],
      { messageId: string; status: boolean; callbackStatus: boolean }
    >;

    "EnabledAsyncRequestSelector(bytes32,bool)"(
      requestSelector?: BytesLike | null,
      enable?: null
    ): TypedEventFilter<
      [string, boolean],
      { requestSelector: string; enable: boolean }
    >;

    EnabledAsyncRequestSelector(
      requestSelector?: BytesLike | null,
      enable?: null
    ): TypedEventFilter<
      [string, boolean],
      { requestSelector: string; enable: boolean }
    >;

    "SignedForUserRequest(address,bytes32)"(
      signer?: string | null,
      messageHash?: null
    ): TypedEventFilter<
      [string, string],
      { signer: string; messageHash: string }
    >;

    SignedForUserRequest(
      signer?: string | null,
      messageHash?: null
    ): TypedEventFilter<
      [string, string],
      { signer: string; messageHash: string }
    >;

    "SignedForAffirmation(address,bytes32)"(
      signer?: string | null,
      messageHash?: null
    ): TypedEventFilter<
      [string, string],
      { signer: string; messageHash: string }
    >;

    SignedForAffirmation(
      signer?: string | null,
      messageHash?: null
    ): TypedEventFilter<
      [string, string],
      { signer: string; messageHash: string }
    >;

    "CollectedSignatures(address,bytes32,uint256)"(
      authorityResponsibleForRelay?: null,
      messageHash?: null,
      NumberOfCollectedSignatures?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      {
        authorityResponsibleForRelay: string;
        messageHash: string;
        NumberOfCollectedSignatures: BigNumber;
      }
    >;

    CollectedSignatures(
      authorityResponsibleForRelay?: null,
      messageHash?: null,
      NumberOfCollectedSignatures?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      {
        authorityResponsibleForRelay: string;
        messageHash: string;
        NumberOfCollectedSignatures: BigNumber;
      }
    >;

    "GasPriceChanged(uint256)"(
      gasPrice?: null
    ): TypedEventFilter<[BigNumber], { gasPrice: BigNumber }>;

    GasPriceChanged(
      gasPrice?: null
    ): TypedEventFilter<[BigNumber], { gasPrice: BigNumber }>;

    "RequiredBlockConfirmationChanged(uint256)"(
      requiredBlockConfirmations?: null
    ): TypedEventFilter<[BigNumber], { requiredBlockConfirmations: BigNumber }>;

    RequiredBlockConfirmationChanged(
      requiredBlockConfirmations?: null
    ): TypedEventFilter<[BigNumber], { requiredBlockConfirmations: BigNumber }>;

    "OwnershipTransferred(address,address)"(
      previousOwner?: null,
      newOwner?: null
    ): TypedEventFilter<
      [string, string],
      { previousOwner: string; newOwner: string }
    >;

    OwnershipTransferred(
      previousOwner?: null,
      newOwner?: null
    ): TypedEventFilter<
      [string, string],
      { previousOwner: string; newOwner: string }
    >;
  };

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

    numMessagesSigned(
      _message: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    confirmInformation(
      _messageId: BytesLike,
      _status: boolean,
      _result: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    _sendMessage(
      _contract: string,
      _data: BytesLike,
      _gas: BigNumberish,
      _dataType: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    signature(
      _hash: BytesLike,
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    initialize(
      _sourceChainId: BigNumberish,
      _destinationChainId: BigNumberish,
      _validatorContract: string,
      _maxGasPerTx: BigNumberish,
      _gasPrice: BigNumberish,
      _requiredBlockConfirmations: BigNumberish,
      _owner: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    getMinimumGasUsage(
      _data: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    failedMessageReceiver(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    setChainIds(
      _sourceChainId: BigNumberish,
      _destinationChainId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    message(_hash: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;

    failedMessageSender(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    requireToGetInformation(
      _requestSelector: BytesLike,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    submitSignature(
      signature: BytesLike,
      message: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    numAffirmationsSigned(
      _hash: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    affirmationsSigned(
      _hash: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    messagesSigned(
      _message: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    requireToConfirmMessage(
      _contract: string,
      _data: BytesLike,
      _gas: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    setAllowReentrantRequests(
      _enable: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    enableAsyncRequestSelector(
      _requestSelector: BytesLike,
      _enable: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    messageCallStatus(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    requireToPassMessage(
      _contract: string,
      _data: BytesLike,
      _gas: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    failedMessageDataHash(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    isAsyncRequestSelectorEnabled(
      _requestSelector: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    isAlreadyProcessed(
      _number: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;
  };

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

    numMessagesSigned(
      _message: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    confirmInformation(
      _messageId: BytesLike,
      _status: boolean,
      _result: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    _sendMessage(
      _contract: string,
      _data: BytesLike,
      _gas: BigNumberish,
      _dataType: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    signature(
      _hash: BytesLike,
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    initialize(
      _sourceChainId: BigNumberish,
      _destinationChainId: BigNumberish,
      _validatorContract: string,
      _maxGasPerTx: BigNumberish,
      _gasPrice: BigNumberish,
      _requiredBlockConfirmations: BigNumberish,
      _owner: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    getMinimumGasUsage(
      _data: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    failedMessageReceiver(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    setChainIds(
      _sourceChainId: BigNumberish,
      _destinationChainId: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    message(
      _hash: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    failedMessageSender(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    requireToGetInformation(
      _requestSelector: BytesLike,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    submitSignature(
      signature: BytesLike,
      message: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    numAffirmationsSigned(
      _hash: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    affirmationsSigned(
      _hash: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    messagesSigned(
      _message: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    requireToConfirmMessage(
      _contract: string,
      _data: BytesLike,
      _gas: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

    setAllowReentrantRequests(
      _enable: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    enableAsyncRequestSelector(
      _requestSelector: BytesLike,
      _enable: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    messageCallStatus(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    requireToPassMessage(
      _contract: string,
      _data: BytesLike,
      _gas: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    failedMessageDataHash(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    isAsyncRequestSelectorEnabled(
      _requestSelector: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    isAlreadyProcessed(
      _number: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;
  };
}