/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  Contract,
  ContractTransaction,
  Overrides,
  CallOverrides,
} from "ethers";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
import { TypedEventFilter, TypedEvent, TypedListener } from "./commons";

interface GranularBondingCurveInterface extends ethers.utils.Interface {
  functions: {
    "PRECISION()": FunctionFragment;
    "ROUNDLIMIT()": FunctionFragment;
    "addDelta(uint128,int128)": FunctionFragment;
    "baseGivenLiquidity(uint256,uint256,uint256)": FunctionFragment;
    "baseToken()": FunctionFragment;
    "bidsLeft(uint16)": FunctionFragment;
    "claimFilledOrder(address,uint16,bool)": FunctionFragment;
    "claimPartiallyFilledOrder(address,uint16,bool)": FunctionFragment;
    "collect(address,uint16,uint16,uint128,uint128)": FunctionFragment;
    "entry()": FunctionFragment;
    "factory()": FunctionFragment;
    "fee()": FunctionFragment;
    "feeGrowthGlobalBase()": FunctionFragment;
    "feeGrowthGlobalTrade()": FunctionFragment;
    "getCurPrice()": FunctionFragment;
    "getLiq(address,uint16,bool)": FunctionFragment;
    "getMaxLiquidity()": FunctionFragment;
    "getNextPriceLimit(uint16,uint256,bool)": FunctionFragment;
    "getNumCross(uint16,bool)": FunctionFragment;
    "getOneTimeLiquidity(uint16,bool)": FunctionFragment;
    "liquidity()": FunctionFragment;
    "liquidityGivenBase(uint256,uint256,uint256)": FunctionFragment;
    "liquidityGivenTrade(uint256,uint256,uint256)": FunctionFragment;
    "lock()": FunctionFragment;
    "owner()": FunctionFragment;
    "placeLimitOrder(address,uint16,uint128,bool)": FunctionFragment;
    "pointToPrice(uint16)": FunctionFragment;
    "positionIsFilled(address,uint16,bool)": FunctionFragment;
    "positions(bytes32)": FunctionFragment;
    "priceDelta()": FunctionFragment;
    "priceToPoint(uint256)": FunctionFragment;
    "provide(address,uint16,uint16,uint128,bytes)": FunctionFragment;
    "reduceLimitOrder(address,uint16,uint128,bool)": FunctionFragment;
    "remove(address,uint16,uint16,uint128)": FunctionFragment;
    "setEntry(address)": FunctionFragment;
    "setLiquidity(uint128)": FunctionFragment;
    "setPriceAndPoint(uint256)": FunctionFragment;
    "slot0()": FunctionFragment;
    "tickSpacing()": FunctionFragment;
    "ticks(uint16)": FunctionFragment;
    "trade(address,bool,int256,uint256,bytes)": FunctionFragment;
    "tradeGivenLiquidity(uint256,uint256,uint256)": FunctionFragment;
    "tradeToken()": FunctionFragment;
    "xMax(uint256,uint256,uint256)": FunctionFragment;
    "xMaxRoundUp(uint256,uint256,uint256)": FunctionFragment;
    "yInt(uint256,bool)": FunctionFragment;
  };

