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

export type EnforcedOptionParamStruct = {
  eid: BigNumberish;
  msgType: BigNumberish;
  options: BytesLike;
};

export type EnforcedOptionParamStructOutput = [number, number, string] & {
  eid: number;
  msgType: number;
  options: string;
};

export type OriginStruct = {
  srcEid: BigNumberish;
  sender: BytesLike;
  nonce: BigNumberish;
};

export type OriginStructOutput = [number, string, BigNumber] & {
  srcEid: number;
  sender: string;
  nonce: BigNumber;
};

export type MessagingFeeStruct = {
  nativeFee: BigNumberish;
  lzTokenFee: BigNumberish;
};

export type MessagingFeeStructOutput = [BigNumber, BigNumber] & {
  nativeFee: BigNumber;
  lzTokenFee: BigNumber;
};

export type MessagingReceiptStruct = {
  guid: BytesLike;
  nonce: BigNumberish;
  fee: MessagingFeeStruct;
};

export type MessagingReceiptStructOutput = [
  string,
  BigNumber,
  MessagingFeeStructOutput
] & { guid: string; nonce: BigNumber; fee: MessagingFeeStructOutput };

export declare namespace IPExchangeRateOracleApp {
  export type ExchangeRateDataStruct = {
    exchangeRate: BigNumberish;
    updatedAt: BigNumberish;
  };

  export type ExchangeRateDataStructOutput = [BigNumber, BigNumber] & {
    exchangeRate: BigNumber;
    updatedAt: BigNumber;
  };

  export type SendExchangeRateParamStruct = {
    exchangeRateSource: string;
    dstEid: BigNumberish;
    extraOptions: BytesLike;
  };

  export type SendExchangeRateParamStructOutput = [string, number, string] & {
    exchangeRateSource: string;
    dstEid: number;
    extraOptions: string;
  };
}

