/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import type {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  PayableOverrides,
  PopulatedTransaction,
  Signer,
  utils,
} from "ethers";
import type {
  FunctionFragment,
  Result,
  EventFragment,
} from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type {
  TypedEventFilter,
  TypedEvent,
  TypedListener,
  OnEvent,
  PromiseOrValue,
} from "../../../common";

export declare namespace IMessagePassingBridge {
  export type BridgeLimitsStruct = {
    dailyLimit: PromiseOrValue<BigNumberish>;
    txLimit: PromiseOrValue<BigNumberish>;
    accountDailyLimit: PromiseOrValue<BigNumberish>;
    minAmount: PromiseOrValue<BigNumberish>;
    onlyWhitelisted: PromiseOrValue<boolean>;
  };

  export type BridgeLimitsStructOutput = [
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    boolean
  ] & {
    dailyLimit: BigNumber;
    txLimit: BigNumber;
    accountDailyLimit: BigNumber;
    minAmount: BigNumber;
    onlyWhitelisted: boolean;
  };

  export type BridgeFeesStruct = {
    minFee: PromiseOrValue<BigNumberish>;
    maxFee: PromiseOrValue<BigNumberish>;
    fee: PromiseOrValue<BigNumberish>;
  };

  export type BridgeFeesStructOutput = [BigNumber, BigNumber, BigNumber] & {
    minFee: BigNumber;
    maxFee: BigNumber;
    fee: BigNumber;
  };
}

