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

export interface SwapInterface extends utils.Interface {
  functions: {
    "addLiquidity(uint256[],uint256,uint256)": FunctionFragment;
    "calculateCurrentWithdrawFee(address)": FunctionFragment;
    "calculateRemoveLiquidity(address,uint256)": FunctionFragment;
    "calculateRemoveLiquidityOneToken(address,uint256,uint8)": FunctionFragment;
    "calculateSwap(uint8,uint8,uint256)": FunctionFragment;
    "calculateSwapUnderlying(uint8,uint8,uint256)": FunctionFragment;
    "calculateTokenAmount(address,uint256[],bool)": FunctionFragment;
    "getA()": FunctionFragment;
    "getAPrecise()": FunctionFragment;
    "getAdminBalance(uint256)": FunctionFragment;
    "getBalances()": FunctionFragment;
    "getDepositTimestamp(address)": FunctionFragment;
    "getLpToken()": FunctionFragment;
    "getToken(uint8)": FunctionFragment;
    "getTokenBalance(uint8)": FunctionFragment;
    "getTokenIndex(address)": FunctionFragment;
    "getVirtualPrice()": FunctionFragment;
    "initialize(address[],uint8[],string,string,uint256,uint256,uint256,uint256,uint256,address)": FunctionFragment;
    "initializeMetaSwap(address[],uint8[],string,string,uint256,uint256,uint256,uint256,uint256,address,address)": FunctionFragment;
    "metaSwapStorage()": FunctionFragment;
    "owner()": FunctionFragment;
    "pause()": FunctionFragment;
    "paused()": FunctionFragment;
    "rampA(uint256,uint256)": FunctionFragment;
    "removeLiquidity(uint256,uint256[],uint256)": FunctionFragment;
    "removeLiquidityImbalance(uint256[],uint256,uint256)": FunctionFragment;
    "removeLiquidityOneToken(uint256,uint8,uint256,uint256)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "setAdminFee(uint256)": FunctionFragment;
    "setDefaultDepositFee(uint256)": FunctionFragment;
    "setDefaultWithdrawFee(uint256)": FunctionFragment;
    "setDevAddress(address)": FunctionFragment;
    "setSwapFee(uint256)": FunctionFragment;
    "stopRampA()": FunctionFragment;
    "swap(uint8,uint8,uint256,uint256,uint256)": FunctionFragment;
    "swapStorage()": FunctionFragment;
    "swapUnderlying(uint8,uint8,uint256,uint256,uint256)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "unpause()": FunctionFragment;
    "updateUserWithdrawFee(address,uint256)": FunctionFragment;
    "withdrawAdminFees()": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "addLiquidity"
      | "calculateCurrentWithdrawFee"
      | "calculateRemoveLiquidity"
      | "calculateRemoveLiquidityOneToken"
      | "calculateSwap"
      | "calculateSwapUnderlying"
      | "calculateTokenAmount"
      | "getA"
      | "getAPrecise"
      | "getAdminBalance"
      | "getBalances"
      | "getDepositTimestamp"
      | "getLpToken"
      | "getToken"
      | "getTokenBalance"
      | "getTokenIndex"
      | "getVirtualPrice"
      | "initialize"
      | "initializeMetaSwap"
      | "metaSwapStorage"
      | "owner"
      | "pause"
      | "paused"
      | "rampA"
      | "removeLiquidity"
      | "removeLiquidityImbalance"
      | "removeLiquidityOneToken"
      | "renounceOwnership"
      | "setAdminFee"
      | "setDefaultDepositFee"
      | "setDefaultWithdrawFee"
      | "setDevAddress"
      | "setSwapFee"
      | "stopRampA"
      | "swap"
      | "swapStorage"
      | "swapUnderlying"
      | "transferOwnership"
      | "unpause"
      | "updateUserWithdrawFee"
      | "withdrawAdminFees"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "addLiquidity",
    values: [
      PromiseOrValue<BigNumberish>[],
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "calculateCurrentWithdrawFee",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "calculateRemoveLiquidity",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "calculateRemoveLiquidityOneToken",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "calculateSwap",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "calculateSwapUnderlying",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "calculateTokenAmount",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>[],
      PromiseOrValue<boolean>
    ]
  ): string;
  encodeFunctionData(functionFragment: "getA", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getAPrecise",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getAdminBalance",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "getBalances",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getDepositTimestamp",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getLpToken",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getToken",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "getTokenBalance",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "getTokenIndex",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getVirtualPrice",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [
      PromiseOrValue<string>[],
      PromiseOrValue<BigNumberish>[],
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "initializeMetaSwap",
    values: [
      PromiseOrValue<string>[],
      PromiseOrValue<BigNumberish>[],
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "metaSwapStorage",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(functionFragment: "pause", values?: undefined): string;
  encodeFunctionData(functionFragment: "paused", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "rampA",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "removeLiquidity",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>[],
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "removeLiquidityImbalance",
    values: [
      PromiseOrValue<BigNumberish>[],
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "removeLiquidityOneToken",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setAdminFee",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setDefaultDepositFee",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setDefaultWithdrawFee",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setDevAddress",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setSwapFee",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(functionFragment: "stopRampA", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "swap",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "swapStorage",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "swapUnderlying",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(functionFragment: "unpause", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "updateUserWithdrawFee",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawAdminFees",
    values?: undefined
  ): string;

  decodeFunctionResult(
    functionFragment: "addLiquidity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "calculateCurrentWithdrawFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "calculateRemoveLiquidity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "calculateRemoveLiquidityOneToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "calculateSwap",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "calculateSwapUnderlying",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "calculateTokenAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getA", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getAPrecise",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getAdminBalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getBalances",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDepositTimestamp",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getLpToken", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getToken", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getTokenBalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTokenIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getVirtualPrice",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "initializeMetaSwap",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "metaSwapStorage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "rampA", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "removeLiquidity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "removeLiquidityImbalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "removeLiquidityOneToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setAdminFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDefaultDepositFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDefaultWithdrawFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDevAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setSwapFee", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stopRampA", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "swap", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "swapStorage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "swapUnderlying",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unpause", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "updateUserWithdrawFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawAdminFees",
    data: BytesLike
  ): Result;

  events: {
    "AddLiquidity(address,uint256[],uint256[],uint256,uint256)": EventFragment;
    "NewAdminFee(uint256)": EventFragment;
    "NewDepositFee(uint256)": EventFragment;
    "NewSwapFee(uint256)": EventFragment;
    "NewWithdrawFee(uint256)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "Paused(address)": EventFragment;
    "RampA(uint256,uint256,uint256,uint256)": EventFragment;
    "RemoveLiquidity(address,uint256[],uint256)": EventFragment;
    "RemoveLiquidityImbalance(address,uint256[],uint256[],uint256,uint256)": EventFragment;
    "RemoveLiquidityOne(address,uint256,uint256,uint256,uint256)": EventFragment;
    "StopRampA(uint256,uint256)": EventFragment;
    "TokenSwap(address,uint256,uint256,uint128,uint128)": EventFragment;
    "TokenSwapUnderlying(address,uint256,uint256,uint128,uint128)": EventFragment;
    "Unpaused(address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "AddLiquidity"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewAdminFee"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewDepositFee"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewSwapFee"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewWithdrawFee"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Paused"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RampA"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RemoveLiquidity"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RemoveLiquidityImbalance"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RemoveLiquidityOne"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StopRampA"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokenSwap"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokenSwapUnderlying"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Unpaused"): EventFragment;
}

export interface AddLiquidityEventObject {
  provider: string;
  tokenAmounts: BigNumber[];
  fees: BigNumber[];
  invariant: BigNumber;
  lpTokenSupply: BigNumber;
}
export type AddLiquidityEvent = TypedEvent<
  [string, BigNumber[], BigNumber[], BigNumber, BigNumber],
  AddLiquidityEventObject
>;

export type AddLiquidityEventFilter = TypedEventFilter<AddLiquidityEvent>;

export interface NewAdminFeeEventObject {
  newAdminFee: BigNumber;
}
export type NewAdminFeeEvent = TypedEvent<[BigNumber], NewAdminFeeEventObject>;

export type NewAdminFeeEventFilter = TypedEventFilter<NewAdminFeeEvent>;

export interface NewDepositFeeEventObject {
  newDepositFee: BigNumber;
}
export type NewDepositFeeEvent = TypedEvent<
  [BigNumber],
  NewDepositFeeEventObject
>;

export type NewDepositFeeEventFilter = TypedEventFilter<NewDepositFeeEvent>;

export interface NewSwapFeeEventObject {
  newSwapFee: BigNumber;
}
export type NewSwapFeeEvent = TypedEvent<[BigNumber], NewSwapFeeEventObject>;

export type NewSwapFeeEventFilter = TypedEventFilter<NewSwapFeeEvent>;

export interface NewWithdrawFeeEventObject {
  newWithdrawFee: BigNumber;
}
export type NewWithdrawFeeEvent = TypedEvent<
  [BigNumber],
  NewWithdrawFeeEventObject
>;

export type NewWithdrawFeeEventFilter = TypedEventFilter<NewWithdrawFeeEvent>;

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 RampAEventObject {
  oldA: BigNumber;
  newA: BigNumber;
  initialTime: BigNumber;
  futureTime: BigNumber;
}
export type RampAEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber, BigNumber],
  RampAEventObject
>;

export type RampAEventFilter = TypedEventFilter<RampAEvent>;

export interface RemoveLiquidityEventObject {
  provider: string;
  tokenAmounts: BigNumber[];
  lpTokenSupply: BigNumber;
}
export type RemoveLiquidityEvent = TypedEvent<
  [string, BigNumber[], BigNumber],
  RemoveLiquidityEventObject
>;

export type RemoveLiquidityEventFilter = TypedEventFilter<RemoveLiquidityEvent>;

export interface RemoveLiquidityImbalanceEventObject {
  provider: string;
  tokenAmounts: BigNumber[];
  fees: BigNumber[];
  invariant: BigNumber;
  lpTokenSupply: BigNumber;
}
export type RemoveLiquidityImbalanceEvent = TypedEvent<
  [string, BigNumber[], BigNumber[], BigNumber, BigNumber],
  RemoveLiquidityImbalanceEventObject
>;

export type RemoveLiquidityImbalanceEventFilter =
  TypedEventFilter<RemoveLiquidityImbalanceEvent>;

export interface RemoveLiquidityOneEventObject {
  provider: string;
  lpTokenAmount: BigNumber;
  lpTokenSupply: BigNumber;
  boughtId: BigNumber;
  tokensBought: BigNumber;
}
export type RemoveLiquidityOneEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber, BigNumber],
  RemoveLiquidityOneEventObject
>;

export type RemoveLiquidityOneEventFilter =
  TypedEventFilter<RemoveLiquidityOneEvent>;

export interface StopRampAEventObject {
  currentA: BigNumber;
  time: BigNumber;
}
export type StopRampAEvent = TypedEvent<
  [BigNumber, BigNumber],
  StopRampAEventObject
>;

export type StopRampAEventFilter = TypedEventFilter<StopRampAEvent>;

export interface TokenSwapEventObject {
  buyer: string;
  tokensSold: BigNumber;
  tokensBought: BigNumber;
  soldId: BigNumber;
  boughtId: BigNumber;
}
export type TokenSwapEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber, BigNumber],
  TokenSwapEventObject
>;

export type TokenSwapEventFilter = TypedEventFilter<TokenSwapEvent>;

export interface TokenSwapUnderlyingEventObject {
  buyer: string;
  tokensSold: BigNumber;
  tokensBought: BigNumber;
  soldId: BigNumber;
  boughtId: BigNumber;
}
export type TokenSwapUnderlyingEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber, BigNumber],
  TokenSwapUnderlyingEventObject