export interface PendleExchangeRateOracleAppInterface extends utils.Interface {
  contractName: "PendleExchangeRateOracleApp";
  functions: {
    "allowInitializePath((uint32,bytes32,uint64))": FunctionFragment;
    "allowedSender()": FunctionFragment;
    "combineOptions(uint32,uint16,bytes)": FunctionFragment;
    "eid()": FunctionFragment;
    "endpoint()": FunctionFragment;
    "enforcedOptions(uint32,uint16)": FunctionFragment;
    "getExchangeRate(uint32,bytes32)": FunctionFragment;
    "initialize(address,address,address)": FunctionFragment;
    "isComposeMsgSender((uint32,bytes32,uint64),bytes,address)": FunctionFragment;
    "lzReceive((uint32,bytes32,uint64),bytes32,bytes,address,bytes)": FunctionFragment;
    "nextNonce(uint32,bytes32)": FunctionFragment;
    "oAppVersion()": FunctionFragment;
    "owner()": FunctionFragment;
    "peers(uint32)": FunctionFragment;
    "quoteSendExchangeRate((address,uint32,bytes),bool)": FunctionFragment;
    "quoteSendExchangeRateBatch((address,uint32,bytes)[],bool[])": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "sendExchangeRate((address,uint32,bytes),(uint256,uint256))": FunctionFragment;
    "sendExchangeRateBatch((address,uint32,bytes)[],(uint256,uint256)[])": FunctionFragment;
    "setAllowedSender(address)": FunctionFragment;
    "setDelegate(address)": FunctionFragment;
    "setEnforcedOptions((uint32,uint16,bytes)[])": FunctionFragment;
    "setPeer(uint32,bytes32)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "allowInitializePath",
    values: [OriginStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "allowedSender",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "combineOptions",
    values: [BigNumberish, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "eid", values?: undefined): string;
  encodeFunctionData(functionFragment: "endpoint", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "enforcedOptions",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getExchangeRate",
    values: [BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [string, string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "isComposeMsgSender",
    values: [OriginStruct, BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "lzReceive",
    values: [OriginStruct, BytesLike, BytesLike, string, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "nextNonce",
    values: [BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "oAppVersion",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(functionFragment: "peers", values: [BigNumberish]): string;
  encodeFunctionData(
    functionFragment: "quoteSendExchangeRate",
    values: [IPExchangeRateOracleApp.SendExchangeRateParamStruct, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "quoteSendExchangeRateBatch",
    values: [IPExchangeRateOracleApp.SendExchangeRateParamStruct[], boolean[]]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "sendExchangeRate",
    values: [
      IPExchangeRateOracleApp.SendExchangeRateParamStruct,
      MessagingFeeStruct
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "sendExchangeRateBatch",
    values: [
      IPExchangeRateOracleApp.SendExchangeRateParamStruct[],
      MessagingFeeStruct[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "setAllowedSender",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "setDelegate", values: [string]): string;
  encodeFunctionData(
    functionFragment: "setEnforcedOptions",
    values: [EnforcedOptionParamStruct[]]
  ): string;
  encodeFunctionData(
    functionFragment: "setPeer",
    values: [BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;

  decodeFunctionResult(
    functionFragment: "allowInitializePath",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "allowedSender",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "combineOptions",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "eid", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "endpoint", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "enforcedOptions",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getExchangeRate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isComposeMsgSender",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "lzReceive", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "nextNonce", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "oAppVersion",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "peers", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "quoteSendExchangeRate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "quoteSendExchangeRateBatch",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "sendExchangeRate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "sendExchangeRateBatch",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setAllowedSender",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDelegate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setEnforcedOptions",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setPeer", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;

  events: {
    "AllowedSenderSet(address)": EventFragment;
    "EnforcedOptionSet(tuple[])": EventFragment;
    "ExchangeRateReceived(bytes32,uint32,bytes32,uint256,uint256,bool)": EventFragment;
    "ExchangeRateSent(bytes32,uint32,address,uint256)": EventFragment;
    "Initialized(uint8)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "PeerSet(uint32,bytes32)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "AllowedSenderSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "EnforcedOptionSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ExchangeRateReceived"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ExchangeRateSent"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PeerSet"): EventFragment;
}

export type AllowedSenderSetEvent = TypedEvent<[string], { sender: string }>;

export type AllowedSenderSetEventFilter =
  TypedEventFilter<AllowedSenderSetEvent>;

export type EnforcedOptionSetEvent = TypedEvent<
  [EnforcedOptionParamStructOutput[]],
  { _enforcedOptions: EnforcedOptionParamStructOutput[] }
>;

export type EnforcedOptionSetEventFilter =
  TypedEventFilter<EnforcedOptionSetEvent>;

export type ExchangeRateReceivedEvent = TypedEvent<
  [string, number, string, BigNumber, BigNumber, boolean],
  {
    guid: string;
    srcEid: number;
    exchangeRateSource: string;
    exchangeRate: BigNumber;
    updatedAt: BigNumber;
    rateAccepted: boolean;
  }
>;

export type ExchangeRateReceivedEventFilter =
  TypedEventFilter<ExchangeRateReceivedEvent>;

export type ExchangeRateSentEvent = TypedEvent<
  [string, number, string, BigNumber],
  {
    guid: string;
    dstEid: number;
    exchangeRateSource: string;
    exchangeRate: BigNumber;
  }
>;

export type ExchangeRateSentEventFilter =
  TypedEventFilter<ExchangeRateSentEvent>;

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

export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;

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

export type OwnershipTransferredEventFilter =
  TypedEventFilter<OwnershipTransferredEvent>;

export type PeerSetEvent = TypedEvent<
  [number, string],
  { eid: number; peer: string }
>;

export type PeerSetEventFilter = TypedEventFilter<PeerSetEvent>;

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

  interface: PendleExchangeRateOracleAppInterface;

  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: {
    allowInitializePath(
      origin: OriginStruct,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

    combineOptions(
      _eid: BigNumberish,
      _msgType: BigNumberish,
      _extraOptions: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

    enforcedOptions(
      _eid: BigNumberish,
      _msgType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getExchangeRate(
      _srcEid: BigNumberish,
      exchangeRateSource: BytesLike,
      overrides?: CallOverrides
    ): Promise<
      [IPExchangeRateOracleApp.ExchangeRateDataStructOutput] & {
        exchangeRateData: IPExchangeRateOracleApp.ExchangeRateDataStructOutput;
      }
    >;

    initialize(
      _owner: string,
      _delegate: string,
      _allowedSender: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    isComposeMsgSender(
      arg0: OriginStruct,
      arg1: BytesLike,
      _sender: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    lzReceive(
      _origin: OriginStruct,
      _guid: BytesLike,
      _message: BytesLike,
      _executor: string,
      _extraData: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    nextNonce(
      arg0: BigNumberish,
      arg1: BytesLike,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { nonce: BigNumber }>;

    oAppVersion(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        senderVersion: BigNumber;
        receiverVersion: BigNumber;
      }
    >;

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

    peers(_eid: BigNumberish, overrides?: CallOverrides): Promise<[string]>;

    quoteSendExchangeRate(
      sendParam: IPExchangeRateOracleApp.SendExchangeRateParamStruct,
      payInLzToken: boolean,
      overrides?: CallOverrides
    ): Promise<[MessagingFeeStructOutput] & { fee: MessagingFeeStructOutput }>;

    quoteSendExchangeRateBatch(
      sendParams: IPExchangeRateOracleApp.SendExchangeRateParamStruct[],
      payInLzTokens: boolean[],
      overrides?: CallOverrides
    ): Promise<
      [MessagingFeeStructOutput[]] & { fees: MessagingFeeStructOutput[] }
    >;

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

    sendExchangeRate(
      sendParam: IPExchangeRateOracleApp.SendExchangeRateParamStruct,
      fee: MessagingFeeStruct,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    sendExchangeRateBatch(
      sendParams: IPExchangeRateOracleApp.SendExchangeRateParamStruct[],
      fees: MessagingFeeStruct[],
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    setEnforcedOptions(
      _enforcedOptions: EnforcedOptionParamStruct[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setPeer(
      _eid: BigNumberish,
      _peer: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

  allowInitializePath(
    origin: OriginStruct,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

  combineOptions(
    _eid: BigNumberish,
    _msgType: BigNumberish,
    _extraOptions: BytesLike,
    overrides?: CallOverrides
  ): Promise<string>;

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

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

  enforcedOptions(
    _eid: BigNumberish,
    _msgType: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  getExchangeRate(
    _srcEid: BigNumberish,
    exchangeRateSource: BytesLike,
    overrides?: CallOverrides
  ): Promise<IPExchangeRateOracleApp.ExchangeRateDataStructOutput>;

  initialize(
    _owner: string,
    _delegate: string,
    _allowedSender: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  isComposeMsgSender(
    arg0: OriginStruct,
    arg1: BytesLike,
    _sender: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  lzReceive(
    _origin: OriginStruct,
    _guid: BytesLike,
    _message: BytesLike,
    _executor: string,
    _extraData: BytesLike,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  oAppVersion(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & {
      senderVersion: BigNumber;
      receiverVersion: BigNumber;
    }
  >;

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

  peers(_eid: BigNumberish, overrides?: CallOverrides): Promise<string>;

  quoteSendExchangeRate(
    sendParam: IPExchangeRateOracleApp.SendExchangeRateParamStruct,
    payInLzToken: boolean,
    overrides?: CallOverrides
  ): Promise<MessagingFeeStructOutput>;

  quoteSendExchangeRateBatch(
    sendParams: IPExchangeRateOracleApp.SendExchangeRateParamStruct[],
    payInLzTokens: boolean[],
    overrides?: CallOverrides
  ): Promise<MessagingFeeStructOutput[]>;

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

  sendExchangeRate(
    sendParam: IPExchangeRateOracleApp.SendExchangeRateParamStruct,
    fee: MessagingFeeStruct,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  sendExchangeRateBatch(
    sendParams: IPExchangeRateOracleApp.SendExchangeRateParamStruct[],
    fees: MessagingFeeStruct[],
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  setEnforcedOptions(
    _enforcedOptions: EnforcedOptionParamStruct[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setPeer(
    _eid: BigNumberish,
    _peer: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  callStatic: {
    allowInitializePath(
      origin: OriginStruct,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    combineOptions(
      _eid: BigNumberish,
      _msgType: BigNumberish,
      _extraOptions: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

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

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

    enforcedOptions(
      _eid: BigNumberish,
      _msgType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    getExchangeRate(
      _srcEid: BigNumberish,
      exchangeRateSource: BytesLike,
      overrides?: CallOverrides
    ): Promise<IPExchangeRateOracleApp.ExchangeRateDataStructOutput>;

    initialize(
      _owner: string,
      _delegate: string,
      _allowedSender: string,
      overrides?: CallOverrides
    ): Promise<void>;

    isComposeMsgSender(
      arg0: OriginStruct,
      arg1: BytesLike,
      _sender: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    lzReceive(
      _origin: OriginStruct,
      _guid: BytesLike,
      _message: BytesLike,
      _executor: string,
      _extraData: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

    oAppVersion(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        senderVersion: BigNumber;
        receiverVersion: BigNumber;
      }
    >;

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

    peers(_eid: BigNumberish, overrides?: CallOverrides): Promise<string>;

    quoteSendExchangeRate(
      sendParam: IPExchangeRateOracleApp.SendExchangeRateParamStruct,
      payInLzToken: boolean,
      overrides?: CallOverrides
    ): Promise<MessagingFeeStructOutput>;

    quoteSendExchangeRateBatch(
      sendParams: IPExchangeRateOracleApp.SendExchangeRateParamStruct[],
      payInLzTokens: boolean[],
      overrides?: CallOverrides
    ): Promise<MessagingFeeStructOutput[]>;

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

    sendExchangeRate(
      sendParam: IPExchangeRateOracleApp.SendExchangeRateParamStruct,
      fee: MessagingFeeStruct,
      overrides?: CallOverrides
    ): Promise<MessagingReceiptStructOutput>;

    sendExchangeRateBatch(
      sendParams: IPExchangeRateOracleApp.SendExchangeRateParamStruct[],
      fees: MessagingFeeStruct[],
      overrides?: CallOverrides
    ): Promise<MessagingReceiptStructOutput[]>;

    setAllowedSender(
      _allowedSender: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setDelegate(_delegate: string, overrides?: CallOverrides): Promise<void>;

    setEnforcedOptions(
      _enforcedOptions: EnforcedOptionParamStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

    setPeer(
      _eid: BigNumberish,
      _peer: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

  filters: {
    "AllowedSenderSet(address)"(
      sender?: string | null
    ): AllowedSenderSetEventFilter;
    AllowedSenderSet(sender?: string | null): AllowedSenderSetEventFilter;

    "EnforcedOptionSet(tuple[])"(
      _enforcedOptions?: null
    ): EnforcedOptionSetEventFilter;
    EnforcedOptionSet(_enforcedOptions?: null): EnforcedOptionSetEventFilter;

    "ExchangeRateReceived(bytes32,uint32,bytes32,uint256,uint256,bool)"(
      guid?: BytesLike | null,
      srcEid?: BigNumberish | null,
      exchangeRateSource?: BytesLike | null,
      exchangeRate?: null,
      updatedAt?: null,
      rateAccepted?: null
    ): ExchangeRateReceivedEventFilter;
    ExchangeRateReceived(
      guid?: BytesLike | null,
      srcEid?: BigNumberish | null,
      exchangeRateSource?: BytesLike | null,
      exchangeRate?: null,
      updatedAt?: null,
      rateAccepted?: null
    ): ExchangeRateReceivedEventFilter;

    "ExchangeRateSent(bytes32,uint32,address,uint256)"(
      guid?: BytesLike | null,
      dstEid?: BigNumberish | null,
      exchangeRateSource?: string | null,
      exchangeRate?: null
    ): ExchangeRateSentEventFilter;
    ExchangeRateSent(
      guid?: BytesLike | null,
      dstEid?: BigNumberish | null,
      exchangeRateSource?: string | null,
      exchangeRate?: null
    ): ExchangeRateSentEventFilter;

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

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

    "PeerSet(uint32,bytes32)"(eid?: null, peer?: null): PeerSetEventFilter;
    PeerSet(eid?: null, peer?: null): PeerSetEventFilter;
  };

  estimateGas: {
    allowInitializePath(
      origin: OriginStruct,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    combineOptions(
      _eid: BigNumberish,
      _msgType: BigNumberish,
      _extraOptions: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    enforcedOptions(
      _eid: BigNumberish,
      _msgType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getExchangeRate(
      _srcEid: BigNumberish,
      exchangeRateSource: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    initialize(
      _owner: string,
      _delegate: string,
      _allowedSender: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    isComposeMsgSender(
      arg0: OriginStruct,
      arg1: BytesLike,
      _sender: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    lzReceive(
      _origin: OriginStruct,
      _guid: BytesLike,
      _message: BytesLike,
      _executor: string,
      _extraData: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

    peers(_eid: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

    quoteSendExchangeRate(
      sendParam: IPExchangeRateOracleApp.SendExchangeRateParamStruct,
      payInLzToken: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    quoteSendExchangeRateBatch(
      sendParams: IPExchangeRateOracleApp.SendExchangeRateParamStruct[],
      payInLzTokens: boolean[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    sendExchangeRate(
      sendParam: IPExchangeRateOracleApp.SendExchangeRateParamStruct,
      fee: MessagingFeeStruct,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    sendExchangeRateBatch(
      sendParams: IPExchangeRateOracleApp.SendExchangeRateParamStruct[],
      fees: MessagingFeeStruct[],
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    setEnforcedOptions(
      _enforcedOptions: EnforcedOptionParamStruct[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setPeer(
      _eid: BigNumberish,
      _peer: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

  populateTransaction: {
    allowInitializePath(
      origin: OriginStruct,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    combineOptions(
      _eid: BigNumberish,
      _msgType: BigNumberish,
      _extraOptions: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    enforcedOptions(
      _eid: BigNumberish,
      _msgType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getExchangeRate(
      _srcEid: BigNumberish,
      exchangeRateSource: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    initialize(
      _owner: string,
      _delegate: string,
      _allowedSender: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    isComposeMsgSender(
      arg0: OriginStruct,
      arg1: BytesLike,
      _sender: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    lzReceive(
      _origin: OriginStruct,
      _guid: BytesLike,
      _message: BytesLike,
      _executor: string,
      _extraData: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

    peers(
      _eid: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    quoteSendExchangeRate(
      sendParam: IPExchangeRateOracleApp.SendExchangeRateParamStruct,
      payInLzToken: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    quoteSendExchangeRateBatch(
      sendParams: IPExchangeRateOracleApp.SendExchangeRateParamStruct[],
      payInLzTokens: boolean[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    sendExchangeRate(
      sendParam: IPExchangeRateOracleApp.SendExchangeRateParamStruct,
      fee: MessagingFeeStruct,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    sendExchangeRateBatch(
      sendParams: IPExchangeRateOracleApp.SendExchangeRateParamStruct[],
      fees: MessagingFeeStruct[],
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    setEnforcedOptions(
      _enforcedOptions: EnforcedOptionParamStruct[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setPeer(
      _eid: BigNumberish,
      _peer: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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