/* 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 } 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 BridgeFeesStruct = {
    minFee: PromiseOrValue<BigNumberish>;
    maxFee: PromiseOrValue<BigNumberish>;
    fee: PromiseOrValue<BigNumberish>;
  };

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

  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 interface IMessagePassingBridgeInterface extends utils.Interface {
  functions: {
    "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;
    "executedRequests(uint256)": FunctionFragment;
    "feeRecipient()": FunctionFragment;
    "guardian()": FunctionFragment;
    "lzEndpoint_()": FunctionFragment;
    "pauseBridge(bool)": FunctionFragment;
    "setBridgeFees((uint256,uint256,uint256))": FunctionFragment;
    "setBridgeLimits((uint256,uint256,uint256,uint256,bool))": FunctionFragment;
    "setDisabledBridges(bytes32[],bool[])": FunctionFragment;
    "setFaucet(address)": FunctionFragment;
    "setFeeRecipient(address)": FunctionFragment;
    "setGuardian(address)": FunctionFragment;
    "toLzChainId(uint256)": FunctionFragment;
    "withdraw(address,uint256)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "bridgeDailyLimit"
      | "bridgeFees"
      | "bridgeLimits"
      | "bridgeTo"
      | "bridgeToWithAxelar"
      | "bridgeToWithLz"
      | "canBridge"
      | "executedRequests"
      | "feeRecipient"
      | "guardian"
      | "lzEndpoint_"
      | "pauseBridge"
      | "setBridgeFees"
      | "setBridgeLimits"
      | "setDisabledBridges"
      | "setFaucet"
      | "setFeeRecipient"
      | "setGuardian"
      | "toLzChainId"
      | "withdraw"
  ): FunctionFragment;

  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: "executedRequests",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "feeRecipient",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "guardian", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "lzEndpoint_",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "pauseBridge",
    values: [PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "setBridgeFees",
    values: [IMessagePassingBridge.BridgeFeesStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "setBridgeLimits",
    values: [IMessagePassingBridge.BridgeLimitsStruct]
  ): 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: "toLzChainId",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;

  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: "executedRequests",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "feeRecipient",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "guardian", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "lzEndpoint_",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "pauseBridge",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setBridgeFees",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setBridgeLimits",
    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: "toLzChainId",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;

  events: {};
}

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

  interface: IMessagePassingBridgeInterface;

  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: {
    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 }>;

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

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

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

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

    pauseBridge(
      isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { 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>;

    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>;

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

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

  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 }>;

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

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

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

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

  pauseBridge(
    isPaused: PromiseOrValue<boolean>,
    overrides?: Overrides & { 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>;

  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>;

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

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

  callStatic: {
    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 }>;

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

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

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

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

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

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

    setBridgeLimits(
      _limits: IMessagePassingBridge.BridgeLimitsStruct,
      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>;

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

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

  filters: {};

  estimateGas: {
    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>;

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

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

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

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

    pauseBridge(
      isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { 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>;

    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>;

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

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

  populateTransaction: {
    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>;

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

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

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

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

    pauseBridge(
      isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { 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>;

    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>;

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

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