/* 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,
} from './common'

export type BridgeTokenStruct = { symbol: string; token: string }

export type BridgeTokenStructOutput = [string, string] & {
  symbol: string
  token: string
}

export interface SynapseCCTPInterface extends utils.Interface {
  functions: {
    'accumulatedFees(address,address)': FunctionFragment
    'addToken(string,address,uint256,uint256,uint256,uint256)': FunctionFragment
    'calculateFeeAmount(address,uint256,bool)': FunctionFragment
    'chainGasAmount()': FunctionFragment
    'circleTokenPool(address)': FunctionFragment
    'feeStructures(address)': FunctionFragment
    'getBridgeTokens()': FunctionFragment
    'getLocalToken(uint32,address)': FunctionFragment
    'isRequestFulfilled(bytes32)': FunctionFragment
    'localDomain()': FunctionFragment
    'messageTransmitter()': FunctionFragment
    'owner()': FunctionFragment
    'pauseSending()': FunctionFragment
    'paused()': FunctionFragment
    'protocolFee()': FunctionFragment
    'receiveCircleToken(bytes,bytes,uint32,bytes)': FunctionFragment
    'relayerFeeCollectors(address)': FunctionFragment
    'remoteDomainConfig(uint256)': FunctionFragment
    'removeToken(address)': FunctionFragment
    'renounceOwnership()': FunctionFragment
    'rescueGas()': FunctionFragment
    'sendCircleToken(address,uint256,address,uint256,uint32,bytes)': FunctionFragment
    'setChainGasAmount(uint256)': FunctionFragment
    'setCircleTokenPool(address,address)': FunctionFragment
    'setFeeCollector(address)': FunctionFragment
    'setProtocolFee(uint256)': FunctionFragment
    'setRemoteDomainConfig(uint256,uint32,address)': FunctionFragment
    'setTokenFee(address,uint256,uint256,uint256,uint256)': FunctionFragment
    'symbolToToken(string)': FunctionFragment
    'tokenMessenger()': FunctionFragment
    'tokenToSymbol(address)': FunctionFragment
    'transferOwnership(address)': FunctionFragment
    'unpauseSending()': FunctionFragment
    'withdrawProtocolFees(address)': FunctionFragment
    'withdrawRelayerFees(address)': FunctionFragment
  }

  getFunction(
    nameOrSignatureOrTopic:
      | 'accumulatedFees'
      | 'addToken'
      | 'calculateFeeAmount'
      | 'chainGasAmount'
      | 'circleTokenPool'
      | 'feeStructures'
      | 'getBridgeTokens'
      | 'getLocalToken'
      | 'isRequestFulfilled'
      | 'localDomain'
      | 'messageTransmitter'
      | 'owner'
      | 'pauseSending'
      | 'paused'
      | 'protocolFee'
      | 'receiveCircleToken'
      | 'relayerFeeCollectors'
      | 'remoteDomainConfig'
      | 'removeToken'
      | 'renounceOwnership'
      | 'rescueGas'
      | 'sendCircleToken'
      | 'setChainGasAmount'
      | 'setCircleTokenPool'
      | 'setFeeCollector'
      | 'setProtocolFee'
      | 'setRemoteDomainConfig'
      | 'setTokenFee'
      | 'symbolToToken'
      | 'tokenMessenger'
      | 'tokenToSymbol'
      | 'transferOwnership'
      | 'unpauseSending'
      | 'withdrawProtocolFees'
      | 'withdrawRelayerFees'
  ): FunctionFragment

  encodeFunctionData(
    functionFragment: 'accumulatedFees',
    values: [string, string]
  ): string
  encodeFunctionData(
    functionFragment: 'addToken',
    values: [
      string,
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish
    ]
  ): string
  encodeFunctionData(
    functionFragment: 'calculateFeeAmount',
    values: [string, BigNumberish, boolean]
  ): string
  encodeFunctionData(
    functionFragment: 'chainGasAmount',
    values?: undefined
  ): string
  encodeFunctionData(
    functionFragment: 'circleTokenPool',
    values: [string]
  ): string
  encodeFunctionData(
    functionFragment: 'feeStructures',
    values: [string]
  ): string
  encodeFunctionData(
    functionFragment: 'getBridgeTokens',
    values?: undefined
  ): string
  encodeFunctionData(
    functionFragment: 'getLocalToken',
    values: [BigNumberish, string]
  ): string
  encodeFunctionData(
    functionFragment: 'isRequestFulfilled',
    values: [BytesLike]
  ): string
  encodeFunctionData(
    functionFragment: 'localDomain',
    values?: undefined
  ): string
  encodeFunctionData(
    functionFragment: 'messageTransmitter',
    values?: undefined
  ): string
  encodeFunctionData(functionFragment: 'owner', values?: undefined): string
  encodeFunctionData(
    functionFragment: 'pauseSending',
    values?: undefined
  ): string
  encodeFunctionData(functionFragment: 'paused', values?: undefined): string
  encodeFunctionData(
    functionFragment: 'protocolFee',
    values?: undefined
  ): string
  encodeFunctionData(
    functionFragment: 'receiveCircleToken',
    values: [BytesLike, BytesLike, BigNumberish, BytesLike]
  ): string
  encodeFunctionData(
    functionFragment: 'relayerFeeCollectors',
    values: [string]
  ): string
  encodeFunctionData(
    functionFragment: 'remoteDomainConfig',
    values: [BigNumberish]
  ): string
  encodeFunctionData(functionFragment: 'removeToken', values: [string]): string
  encodeFunctionData(
    functionFragment: 'renounceOwnership',
    values?: undefined
  ): string
  encodeFunctionData(functionFragment: 'rescueGas', values?: undefined): string
  encodeFunctionData(
    functionFragment: 'sendCircleToken',
    values: [
      string,
      BigNumberish,
      string,
      BigNumberish,
      BigNumberish,
      BytesLike
    ]
  ): string
  encodeFunctionData(
    functionFragment: 'setChainGasAmount',
    values: [BigNumberish]
  ): string
  encodeFunctionData(
    functionFragment: 'setCircleTokenPool',
    values: [string, string]
  ): string
  encodeFunctionData(
    functionFragment: 'setFeeCollector',
    values: [string]
  ): string
  encodeFunctionData(
    functionFragment: 'setProtocolFee',
    values: [BigNumberish]
  ): string
  encodeFunctionData(
    functionFragment: 'setRemoteDomainConfig',
    values: [BigNumberish, BigNumberish, string]
  ): string
  encodeFunctionData(
    functionFragment: 'setTokenFee',
    values: [string, BigNumberish, BigNumberish, BigNumberish, BigNumberish]
  ): string
  encodeFunctionData(
    functionFragment: 'symbolToToken',
    values: [string]
  ): string
  encodeFunctionData(
    functionFragment: 'tokenMessenger',
    values?: undefined
  ): string
  encodeFunctionData(
    functionFragment: 'tokenToSymbol',
    values: [string]
  ): string
  encodeFunctionData(
    functionFragment: 'transferOwnership',
    values: [string]
  ): string
  encodeFunctionData(
    functionFragment: 'unpauseSending',
    values?: undefined
  ): string
  encodeFunctionData(
    functionFragment: 'withdrawProtocolFees',
    values: [string]
  ): string
  encodeFunctionData(
    functionFragment: 'withdrawRelayerFees',
    values: [string]
  ): string

  decodeFunctionResult(
    functionFragment: 'accumulatedFees',
    data: BytesLike
  ): Result
  decodeFunctionResult(functionFragment: 'addToken', data: BytesLike): Result
  decodeFunctionResult(
    functionFragment: 'calculateFeeAmount',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'chainGasAmount',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'circleTokenPool',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'feeStructures',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'getBridgeTokens',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'getLocalToken',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'isRequestFulfilled',
    data: BytesLike
  ): Result
  decodeFunctionResult(functionFragment: 'localDomain', data: BytesLike): Result
  decodeFunctionResult(
    functionFragment: 'messageTransmitter',
    data: BytesLike
  ): Result
  decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result
  decodeFunctionResult(
    functionFragment: 'pauseSending',
    data: BytesLike
  ): Result
  decodeFunctionResult(functionFragment: 'paused', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'protocolFee', data: BytesLike): Result
  decodeFunctionResult(
    functionFragment: 'receiveCircleToken',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'relayerFeeCollectors',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'remoteDomainConfig',
    data: BytesLike
  ): Result
  decodeFunctionResult(functionFragment: 'removeToken', data: BytesLike): Result
  decodeFunctionResult(
    functionFragment: 'renounceOwnership',
    data: BytesLike
  ): Result
  decodeFunctionResult(functionFragment: 'rescueGas', data: BytesLike): Result
  decodeFunctionResult(
    functionFragment: 'sendCircleToken',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'setChainGasAmount',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'setCircleTokenPool',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'setFeeCollector',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'setProtocolFee',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'setRemoteDomainConfig',
    data: BytesLike
  ): Result
  decodeFunctionResult(functionFragment: 'setTokenFee', data: BytesLike): Result
  decodeFunctionResult(
    functionFragment: 'symbolToToken',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'tokenMessenger',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'tokenToSymbol',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'transferOwnership',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'unpauseSending',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'withdrawProtocolFees',
    data: BytesLike
  ): Result
  decodeFunctionResult(
    functionFragment: 'withdrawRelayerFees',
    data: BytesLike
  ): Result

  events: {
    'ChainGasAirdropped(uint256)': EventFragment
    'ChainGasAmountUpdated(uint256)': EventFragment
    'CircleRequestFulfilled(uint32,address,address,uint256,address,uint256,bytes32)': EventFragment
    'CircleRequestSent(uint256,address,uint64,address,uint256,uint32,bytes,bytes32)': EventFragment
    'FeeCollected(address,uint256,uint256)': EventFragment
    'FeeCollectorUpdated(address,address,address)': EventFragment
    'OwnershipTransferred(address,address)': EventFragment
    'Paused(address)': EventFragment
    'ProtocolFeeUpdated(uint256)': EventFragment
    'Unpaused(address)': EventFragment
  }

  getEvent(nameOrSignatureOrTopic: 'ChainGasAirdropped'): EventFragment
  getEvent(nameOrSignatureOrTopic: 'ChainGasAmountUpdated'): EventFragment
  getEvent(nameOrSignatureOrTopic: 'CircleRequestFulfilled'): EventFragment
  getEvent(nameOrSignatureOrTopic: 'CircleRequestSent'): EventFragment
  getEvent(nameOrSignatureOrTopic: 'FeeCollected'): EventFragment
  getEvent(nameOrSignatureOrTopic: 'FeeCollectorUpdated'): EventFragment
  getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment
  getEvent(nameOrSignatureOrTopic: 'Paused'): EventFragment
  getEvent(nameOrSignatureOrTopic: 'ProtocolFeeUpdated'): EventFragment
  getEvent(nameOrSignatureOrTopic: 'Unpaused'): EventFragment
}

export interface ChainGasAirdroppedEventObject {
  amount: BigNumber
}
export type ChainGasAirdroppedEvent = TypedEvent<
  [BigNumber],
  ChainGasAirdroppedEventObject
>

export type ChainGasAirdroppedEventFilter =
  TypedEventFilter<ChainGasAirdroppedEvent>

export interface ChainGasAmountUpdatedEventObject {
  chainGasAmount: BigNumber
}
export type ChainGasAmountUpdatedEvent = TypedEvent<
  [BigNumber],
  ChainGasAmountUpdatedEventObject
>

export type ChainGasAmountUpdatedEventFilter =
  TypedEventFilter<ChainGasAmountUpdatedEvent>

export interface CircleRequestFulfilledEventObject {
  originDomain: number
  recipient: string
  mintToken: string
  fee: BigNumber
  token: string
  amount: BigNumber
  requestID: string
}
export type CircleRequestFulfilledEvent = TypedEvent<
  [number, string, string, BigNumber, string, BigNumber, string],
  CircleRequestFulfilledEventObject
>

export type CircleRequestFulfilledEventFilter =
  TypedEventFilter<CircleRequestFulfilledEvent>

export interface CircleRequestSentEventObject {
  chainId: BigNumber
  sender: string
  nonce: BigNumber
  token: string
  amount: BigNumber
  requestVersion: number
  formattedRequest: string
  requestID: string
}
export type CircleRequestSentEvent = TypedEvent<
  [BigNumber, string, BigNumber, string, BigNumber, number, string, string],
  CircleRequestSentEventObject
>

export type CircleRequestSentEventFilter =
  TypedEventFilter<CircleRequestSentEvent>

export interface FeeCollectedEventObject {
  feeCollector: string
  relayerFeeAmount: BigNumber
  protocolFeeAmount: BigNumber
}
export type FeeCollectedEvent = TypedEvent<
  [string, BigNumber, BigNumber],
  FeeCollectedEventObject
>

export type FeeCollectedEventFilter = TypedEventFilter<FeeCollectedEvent>

export interface FeeCollectorUpdatedEventObject {
  relayer: string
  oldFeeCollector: string
  newFeeCollector: string
}
export type FeeCollectorUpdatedEvent = TypedEvent<
  [string, string, string],
  FeeCollectorUpdatedEventObject
>

export type FeeCollectorUpdatedEventFilter =
  TypedEventFilter<FeeCollectorUpdatedEvent>

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

export type OwnershipTransferredEventFilter =
  TypedEventFilter<OwnershipTransferredEvent>

export interface PausedEventObject {
  account: string
}
export type PausedEvent = TypedEvent<[string], PausedEventObject>

export type PausedEventFilter = TypedEventFilter<PausedEvent>

export interface ProtocolFeeUpdatedEventObject {
  newProtocolFee: BigNumber
}
export type ProtocolFeeUpdatedEvent = TypedEvent<
  [BigNumber],
  ProtocolFeeUpdatedEventObject
>

export type ProtocolFeeUpdatedEventFilter =
  TypedEventFilter<ProtocolFeeUpdatedEvent>

export interface UnpausedEventObject {
  account: string
}
export type UnpausedEvent = TypedEvent<[string], UnpausedEventObject>

export type UnpausedEventFilter = TypedEventFilter<UnpausedEvent>

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

  interface: SynapseCCTPInterface

  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: {
    accumulatedFees(
      arg0: string,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>

    addToken(
      symbol: string,
      token: string,
      relayerFee: BigNumberish,
      minBaseFee: BigNumberish,
      minSwapFee: BigNumberish,
      maxFee: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>

    calculateFeeAmount(
      token: string,
      amount: BigNumberish,
      isSwap: boolean,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { fee: BigNumber }>

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

    circleTokenPool(arg0: string, overrides?: CallOverrides): Promise<[string]>

    feeStructures(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [number, BigNumber, BigNumber, BigNumber] & {
        relayerFee: number
        minBaseFee: BigNumber
        minSwapFee: BigNumber
        maxFee: BigNumber
      }
    >

    getBridgeTokens(
      overrides?: CallOverrides
    ): Promise<
      [BridgeTokenStructOutput[]] & { bridgeTokens: BridgeTokenStructOutput[] }
    >

    getLocalToken(
      remoteDomain: BigNumberish,
      remoteToken: string,
      overrides?: CallOverrides
    ): Promise<[string]>

    isRequestFulfilled(
      requestID: BytesLike,
      overrides?: CallOverrides
    ): Promise<[boolean]>

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

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

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

    pauseSending(
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>

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

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

    receiveCircleToken(
      message: BytesLike,
      signature: BytesLike,
      requestVersion: BigNumberish,
      formattedRequest: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<ContractTransaction>

    relayerFeeCollectors(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[string]>

    remoteDomainConfig(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number, string] & { domain: number; synapseCCTP: string }>

    removeToken(
      token: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>

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

    rescueGas(
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>

    sendCircleToken(
      recipient: string,
      chainId: BigNumberish,
      burnToken: string,
      amount: BigNumberish,
      requestVersion: BigNumberish,
      swapParams: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>

    setChainGasAmount(
      newChainGasAmount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>

    setCircleTokenPool(
      circleToken: string,
      pool: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>

    setFeeCollector(
      feeCollector: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>

    setProtocolFee(
      newProtocolFee: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>

    setRemoteDomainConfig(
      remoteChainId: BigNumberish,
      remoteDomain: BigNumberish,
      remoteSynapseCCTP: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>

    setTokenFee(
      token: string,
      relayerFee: BigNumberish,
      minBaseFee: BigNumberish,
      minSwapFee: BigNumberish,
      maxFee: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>

    symbolToToken(arg0: string, overrides?: CallOverrides): Promise<[string]>

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

    tokenToSymbol(arg0: string, overrides?: CallOverrides): Promise<[string]>

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

    unpauseSending(
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>

    withdrawProtocolFees(
      token: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>

    withdrawRelayerFees(
      token: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>
  }

  accumulatedFees(
    arg0: string,
    arg1: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>

  addToken(
    symbol: string,
    token: string,
    relayerFee: BigNumberish,
    minBaseFee: BigNumberish,
    minSwapFee: BigNumberish,
    maxFee: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>

  calculateFeeAmount(
    token: string,
    amount: BigNumberish,
    isSwap: boolean,
    overrides?: CallOverrides
  ): Promise<BigNumber>

  chainGasAmount(overrides?: CallOverrides): Promise<BigNumber>

  circleTokenPool(arg0: string, overrides?: CallOverrides): Promise<string>

  feeStructures(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<
    [number, BigNumber, BigNumber, BigNumber] & {
      relayerFee: number
      minBaseFee: BigNumber
      minSwapFee: BigNumber
      maxFee: BigNumber
    }
  >

  getBridgeTokens(overrides?: CallOverrides): Promise<BridgeTokenStructOutput[]>

  getLocalToken(
    remoteDomain: BigNumberish,
    remoteToken: string,
    overrides?: CallOverrides
  ): Promise<string>

  isRequestFulfilled(
    requestID: BytesLike,
    overrides?: CallOverrides
  ): Promise<boolean>

  localDomain(overrides?: CallOverrides): Promise<number>

  messageTransmitter(overrides?: CallOverrides): Promise<string>

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

  pauseSending(
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>

  paused(overrides?: CallOverrides): Promise<boolean>

  protocolFee(overrides?: CallOverrides): Promise<BigNumber>

  receiveCircleToken(
    message: BytesLike,
    signature: BytesLike,
    requestVersion: BigNumberish,
    formattedRequest: BytesLike,
    overrides?: PayableOverrides & { from?: string }
  ): Promise<ContractTransaction>

  relayerFeeCollectors(arg0: string, overrides?: CallOverrides): Promise<string>

  remoteDomainConfig(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<[number, string] & { domain: number; synapseCCTP: string }>

  removeToken(
    token: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>

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

  rescueGas(
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>

  sendCircleToken(
    recipient: string,
    chainId: BigNumberish,
    burnToken: string,
    amount: BigNumberish,
    requestVersion: BigNumberish,
    swapParams: BytesLike,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>

  setChainGasAmount(
    newChainGasAmount: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>

  setCircleTokenPool(
    circleToken: string,
    pool: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>

  setFeeCollector(
    feeCollector: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>

  setProtocolFee(
    newProtocolFee: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>

  setRemoteDomainConfig(
    remoteChainId: BigNumberish,
    remoteDomain: BigNumberish,
    remoteSynapseCCTP: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>

  setTokenFee(
    token: string,
    relayerFee: BigNumberish,
    minBaseFee: BigNumberish,
    minSwapFee: BigNumberish,
    maxFee: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>

  symbolToToken(arg0: string, overrides?: CallOverrides): Promise<string>

  tokenMessenger(overrides?: CallOverrides): Promise<string>

  tokenToSymbol(arg0: string, overrides?: CallOverrides): Promise<string>

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

  unpauseSending(
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>

  withdrawProtocolFees(
    token: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>

  withdrawRelayerFees(
    token: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>

  callStatic: {
    accumulatedFees(
      arg0: string,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>

    addToken(
      symbol: string,
      token: string,
      relayerFee: BigNumberish,
      minBaseFee: BigNumberish,
      minSwapFee: BigNumberish,
      maxFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>

    calculateFeeAmount(
      token: string,
      amount: BigNumberish,
      isSwap: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>

    chainGasAmount(overrides?: CallOverrides): Promise<BigNumber>

    circleTokenPool(arg0: string, overrides?: CallOverrides): Promise<string>

    feeStructures(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [number, BigNumber, BigNumber, BigNumber] & {
        relayerFee: number
        minBaseFee: BigNumber
        minSwapFee: BigNumber
        maxFee: BigNumber
      }
    >

    getBridgeTokens(
      overrides?: CallOverrides
    ): Promise<BridgeTokenStructOutput[]>

    getLocalToken(
      remoteDomain: BigNumberish,
      remoteToken: string,
      overrides?: CallOverrides
    ): Promise<string>

    isRequestFulfilled(
      requestID: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>

    localDomain(overrides?: CallOverrides): Promise<number>

    messageTransmitter(overrides?: CallOverrides): Promise<string>

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

    pauseSending(overrides?: CallOverrides): Promise<void>

    paused(overrides?: CallOverrides): Promise<boolean>

    protocolFee(overrides?: CallOverrides): Promise<BigNumber>

    receiveCircleToken(
      message: BytesLike,
      signature: BytesLike,
      requestVersion: BigNumberish,
      formattedRequest: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>

    relayerFeeCollectors(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<string>

    remoteDomainConfig(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number, string] & { domain: number; synapseCCTP: string }>

    removeToken(token: string, overrides?: CallOverrides): Promise<void>

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

    rescueGas(overrides?: CallOverrides): Promise<void>

    sendCircleToken(
      recipient: string,
      chainId: BigNumberish,
      burnToken: string,
      amount: BigNumberish,
      requestVersion: BigNumberish,
      swapParams: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>

    setChainGasAmount(
      newChainGasAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>

    setCircleTokenPool(
      circleToken: string,
      pool: string,
      overrides?: CallOverrides
    ): Promise<void>

    setFeeCollector(
      feeCollector: string,
      overrides?: CallOverrides
    ): Promise<void>

    setProtocolFee(
      newProtocolFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>

    setRemoteDomainConfig(
      remoteChainId: BigNumberish,
      remoteDomain: BigNumberish,
      remoteSynapseCCTP: string,
      overrides?: CallOverrides
    ): Promise<void>

    setTokenFee(
      token: string,
      relayerFee: BigNumberish,
      minBaseFee: BigNumberish,
      minSwapFee: BigNumberish,
      maxFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>

    symbolToToken(arg0: string, overrides?: CallOverrides): Promise<string>

    tokenMessenger(overrides?: CallOverrides): Promise<string>

    tokenToSymbol(arg0: string, overrides?: CallOverrides): Promise<string>

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

    unpauseSending(overrides?: CallOverrides): Promise<void>

    withdrawProtocolFees(
      token: string,
      overrides?: CallOverrides
    ): Promise<void>

    withdrawRelayerFees(token: string, overrides?: CallOverrides): Promise<void>
  }

  filters: {
    'ChainGasAirdropped(uint256)'(amount?: null): ChainGasAirdroppedEventFilter
    ChainGasAirdropped(amount?: null): ChainGasAirdroppedEventFilter

    'ChainGasAmountUpdated(uint256)'(
      chainGasAmount?: null
    ): ChainGasAmountUpdatedEventFilter
    ChainGasAmountUpdated(
      chainGasAmount?: null
    ): ChainGasAmountUpdatedEventFilter

    'CircleRequestFulfilled(uint32,address,address,uint256,address,uint256,bytes32)'(
      originDomain?: null,
      recipient?: string | null,
      mintToken?: null,
      fee?: null,
      token?: null,
      amount?: null,
      requestID?: null
    ): CircleRequestFulfilledEventFilter
    CircleRequestFulfilled(
      originDomain?: null,
      recipient?: string | null,
      mintToken?: null,
      fee?: null,
      token?: null,
      amount?: null,
      requestID?: null
    ): CircleRequestFulfilledEventFilter

    'CircleRequestSent(uint256,address,uint64,address,uint256,uint32,bytes,bytes32)'(
      chainId?: null,
      sender?: string | null,
      nonce?: null,
      token?: null,
      amount?: null,
      requestVersion?: null,
      formattedRequest?: null,
      requestID?: null
    ): CircleRequestSentEventFilter
    CircleRequestSent(
      chainId?: null,
      sender?: string | null,
      nonce?: null,
      token?: null,
      amount?: null,
      requestVersion?: null,
      formattedRequest?: null,
      requestID?: null
    ): CircleRequestSentEventFilter

    'FeeCollected(address,uint256,uint256)'(
      feeCollector?: null,
      relayerFeeAmount?: null,
      protocolFeeAmount?: null
    ): FeeCollectedEventFilter
    FeeCollected(
      feeCollector?: null,
      relayerFeeAmount?: null,
      protocolFeeAmount?: null
    ): FeeCollectedEventFilter

    'FeeCollectorUpdated(address,address,address)'(
      relayer?: string | null,
      oldFeeCollector?: null,
      newFeeCollector?: null
    ): FeeCollectorUpdatedEventFilter
    FeeCollectorUpdated(
      relayer?: string | null,
      oldFeeCollector?: null,
      newFeeCollector?: null
    ): FeeCollectorUpdatedEventFilter

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

    'Paused(address)'(account?: null): PausedEventFilter
    Paused(account?: null): PausedEventFilter

    'ProtocolFeeUpdated(uint256)'(
      newProtocolFee?: null
    ): ProtocolFeeUpdatedEventFilter
    ProtocolFeeUpdated(newProtocolFee?: null): ProtocolFeeUpdatedEventFilter

    'Unpaused(address)'(account?: null): UnpausedEventFilter
    Unpaused(account?: null): UnpausedEventFilter
  }

  estimateGas: {
    accumulatedFees(
      arg0: string,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>

    addToken(
      symbol: string,
      token: string,
      relayerFee: BigNumberish,
      minBaseFee: BigNumberish,
      minSwapFee: BigNumberish,
      maxFee: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>

    calculateFeeAmount(
      token: string,
      amount: BigNumberish,
      isSwap: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>

    chainGasAmount(overrides?: CallOverrides): Promise<BigNumber>

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

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

    getBridgeTokens(overrides?: CallOverrides): Promise<BigNumber>

    getLocalToken(
      remoteDomain: BigNumberish,
      remoteToken: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>

    isRequestFulfilled(
      requestID: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>

    localDomain(overrides?: CallOverrides): Promise<BigNumber>

    messageTransmitter(overrides?: CallOverrides): Promise<BigNumber>

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

    pauseSending(overrides?: Overrides & { from?: string }): Promise<BigNumber>

    paused(overrides?: CallOverrides): Promise<BigNumber>

    protocolFee(overrides?: CallOverrides): Promise<BigNumber>

    receiveCircleToken(
      message: BytesLike,
      signature: BytesLike,
      requestVersion: BigNumberish,
      formattedRequest: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<BigNumber>

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

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

    removeToken(
      token: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>

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

    rescueGas(overrides?: Overrides & { from?: string }): Promise<BigNumber>

    sendCircleToken(
      recipient: string,
      chainId: BigNumberish,
      burnToken: string,
      amount: BigNumberish,
      requestVersion: BigNumberish,
      swapParams: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>

    setChainGasAmount(
      newChainGasAmount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>

    setCircleTokenPool(
      circleToken: string,
      pool: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>

    setFeeCollector(
      feeCollector: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>

    setProtocolFee(
      newProtocolFee: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>

    setRemoteDomainConfig(
      remoteChainId: BigNumberish,
      remoteDomain: BigNumberish,
      remoteSynapseCCTP: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>

    setTokenFee(
      token: string,
      relayerFee: BigNumberish,
      minBaseFee: BigNumberish,
      minSwapFee: BigNumberish,
      maxFee: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>

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

    tokenMessenger(overrides?: CallOverrides): Promise<BigNumber>

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

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

    unpauseSending(
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>

    withdrawProtocolFees(
      token: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>

    withdrawRelayerFees(
      token: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>
  }

  populateTransaction: {
    accumulatedFees(
      arg0: string,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>

    addToken(
      symbol: string,
      token: string,
      relayerFee: BigNumberish,
      minBaseFee: BigNumberish,
      minSwapFee: BigNumberish,
      maxFee: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>

    calculateFeeAmount(
      token: string,
      amount: BigNumberish,
      isSwap: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>

    chainGasAmount(overrides?: CallOverrides): Promise<PopulatedTransaction>

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

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

    getBridgeTokens(overrides?: CallOverrides): Promise<PopulatedTransaction>

    getLocalToken(
      remoteDomain: BigNumberish,
      remoteToken: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>

    isRequestFulfilled(
      requestID: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>

    localDomain(overrides?: CallOverrides): Promise<PopulatedTransaction>

    messageTransmitter(overrides?: CallOverrides): Promise<PopulatedTransaction>

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

    pauseSending(
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>

    paused(overrides?: CallOverrides): Promise<PopulatedTransaction>

    protocolFee(overrides?: CallOverrides): Promise<PopulatedTransaction>

    receiveCircleToken(
      message: BytesLike,
      signature: BytesLike,
      requestVersion: BigNumberish,
      formattedRequest: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<PopulatedTransaction>

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

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

    removeToken(
      token: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>

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

    rescueGas(
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>

    sendCircleToken(
      recipient: string,
      chainId: BigNumberish,
      burnToken: string,
      amount: BigNumberish,
      requestVersion: BigNumberish,
      swapParams: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>

    setChainGasAmount(
      newChainGasAmount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>

    setCircleTokenPool(
      circleToken: string,
      pool: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>

    setFeeCollector(
      feeCollector: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>

    setProtocolFee(
      newProtocolFee: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>

    setRemoteDomainConfig(
      remoteChainId: BigNumberish,
      remoteDomain: BigNumberish,
      remoteSynapseCCTP: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>

    setTokenFee(
      token: string,
      relayerFee: BigNumberish,
      minBaseFee: BigNumberish,
      minSwapFee: BigNumberish,
      maxFee: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>

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

    tokenMessenger(overrides?: CallOverrides): Promise<PopulatedTransaction>

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

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

    unpauseSending(
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>

    withdrawProtocolFees(
      token: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>

    withdrawRelayerFees(
      token: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>
  }
}