>;

export type TokenSwapUnderlyingEventFilter =
  TypedEventFilter<TokenSwapUnderlyingEvent>;

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

export type UnpausedEventFilter = TypedEventFilter<UnpausedEvent>;

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

  interface: SwapInterface;

  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: {
    addLiquidity(
      amounts: PromiseOrValue<BigNumberish>[],
      minToMint: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    calculateCurrentWithdrawFee(
      user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    calculateRemoveLiquidity(
      account: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber[]]>;

    calculateRemoveLiquidityOneToken(
      account: PromiseOrValue<string>,
      tokenAmount: PromiseOrValue<BigNumberish>,
      tokenIndex: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    calculateSwap(
      tokenIndexFrom: PromiseOrValue<BigNumberish>,
      tokenIndexTo: PromiseOrValue<BigNumberish>,
      dx: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    calculateSwapUnderlying(
      tokenIndexFrom: PromiseOrValue<BigNumberish>,
      tokenIndexTo: PromiseOrValue<BigNumberish>,
      dx: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    calculateTokenAmount(
      account: PromiseOrValue<string>,
      amounts: PromiseOrValue<BigNumberish>[],
      deposit: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

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

    getDepositTimestamp(
      user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

    getTokenIndex(
      tokenAddress: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[number]>;

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

    initialize(
      _pooledTokens: PromiseOrValue<string>[],
      decimals: PromiseOrValue<BigNumberish>[],
      lpTokenName: PromiseOrValue<string>,
      lpTokenSymbol: PromiseOrValue<string>,
      _a: PromiseOrValue<BigNumberish>,
      _fee: PromiseOrValue<BigNumberish>,
      _adminFee: PromiseOrValue<BigNumberish>,
      _depositFee: PromiseOrValue<BigNumberish>,
      _withdrawFee: PromiseOrValue<BigNumberish>,
      _devaddr: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    initializeMetaSwap(
      _pooledTokens: PromiseOrValue<string>[],
      decimals: PromiseOrValue<BigNumberish>[],
      lpTokenName: PromiseOrValue<string>,
      lpTokenSymbol: PromiseOrValue<string>,
      _a: PromiseOrValue<BigNumberish>,
      _fee: PromiseOrValue<BigNumberish>,
      _adminFee: PromiseOrValue<BigNumberish>,
      _depositFee: PromiseOrValue<BigNumberish>,
      _withdrawFee: PromiseOrValue<BigNumberish>,
      _devaddr: PromiseOrValue<string>,
      baseSwap: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    metaSwapStorage(
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber] & {
        baseSwap: string;
        baseVirtualPrice: BigNumber;
        baseCacheLastUpdated: BigNumber;
      }
    >;

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

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

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

    rampA(
      futureA: PromiseOrValue<BigNumberish>,
      futureTime: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    removeLiquidity(
      amount: PromiseOrValue<BigNumberish>,
      minAmounts: PromiseOrValue<BigNumberish>[],
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    removeLiquidityImbalance(
      amounts: PromiseOrValue<BigNumberish>[],
      maxBurnAmount: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    removeLiquidityOneToken(
      tokenAmount: PromiseOrValue<BigNumberish>,
      tokenIndex: PromiseOrValue<BigNumberish>,
      minAmount: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

    swap(
      tokenIndexFrom: PromiseOrValue<BigNumberish>,
      tokenIndexTo: PromiseOrValue<BigNumberish>,
      dx: PromiseOrValue<BigNumberish>,
      minDy: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    swapStorage(
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        string,
        string
      ] & {
        initialA: BigNumber;
        futureA: BigNumber;
        initialATime: BigNumber;
        futureATime: BigNumber;
        swapFee: BigNumber;
        adminFee: BigNumber;
        defaultDepositFee: BigNumber;
        defaultWithdrawFee: BigNumber;
        lpToken: string;
        devaddr: string;
      }
    >;

    swapUnderlying(
      tokenIndexFrom: PromiseOrValue<BigNumberish>,
      tokenIndexTo: PromiseOrValue<BigNumberish>,
      dx: PromiseOrValue<BigNumberish>,
      minDy: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

  addLiquidity(
    amounts: PromiseOrValue<BigNumberish>[],
    minToMint: PromiseOrValue<BigNumberish>,
    deadline: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  calculateCurrentWithdrawFee(
    user: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  calculateRemoveLiquidity(
    account: PromiseOrValue<string>,
    amount: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber[]>;

  calculateRemoveLiquidityOneToken(
    account: PromiseOrValue<string>,
    tokenAmount: PromiseOrValue<BigNumberish>,
    tokenIndex: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  calculateSwap(
    tokenIndexFrom: PromiseOrValue<BigNumberish>,
    tokenIndexTo: PromiseOrValue<BigNumberish>,
    dx: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  calculateSwapUnderlying(
    tokenIndexFrom: PromiseOrValue<BigNumberish>,
    tokenIndexTo: PromiseOrValue<BigNumberish>,
    dx: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  calculateTokenAmount(
    account: PromiseOrValue<string>,
    amounts: PromiseOrValue<BigNumberish>[],
    deposit: PromiseOrValue<boolean>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

  getAdminBalance(
    index: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  getDepositTimestamp(
    user: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  getToken(
    index: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string>;

  getTokenBalance(
    index: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getTokenIndex(
    tokenAddress: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<number>;

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

  initialize(
    _pooledTokens: PromiseOrValue<string>[],
    decimals: PromiseOrValue<BigNumberish>[],
    lpTokenName: PromiseOrValue<string>,
    lpTokenSymbol: PromiseOrValue<string>,
    _a: PromiseOrValue<BigNumberish>,
    _fee: PromiseOrValue<BigNumberish>,
    _adminFee: PromiseOrValue<BigNumberish>,
    _depositFee: PromiseOrValue<BigNumberish>,
    _withdrawFee: PromiseOrValue<BigNumberish>,
    _devaddr: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  initializeMetaSwap(
    _pooledTokens: PromiseOrValue<string>[],
    decimals: PromiseOrValue<BigNumberish>[],
    lpTokenName: PromiseOrValue<string>,
    lpTokenSymbol: PromiseOrValue<string>,
    _a: PromiseOrValue<BigNumberish>,
    _fee: PromiseOrValue<BigNumberish>,
    _adminFee: PromiseOrValue<BigNumberish>,
    _depositFee: PromiseOrValue<BigNumberish>,
    _withdrawFee: PromiseOrValue<BigNumberish>,
    _devaddr: PromiseOrValue<string>,
    baseSwap: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  metaSwapStorage(
    overrides?: CallOverrides
  ): Promise<
    [string, BigNumber, BigNumber] & {
      baseSwap: string;
      baseVirtualPrice: BigNumber;
      baseCacheLastUpdated: BigNumber;
    }
  >;

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

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

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

  rampA(
    futureA: PromiseOrValue<BigNumberish>,
    futureTime: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  removeLiquidity(
    amount: PromiseOrValue<BigNumberish>,
    minAmounts: PromiseOrValue<BigNumberish>[],
    deadline: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  removeLiquidityImbalance(
    amounts: PromiseOrValue<BigNumberish>[],
    maxBurnAmount: PromiseOrValue<BigNumberish>,
    deadline: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  removeLiquidityOneToken(
    tokenAmount: PromiseOrValue<BigNumberish>,
    tokenIndex: PromiseOrValue<BigNumberish>,
    minAmount: PromiseOrValue<BigNumberish>,
    deadline: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

  swap(
    tokenIndexFrom: PromiseOrValue<BigNumberish>,
    tokenIndexTo: PromiseOrValue<BigNumberish>,
    dx: PromiseOrValue<BigNumberish>,
    minDy: PromiseOrValue<BigNumberish>,
    deadline: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  swapStorage(
    overrides?: CallOverrides
  ): Promise<
    [
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      string,
      string
    ] & {
      initialA: BigNumber;
      futureA: BigNumber;
      initialATime: BigNumber;
      futureATime: BigNumber;
      swapFee: BigNumber;
      adminFee: BigNumber;
      defaultDepositFee: BigNumber;
      defaultWithdrawFee: BigNumber;
      lpToken: string;
      devaddr: string;
    }
  >;

  swapUnderlying(
    tokenIndexFrom: PromiseOrValue<BigNumberish>,
    tokenIndexTo: PromiseOrValue<BigNumberish>,
    dx: PromiseOrValue<BigNumberish>,
    minDy: PromiseOrValue<BigNumberish>,
    deadline: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

  callStatic: {
    addLiquidity(
      amounts: PromiseOrValue<BigNumberish>[],
      minToMint: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calculateCurrentWithdrawFee(
      user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calculateRemoveLiquidity(
      account: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

    calculateRemoveLiquidityOneToken(
      account: PromiseOrValue<string>,
      tokenAmount: PromiseOrValue<BigNumberish>,
      tokenIndex: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calculateSwap(
      tokenIndexFrom: PromiseOrValue<BigNumberish>,
      tokenIndexTo: PromiseOrValue<BigNumberish>,
      dx: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calculateSwapUnderlying(
      tokenIndexFrom: PromiseOrValue<BigNumberish>,
      tokenIndexTo: PromiseOrValue<BigNumberish>,
      dx: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calculateTokenAmount(
      account: PromiseOrValue<string>,
      amounts: PromiseOrValue<BigNumberish>[],
      deposit: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getAdminBalance(
      index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getDepositTimestamp(
      user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getToken(
      index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

    getTokenBalance(
      index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getTokenIndex(
      tokenAddress: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<number>;

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

    initialize(
      _pooledTokens: PromiseOrValue<string>[],
      decimals: PromiseOrValue<BigNumberish>[],
      lpTokenName: PromiseOrValue<string>,
      lpTokenSymbol: PromiseOrValue<string>,
      _a: PromiseOrValue<BigNumberish>,
      _fee: PromiseOrValue<BigNumberish>,
      _adminFee: PromiseOrValue<BigNumberish>,
      _depositFee: PromiseOrValue<BigNumberish>,
      _withdrawFee: PromiseOrValue<BigNumberish>,
      _devaddr: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    initializeMetaSwap(
      _pooledTokens: PromiseOrValue<string>[],
      decimals: PromiseOrValue<BigNumberish>[],
      lpTokenName: PromiseOrValue<string>,
      lpTokenSymbol: PromiseOrValue<string>,
      _a: PromiseOrValue<BigNumberish>,
      _fee: PromiseOrValue<BigNumberish>,
      _adminFee: PromiseOrValue<BigNumberish>,
      _depositFee: PromiseOrValue<BigNumberish>,
      _withdrawFee: PromiseOrValue<BigNumberish>,
      _devaddr: PromiseOrValue<string>,
      baseSwap: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    metaSwapStorage(
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber] & {
        baseSwap: string;
        baseVirtualPrice: BigNumber;
        baseCacheLastUpdated: BigNumber;
      }
    >;

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

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

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

    rampA(
      futureA: PromiseOrValue<BigNumberish>,
      futureTime: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    removeLiquidity(
      amount: PromiseOrValue<BigNumberish>,
      minAmounts: PromiseOrValue<BigNumberish>[],
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

    removeLiquidityImbalance(
      amounts: PromiseOrValue<BigNumberish>[],
      maxBurnAmount: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    removeLiquidityOneToken(
      tokenAmount: PromiseOrValue<BigNumberish>,
      tokenIndex: PromiseOrValue<BigNumberish>,
      minAmount: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    setAdminFee(
      newAdminFee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setDefaultDepositFee(
      newDepositFee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setDefaultWithdrawFee(
      newWithdrawFee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setDevAddress(
      _devaddr: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setSwapFee(
      newSwapFee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

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

    swap(
      tokenIndexFrom: PromiseOrValue<BigNumberish>,
      tokenIndexTo: PromiseOrValue<BigNumberish>,
      dx: PromiseOrValue<BigNumberish>,
      minDy: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    swapStorage(
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        string,
        string
      ] & {
        initialA: BigNumber;
        futureA: BigNumber;
        initialATime: BigNumber;
        futureATime: BigNumber;
        swapFee: BigNumber;
        adminFee: BigNumber;
        defaultDepositFee: BigNumber;
        defaultWithdrawFee: BigNumber;
        lpToken: string;
        devaddr: string;
      }
    >;

    swapUnderlying(
      tokenIndexFrom: PromiseOrValue<BigNumberish>,
      tokenIndexTo: PromiseOrValue<BigNumberish>,
      dx: PromiseOrValue<BigNumberish>,
      minDy: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    updateUserWithdrawFee(
      recipient: PromiseOrValue<string>,
      transferAmount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawAdminFees(overrides?: CallOverrides): Promise<void>;
  };

  filters: {
    "AddLiquidity(address,uint256[],uint256[],uint256,uint256)"(
      provider?: PromiseOrValue<string> | null,
      tokenAmounts?: null,
      fees?: null,
      invariant?: null,
      lpTokenSupply?: null
    ): AddLiquidityEventFilter;
    AddLiquidity(
      provider?: PromiseOrValue<string> | null,
      tokenAmounts?: null,
      fees?: null,
      invariant?: null,
      lpTokenSupply?: null
    ): AddLiquidityEventFilter;

    "NewAdminFee(uint256)"(newAdminFee?: null): NewAdminFeeEventFilter;
    NewAdminFee(newAdminFee?: null): NewAdminFeeEventFilter;

    "NewDepositFee(uint256)"(newDepositFee?: null): NewDepositFeeEventFilter;
    NewDepositFee(newDepositFee?: null): NewDepositFeeEventFilter;

    "NewSwapFee(uint256)"(newSwapFee?: null): NewSwapFeeEventFilter;
    NewSwapFee(newSwapFee?: null): NewSwapFeeEventFilter;

    "NewWithdrawFee(uint256)"(newWithdrawFee?: null): NewWithdrawFeeEventFilter;
    NewWithdrawFee(newWithdrawFee?: null): NewWithdrawFeeEventFilter;

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

    "Paused(address)"(account?: null): PausedEventFilter;
    Paused(account?: null): PausedEventFilter;

    "RampA(uint256,uint256,uint256,uint256)"(
      oldA?: null,
      newA?: null,
      initialTime?: null,
      futureTime?: null
    ): RampAEventFilter;
    RampA(
      oldA?: null,
      newA?: null,
      initialTime?: null,
      futureTime?: null
    ): RampAEventFilter;

    "RemoveLiquidity(address,uint256[],uint256)"(
      provider?: PromiseOrValue<string> | null,
      tokenAmounts?: null,
      lpTokenSupply?: null
    ): RemoveLiquidityEventFilter;
    RemoveLiquidity(
      provider?: PromiseOrValue<string> | null,
      tokenAmounts?: null,
      lpTokenSupply?: null
    ): RemoveLiquidityEventFilter;

    "RemoveLiquidityImbalance(address,uint256[],uint256[],uint256,uint256)"(
      provider?: PromiseOrValue<string> | null,
      tokenAmounts?: null,
      fees?: null,
      invariant?: null,
      lpTokenSupply?: null
    ): RemoveLiquidityImbalanceEventFilter;
    RemoveLiquidityImbalance(
      provider?: PromiseOrValue<string> | null,
      tokenAmounts?: null,
      fees?: null,
      invariant?: null,
      lpTokenSupply?: null
    ): RemoveLiquidityImbalanceEventFilter;

    "RemoveLiquidityOne(address,uint256,uint256,uint256,uint256)"(
      provider?: PromiseOrValue<string> | null,
      lpTokenAmount?: null,
      lpTokenSupply?: null,
      boughtId?: null,
      tokensBought?: null
    ): RemoveLiquidityOneEventFilter;
    RemoveLiquidityOne(
      provider?: PromiseOrValue<string> | null,
      lpTokenAmount?: null,
      lpTokenSupply?: null,
      boughtId?: null,
      tokensBought?: null
    ): RemoveLiquidityOneEventFilter;

    "StopRampA(uint256,uint256)"(
      currentA?: null,
      time?: null
    ): StopRampAEventFilter;
    StopRampA(currentA?: null, time?: null): StopRampAEventFilter;

    "TokenSwap(address,uint256,uint256,uint128,uint128)"(
      buyer?: PromiseOrValue<string> | null,
      tokensSold?: null,
      tokensBought?: null,
      soldId?: null,
      boughtId?: null
    ): TokenSwapEventFilter;
    TokenSwap(
      buyer?: PromiseOrValue<string> | null,
      tokensSold?: null,
      tokensBought?: null,
      soldId?: null,
      boughtId?: null
    ): TokenSwapEventFilter;

    "TokenSwapUnderlying(address,uint256,uint256,uint128,uint128)"(
      buyer?: PromiseOrValue<string> | null,
      tokensSold?: null,
      tokensBought?: null,
      soldId?: null,
      boughtId?: null
    ): TokenSwapUnderlyingEventFilter;
    TokenSwapUnderlying(
      buyer?: PromiseOrValue<string> | null,
      tokensSold?: null,
      tokensBought?: null,
      soldId?: null,
      boughtId?: null
    ): TokenSwapUnderlyingEventFilter;

    "Unpaused(address)"(account?: null): UnpausedEventFilter;
    Unpaused(account?: null): UnpausedEventFilter;
  };

  estimateGas: {
    addLiquidity(
      amounts: PromiseOrValue<BigNumberish>[],
      minToMint: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    calculateCurrentWithdrawFee(
      user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    calculateRemoveLiquidityOneToken(
      account: PromiseOrValue<string>,
      tokenAmount: PromiseOrValue<BigNumberish>,
      tokenIndex: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calculateSwap(
      tokenIndexFrom: PromiseOrValue<BigNumberish>,
      tokenIndexTo: PromiseOrValue<BigNumberish>,
      dx: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calculateSwapUnderlying(
      tokenIndexFrom: PromiseOrValue<BigNumberish>,
      tokenIndexTo: PromiseOrValue<BigNumberish>,
      dx: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calculateTokenAmount(
      account: PromiseOrValue<string>,
      amounts: PromiseOrValue<BigNumberish>[],
      deposit: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getAdminBalance(
      index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getDepositTimestamp(
      user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getToken(
      index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getTokenBalance(
      index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getTokenIndex(
      tokenAddress: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    initialize(
      _pooledTokens: PromiseOrValue<string>[],
      decimals: PromiseOrValue<BigNumberish>[],
      lpTokenName: PromiseOrValue<string>,
      lpTokenSymbol: PromiseOrValue<string>,
      _a: PromiseOrValue<BigNumberish>,
      _fee: PromiseOrValue<BigNumberish>,
      _adminFee: PromiseOrValue<BigNumberish>,
      _depositFee: PromiseOrValue<BigNumberish>,
      _withdrawFee: PromiseOrValue<BigNumberish>,
      _devaddr: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    initializeMetaSwap(
      _pooledTokens: PromiseOrValue<string>[],
      decimals: PromiseOrValue<BigNumberish>[],
      lpTokenName: PromiseOrValue<string>,
      lpTokenSymbol: PromiseOrValue<string>,
      _a: PromiseOrValue<BigNumberish>,
      _fee: PromiseOrValue<BigNumberish>,
      _adminFee: PromiseOrValue<BigNumberish>,
      _depositFee: PromiseOrValue<BigNumberish>,
      _withdrawFee: PromiseOrValue<BigNumberish>,
      _devaddr: PromiseOrValue<string>,
      baseSwap: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

    rampA(
      futureA: PromiseOrValue<BigNumberish>,
      futureTime: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    removeLiquidity(
      amount: PromiseOrValue<BigNumberish>,
      minAmounts: PromiseOrValue<BigNumberish>[],
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    removeLiquidityImbalance(
      amounts: PromiseOrValue<BigNumberish>[],
      maxBurnAmount: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    removeLiquidityOneToken(
      tokenAmount: PromiseOrValue<BigNumberish>,
      tokenIndex: PromiseOrValue<BigNumberish>,
      minAmount: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    swap(
      tokenIndexFrom: PromiseOrValue<BigNumberish>,
      tokenIndexTo: PromiseOrValue<BigNumberish>,
      dx: PromiseOrValue<BigNumberish>,
      minDy: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

    swapUnderlying(
      tokenIndexFrom: PromiseOrValue<BigNumberish>,
      tokenIndexTo: PromiseOrValue<BigNumberish>,
      dx: PromiseOrValue<BigNumberish>,
      minDy: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

  populateTransaction: {
    addLiquidity(
      amounts: PromiseOrValue<BigNumberish>[],
      minToMint: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    calculateCurrentWithdrawFee(
      user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    calculateRemoveLiquidityOneToken(
      account: PromiseOrValue<string>,
      tokenAmount: PromiseOrValue<BigNumberish>,
      tokenIndex: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    calculateSwap(
      tokenIndexFrom: PromiseOrValue<BigNumberish>,
      tokenIndexTo: PromiseOrValue<BigNumberish>,
      dx: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    calculateSwapUnderlying(
      tokenIndexFrom: PromiseOrValue<BigNumberish>,
      tokenIndexTo: PromiseOrValue<BigNumberish>,
      dx: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    calculateTokenAmount(
      account: PromiseOrValue<string>,
      amounts: PromiseOrValue<BigNumberish>[],
      deposit: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    getAdminBalance(
      index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    getDepositTimestamp(
      user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    getToken(
      index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getTokenBalance(
      index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getTokenIndex(
      tokenAddress: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    initialize(
      _pooledTokens: PromiseOrValue<string>[],
      decimals: PromiseOrValue<BigNumberish>[],
      lpTokenName: PromiseOrValue<string>,
      lpTokenSymbol: PromiseOrValue<string>,
      _a: PromiseOrValue<BigNumberish>,
      _fee: PromiseOrValue<BigNumberish>,
      _adminFee: PromiseOrValue<BigNumberish>,
      _depositFee: PromiseOrValue<BigNumberish>,
      _withdrawFee: PromiseOrValue<BigNumberish>,
      _devaddr: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    initializeMetaSwap(
      _pooledTokens: PromiseOrValue<string>[],
      decimals: PromiseOrValue<BigNumberish>[],
      lpTokenName: PromiseOrValue<string>,
      lpTokenSymbol: PromiseOrValue<string>,
      _a: PromiseOrValue<BigNumberish>,
      _fee: PromiseOrValue<BigNumberish>,
      _adminFee: PromiseOrValue<BigNumberish>,
      _depositFee: PromiseOrValue<BigNumberish>,
      _withdrawFee: PromiseOrValue<BigNumberish>,
      _devaddr: PromiseOrValue<string>,
      baseSwap: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    rampA(
      futureA: PromiseOrValue<BigNumberish>,
      futureTime: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    removeLiquidity(
      amount: PromiseOrValue<BigNumberish>,
      minAmounts: PromiseOrValue<BigNumberish>[],
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    removeLiquidityImbalance(
      amounts: PromiseOrValue<BigNumberish>[],
      maxBurnAmount: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    removeLiquidityOneToken(
      tokenAmount: PromiseOrValue<BigNumberish>,
      tokenIndex: PromiseOrValue<BigNumberish>,
      minAmount: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

    swap(
      tokenIndexFrom: PromiseOrValue<BigNumberish>,
      tokenIndexTo: PromiseOrValue<BigNumberish>,
      dx: PromiseOrValue<BigNumberish>,
      minDy: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

    swapUnderlying(
      tokenIndexFrom: PromiseOrValue<BigNumberish>,
      tokenIndexTo: PromiseOrValue<BigNumberish>,
      dx: PromiseOrValue<BigNumberish>,
      minDy: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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