  encodeFunctionData(functionFragment: "PRECISION", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "ROUNDLIMIT",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "addDelta",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "baseGivenLiquidity",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "baseToken", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "bidsLeft",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "claimFilledOrder",
    values: [string, BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "claimPartiallyFilledOrder",
    values: [string, BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "collect",
    values: [string, BigNumberish, BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "entry", values?: undefined): string;
  encodeFunctionData(functionFragment: "factory", values?: undefined): string;
  encodeFunctionData(functionFragment: "fee", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "feeGrowthGlobalBase",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "feeGrowthGlobalTrade",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getCurPrice",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getLiq",
    values: [string, BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "getMaxLiquidity",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getNextPriceLimit",
    values: [BigNumberish, BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "getNumCross",
    values: [BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "getOneTimeLiquidity",
    values: [BigNumberish, boolean]
  ): string;
  encodeFunctionData(functionFragment: "liquidity", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "liquidityGivenBase",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "liquidityGivenTrade",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "lock", values?: undefined): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "placeLimitOrder",
    values: [string, BigNumberish, BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "pointToPrice",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "positionIsFilled",
    values: [string, BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "positions",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "priceDelta",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "priceToPoint",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "provide",
    values: [string, BigNumberish, BigNumberish, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "reduceLimitOrder",
    values: [string, BigNumberish, BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "remove",
    values: [string, BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "setEntry", values: [string]): string;
  encodeFunctionData(
    functionFragment: "setLiquidity",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setPriceAndPoint",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "slot0", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "tickSpacing",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "ticks", values: [BigNumberish]): string;
  encodeFunctionData(
    functionFragment: "trade",
    values: [string, boolean, BigNumberish, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "tradeGivenLiquidity",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "tradeToken",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "xMax",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "xMaxRoundUp",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "yInt",
    values: [BigNumberish, boolean]
  ): string;

  decodeFunctionResult(functionFragment: "PRECISION", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "ROUNDLIMIT", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "addDelta", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "baseGivenLiquidity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "baseToken", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "bidsLeft", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "claimFilledOrder",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimPartiallyFilledOrder",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "collect", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "entry", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "factory", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "fee", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "feeGrowthGlobalBase",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "feeGrowthGlobalTrade",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getCurPrice",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getLiq", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getMaxLiquidity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getNextPriceLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getNumCross",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getOneTimeLiquidity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "liquidity", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "liquidityGivenBase",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidityGivenTrade",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "lock", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "placeLimitOrder",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "pointToPrice",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "positionIsFilled",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "positions", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "priceDelta", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "priceToPoint",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "provide", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "reduceLimitOrder",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "remove", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "setEntry", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setLiquidity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPriceAndPoint",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "slot0", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "tickSpacing",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "ticks", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "trade", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "tradeGivenLiquidity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "tradeToken", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "xMax", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "xMaxRoundUp",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "yInt", data: BytesLike): Result;

  events: {};
}

export class GranularBondingCurve extends Contract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  listeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter?: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): Array<TypedListener<EventArgsArray, EventArgsObject>>;
  off<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  on<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  once<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeListener<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeAllListeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): this;

  listeners(eventName?: string): Array<Listener>;
  off(eventName: string, listener: Listener): this;
  on(eventName: string, listener: Listener): this;
  once(eventName: string, listener: Listener): this;
  removeListener(eventName: string, listener: Listener): this;
  removeAllListeners(eventName?: string): this;

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

  interface: GranularBondingCurveInterface;

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

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

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

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

    addDelta(
      x: BigNumberish,
      y: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { z: BigNumber }>;

    "addDelta(uint128,int128)"(
      x: BigNumberish,
      y: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { z: BigNumber }>;

    baseGivenLiquidity(
      p2: BigNumberish,
      p1: BigNumberish,
      L: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    "baseGivenLiquidity(uint256,uint256,uint256)"(
      p2: BigNumberish,
      p1: BigNumberish,
      L: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

    bidsLeft(
      point: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    "bidsLeft(uint16)"(
      point: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    claimFilledOrder(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "claimFilledOrder(address,uint16,bool)"(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    claimPartiallyFilledOrder(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "claimPartiallyFilledOrder(address,uint16,bool)"(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    collect(
      recipient: string,
      tickLower: BigNumberish,
      tickUpper: BigNumberish,
      amount0Requested: BigNumberish,
      amount1Requested: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "collect(address,uint16,uint16,uint128,uint128)"(
      recipient: string,
      tickLower: BigNumberish,
      tickUpper: BigNumberish,
      amount0Requested: BigNumberish,
      amount1Requested: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

    getLiq(
      to: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    "getLiq(address,uint16,bool)"(
      to: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

    getNextPriceLimit(
      point: BigNumberish,
      pDelta: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    "getNextPriceLimit(uint16,uint256,bool)"(
      point: BigNumberish,
      pDelta: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getNumCross(
      point: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    "getNumCross(uint16,bool)"(
      point: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getOneTimeLiquidity(
      point: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    "getOneTimeLiquidity(uint16,bool)"(
      point: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

    liquidityGivenBase(
      p2: BigNumberish,
      p1: BigNumberish,
      B: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    "liquidityGivenBase(uint256,uint256,uint256)"(
      p2: BigNumberish,
      p1: BigNumberish,
      B: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    liquidityGivenTrade(
      p2: BigNumberish,
      p1: BigNumberish,
      T: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    "liquidityGivenTrade(uint256,uint256,uint256)"(
      p2: BigNumberish,
      p1: BigNumberish,
      T: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

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

    placeLimitOrder(
      recipient: string,
      point: BigNumberish,
      amount: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "placeLimitOrder(address,uint16,uint128,bool)"(
      recipient: string,
      point: BigNumberish,
      amount: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    pointToPrice(
      point: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    "pointToPrice(uint16)"(
      point: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    positionIsFilled(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    "positionIsFilled(address,uint16,bool)"(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    positions(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        bidCrossId: BigNumber;
        askCrossId: BigNumber;
        askLiq: BigNumber;
        bidLiq: BigNumber;
        liquidity: BigNumber;
        feeGrowthInside0LastX128: BigNumber;
        feeGrowthInside1LastX128: BigNumber;
        tokensOwed0: BigNumber;
        tokensOwed1: BigNumber;
      }
    >;

    "positions(bytes32)"(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        bidCrossId: BigNumber;
        askCrossId: BigNumber;
        askLiq: BigNumber;
        bidLiq: BigNumber;
        liquidity: BigNumber;
        feeGrowthInside0LastX128: BigNumber;
        feeGrowthInside1LastX128: BigNumber;
        tokensOwed0: BigNumber;
        tokensOwed1: BigNumber;
      }
    >;

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

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

    priceToPoint(
      price: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number]>;

    "priceToPoint(uint256)"(
      price: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number]>;

    provide(
      recipient: string,
      pointLower: BigNumberish,
      pointUpper: BigNumberish,
      amount: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "provide(address,uint16,uint16,uint128,bytes)"(
      recipient: string,
      pointLower: BigNumberish,
      pointUpper: BigNumberish,
      amount: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    reduceLimitOrder(
      recipient: string,
      point: BigNumberish,
      amount: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "reduceLimitOrder(address,uint16,uint128,bool)"(
      recipient: string,
      point: BigNumberish,
      amount: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    remove(
      recipient: string,
      pointLower: BigNumberish,
      pointUpper: BigNumberish,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "remove(address,uint16,uint16,uint128)"(
      recipient: string,
      pointLower: BigNumberish,
      pointUpper: BigNumberish,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    "setEntry(address)"(
      _entry: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setLiquidity(
      liq: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "setLiquidity(uint128)"(
      liq: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setPriceAndPoint(
      price: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "setPriceAndPoint(uint256)"(
      price: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    slot0(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, number, number, boolean] & {
        curPrice: BigNumber;
        point: number;
        feeProtocol: number;
        unlocked: boolean;
      }
    >;

    "slot0()"(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, number, number, boolean] & {
        curPrice: BigNumber;
        point: number;
        feeProtocol: number;
        unlocked: boolean;
      }
    >;

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

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

    ticks(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        number,
        boolean,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        liquidityGross: BigNumber;
        liquidityNet: BigNumber;
        feeGrowthOutsideBase: BigNumber;
        feeGrowthOutsideTrade: BigNumber;
        tickCumulativeOutside: BigNumber;
        secondsPerLiquidityOutsideX128: BigNumber;
        secondsOutside: number;
        initialized: boolean;
        askLiquidityGross: BigNumber;
        bidLiquidityGross: BigNumber;
        askNumCross: BigNumber;
        bidNumCross: BigNumber;
      }
    >;

    "ticks(uint16)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        number,
        boolean,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        liquidityGross: BigNumber;
        liquidityNet: BigNumber;
        feeGrowthOutsideBase: BigNumber;
        feeGrowthOutsideTrade: BigNumber;
        tickCumulativeOutside: BigNumber;
        secondsPerLiquidityOutsideX128: BigNumber;
        secondsOutside: number;
        initialized: boolean;
        askLiquidityGross: BigNumber;
        bidLiquidityGross: BigNumber;
        askNumCross: BigNumber;
        bidNumCross: BigNumber;
      }
    >;

    trade(
      recipient: string,
      moveUp: boolean,
      amountSpecified: BigNumberish,
      priceLimit: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "trade(address,bool,int256,uint256,bytes)"(
      recipient: string,
      moveUp: boolean,
      amountSpecified: BigNumberish,
      priceLimit: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    tradeGivenLiquidity(
      p2: BigNumberish,
      p1: BigNumberish,
      L: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    "tradeGivenLiquidity(uint256,uint256,uint256)"(
      p2: BigNumberish,
      p1: BigNumberish,
      L: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

    xMax(
      curPrice: BigNumberish,
      b: BigNumberish,
      a: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    "xMax(uint256,uint256,uint256)"(
      curPrice: BigNumberish,
      b: BigNumberish,
      a: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    xMaxRoundUp(
      curPrice: BigNumberish,
      b: BigNumberish,
      a: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    "xMaxRoundUp(uint256,uint256,uint256)"(
      curPrice: BigNumberish,
      b: BigNumberish,
      a: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    yInt(
      curPrice: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    "yInt(uint256,bool)"(
      curPrice: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;
  };

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

  "PRECISION()"(overrides?: CallOverrides): Promise<BigNumber>;

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

  "ROUNDLIMIT()"(overrides?: CallOverrides): Promise<BigNumber>;

  addDelta(
    x: BigNumberish,
    y: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "addDelta(uint128,int128)"(
    x: BigNumberish,
    y: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  baseGivenLiquidity(
    p2: BigNumberish,
    p1: BigNumberish,
    L: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "baseGivenLiquidity(uint256,uint256,uint256)"(
    p2: BigNumberish,
    p1: BigNumberish,
    L: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  "baseToken()"(overrides?: CallOverrides): Promise<string>;

  bidsLeft(point: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

  "bidsLeft(uint16)"(
    point: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  claimFilledOrder(
    recipient: string,
    point: BigNumberish,
    isAsk: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "claimFilledOrder(address,uint16,bool)"(
    recipient: string,
    point: BigNumberish,
    isAsk: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  claimPartiallyFilledOrder(
    recipient: string,
    point: BigNumberish,
    isAsk: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "claimPartiallyFilledOrder(address,uint16,bool)"(
    recipient: string,
    point: BigNumberish,
    isAsk: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  collect(
    recipient: string,
    tickLower: BigNumberish,
    tickUpper: BigNumberish,
    amount0Requested: BigNumberish,
    amount1Requested: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "collect(address,uint16,uint16,uint128,uint128)"(
    recipient: string,
    tickLower: BigNumberish,
    tickUpper: BigNumberish,
    amount0Requested: BigNumberish,
    amount1Requested: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  "entry()"(overrides?: CallOverrides): Promise<string>;

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

  "factory()"(overrides?: CallOverrides): Promise<string>;

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

  "fee()"(overrides?: CallOverrides): Promise<number>;

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

  "feeGrowthGlobalBase()"(overrides?: CallOverrides): Promise<BigNumber>;

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

  "feeGrowthGlobalTrade()"(overrides?: CallOverrides): Promise<BigNumber>;

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

  "getCurPrice()"(overrides?: CallOverrides): Promise<BigNumber>;

  getLiq(
    to: string,
    point: BigNumberish,
    isAsk: boolean,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getLiq(address,uint16,bool)"(
    to: string,
    point: BigNumberish,
    isAsk: boolean,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  "getMaxLiquidity()"(overrides?: CallOverrides): Promise<BigNumber>;

  getNextPriceLimit(
    point: BigNumberish,
    pDelta: BigNumberish,
    moveUp: boolean,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getNextPriceLimit(uint16,uint256,bool)"(
    point: BigNumberish,
    pDelta: BigNumberish,
    moveUp: boolean,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getNumCross(
    point: BigNumberish,
    moveUp: boolean,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getNumCross(uint16,bool)"(
    point: BigNumberish,
    moveUp: boolean,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getOneTimeLiquidity(
    point: BigNumberish,
    moveUp: boolean,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getOneTimeLiquidity(uint16,bool)"(
    point: BigNumberish,
    moveUp: boolean,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  "liquidity()"(overrides?: CallOverrides): Promise<BigNumber>;

  liquidityGivenBase(
    p2: BigNumberish,
    p1: BigNumberish,
    B: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "liquidityGivenBase(uint256,uint256,uint256)"(
    p2: BigNumberish,
    p1: BigNumberish,
    B: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  liquidityGivenTrade(
    p2: BigNumberish,
    p1: BigNumberish,
    T: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "liquidityGivenTrade(uint256,uint256,uint256)"(
    p2: BigNumberish,
    p1: BigNumberish,
    T: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

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

  placeLimitOrder(
    recipient: string,
    point: BigNumberish,
    amount: BigNumberish,
    isAsk: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "placeLimitOrder(address,uint16,uint128,bool)"(
    recipient: string,
    point: BigNumberish,
    amount: BigNumberish,
    isAsk: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  pointToPrice(
    point: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "pointToPrice(uint16)"(
    point: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  positionIsFilled(
    recipient: string,
    point: BigNumberish,
    isAsk: boolean,
    overrides?: CallOverrides
  ): Promise<boolean>;

  "positionIsFilled(address,uint16,bool)"(
    recipient: string,
    point: BigNumberish,
    isAsk: boolean,
    overrides?: CallOverrides
  ): Promise<boolean>;

  positions(
    arg0: BytesLike,
    overrides?: CallOverrides
  ): Promise<
    [
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber
    ] & {
      bidCrossId: BigNumber;
      askCrossId: BigNumber;
      askLiq: BigNumber;
      bidLiq: BigNumber;
      liquidity: BigNumber;
      feeGrowthInside0LastX128: BigNumber;
      feeGrowthInside1LastX128: BigNumber;
      tokensOwed0: BigNumber;
      tokensOwed1: BigNumber;
    }
  >;

  "positions(bytes32)"(
    arg0: BytesLike,
    overrides?: CallOverrides
  ): Promise<
    [
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber
    ] & {
      bidCrossId: BigNumber;
      askCrossId: BigNumber;
      askLiq: BigNumber;
      bidLiq: BigNumber;
      liquidity: BigNumber;
      feeGrowthInside0LastX128: BigNumber;
      feeGrowthInside1LastX128: BigNumber;
      tokensOwed0: BigNumber;
      tokensOwed1: BigNumber;
    }
  >;

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

  "priceDelta()"(overrides?: CallOverrides): Promise<BigNumber>;

  priceToPoint(price: BigNumberish, overrides?: CallOverrides): Promise<number>;

  "priceToPoint(uint256)"(
    price: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

  provide(
    recipient: string,
    pointLower: BigNumberish,
    pointUpper: BigNumberish,
    amount: BigNumberish,
    data: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "provide(address,uint16,uint16,uint128,bytes)"(
    recipient: string,
    pointLower: BigNumberish,
    pointUpper: BigNumberish,
    amount: BigNumberish,
    data: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  reduceLimitOrder(
    recipient: string,
    point: BigNumberish,
    amount: BigNumberish,
    isAsk: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "reduceLimitOrder(address,uint16,uint128,bool)"(
    recipient: string,
    point: BigNumberish,
    amount: BigNumberish,
    isAsk: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  remove(
    recipient: string,
    pointLower: BigNumberish,
    pointUpper: BigNumberish,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "remove(address,uint16,uint16,uint128)"(
    recipient: string,
    pointLower: BigNumberish,
    pointUpper: BigNumberish,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  "setEntry(address)"(
    _entry: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setLiquidity(
    liq: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "setLiquidity(uint128)"(
    liq: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setPriceAndPoint(
    price: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "setPriceAndPoint(uint256)"(
    price: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  slot0(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, number, number, boolean] & {
      curPrice: BigNumber;
      point: number;
      feeProtocol: number;
      unlocked: boolean;
    }
  >;

  "slot0()"(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, number, number, boolean] & {
      curPrice: BigNumber;
      point: number;
      feeProtocol: number;
      unlocked: boolean;
    }
  >;

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

  "tickSpacing()"(overrides?: CallOverrides): Promise<number>;

  ticks(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      number,
      boolean,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber
    ] & {
      liquidityGross: BigNumber;
      liquidityNet: BigNumber;
      feeGrowthOutsideBase: BigNumber;
      feeGrowthOutsideTrade: BigNumber;
      tickCumulativeOutside: BigNumber;
      secondsPerLiquidityOutsideX128: BigNumber;
      secondsOutside: number;
      initialized: boolean;
      askLiquidityGross: BigNumber;
      bidLiquidityGross: BigNumber;
      askNumCross: BigNumber;
      bidNumCross: BigNumber;
    }
  >;

  "ticks(uint16)"(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      number,
      boolean,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber
    ] & {
      liquidityGross: BigNumber;
      liquidityNet: BigNumber;
      feeGrowthOutsideBase: BigNumber;
      feeGrowthOutsideTrade: BigNumber;
      tickCumulativeOutside: BigNumber;
      secondsPerLiquidityOutsideX128: BigNumber;
      secondsOutside: number;
      initialized: boolean;
      askLiquidityGross: BigNumber;
      bidLiquidityGross: BigNumber;
      askNumCross: BigNumber;
      bidNumCross: BigNumber;
    }
  >;

  trade(
    recipient: string,
    moveUp: boolean,
    amountSpecified: BigNumberish,
    priceLimit: BigNumberish,
    data: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "trade(address,bool,int256,uint256,bytes)"(
    recipient: string,
    moveUp: boolean,
    amountSpecified: BigNumberish,
    priceLimit: BigNumberish,
    data: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  tradeGivenLiquidity(
    p2: BigNumberish,
    p1: BigNumberish,
    L: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "tradeGivenLiquidity(uint256,uint256,uint256)"(
    p2: BigNumberish,
    p1: BigNumberish,
    L: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  "tradeToken()"(overrides?: CallOverrides): Promise<string>;

  xMax(
    curPrice: BigNumberish,
    b: BigNumberish,
    a: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "xMax(uint256,uint256,uint256)"(
    curPrice: BigNumberish,
    b: BigNumberish,
    a: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  xMaxRoundUp(
    curPrice: BigNumberish,
    b: BigNumberish,
    a: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "xMaxRoundUp(uint256,uint256,uint256)"(
    curPrice: BigNumberish,
    b: BigNumberish,
    a: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  yInt(
    curPrice: BigNumberish,
    moveUp: boolean,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "yInt(uint256,bool)"(
    curPrice: BigNumberish,
    moveUp: boolean,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

    "PRECISION()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "ROUNDLIMIT()"(overrides?: CallOverrides): Promise<BigNumber>;

    addDelta(
      x: BigNumberish,
      y: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "addDelta(uint128,int128)"(
      x: BigNumberish,
      y: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    baseGivenLiquidity(
      p2: BigNumberish,
      p1: BigNumberish,
      L: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "baseGivenLiquidity(uint256,uint256,uint256)"(
      p2: BigNumberish,
      p1: BigNumberish,
      L: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "baseToken()"(overrides?: CallOverrides): Promise<string>;

    bidsLeft(
      point: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "bidsLeft(uint16)"(
      point: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    claimFilledOrder(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "claimFilledOrder(address,uint16,bool)"(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    claimPartiallyFilledOrder(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { baseAmount: BigNumber; tradeAmount: BigNumber }
    >;

    "claimPartiallyFilledOrder(address,uint16,bool)"(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { baseAmount: BigNumber; tradeAmount: BigNumber }
    >;

    collect(
      recipient: string,
      tickLower: BigNumberish,
      tickUpper: BigNumberish,
      amount0Requested: BigNumberish,
      amount1Requested: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { amount0: BigNumber; amount1: BigNumber }
    >;

    "collect(address,uint16,uint16,uint128,uint128)"(
      recipient: string,
      tickLower: BigNumberish,
      tickUpper: BigNumberish,
      amount0Requested: BigNumberish,
      amount1Requested: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { amount0: BigNumber; amount1: BigNumber }
    >;

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

    "entry()"(overrides?: CallOverrides): Promise<string>;

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

    "factory()"(overrides?: CallOverrides): Promise<string>;

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

    "fee()"(overrides?: CallOverrides): Promise<number>;

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

    "feeGrowthGlobalBase()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "feeGrowthGlobalTrade()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "getCurPrice()"(overrides?: CallOverrides): Promise<BigNumber>;

    getLiq(
      to: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getLiq(address,uint16,bool)"(
      to: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "getMaxLiquidity()"(overrides?: CallOverrides): Promise<BigNumber>;

    getNextPriceLimit(
      point: BigNumberish,
      pDelta: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getNextPriceLimit(uint16,uint256,bool)"(
      point: BigNumberish,
      pDelta: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getNumCross(
      point: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getNumCross(uint16,bool)"(
      point: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getOneTimeLiquidity(
      point: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getOneTimeLiquidity(uint16,bool)"(
      point: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "liquidity()"(overrides?: CallOverrides): Promise<BigNumber>;

    liquidityGivenBase(
      p2: BigNumberish,
      p1: BigNumberish,
      B: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "liquidityGivenBase(uint256,uint256,uint256)"(
      p2: BigNumberish,
      p1: BigNumberish,
      B: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    liquidityGivenTrade(
      p2: BigNumberish,
      p1: BigNumberish,
      T: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "liquidityGivenTrade(uint256,uint256,uint256)"(
      p2: BigNumberish,
      p1: BigNumberish,
      T: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "lock()"(overrides?: CallOverrides): Promise<void>;

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

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

    placeLimitOrder(
      recipient: string,
      point: BigNumberish,
      amount: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        amountToEscrow: BigNumber;
        numCross: BigNumber;
      }
    >;

    "placeLimitOrder(address,uint16,uint128,bool)"(
      recipient: string,
      point: BigNumberish,
      amount: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        amountToEscrow: BigNumber;
        numCross: BigNumber;
      }
    >;

    pointToPrice(
      point: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "pointToPrice(uint16)"(
      point: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    positionIsFilled(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<boolean>;

    "positionIsFilled(address,uint16,bool)"(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<boolean>;

    positions(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        bidCrossId: BigNumber;
        askCrossId: BigNumber;
        askLiq: BigNumber;
        bidLiq: BigNumber;
        liquidity: BigNumber;
        feeGrowthInside0LastX128: BigNumber;
        feeGrowthInside1LastX128: BigNumber;
        tokensOwed0: BigNumber;
        tokensOwed1: BigNumber;
      }
    >;

    "positions(bytes32)"(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        bidCrossId: BigNumber;
        askCrossId: BigNumber;
        askLiq: BigNumber;
        bidLiq: BigNumber;
        liquidity: BigNumber;
        feeGrowthInside0LastX128: BigNumber;
        feeGrowthInside1LastX128: BigNumber;
        tokensOwed0: BigNumber;
        tokensOwed1: BigNumber;
      }
    >;

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

    "priceDelta()"(overrides?: CallOverrides): Promise<BigNumber>;

    priceToPoint(
      price: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    "priceToPoint(uint256)"(
      price: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    provide(
      recipient: string,
      pointLower: BigNumberish,
      pointUpper: BigNumberish,
      amount: BigNumberish,
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { amount0: BigNumber; amount1: BigNumber }
    >;

    "provide(address,uint16,uint16,uint128,bytes)"(
      recipient: string,
      pointLower: BigNumberish,
      pointUpper: BigNumberish,
      amount: BigNumberish,
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { amount0: BigNumber; amount1: BigNumber }
    >;

    reduceLimitOrder(
      recipient: string,
      point: BigNumberish,
      amount: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "reduceLimitOrder(address,uint16,uint128,bool)"(
      recipient: string,
      point: BigNumberish,
      amount: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    remove(
      recipient: string,
      pointLower: BigNumberish,
      pointUpper: BigNumberish,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber]>;

    "remove(address,uint16,uint16,uint128)"(
      recipient: string,
      pointLower: BigNumberish,
      pointUpper: BigNumberish,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber]>;

    setEntry(_entry: string, overrides?: CallOverrides): Promise<void>;

    "setEntry(address)"(
      _entry: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setLiquidity(liq: BigNumberish, overrides?: CallOverrides): Promise<void>;

    "setLiquidity(uint128)"(
      liq: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setPriceAndPoint(
      price: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "setPriceAndPoint(uint256)"(
      price: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    slot0(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, number, number, boolean] & {
        curPrice: BigNumber;
        point: number;
        feeProtocol: number;
        unlocked: boolean;
      }
    >;

    "slot0()"(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, number, number, boolean] & {
        curPrice: BigNumber;
        point: number;
        feeProtocol: number;
        unlocked: boolean;
      }
    >;

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

    "tickSpacing()"(overrides?: CallOverrides): Promise<number>;

    ticks(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        number,
        boolean,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        liquidityGross: BigNumber;
        liquidityNet: BigNumber;
        feeGrowthOutsideBase: BigNumber;
        feeGrowthOutsideTrade: BigNumber;
        tickCumulativeOutside: BigNumber;
        secondsPerLiquidityOutsideX128: BigNumber;
        secondsOutside: number;
        initialized: boolean;
        askLiquidityGross: BigNumber;
        bidLiquidityGross: BigNumber;
        askNumCross: BigNumber;
        bidNumCross: BigNumber;
      }
    >;

    "ticks(uint16)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        number,
        boolean,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        liquidityGross: BigNumber;
        liquidityNet: BigNumber;
        feeGrowthOutsideBase: BigNumber;
        feeGrowthOutsideTrade: BigNumber;
        tickCumulativeOutside: BigNumber;
        secondsPerLiquidityOutsideX128: BigNumber;
        secondsOutside: number;
        initialized: boolean;
        askLiquidityGross: BigNumber;
        bidLiquidityGross: BigNumber;
        askNumCross: BigNumber;
        bidNumCross: BigNumber;
      }
    >;

    trade(
      recipient: string,
      moveUp: boolean,
      amountSpecified: BigNumberish,
      priceLimit: BigNumberish,
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { amountIn: BigNumber; amountOut: BigNumber }
    >;

    "trade(address,bool,int256,uint256,bytes)"(
      recipient: string,
      moveUp: boolean,
      amountSpecified: BigNumberish,
      priceLimit: BigNumberish,
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { amountIn: BigNumber; amountOut: BigNumber }
    >;

    tradeGivenLiquidity(
      p2: BigNumberish,
      p1: BigNumberish,
      L: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "tradeGivenLiquidity(uint256,uint256,uint256)"(
      p2: BigNumberish,
      p1: BigNumberish,
      L: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "tradeToken()"(overrides?: CallOverrides): Promise<string>;

    xMax(
      curPrice: BigNumberish,
      b: BigNumberish,
      a: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "xMax(uint256,uint256,uint256)"(
      curPrice: BigNumberish,
      b: BigNumberish,
      a: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    xMaxRoundUp(
      curPrice: BigNumberish,
      b: BigNumberish,
      a: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "xMaxRoundUp(uint256,uint256,uint256)"(
      curPrice: BigNumberish,
      b: BigNumberish,
      a: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    yInt(
      curPrice: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "yInt(uint256,bool)"(
      curPrice: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;
  };

  filters: {};

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

    "PRECISION()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "ROUNDLIMIT()"(overrides?: CallOverrides): Promise<BigNumber>;

    addDelta(
      x: BigNumberish,
      y: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "addDelta(uint128,int128)"(
      x: BigNumberish,
      y: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    baseGivenLiquidity(
      p2: BigNumberish,
      p1: BigNumberish,
      L: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "baseGivenLiquidity(uint256,uint256,uint256)"(
      p2: BigNumberish,
      p1: BigNumberish,
      L: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "baseToken()"(overrides?: CallOverrides): Promise<BigNumber>;

    bidsLeft(
      point: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "bidsLeft(uint16)"(
      point: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    claimFilledOrder(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "claimFilledOrder(address,uint16,bool)"(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    claimPartiallyFilledOrder(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "claimPartiallyFilledOrder(address,uint16,bool)"(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    collect(
      recipient: string,
      tickLower: BigNumberish,
      tickUpper: BigNumberish,
      amount0Requested: BigNumberish,
      amount1Requested: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "collect(address,uint16,uint16,uint128,uint128)"(
      recipient: string,
      tickLower: BigNumberish,
      tickUpper: BigNumberish,
      amount0Requested: BigNumberish,
      amount1Requested: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    "entry()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "factory()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "fee()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "feeGrowthGlobalBase()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "feeGrowthGlobalTrade()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "getCurPrice()"(overrides?: CallOverrides): Promise<BigNumber>;

    getLiq(
      to: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getLiq(address,uint16,bool)"(
      to: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "getMaxLiquidity()"(overrides?: CallOverrides): Promise<BigNumber>;

    getNextPriceLimit(
      point: BigNumberish,
      pDelta: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getNextPriceLimit(uint16,uint256,bool)"(
      point: BigNumberish,
      pDelta: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getNumCross(
      point: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getNumCross(uint16,bool)"(
      point: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getOneTimeLiquidity(
      point: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getOneTimeLiquidity(uint16,bool)"(
      point: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "liquidity()"(overrides?: CallOverrides): Promise<BigNumber>;

    liquidityGivenBase(
      p2: BigNumberish,
      p1: BigNumberish,
      B: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "liquidityGivenBase(uint256,uint256,uint256)"(
      p2: BigNumberish,
      p1: BigNumberish,
      B: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    liquidityGivenTrade(
      p2: BigNumberish,
      p1: BigNumberish,
      T: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "liquidityGivenTrade(uint256,uint256,uint256)"(
      p2: BigNumberish,
      p1: BigNumberish,
      T: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    placeLimitOrder(
      recipient: string,
      point: BigNumberish,
      amount: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "placeLimitOrder(address,uint16,uint128,bool)"(
      recipient: string,
      point: BigNumberish,
      amount: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    pointToPrice(
      point: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "pointToPrice(uint16)"(
      point: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    positionIsFilled(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "positionIsFilled(address,uint16,bool)"(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "positions(bytes32)"(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "priceDelta()"(overrides?: CallOverrides): Promise<BigNumber>;

    priceToPoint(
      price: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "priceToPoint(uint256)"(
      price: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    provide(
      recipient: string,
      pointLower: BigNumberish,
      pointUpper: BigNumberish,
      amount: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "provide(address,uint16,uint16,uint128,bytes)"(
      recipient: string,
      pointLower: BigNumberish,
      pointUpper: BigNumberish,
      amount: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    reduceLimitOrder(
      recipient: string,
      point: BigNumberish,
      amount: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "reduceLimitOrder(address,uint16,uint128,bool)"(
      recipient: string,
      point: BigNumberish,
      amount: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    remove(
      recipient: string,
      pointLower: BigNumberish,
      pointUpper: BigNumberish,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "remove(address,uint16,uint16,uint128)"(
      recipient: string,
      pointLower: BigNumberish,
      pointUpper: BigNumberish,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    "setEntry(address)"(
      _entry: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setLiquidity(
      liq: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "setLiquidity(uint128)"(
      liq: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setPriceAndPoint(
      price: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "setPriceAndPoint(uint256)"(
      price: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    "slot0()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "tickSpacing()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "ticks(uint16)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    trade(
      recipient: string,
      moveUp: boolean,
      amountSpecified: BigNumberish,
      priceLimit: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "trade(address,bool,int256,uint256,bytes)"(
      recipient: string,
      moveUp: boolean,
      amountSpecified: BigNumberish,
      priceLimit: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    tradeGivenLiquidity(
      p2: BigNumberish,
      p1: BigNumberish,
      L: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "tradeGivenLiquidity(uint256,uint256,uint256)"(
      p2: BigNumberish,
      p1: BigNumberish,
      L: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "tradeToken()"(overrides?: CallOverrides): Promise<BigNumber>;

    xMax(
      curPrice: BigNumberish,
      b: BigNumberish,
      a: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "xMax(uint256,uint256,uint256)"(
      curPrice: BigNumberish,
      b: BigNumberish,
      a: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    xMaxRoundUp(
      curPrice: BigNumberish,
      b: BigNumberish,
      a: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "xMaxRoundUp(uint256,uint256,uint256)"(
      curPrice: BigNumberish,
      b: BigNumberish,
      a: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    yInt(
      curPrice: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "yInt(uint256,bool)"(
      curPrice: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;
  };

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

    "PRECISION()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "ROUNDLIMIT()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    addDelta(
      x: BigNumberish,
      y: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "addDelta(uint128,int128)"(
      x: BigNumberish,
      y: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    baseGivenLiquidity(
      p2: BigNumberish,
      p1: BigNumberish,
      L: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "baseGivenLiquidity(uint256,uint256,uint256)"(
      p2: BigNumberish,
      p1: BigNumberish,
      L: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "baseToken()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    bidsLeft(
      point: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "bidsLeft(uint16)"(
      point: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    claimFilledOrder(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "claimFilledOrder(address,uint16,bool)"(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    claimPartiallyFilledOrder(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "claimPartiallyFilledOrder(address,uint16,bool)"(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    collect(
      recipient: string,
      tickLower: BigNumberish,
      tickUpper: BigNumberish,
      amount0Requested: BigNumberish,
      amount1Requested: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "collect(address,uint16,uint16,uint128,uint128)"(
      recipient: string,
      tickLower: BigNumberish,
      tickUpper: BigNumberish,
      amount0Requested: BigNumberish,
      amount1Requested: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    "entry()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "factory()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "fee()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "feeGrowthGlobalBase()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "feeGrowthGlobalTrade()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "getCurPrice()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    getLiq(
      to: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getLiq(address,uint16,bool)"(
      to: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "getMaxLiquidity()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getNextPriceLimit(
      point: BigNumberish,
      pDelta: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getNextPriceLimit(uint16,uint256,bool)"(
      point: BigNumberish,
      pDelta: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getNumCross(
      point: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getNumCross(uint16,bool)"(
      point: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getOneTimeLiquidity(
      point: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getOneTimeLiquidity(uint16,bool)"(
      point: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "liquidity()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    liquidityGivenBase(
      p2: BigNumberish,
      p1: BigNumberish,
      B: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "liquidityGivenBase(uint256,uint256,uint256)"(
      p2: BigNumberish,
      p1: BigNumberish,
      B: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    liquidityGivenTrade(
      p2: BigNumberish,
      p1: BigNumberish,
      T: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "liquidityGivenTrade(uint256,uint256,uint256)"(
      p2: BigNumberish,
      p1: BigNumberish,
      T: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    placeLimitOrder(
      recipient: string,
      point: BigNumberish,
      amount: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "placeLimitOrder(address,uint16,uint128,bool)"(
      recipient: string,
      point: BigNumberish,
      amount: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    pointToPrice(
      point: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "pointToPrice(uint16)"(
      point: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    positionIsFilled(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "positionIsFilled(address,uint16,bool)"(
      recipient: string,
      point: BigNumberish,
      isAsk: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "positions(bytes32)"(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "priceDelta()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    priceToPoint(
      price: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "priceToPoint(uint256)"(
      price: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    provide(
      recipient: string,
      pointLower: BigNumberish,
      pointUpper: BigNumberish,
      amount: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "provide(address,uint16,uint16,uint128,bytes)"(
      recipient: string,
      pointLower: BigNumberish,
      pointUpper: BigNumberish,
      amount: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    reduceLimitOrder(
      recipient: string,
      point: BigNumberish,
      amount: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "reduceLimitOrder(address,uint16,uint128,bool)"(
      recipient: string,
      point: BigNumberish,
      amount: BigNumberish,
      isAsk: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    remove(
      recipient: string,
      pointLower: BigNumberish,
      pointUpper: BigNumberish,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "remove(address,uint16,uint16,uint128)"(
      recipient: string,
      pointLower: BigNumberish,
      pointUpper: BigNumberish,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    "setEntry(address)"(
      _entry: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setLiquidity(
      liq: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "setLiquidity(uint128)"(
      liq: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setPriceAndPoint(
      price: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "setPriceAndPoint(uint256)"(
      price: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    "slot0()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "tickSpacing()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "ticks(uint16)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    trade(
      recipient: string,
      moveUp: boolean,
      amountSpecified: BigNumberish,
      priceLimit: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "trade(address,bool,int256,uint256,bytes)"(
      recipient: string,
      moveUp: boolean,
      amountSpecified: BigNumberish,
      priceLimit: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    tradeGivenLiquidity(
      p2: BigNumberish,
      p1: BigNumberish,
      L: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "tradeGivenLiquidity(uint256,uint256,uint256)"(
      p2: BigNumberish,
      p1: BigNumberish,
      L: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "tradeToken()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    xMax(
      curPrice: BigNumberish,
      b: BigNumberish,
      a: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "xMax(uint256,uint256,uint256)"(
      curPrice: BigNumberish,
      b: BigNumberish,
      a: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    xMaxRoundUp(
      curPrice: BigNumberish,
      b: BigNumberish,
      a: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "xMaxRoundUp(uint256,uint256,uint256)"(
      curPrice: BigNumberish,
      b: BigNumberish,
      a: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    yInt(
      curPrice: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "yInt(uint256,bool)"(
      curPrice: BigNumberish,
      moveUp: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;
  };
}