export interface MessagePassingBridgeInterface extends utils.Interface {
  functions: {
    "DEFAULT_PAYLOAD_SIZE_LIMIT()": FunctionFragment;
    "HOME_CHAIN_ID()": FunctionFragment;
    "accountsDailyLimit(address)": FunctionFragment;
    "addLzChainSupport(uint16,uint256,address)": FunctionFragment;
    "approveRequest(uint256)": FunctionFragment;
    "approvedRequests(uint256)": FunctionFragment;
    "avatar()": FunctionFragment;
    "bridgeDailyLimit()": FunctionFragment;
    "bridgeFees()": FunctionFragment;
    "bridgeLimits()": FunctionFragment;
    "bridgeTo(address,uint256,uint256,uint8)": FunctionFragment;
    "bridgeToWithAxelar(address,uint256,uint256,address)": FunctionFragment;
    "bridgeToWithLz(address,uint256,uint256,bytes)": FunctionFragment;
    "canBridge(address,uint256)": FunctionFragment;
    "currentId()": FunctionFragment;
    "dao()": FunctionFragment;
    "disabledSourceBridges(bytes32)": FunctionFragment;
    "estimateSendFee(uint16,address,address,uint256,bool,bytes)": FunctionFragment;
    "execute(bytes32,string,string,bytes)": FunctionFragment;
    "executeWithToken(bytes32,string,string,bytes,string,uint256)": FunctionFragment;
    "executedRequests(uint256)": FunctionFragment;
    "failedMessages(uint16,bytes,uint64)": FunctionFragment;
    "faucet()": FunctionFragment;
    "feeRecipient()": FunctionFragment;
    "forceResumeReceive(uint16,bytes)": FunctionFragment;
    "fromAxelarChainId(string)": FunctionFragment;
    "fromLzChainId(uint16)": FunctionFragment;
    "gasService()": FunctionFragment;
    "gateway()": FunctionFragment;
    "getConfig(uint16,uint16,address,uint256)": FunctionFragment;
    "getTrustedRemoteAddress(uint16)": FunctionFragment;
    "guardian()": FunctionFragment;
    "initialize(address,(uint256,uint256,uint256,uint256,bool),(uint256,uint256,uint256))": FunctionFragment;
    "isClosed()": FunctionFragment;
    "isTrustedRemote(uint16,bytes)": FunctionFragment;
    "lzChainIdsMapping(uint256)": FunctionFragment;
    "lzChainToIdsMapping(uint16)": FunctionFragment;
    "lzEndpoint()": FunctionFragment;
    "lzEndpoint_()": FunctionFragment;
    "lzReceive(uint16,bytes,uint64,bytes)": FunctionFragment;
    "minDstGasLookup(uint16,uint16)": FunctionFragment;
    "nameService()": FunctionFragment;
    "nativeToken()": FunctionFragment;
    "nonblockingLzReceive(uint16,bytes,uint64,bytes)": FunctionFragment;
    "owner()": FunctionFragment;
    "pauseBridge(bool)": FunctionFragment;
    "payloadSizeLimitLookup(uint16)": FunctionFragment;
    "precrime()": FunctionFragment;
    "preventRequest(uint256)": FunctionFragment;
    "proxiableUUID()": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "retryMessage(uint16,bytes,uint64,bytes)": FunctionFragment;
    "setBridgeFees((uint256,uint256,uint256))": FunctionFragment;
    "setBridgeLimits((uint256,uint256,uint256,uint256,bool))": FunctionFragment;
    "setConfig(uint16,uint16,uint256,bytes)": FunctionFragment;
    "setDisabledBridges(bytes32[],bool[])": FunctionFragment;
    "setFaucet(address)": FunctionFragment;
    "setFeeRecipient(address)": FunctionFragment;
    "setGuardian(address)": FunctionFragment;
    "setMinDstGas(uint16,uint16,uint256)": FunctionFragment;
    "setPayloadSizeLimit(uint16,uint256)": FunctionFragment;
    "setPrecrime(address)": FunctionFragment;
    "setReceiveVersion(uint16)": FunctionFragment;
    "setSendVersion(uint16)": FunctionFragment;
    "setTrustedRemote(uint16,bytes)": FunctionFragment;
    "setTrustedRemoteAddress(uint16,bytes)": FunctionFragment;
    "toAxelarChainId(uint256)": FunctionFragment;
    "toLzChainId(uint256)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "trustedRemoteLookup(uint16)": FunctionFragment;
    "updateAvatar()": FunctionFragment;
    "upgrade()": FunctionFragment;
    "upgradeTo(address)": FunctionFragment;
    "upgradeToAndCall(address,bytes)": FunctionFragment;
    "withdraw(address,uint256)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "DEFAULT_PAYLOAD_SIZE_LIMIT"
      | "HOME_CHAIN_ID"
      | "accountsDailyLimit"
      | "addLzChainSupport"
      | "approveRequest"
      | "approvedRequests"
      | "avatar"
      | "bridgeDailyLimit"
      | "bridgeFees"
      | "bridgeLimits"
      | "bridgeTo"
      | "bridgeToWithAxelar"
      | "bridgeToWithLz"
      | "canBridge"
      | "currentId"
      | "dao"
      | "disabledSourceBridges"
      | "estimateSendFee"
      | "execute"
      | "executeWithToken"
      | "executedRequests"
      | "failedMessages"
      | "faucet"
      | "feeRecipient"
      | "forceResumeReceive"
      | "fromAxelarChainId"
      | "fromLzChainId"
      | "gasService"
      | "gateway"
      | "getConfig"
      | "getTrustedRemoteAddress"
      | "guardian"
      | "initialize"
      | "isClosed"
      | "isTrustedRemote"
      | "lzChainIdsMapping"
      | "lzChainToIdsMapping"
      | "lzEndpoint"
      | "lzEndpoint_"
      | "lzReceive"
      | "minDstGasLookup"
      | "nameService"
      | "nativeToken"
      | "nonblockingLzReceive"
      | "owner"
      | "pauseBridge"
      | "payloadSizeLimitLookup"
      | "precrime"
      | "preventRequest"
      | "proxiableUUID"
      | "renounceOwnership"
      | "retryMessage"
      | "setBridgeFees"
      | "setBridgeLimits"
      | "setConfig"
      | "setDisabledBridges"
      | "setFaucet"
      | "setFeeRecipient"
      | "setGuardian"
      | "setMinDstGas"
      | "setPayloadSizeLimit"
      | "setPrecrime"
      | "setReceiveVersion"
      | "setSendVersion"
      | "setTrustedRemote"
      | "setTrustedRemoteAddress"
      | "toAxelarChainId"
      | "toLzChainId"
      | "transferOwnership"
      | "trustedRemoteLookup"
      | "updateAvatar"
      | "upgrade"
      | "upgradeTo"
      | "upgradeToAndCall"
      | "withdraw"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "DEFAULT_PAYLOAD_SIZE_LIMIT",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "HOME_CHAIN_ID",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "accountsDailyLimit",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "addLzChainSupport",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "approveRequest",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "approvedRequests",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(functionFragment: "avatar", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "bridgeDailyLimit",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "bridgeFees",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "bridgeLimits",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "bridgeTo",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "bridgeToWithAxelar",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "bridgeToWithLz",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "canBridge",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(functionFragment: "currentId", values?: undefined): string;
  encodeFunctionData(functionFragment: "dao", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "disabledSourceBridges",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "estimateSendFee",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<boolean>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "execute",
    values: [
      PromiseOrValue<BytesLike>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "executeWithToken",
    values: [
      PromiseOrValue<BytesLike>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "executedRequests",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "failedMessages",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(functionFragment: "faucet", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "feeRecipient",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "forceResumeReceive",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "fromAxelarChainId",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "fromLzChainId",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "gasService",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "gateway", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getConfig",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "getTrustedRemoteAddress",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(functionFragment: "guardian", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [
      PromiseOrValue<string>,
      IMessagePassingBridge.BridgeLimitsStruct,
      IMessagePassingBridge.BridgeFeesStruct
    ]
  ): string;
  encodeFunctionData(functionFragment: "isClosed", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "isTrustedRemote",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "lzChainIdsMapping",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "lzChainToIdsMapping",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "lzEndpoint",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "lzEndpoint_",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "lzReceive",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "minDstGasLookup",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "nameService",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "nativeToken",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "nonblockingLzReceive",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "pauseBridge",
    values: [PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "payloadSizeLimitLookup",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(functionFragment: "precrime", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "preventRequest",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "proxiableUUID",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "retryMessage",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "setBridgeFees",
    values: [IMessagePassingBridge.BridgeFeesStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "setBridgeLimits",
    values: [IMessagePassingBridge.BridgeLimitsStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "setConfig",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "setDisabledBridges",
    values: [PromiseOrValue<BytesLike>[], PromiseOrValue<boolean>[]]
  ): string;
  encodeFunctionData(
    functionFragment: "setFaucet",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setFeeRecipient",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setGuardian",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setMinDstGas",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "setPayloadSizeLimit",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setPrecrime",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setReceiveVersion",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setSendVersion",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setTrustedRemote",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "setTrustedRemoteAddress",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "toAxelarChainId",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "toLzChainId",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "trustedRemoteLookup",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "updateAvatar",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "upgrade", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "upgradeTo",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "upgradeToAndCall",
    values: [PromiseOrValue<string>, PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;

  decodeFunctionResult(
    functionFragment: "DEFAULT_PAYLOAD_SIZE_LIMIT",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "HOME_CHAIN_ID",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "accountsDailyLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "addLzChainSupport",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "approveRequest",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "approvedRequests",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "avatar", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "bridgeDailyLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "bridgeFees", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "bridgeLimits",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "bridgeTo", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "bridgeToWithAxelar",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "bridgeToWithLz",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "canBridge", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "currentId", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "dao", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "disabledSourceBridges",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "estimateSendFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "executeWithToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "executedRequests",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "failedMessages",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "faucet", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "feeRecipient",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "forceResumeReceive",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "fromAxelarChainId",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "fromLzChainId",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "gasService", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "gateway", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getConfig", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getTrustedRemoteAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "guardian", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "isClosed", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isTrustedRemote",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lzChainIdsMapping",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lzChainToIdsMapping",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "lzEndpoint", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "lzEndpoint_",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "lzReceive", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "minDstGasLookup",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "nameService",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "nativeToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "nonblockingLzReceive",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "pauseBridge",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "payloadSizeLimitLookup",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "precrime", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "preventRequest",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "proxiableUUID",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "retryMessage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setBridgeFees",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setBridgeLimits",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setConfig", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setDisabledBridges",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setFaucet", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setFeeRecipient",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setGuardian",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMinDstGas",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPayloadSizeLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPrecrime",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setReceiveVersion",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setSendVersion",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTrustedRemote",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTrustedRemoteAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "toAxelarChainId",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "toLzChainId",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "trustedRemoteLookup",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateAvatar",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "upgrade", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "upgradeToAndCall",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;

  events: {
    "AdminChanged(address,address)": EventFragment;
    "BeaconUpgraded(address)": EventFragment;
    "BridgeRequest(address,address,uint256,uint256,uint256,uint8,uint256)": EventFragment;
    "ExecutedTransfer(address,address,uint256,uint256,uint256,uint8,uint256)": EventFragment;
    "FalseSender(uint256,address)": EventFragment;
    "Initialized(uint8)": EventFragment;
    "MessageFailed(uint16,bytes,uint64,bytes,bytes)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "RetryMessageSuccess(uint16,bytes,uint64,bytes32)": EventFragment;
    "SetMinDstGas(uint16,uint16,uint256)": EventFragment;
    "SetPrecrime(address)": EventFragment;
    "SetTrustedRemote(uint16,bytes)": EventFragment;
    "SetTrustedRemoteAddress(uint16,bytes)": EventFragment;
    "Upgraded(address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "BridgeRequest"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ExecutedTransfer"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FalseSender"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MessageFailed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RetryMessageSuccess"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetMinDstGas"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetPrecrime"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetTrustedRemote"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetTrustedRemoteAddress"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
}

export interface AdminChangedEventObject {
  previousAdmin: string;
  newAdmin: string;
}
export type AdminChangedEvent = TypedEvent<
  [string, string],
  AdminChangedEventObject
>;

export type AdminChangedEventFilter = TypedEventFilter<AdminChangedEvent>;

export interface BeaconUpgradedEventObject {
  beacon: string;
}
export type BeaconUpgradedEvent = TypedEvent<
  [string],
  BeaconUpgradedEventObject
>;

export type BeaconUpgradedEventFilter = TypedEventFilter<BeaconUpgradedEvent>;

export interface BridgeRequestEventObject {
  from: string;
  to: string;
  targetChainId: BigNumber;
  normalizedAmount: BigNumber;
  timestamp: BigNumber;
  bridge: number;
  id: BigNumber;
}
export type BridgeRequestEvent = TypedEvent<
  [string, string, BigNumber, BigNumber, BigNumber, number, BigNumber],
  BridgeRequestEventObject
>;

export type BridgeRequestEventFilter = TypedEventFilter<BridgeRequestEvent>;

export interface ExecutedTransferEventObject {
  from: string;
  to: string;
  normalizedAmount: BigNumber;
  fee: BigNumber;
  sourceChainId: BigNumber;
  bridge: number;
  id: BigNumber;
}
export type ExecutedTransferEvent = TypedEvent<
  [string, string, BigNumber, BigNumber, BigNumber, number, BigNumber],
  ExecutedTransferEventObject
>;

export type ExecutedTransferEventFilter =
  TypedEventFilter<ExecutedTransferEvent>;

export interface FalseSenderEventObject {
  sourceChainId: BigNumber;
  sourceAddress: string;
}
export type FalseSenderEvent = TypedEvent<
  [BigNumber, string],
  FalseSenderEventObject
>;

export type FalseSenderEventFilter = TypedEventFilter<FalseSenderEvent>;

export interface InitializedEventObject {
  version: number;
}
export type InitializedEvent = TypedEvent<[number], InitializedEventObject>;

export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;

export interface MessageFailedEventObject {
  _srcChainId: number;
  _srcAddress: string;
  _nonce: BigNumber;
  _payload: string;
  _reason: string;
}
export type MessageFailedEvent = TypedEvent<
  [number, string, BigNumber, string, string],
  MessageFailedEventObject
>;

export type MessageFailedEventFilter = TypedEventFilter<MessageFailedEvent>;

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

export type OwnershipTransferredEventFilter =
  TypedEventFilter<OwnershipTransferredEvent>;

export interface RetryMessageSuccessEventObject {
  _srcChainId: number;
  _srcAddress: string;
  _nonce: BigNumber;
  _payloadHash: string;
}
export type RetryMessageSuccessEvent = TypedEvent<
  [number, string, BigNumber, string],
  RetryMessageSuccessEventObject
>;

export type RetryMessageSuccessEventFilter =
  TypedEventFilter<RetryMessageSuccessEvent>;

export interface SetMinDstGasEventObject {
  _dstChainId: number;
  _type: number;
  _minDstGas: BigNumber;
}
export type SetMinDstGasEvent = TypedEvent<
  [number, number, BigNumber],
  SetMinDstGasEventObject
>;

export type SetMinDstGasEventFilter = TypedEventFilter<SetMinDstGasEvent>;

export interface SetPrecrimeEventObject {
  precrime: string;
}
export type SetPrecrimeEvent = TypedEvent<[string], SetPrecrimeEventObject>;

export type SetPrecrimeEventFilter = TypedEventFilter<SetPrecrimeEvent>;

export interface SetTrustedRemoteEventObject {
  _remoteChainId: number;
  _path: string;
}
export type SetTrustedRemoteEvent = TypedEvent<
  [number, string],
  SetTrustedRemoteEventObject
>;

export type SetTrustedRemoteEventFilter =
  TypedEventFilter<SetTrustedRemoteEvent>;

export interface SetTrustedRemoteAddressEventObject {
  _remoteChainId: number;
  _remoteAddress: string;
}
export type SetTrustedRemoteAddressEvent = TypedEvent<
  [number, string],
  SetTrustedRemoteAddressEventObject
>;

export type SetTrustedRemoteAddressEventFilter =
  TypedEventFilter<SetTrustedRemoteAddressEvent>;

export interface UpgradedEventObject {
  implementation: string;
}
export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>;

export type UpgradedEventFilter = TypedEventFilter<UpgradedEvent>;

export interface MessagePassingBridge extends BaseContract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  interface: MessagePassingBridgeInterface;

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

  listeners<TEvent extends TypedEvent>(
    eventFilter?: TypedEventFilter<TEvent>
  ): Array<TypedListener<TEvent>>;
  listeners(eventName?: string): Array<Listener>;
  removeAllListeners<TEvent extends TypedEvent>(
    eventFilter: TypedEventFilter<TEvent>
  ): this;
  removeAllListeners(eventName?: string): this;
  off: OnEvent<this>;
  on: OnEvent<this>;
  once: OnEvent<this>;
  removeListener: OnEvent<this>;

  functions: {
    DEFAULT_PAYLOAD_SIZE_LIMIT(overrides?: CallOverrides): Promise<[BigNumber]>;

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

    accountsDailyLimit(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        lastTransferReset: BigNumber;
        bridged24Hours: BigNumber;
      }
    >;

    addLzChainSupport(
      lzChainId: PromiseOrValue<BigNumberish>,
      chainId: PromiseOrValue<BigNumberish>,
      remote: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    approveRequest(
      id: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    approvedRequests(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

    bridgeDailyLimit(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        lastTransferReset: BigNumber;
        bridged24Hours: BigNumber;
      }
    >;

    bridgeFees(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        minFee: BigNumber;
        maxFee: BigNumber;
        fee: BigNumber;
      }
    >;

    bridgeLimits(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, boolean] & {
        dailyLimit: BigNumber;
        txLimit: BigNumber;
        accountDailyLimit: BigNumber;
        minAmount: BigNumber;
        onlyWhitelisted: boolean;
      }
    >;

    bridgeTo(
      target: PromiseOrValue<string>,
      targetChainId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      bridge: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    bridgeToWithAxelar(
      target: PromiseOrValue<string>,
      targetChainId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      gasRefundAddress: PromiseOrValue<string>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    bridgeToWithLz(
      target: PromiseOrValue<string>,
      targetChainId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      adapterParams: PromiseOrValue<BytesLike>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    canBridge(
      from: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[boolean, string] & { isWithinLimit: boolean; error: string }>;

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

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

    disabledSourceBridges(
      arg0: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    estimateSendFee(
      _dstChainId: PromiseOrValue<BigNumberish>,
      _fromAddress: PromiseOrValue<string>,
      _toAddress: PromiseOrValue<string>,
      _normalizedAmount: PromiseOrValue<BigNumberish>,
      _useZro: PromiseOrValue<boolean>,
      _adapterParams: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { nativeFee: BigNumber; zroFee: BigNumber }
    >;

    execute(
      commandId: PromiseOrValue<BytesLike>,
      sourceChain: PromiseOrValue<string>,
      sourceAddress: PromiseOrValue<string>,
      payload: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    executeWithToken(
      commandId: PromiseOrValue<BytesLike>,
      sourceChain: PromiseOrValue<string>,
      sourceAddress: PromiseOrValue<string>,
      payload: PromiseOrValue<BytesLike>,
      tokenSymbol: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    executedRequests(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    failedMessages(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BytesLike>,
      arg2: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

    forceResumeReceive(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    fromAxelarChainId(
      axlChainId: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { chainId: BigNumber }>;

    fromLzChainId(
      lzChainId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { chainId: BigNumber }>;

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

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

    getConfig(
      _version: PromiseOrValue<BigNumberish>,
      _chainId: PromiseOrValue<BigNumberish>,
      arg2: PromiseOrValue<string>,
      _configType: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getTrustedRemoteAddress(
      _remoteChainId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

    initialize(
      nameService: PromiseOrValue<string>,
      limits: IMessagePassingBridge.BridgeLimitsStruct,
      fees: IMessagePassingBridge.BridgeFeesStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

    isTrustedRemote(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    lzChainIdsMapping(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[number]>;

    lzChainToIdsMapping(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

    lzReceive(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      _nonce: PromiseOrValue<BigNumberish>,
      _payload: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    minDstGasLookup(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

    nonblockingLzReceive(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      _nonce: PromiseOrValue<BigNumberish>,
      _payload: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

    pauseBridge(
      isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    payloadSizeLimitLookup(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    preventRequest(
      id: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

    retryMessage(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      _nonce: PromiseOrValue<BigNumberish>,
      _payload: PromiseOrValue<BytesLike>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setBridgeFees(
      fees: IMessagePassingBridge.BridgeFeesStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setBridgeLimits(
      limits: IMessagePassingBridge.BridgeLimitsStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setConfig(
      _version: PromiseOrValue<BigNumberish>,
      _chainId: PromiseOrValue<BigNumberish>,
      _configType: PromiseOrValue<BigNumberish>,
      _config: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setDisabledBridges(
      bridgeKeys: PromiseOrValue<BytesLike>[],
      disabled: PromiseOrValue<boolean>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setFaucet(
      _faucet: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setFeeRecipient(
      recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setGuardian(
      _guardian: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setMinDstGas(
      _dstChainId: PromiseOrValue<BigNumberish>,
      _packetType: PromiseOrValue<BigNumberish>,
      _minGas: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setPayloadSizeLimit(
      _dstChainId: PromiseOrValue<BigNumberish>,
      _size: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setPrecrime(
      _precrime: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setReceiveVersion(
      _version: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setSendVersion(
      _version: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setTrustedRemote(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _path: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setTrustedRemoteAddress(
      _remoteChainId: PromiseOrValue<BigNumberish>,
      _remoteAddress: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    toAxelarChainId(
      chainId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string] & { axlChainId: string }>;

    toLzChainId(
      chainId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[number] & { lzChainId: number }>;

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

    trustedRemoteLookup(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

    upgradeTo(
      newImplementation: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    upgradeToAndCall(
      newImplementation: PromiseOrValue<string>,
      data: PromiseOrValue<BytesLike>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    withdraw(
      token: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;
  };

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

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

  accountsDailyLimit(
    arg0: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & {
      lastTransferReset: BigNumber;
      bridged24Hours: BigNumber;
    }
  >;

  addLzChainSupport(
    lzChainId: PromiseOrValue<BigNumberish>,
    chainId: PromiseOrValue<BigNumberish>,
    remote: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  approveRequest(
    id: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  approvedRequests(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

  bridgeDailyLimit(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & {
      lastTransferReset: BigNumber;
      bridged24Hours: BigNumber;
    }
  >;

  bridgeFees(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber] & {
      minFee: BigNumber;
      maxFee: BigNumber;
      fee: BigNumber;
    }
  >;

  bridgeLimits(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, BigNumber, boolean] & {
      dailyLimit: BigNumber;
      txLimit: BigNumber;
      accountDailyLimit: BigNumber;
      minAmount: BigNumber;
      onlyWhitelisted: boolean;
    }
  >;

  bridgeTo(
    target: PromiseOrValue<string>,
    targetChainId: PromiseOrValue<BigNumberish>,
    amount: PromiseOrValue<BigNumberish>,
    bridge: PromiseOrValue<BigNumberish>,
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  bridgeToWithAxelar(
    target: PromiseOrValue<string>,
    targetChainId: PromiseOrValue<BigNumberish>,
    amount: PromiseOrValue<BigNumberish>,
    gasRefundAddress: PromiseOrValue<string>,
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  bridgeToWithLz(
    target: PromiseOrValue<string>,
    targetChainId: PromiseOrValue<BigNumberish>,
    amount: PromiseOrValue<BigNumberish>,
    adapterParams: PromiseOrValue<BytesLike>,
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  canBridge(
    from: PromiseOrValue<string>,
    amount: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<[boolean, string] & { isWithinLimit: boolean; error: string }>;

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

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

  disabledSourceBridges(
    arg0: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  estimateSendFee(
    _dstChainId: PromiseOrValue<BigNumberish>,
    _fromAddress: PromiseOrValue<string>,
    _toAddress: PromiseOrValue<string>,
    _normalizedAmount: PromiseOrValue<BigNumberish>,
    _useZro: PromiseOrValue<boolean>,
    _adapterParams: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & { nativeFee: BigNumber; zroFee: BigNumber }
  >;

  execute(
    commandId: PromiseOrValue<BytesLike>,
    sourceChain: PromiseOrValue<string>,
    sourceAddress: PromiseOrValue<string>,
    payload: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  executeWithToken(
    commandId: PromiseOrValue<BytesLike>,
    sourceChain: PromiseOrValue<string>,
    sourceAddress: PromiseOrValue<string>,
    payload: PromiseOrValue<BytesLike>,
    tokenSymbol: PromiseOrValue<string>,
    amount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  executedRequests(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  failedMessages(
    arg0: PromiseOrValue<BigNumberish>,
    arg1: PromiseOrValue<BytesLike>,
    arg2: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string>;

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

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

  forceResumeReceive(
    _srcChainId: PromiseOrValue<BigNumberish>,
    _srcAddress: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  fromAxelarChainId(
    axlChainId: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  fromLzChainId(
    lzChainId: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

  getConfig(
    _version: PromiseOrValue<BigNumberish>,
    _chainId: PromiseOrValue<BigNumberish>,
    arg2: PromiseOrValue<string>,
    _configType: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string>;

  getTrustedRemoteAddress(
    _remoteChainId: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string>;

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

  initialize(
    nameService: PromiseOrValue<string>,
    limits: IMessagePassingBridge.BridgeLimitsStruct,
    fees: IMessagePassingBridge.BridgeFeesStruct,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

  isTrustedRemote(
    _srcChainId: PromiseOrValue<BigNumberish>,
    _srcAddress: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  lzChainIdsMapping(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<number>;

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

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

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

  lzReceive(
    _srcChainId: PromiseOrValue<BigNumberish>,
    _srcAddress: PromiseOrValue<BytesLike>,
    _nonce: PromiseOrValue<BigNumberish>,
    _payload: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  minDstGasLookup(
    arg0: PromiseOrValue<BigNumberish>,
    arg1: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

  nonblockingLzReceive(
    _srcChainId: PromiseOrValue<BigNumberish>,
    _srcAddress: PromiseOrValue<BytesLike>,
    _nonce: PromiseOrValue<BigNumberish>,
    _payload: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

  pauseBridge(
    isPaused: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

  preventRequest(
    id: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

  retryMessage(
    _srcChainId: PromiseOrValue<BigNumberish>,
    _srcAddress: PromiseOrValue<BytesLike>,
    _nonce: PromiseOrValue<BigNumberish>,
    _payload: PromiseOrValue<BytesLike>,
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setBridgeFees(
    fees: IMessagePassingBridge.BridgeFeesStruct,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setBridgeLimits(
    limits: IMessagePassingBridge.BridgeLimitsStruct,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setConfig(
    _version: PromiseOrValue<BigNumberish>,
    _chainId: PromiseOrValue<BigNumberish>,
    _configType: PromiseOrValue<BigNumberish>,
    _config: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setDisabledBridges(
    bridgeKeys: PromiseOrValue<BytesLike>[],
    disabled: PromiseOrValue<boolean>[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setFaucet(
    _faucet: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setFeeRecipient(
    recipient: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setGuardian(
    _guardian: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setMinDstGas(
    _dstChainId: PromiseOrValue<BigNumberish>,
    _packetType: PromiseOrValue<BigNumberish>,
    _minGas: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setPayloadSizeLimit(
    _dstChainId: PromiseOrValue<BigNumberish>,
    _size: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setPrecrime(
    _precrime: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setReceiveVersion(
    _version: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setSendVersion(
    _version: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setTrustedRemote(
    _srcChainId: PromiseOrValue<BigNumberish>,
    _path: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setTrustedRemoteAddress(
    _remoteChainId: PromiseOrValue<BigNumberish>,
    _remoteAddress: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  toAxelarChainId(
    chainId: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string>;

  toLzChainId(
    chainId: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<number>;

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

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

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

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

  upgradeTo(
    newImplementation: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  upgradeToAndCall(
    newImplementation: PromiseOrValue<string>,
    data: PromiseOrValue<BytesLike>,
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  withdraw(
    token: PromiseOrValue<string>,
    amount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

    accountsDailyLimit(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        lastTransferReset: BigNumber;
        bridged24Hours: BigNumber;
      }
    >;

    addLzChainSupport(
      lzChainId: PromiseOrValue<BigNumberish>,
      chainId: PromiseOrValue<BigNumberish>,
      remote: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    approveRequest(
      id: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    approvedRequests(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    bridgeDailyLimit(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        lastTransferReset: BigNumber;
        bridged24Hours: BigNumber;
      }
    >;

    bridgeFees(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        minFee: BigNumber;
        maxFee: BigNumber;
        fee: BigNumber;
      }
    >;

    bridgeLimits(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, boolean] & {
        dailyLimit: BigNumber;
        txLimit: BigNumber;
        accountDailyLimit: BigNumber;
        minAmount: BigNumber;
        onlyWhitelisted: boolean;
      }
    >;

    bridgeTo(
      target: PromiseOrValue<string>,
      targetChainId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      bridge: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    bridgeToWithAxelar(
      target: PromiseOrValue<string>,
      targetChainId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      gasRefundAddress: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    bridgeToWithLz(
      target: PromiseOrValue<string>,
      targetChainId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      adapterParams: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    canBridge(
      from: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[boolean, string] & { isWithinLimit: boolean; error: string }>;

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

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

    disabledSourceBridges(
      arg0: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    estimateSendFee(
      _dstChainId: PromiseOrValue<BigNumberish>,
      _fromAddress: PromiseOrValue<string>,
      _toAddress: PromiseOrValue<string>,
      _normalizedAmount: PromiseOrValue<BigNumberish>,
      _useZro: PromiseOrValue<boolean>,
      _adapterParams: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { nativeFee: BigNumber; zroFee: BigNumber }
    >;

    execute(
      commandId: PromiseOrValue<BytesLike>,
      sourceChain: PromiseOrValue<string>,
      sourceAddress: PromiseOrValue<string>,
      payload: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    executeWithToken(
      commandId: PromiseOrValue<BytesLike>,
      sourceChain: PromiseOrValue<string>,
      sourceAddress: PromiseOrValue<string>,
      payload: PromiseOrValue<BytesLike>,
      tokenSymbol: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    executedRequests(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    failedMessages(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BytesLike>,
      arg2: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

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

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

    forceResumeReceive(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    fromAxelarChainId(
      axlChainId: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    fromLzChainId(
      lzChainId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getConfig(
      _version: PromiseOrValue<BigNumberish>,
      _chainId: PromiseOrValue<BigNumberish>,
      arg2: PromiseOrValue<string>,
      _configType: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

    getTrustedRemoteAddress(
      _remoteChainId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

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

    initialize(
      nameService: PromiseOrValue<string>,
      limits: IMessagePassingBridge.BridgeLimitsStruct,
      fees: IMessagePassingBridge.BridgeFeesStruct,
      overrides?: CallOverrides
    ): Promise<void>;

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

    isTrustedRemote(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    lzChainIdsMapping(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<number>;

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

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

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

    lzReceive(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      _nonce: PromiseOrValue<BigNumberish>,
      _payload: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    minDstGasLookup(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    nonblockingLzReceive(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      _nonce: PromiseOrValue<BigNumberish>,
      _payload: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

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

    pauseBridge(
      isPaused: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    preventRequest(
      id: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    retryMessage(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      _nonce: PromiseOrValue<BigNumberish>,
      _payload: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    setBridgeFees(
      fees: IMessagePassingBridge.BridgeFeesStruct,
      overrides?: CallOverrides
    ): Promise<void>;

    setBridgeLimits(
      limits: IMessagePassingBridge.BridgeLimitsStruct,
      overrides?: CallOverrides
    ): Promise<void>;

    setConfig(
      _version: PromiseOrValue<BigNumberish>,
      _chainId: PromiseOrValue<BigNumberish>,
      _configType: PromiseOrValue<BigNumberish>,
      _config: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    setDisabledBridges(
      bridgeKeys: PromiseOrValue<BytesLike>[],
      disabled: PromiseOrValue<boolean>[],
      overrides?: CallOverrides
    ): Promise<void>;

    setFaucet(
      _faucet: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setFeeRecipient(
      recipient: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setGuardian(
      _guardian: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setMinDstGas(
      _dstChainId: PromiseOrValue<BigNumberish>,
      _packetType: PromiseOrValue<BigNumberish>,
      _minGas: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setPayloadSizeLimit(
      _dstChainId: PromiseOrValue<BigNumberish>,
      _size: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setPrecrime(
      _precrime: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setReceiveVersion(
      _version: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setSendVersion(
      _version: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setTrustedRemote(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _path: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    setTrustedRemoteAddress(
      _remoteChainId: PromiseOrValue<BigNumberish>,
      _remoteAddress: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    toAxelarChainId(
      chainId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

    toLzChainId(
      chainId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<number>;

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

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

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

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

    upgradeTo(
      newImplementation: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    upgradeToAndCall(
      newImplementation: PromiseOrValue<string>,
      data: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    withdraw(
      token: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "AdminChanged(address,address)"(
      previousAdmin?: null,
      newAdmin?: null
    ): AdminChangedEventFilter;
    AdminChanged(
      previousAdmin?: null,
      newAdmin?: null
    ): AdminChangedEventFilter;

    "BeaconUpgraded(address)"(
      beacon?: PromiseOrValue<string> | null
    ): BeaconUpgradedEventFilter;
    BeaconUpgraded(
      beacon?: PromiseOrValue<string> | null
    ): BeaconUpgradedEventFilter;

    "BridgeRequest(address,address,uint256,uint256,uint256,uint8,uint256)"(
      from?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null,
      targetChainId?: null,
      normalizedAmount?: null,
      timestamp?: null,
      bridge?: null,
      id?: PromiseOrValue<BigNumberish> | null
    ): BridgeRequestEventFilter;
    BridgeRequest(
      from?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null,
      targetChainId?: null,
      normalizedAmount?: null,
      timestamp?: null,
      bridge?: null,
      id?: PromiseOrValue<BigNumberish> | null
    ): BridgeRequestEventFilter;

    "ExecutedTransfer(address,address,uint256,uint256,uint256,uint8,uint256)"(
      from?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null,
      normalizedAmount?: null,
      fee?: null,
      sourceChainId?: null,
      bridge?: null,
      id?: PromiseOrValue<BigNumberish> | null
    ): ExecutedTransferEventFilter;
    ExecutedTransfer(
      from?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null,
      normalizedAmount?: null,
      fee?: null,
      sourceChainId?: null,
      bridge?: null,
      id?: PromiseOrValue<BigNumberish> | null
    ): ExecutedTransferEventFilter;

    "FalseSender(uint256,address)"(
      sourceChainId?: null,
      sourceAddress?: null
    ): FalseSenderEventFilter;
    FalseSender(
      sourceChainId?: null,
      sourceAddress?: null
    ): FalseSenderEventFilter;

    "Initialized(uint8)"(version?: null): InitializedEventFilter;
    Initialized(version?: null): InitializedEventFilter;

    "MessageFailed(uint16,bytes,uint64,bytes,bytes)"(
      _srcChainId?: null,
      _srcAddress?: null,
      _nonce?: null,
      _payload?: null,
      _reason?: null
    ): MessageFailedEventFilter;
    MessageFailed(
      _srcChainId?: null,
      _srcAddress?: null,
      _nonce?: null,
      _payload?: null,
      _reason?: null
    ): MessageFailedEventFilter;

    "OwnershipTransferred(address,address)"(
      previousOwner?: PromiseOrValue<string> | null,
      newOwner?: PromiseOrValue<string> | null
    ): OwnershipTransferredEventFilter;
    OwnershipTransferred(
      previousOwner?: PromiseOrValue<string> | null,
      newOwner?: PromiseOrValue<string> | null
    ): OwnershipTransferredEventFilter;

    "RetryMessageSuccess(uint16,bytes,uint64,bytes32)"(
      _srcChainId?: null,
      _srcAddress?: null,
      _nonce?: null,
      _payloadHash?: null
    ): RetryMessageSuccessEventFilter;
    RetryMessageSuccess(
      _srcChainId?: null,
      _srcAddress?: null,
      _nonce?: null,
      _payloadHash?: null
    ): RetryMessageSuccessEventFilter;

    "SetMinDstGas(uint16,uint16,uint256)"(
      _dstChainId?: null,
      _type?: null,
      _minDstGas?: null
    ): SetMinDstGasEventFilter;
    SetMinDstGas(
      _dstChainId?: null,
      _type?: null,
      _minDstGas?: null
    ): SetMinDstGasEventFilter;

    "SetPrecrime(address)"(precrime?: null): SetPrecrimeEventFilter;
    SetPrecrime(precrime?: null): SetPrecrimeEventFilter;

    "SetTrustedRemote(uint16,bytes)"(
      _remoteChainId?: null,
      _path?: null
    ): SetTrustedRemoteEventFilter;
    SetTrustedRemote(
      _remoteChainId?: null,
      _path?: null
    ): SetTrustedRemoteEventFilter;

    "SetTrustedRemoteAddress(uint16,bytes)"(
      _remoteChainId?: null,
      _remoteAddress?: null
    ): SetTrustedRemoteAddressEventFilter;
    SetTrustedRemoteAddress(
      _remoteChainId?: null,
      _remoteAddress?: null
    ): SetTrustedRemoteAddressEventFilter;

    "Upgraded(address)"(
      implementation?: PromiseOrValue<string> | null
    ): UpgradedEventFilter;
    Upgraded(
      implementation?: PromiseOrValue<string> | null
    ): UpgradedEventFilter;
  };

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

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

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

    addLzChainSupport(
      lzChainId: PromiseOrValue<BigNumberish>,
      chainId: PromiseOrValue<BigNumberish>,
      remote: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    approveRequest(
      id: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

    bridgeTo(
      target: PromiseOrValue<string>,
      targetChainId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      bridge: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    bridgeToWithAxelar(
      target: PromiseOrValue<string>,
      targetChainId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      gasRefundAddress: PromiseOrValue<string>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    bridgeToWithLz(
      target: PromiseOrValue<string>,
      targetChainId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      adapterParams: PromiseOrValue<BytesLike>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    canBridge(
      from: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    disabledSourceBridges(
      arg0: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    estimateSendFee(
      _dstChainId: PromiseOrValue<BigNumberish>,
      _fromAddress: PromiseOrValue<string>,
      _toAddress: PromiseOrValue<string>,
      _normalizedAmount: PromiseOrValue<BigNumberish>,
      _useZro: PromiseOrValue<boolean>,
      _adapterParams: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    execute(
      commandId: PromiseOrValue<BytesLike>,
      sourceChain: PromiseOrValue<string>,
      sourceAddress: PromiseOrValue<string>,
      payload: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    executeWithToken(
      commandId: PromiseOrValue<BytesLike>,
      sourceChain: PromiseOrValue<string>,
      sourceAddress: PromiseOrValue<string>,
      payload: PromiseOrValue<BytesLike>,
      tokenSymbol: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

    failedMessages(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BytesLike>,
      arg2: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    forceResumeReceive(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    fromAxelarChainId(
      axlChainId: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    fromLzChainId(
      lzChainId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getConfig(
      _version: PromiseOrValue<BigNumberish>,
      _chainId: PromiseOrValue<BigNumberish>,
      arg2: PromiseOrValue<string>,
      _configType: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getTrustedRemoteAddress(
      _remoteChainId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    initialize(
      nameService: PromiseOrValue<string>,
      limits: IMessagePassingBridge.BridgeLimitsStruct,
      fees: IMessagePassingBridge.BridgeFeesStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

    isTrustedRemote(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    lzReceive(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      _nonce: PromiseOrValue<BigNumberish>,
      _payload: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    minDstGasLookup(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    nonblockingLzReceive(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      _nonce: PromiseOrValue<BigNumberish>,
      _payload: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

    pauseBridge(
      isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

    preventRequest(
      id: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

    retryMessage(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      _nonce: PromiseOrValue<BigNumberish>,
      _payload: PromiseOrValue<BytesLike>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setBridgeFees(
      fees: IMessagePassingBridge.BridgeFeesStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setBridgeLimits(
      limits: IMessagePassingBridge.BridgeLimitsStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setConfig(
      _version: PromiseOrValue<BigNumberish>,
      _chainId: PromiseOrValue<BigNumberish>,
      _configType: PromiseOrValue<BigNumberish>,
      _config: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setDisabledBridges(
      bridgeKeys: PromiseOrValue<BytesLike>[],
      disabled: PromiseOrValue<boolean>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setFaucet(
      _faucet: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setFeeRecipient(
      recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setGuardian(
      _guardian: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setMinDstGas(
      _dstChainId: PromiseOrValue<BigNumberish>,
      _packetType: PromiseOrValue<BigNumberish>,
      _minGas: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setPayloadSizeLimit(
      _dstChainId: PromiseOrValue<BigNumberish>,
      _size: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setPrecrime(
      _precrime: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setReceiveVersion(
      _version: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setSendVersion(
      _version: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setTrustedRemote(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _path: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setTrustedRemoteAddress(
      _remoteChainId: PromiseOrValue<BigNumberish>,
      _remoteAddress: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    toAxelarChainId(
      chainId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    toLzChainId(
      chainId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    upgradeTo(
      newImplementation: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    upgradeToAndCall(
      newImplementation: PromiseOrValue<string>,
      data: PromiseOrValue<BytesLike>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    withdraw(
      token: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;
  };

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

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

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

    addLzChainSupport(
      lzChainId: PromiseOrValue<BigNumberish>,
      chainId: PromiseOrValue<BigNumberish>,
      remote: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    approveRequest(
      id: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

    bridgeTo(
      target: PromiseOrValue<string>,
      targetChainId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      bridge: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    bridgeToWithAxelar(
      target: PromiseOrValue<string>,
      targetChainId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      gasRefundAddress: PromiseOrValue<string>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    bridgeToWithLz(
      target: PromiseOrValue<string>,
      targetChainId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      adapterParams: PromiseOrValue<BytesLike>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    canBridge(
      from: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    disabledSourceBridges(
      arg0: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    estimateSendFee(
      _dstChainId: PromiseOrValue<BigNumberish>,
      _fromAddress: PromiseOrValue<string>,
      _toAddress: PromiseOrValue<string>,
      _normalizedAmount: PromiseOrValue<BigNumberish>,
      _useZro: PromiseOrValue<boolean>,
      _adapterParams: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    execute(
      commandId: PromiseOrValue<BytesLike>,
      sourceChain: PromiseOrValue<string>,
      sourceAddress: PromiseOrValue<string>,
      payload: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    executeWithToken(
      commandId: PromiseOrValue<BytesLike>,
      sourceChain: PromiseOrValue<string>,
      sourceAddress: PromiseOrValue<string>,
      payload: PromiseOrValue<BytesLike>,
      tokenSymbol: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

    failedMessages(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BytesLike>,
      arg2: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    forceResumeReceive(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    fromAxelarChainId(
      axlChainId: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    fromLzChainId(
      lzChainId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    getConfig(
      _version: PromiseOrValue<BigNumberish>,
      _chainId: PromiseOrValue<BigNumberish>,
      arg2: PromiseOrValue<string>,
      _configType: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getTrustedRemoteAddress(
      _remoteChainId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    initialize(
      nameService: PromiseOrValue<string>,
      limits: IMessagePassingBridge.BridgeLimitsStruct,
      fees: IMessagePassingBridge.BridgeFeesStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

    isTrustedRemote(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    lzReceive(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      _nonce: PromiseOrValue<BigNumberish>,
      _payload: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    minDstGasLookup(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    nonblockingLzReceive(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      _nonce: PromiseOrValue<BigNumberish>,
      _payload: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

    pauseBridge(
      isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

    preventRequest(
      id: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

    retryMessage(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _srcAddress: PromiseOrValue<BytesLike>,
      _nonce: PromiseOrValue<BigNumberish>,
      _payload: PromiseOrValue<BytesLike>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setBridgeFees(
      fees: IMessagePassingBridge.BridgeFeesStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setBridgeLimits(
      limits: IMessagePassingBridge.BridgeLimitsStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setConfig(
      _version: PromiseOrValue<BigNumberish>,
      _chainId: PromiseOrValue<BigNumberish>,
      _configType: PromiseOrValue<BigNumberish>,
      _config: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setDisabledBridges(
      bridgeKeys: PromiseOrValue<BytesLike>[],
      disabled: PromiseOrValue<boolean>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setFaucet(
      _faucet: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setFeeRecipient(
      recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setGuardian(
      _guardian: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setMinDstGas(
      _dstChainId: PromiseOrValue<BigNumberish>,
      _packetType: PromiseOrValue<BigNumberish>,
      _minGas: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setPayloadSizeLimit(
      _dstChainId: PromiseOrValue<BigNumberish>,
      _size: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setPrecrime(
      _precrime: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setReceiveVersion(
      _version: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setSendVersion(
      _version: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setTrustedRemote(
      _srcChainId: PromiseOrValue<BigNumberish>,
      _path: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setTrustedRemoteAddress(
      _remoteChainId: PromiseOrValue<BigNumberish>,
      _remoteAddress: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    toAxelarChainId(
      chainId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    toLzChainId(
      chainId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    upgradeTo(
      newImplementation: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    upgradeToAndCall(
      newImplementation: PromiseOrValue<string>,
      data: PromiseOrValue<BytesLike>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    withdraw(
      token: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;
  };
}