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

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

interface GuniPoolInterface extends ethers.utils.Interface {
  functions: {
    "GELATO()": FunctionFragment;
    "allowance(address,address)": FunctionFragment;
    "approve(address,uint256)": FunctionFragment;
    "balanceOf(address)": FunctionFragment;
    "burn(uint256,address)": FunctionFragment;
    "decimals()": FunctionFragment;
    "decreaseAllowance(address,uint256)": FunctionFragment;
    "executiveRebalance(int24,int24,uint160,uint256,bool)": FunctionFragment;
    "gelatoBalance0()": FunctionFragment;
    "gelatoBalance1()": FunctionFragment;
    "gelatoFeeBPS()": FunctionFragment;
    "gelatoRebalanceBPS()": FunctionFragment;
    "gelatoSlippageBPS()": FunctionFragment;
    "gelatoSlippageInterval()": FunctionFragment;
    "gelatoWithdrawBPS()": FunctionFragment;
    "getMintAmounts(uint256,uint256)": FunctionFragment;
    "getPositionID()": FunctionFragment;
    "getUnderlyingBalances()": FunctionFragment;
    "increaseAllowance(address,uint256)": FunctionFragment;
    "initialize(string,string,address,uint16,int24,int24,address)": FunctionFragment;
    "initializeManagerFee(uint16)": FunctionFragment;
    "lowerTick()": FunctionFragment;
    "manager()": FunctionFragment;
    "managerBalance0()": FunctionFragment;
    "managerBalance1()": FunctionFragment;
    "managerFeeBPS()": FunctionFragment;
    "managerTreasury()": FunctionFragment;
    "mint(uint256,address)": FunctionFragment;
    "name()": FunctionFragment;
    "pool()": FunctionFragment;
    "rebalance(uint160,uint256,bool,uint256,address)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "symbol()": FunctionFragment;
    "token0()": FunctionFragment;
    "token1()": FunctionFragment;
    "totalSupply()": FunctionFragment;
    "transfer(address,uint256)": FunctionFragment;
    "transferFrom(address,address,uint256)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "uniswapV3MintCallback(uint256,uint256,bytes)": FunctionFragment;
    "uniswapV3SwapCallback(int256,int256,bytes)": FunctionFragment;
    "updateGelatoParams(uint16,uint16,uint16,uint32,address)": FunctionFragment;
    "upperTick()": FunctionFragment;
    "version()": FunctionFragment;
    "withdrawGelatoBalance(uint256,address)": FunctionFragment;
    "withdrawManagerBalance(uint256,address)": FunctionFragment;
  };

  encodeFunctionData(functionFragment: "GELATO", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "allowance",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "approve",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
  encodeFunctionData(
    functionFragment: "burn",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "decreaseAllowance",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "executiveRebalance",
    values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "gelatoBalance0",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "gelatoBalance1",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "gelatoFeeBPS",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "gelatoRebalanceBPS",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "gelatoSlippageBPS",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "gelatoSlippageInterval",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "gelatoWithdrawBPS",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getMintAmounts",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getPositionID",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getUnderlyingBalances",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "increaseAllowance",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [
      string,
      string,
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      string
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "initializeManagerFee",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "lowerTick", values?: undefined): string;
  encodeFunctionData(functionFragment: "manager", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "managerBalance0",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "managerBalance1",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "managerFeeBPS",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "managerTreasury",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "mint",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(functionFragment: "name", values?: undefined): string;
  encodeFunctionData(functionFragment: "pool", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "rebalance",
    values: [BigNumberish, BigNumberish, boolean, BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
  encodeFunctionData(functionFragment: "token0", values?: undefined): string;
  encodeFunctionData(functionFragment: "token1", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "totalSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transfer",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferFrom",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "uniswapV3MintCallback",
    values: [BigNumberish, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "uniswapV3SwapCallback",
    values: [BigNumberish, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "updateGelatoParams",
    values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish, string]
  ): string;
  encodeFunctionData(functionFragment: "upperTick", values?: undefined): string;
  encodeFunctionData(functionFragment: "version", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "withdrawGelatoBalance",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawManagerBalance",
    values: [BigNumberish, string]
  ): string;

  decodeFunctionResult(functionFragment: "GELATO", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "decreaseAllowance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "executiveRebalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "gelatoBalance0",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "gelatoBalance1",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "gelatoFeeBPS",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "gelatoRebalanceBPS",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "gelatoSlippageBPS",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "gelatoSlippageInterval",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "gelatoWithdrawBPS",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getMintAmounts",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPositionID",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getUnderlyingBalances",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "increaseAllowance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "initializeManagerFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "lowerTick", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "manager", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "managerBalance0",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "managerBalance1",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "managerFeeBPS",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "managerTreasury",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "pool", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "rebalance", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "token0", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "token1", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "totalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "uniswapV3MintCallback",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "uniswapV3SwapCallback",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateGelatoParams",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "upperTick", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "withdrawGelatoBalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawManagerBalance",
    data: BytesLike
  ): Result;

  events: {
    "Approval(address,address,uint256)": EventFragment;
    "Burned(address,uint256,uint256,uint256,uint128)": EventFragment;
    "Minted(address,uint256,uint256,uint256,uint128)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "Rebalance(int24,int24)": EventFragment;
    "Transfer(address,address,uint256)": EventFragment;
    "UpdateAdminTreasury(address,address)": EventFragment;
    "UpdateGelatoParams(uint16,uint16,uint16,uint32)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Burned"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Minted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Rebalance"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UpdateAdminTreasury"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UpdateGelatoParams"): EventFragment;
}

export type ApprovalEvent = TypedEvent<
  [string, string, BigNumber] & {
    owner: string;
    spender: string;
    value: BigNumber;
  }
>;

export type BurnedEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber, BigNumber] & {
    receiver: string;
    burnAmount: BigNumber;
    amount0Out: BigNumber;
    amount1Out: BigNumber;
    liquidityBurned: BigNumber;
  }
>;

export type MintedEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber, BigNumber] & {
    receiver: string;
    mintAmount: BigNumber;
    amount0In: BigNumber;
    amount1In: BigNumber;
    liquidityMinted: BigNumber;
  }
>;

export type OwnershipTransferredEvent = TypedEvent<
  [string, string] & { previousManager: string; newManager: string }
>;

export type RebalanceEvent = TypedEvent<
  [number, number] & { lowerTick_: number; upperTick_: number }
>;

export type TransferEvent = TypedEvent<
  [string, string, BigNumber] & { from: string; to: string; value: BigNumber }
>;

export type UpdateAdminTreasuryEvent = TypedEvent<
  [string, string] & { oldAdminTreasury: string; newAdminTreasury: string }
>;

export type UpdateGelatoParamsEvent = TypedEvent<
  [number, number, number, number] & {
    gelatoRebalanceBPS: number;
    gelatoWithdrawBPS: number;
    gelatoSlippageBPS: number;
    gelatoSlippageInterval: number;
  }
>;

export class GuniPool extends BaseContract {
  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: GuniPoolInterface;

  functions: {
    GELATO(overrides?: CallOverrides): Promise<[string]>;

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    balanceOf(account: string, overrides?: CallOverrides): Promise<[BigNumber]>;

    burn(
      burnAmount: BigNumberish,
      receiver: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    executiveRebalance(
      newLowerTick: BigNumberish,
      newUpperTick: BigNumberish,
      swapThresholdPrice: BigNumberish,
      swapAmountBPS: BigNumberish,
      zeroForOne: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

    getMintAmounts(
      amount0Max: BigNumberish,
      amount1Max: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        amount0: BigNumber;
        amount1: BigNumber;
        mintAmount: BigNumber;
      }
    >;

    getPositionID(
      overrides?: CallOverrides
    ): Promise<[string] & { positionID: string }>;

    getUnderlyingBalances(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        amount0Current: BigNumber;
        amount1Current: BigNumber;
      }
    >;

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    initialize(
      _name: string,
      _symbol: string,
      _pool: string,
      _managerFeeBPS: BigNumberish,
      _lowerTick: BigNumberish,
      _upperTick: BigNumberish,
      _manager_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

    mint(
      mintAmount: BigNumberish,
      receiver: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    rebalance(
      swapThresholdPrice: BigNumberish,
      swapAmountBPS: BigNumberish,
      zeroForOne: boolean,
      feeAmount: BigNumberish,
      paymentToken: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

    uniswapV3MintCallback(
      amount0Owed: BigNumberish,
      amount1Owed: BigNumberish,
      arg2: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    uniswapV3SwapCallback(
      amount0Delta: BigNumberish,
      amount1Delta: BigNumberish,
      arg2: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    updateGelatoParams(
      newRebalanceBPS: BigNumberish,
      newWithdrawBPS: BigNumberish,
      newSlippageBPS: BigNumberish,
      newSlippageInterval: BigNumberish,
      newTreasury: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    withdrawGelatoBalance(
      feeAmount: BigNumberish,
      feeToken: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    withdrawManagerBalance(
      feeAmount: BigNumberish,
      feeToken: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;
  };

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

  allowance(
    owner: string,
    spender: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  approve(
    spender: string,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

  burn(
    burnAmount: BigNumberish,
    receiver: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  decreaseAllowance(
    spender: string,
    subtractedValue: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  executiveRebalance(
    newLowerTick: BigNumberish,
    newUpperTick: BigNumberish,
    swapThresholdPrice: BigNumberish,
    swapAmountBPS: BigNumberish,
    zeroForOne: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

  getMintAmounts(
    amount0Max: BigNumberish,
    amount1Max: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber] & {
      amount0: BigNumber;
      amount1: BigNumber;
      mintAmount: BigNumber;
    }
  >;

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

  getUnderlyingBalances(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & {
      amount0Current: BigNumber;
      amount1Current: BigNumber;
    }
  >;

  increaseAllowance(
    spender: string,
    addedValue: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  initialize(
    _name: string,
    _symbol: string,
    _pool: string,
    _managerFeeBPS: BigNumberish,
    _lowerTick: BigNumberish,
    _upperTick: BigNumberish,
    _manager_: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

  mint(
    mintAmount: BigNumberish,
    receiver: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  rebalance(
    swapThresholdPrice: BigNumberish,
    swapAmountBPS: BigNumberish,
    zeroForOne: boolean,
    feeAmount: BigNumberish,
    paymentToken: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

  uniswapV3MintCallback(
    amount0Owed: BigNumberish,
    amount1Owed: BigNumberish,
    arg2: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  uniswapV3SwapCallback(
    amount0Delta: BigNumberish,
    amount1Delta: BigNumberish,
    arg2: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  updateGelatoParams(
    newRebalanceBPS: BigNumberish,
    newWithdrawBPS: BigNumberish,
    newSlippageBPS: BigNumberish,
    newSlippageInterval: BigNumberish,
    newTreasury: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  withdrawGelatoBalance(
    feeAmount: BigNumberish,
    feeToken: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  withdrawManagerBalance(
    feeAmount: BigNumberish,
    feeToken: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  callStatic: {
    GELATO(overrides?: CallOverrides): Promise<string>;

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

    burn(
      burnAmount: BigNumberish,
      receiver: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        amount0: BigNumber;
        amount1: BigNumber;
        liquidityBurned: BigNumber;
      }
    >;

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    executiveRebalance(
      newLowerTick: BigNumberish,
      newUpperTick: BigNumberish,
      swapThresholdPrice: BigNumberish,
      swapAmountBPS: BigNumberish,
      zeroForOne: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

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

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

    getMintAmounts(
      amount0Max: BigNumberish,
      amount1Max: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        amount0: BigNumber;
        amount1: BigNumber;
        mintAmount: BigNumber;
      }
    >;

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

    getUnderlyingBalances(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        amount0Current: BigNumber;
        amount1Current: BigNumber;
      }
    >;

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    initialize(
      _name: string,
      _symbol: string,
      _pool: string,
      _managerFeeBPS: BigNumberish,
      _lowerTick: BigNumberish,
      _upperTick: BigNumberish,
      _manager_: string,
      overrides?: CallOverrides
    ): Promise<void>;

    initializeManagerFee(
      _managerFeeBPS: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

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

    mint(
      mintAmount: BigNumberish,
      receiver: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        amount0: BigNumber;
        amount1: BigNumber;
        liquidityMinted: BigNumber;
      }
    >;

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

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

    rebalance(
      swapThresholdPrice: BigNumberish,
      swapAmountBPS: BigNumberish,
      zeroForOne: boolean,
      feeAmount: BigNumberish,
      paymentToken: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

    transfer(
      recipient: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    transferFrom(
      sender: string,
      recipient: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    uniswapV3MintCallback(
      amount0Owed: BigNumberish,
      amount1Owed: BigNumberish,
      arg2: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    uniswapV3SwapCallback(
      amount0Delta: BigNumberish,
      amount1Delta: BigNumberish,
      arg2: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    updateGelatoParams(
      newRebalanceBPS: BigNumberish,
      newWithdrawBPS: BigNumberish,
      newSlippageBPS: BigNumberish,
      newSlippageInterval: BigNumberish,
      newTreasury: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    withdrawGelatoBalance(
      feeAmount: BigNumberish,
      feeToken: string,
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawManagerBalance(
      feeAmount: BigNumberish,
      feeToken: string,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "Approval(address,address,uint256)"(
      owner?: string | null,
      spender?: string | null,
      value?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { owner: string; spender: string; value: BigNumber }
    >;

    Approval(
      owner?: string | null,
      spender?: string | null,
      value?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { owner: string; spender: string; value: BigNumber }
    >;

    "Burned(address,uint256,uint256,uint256,uint128)"(
      receiver?: null,
      burnAmount?: null,
      amount0Out?: null,
      amount1Out?: null,
      liquidityBurned?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber, BigNumber],
      {
        receiver: string;
        burnAmount: BigNumber;
        amount0Out: BigNumber;
        amount1Out: BigNumber;
        liquidityBurned: BigNumber;
      }
    >;

    Burned(
      receiver?: null,
      burnAmount?: null,
      amount0Out?: null,
      amount1Out?: null,
      liquidityBurned?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber, BigNumber],
      {
        receiver: string;
        burnAmount: BigNumber;
        amount0Out: BigNumber;
        amount1Out: BigNumber;
        liquidityBurned: BigNumber;
      }
    >;

    "Minted(address,uint256,uint256,uint256,uint128)"(
      receiver?: null,
      mintAmount?: null,
      amount0In?: null,
      amount1In?: null,
      liquidityMinted?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber, BigNumber],
      {
        receiver: string;
        mintAmount: BigNumber;
        amount0In: BigNumber;
        amount1In: BigNumber;
        liquidityMinted: BigNumber;
      }
    >;

    Minted(
      receiver?: null,
      mintAmount?: null,
      amount0In?: null,
      amount1In?: null,
      liquidityMinted?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber, BigNumber],
      {
        receiver: string;
        mintAmount: BigNumber;
        amount0In: BigNumber;
        amount1In: BigNumber;
        liquidityMinted: BigNumber;
      }
    >;

    "OwnershipTransferred(address,address)"(
      previousManager?: string | null,
      newManager?: string | null
    ): TypedEventFilter<
      [string, string],
      { previousManager: string; newManager: string }
    >;

    OwnershipTransferred(
      previousManager?: string | null,
      newManager?: string | null
    ): TypedEventFilter<
      [string, string],
      { previousManager: string; newManager: string }
    >;

    "Rebalance(int24,int24)"(
      lowerTick_?: null,
      upperTick_?: null
    ): TypedEventFilter<
      [number, number],
      { lowerTick_: number; upperTick_: number }
    >;

    Rebalance(
      lowerTick_?: null,
      upperTick_?: null
    ): TypedEventFilter<
      [number, number],
      { lowerTick_: number; upperTick_: number }
    >;

    "Transfer(address,address,uint256)"(
      from?: string | null,
      to?: string | null,
      value?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { from: string; to: string; value: BigNumber }
    >;

    Transfer(
      from?: string | null,
      to?: string | null,
      value?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { from: string; to: string; value: BigNumber }
    >;

    "UpdateAdminTreasury(address,address)"(
      oldAdminTreasury?: null,
      newAdminTreasury?: null
    ): TypedEventFilter<
      [string, string],
      { oldAdminTreasury: string; newAdminTreasury: string }
    >;

    UpdateAdminTreasury(
      oldAdminTreasury?: null,
      newAdminTreasury?: null
    ): TypedEventFilter<
      [string, string],
      { oldAdminTreasury: string; newAdminTreasury: string }
    >;

    "UpdateGelatoParams(uint16,uint16,uint16,uint32)"(
      gelatoRebalanceBPS?: null,
      gelatoWithdrawBPS?: null,
      gelatoSlippageBPS?: null,
      gelatoSlippageInterval?: null
    ): TypedEventFilter<
      [number, number, number, number],
      {
        gelatoRebalanceBPS: number;
        gelatoWithdrawBPS: number;
        gelatoSlippageBPS: number;
        gelatoSlippageInterval: number;
      }
    >;

    UpdateGelatoParams(
      gelatoRebalanceBPS?: null,
      gelatoWithdrawBPS?: null,
      gelatoSlippageBPS?: null,
      gelatoSlippageInterval?: null
    ): TypedEventFilter<
      [number, number, number, number],
      {
        gelatoRebalanceBPS: number;
        gelatoWithdrawBPS: number;
        gelatoSlippageBPS: number;
        gelatoSlippageInterval: number;
      }
    >;
  };

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

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

    burn(
      burnAmount: BigNumberish,
      receiver: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    executiveRebalance(
      newLowerTick: BigNumberish,
      newUpperTick: BigNumberish,
      swapThresholdPrice: BigNumberish,
      swapAmountBPS: BigNumberish,
      zeroForOne: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    getMintAmounts(
      amount0Max: BigNumberish,
      amount1Max: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    initialize(
      _name: string,
      _symbol: string,
      _pool: string,
      _managerFeeBPS: BigNumberish,
      _lowerTick: BigNumberish,
      _upperTick: BigNumberish,
      _manager_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    mint(
      mintAmount: BigNumberish,
      receiver: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    rebalance(
      swapThresholdPrice: BigNumberish,
      swapAmountBPS: BigNumberish,
      zeroForOne: boolean,
      feeAmount: BigNumberish,
      paymentToken: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

    uniswapV3MintCallback(
      amount0Owed: BigNumberish,
      amount1Owed: BigNumberish,
      arg2: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    uniswapV3SwapCallback(
      amount0Delta: BigNumberish,
      amount1Delta: BigNumberish,
      arg2: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    updateGelatoParams(
      newRebalanceBPS: BigNumberish,
      newWithdrawBPS: BigNumberish,
      newSlippageBPS: BigNumberish,
      newSlippageInterval: BigNumberish,
      newTreasury: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    withdrawGelatoBalance(
      feeAmount: BigNumberish,
      feeToken: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    withdrawManagerBalance(
      feeAmount: BigNumberish,
      feeToken: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;
  };

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

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    balanceOf(
      account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    burn(
      burnAmount: BigNumberish,
      receiver: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    executiveRebalance(
      newLowerTick: BigNumberish,
      newUpperTick: BigNumberish,
      swapThresholdPrice: BigNumberish,
      swapAmountBPS: BigNumberish,
      zeroForOne: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

    getMintAmounts(
      amount0Max: BigNumberish,
      amount1Max: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    initialize(
      _name: string,
      _symbol: string,
      _pool: string,
      _managerFeeBPS: BigNumberish,
      _lowerTick: BigNumberish,
      _upperTick: BigNumberish,
      _manager_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

    mint(
      mintAmount: BigNumberish,
      receiver: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    rebalance(
      swapThresholdPrice: BigNumberish,
      swapAmountBPS: BigNumberish,
      zeroForOne: boolean,
      feeAmount: BigNumberish,
      paymentToken: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

    uniswapV3MintCallback(
      amount0Owed: BigNumberish,
      amount1Owed: BigNumberish,
      arg2: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    uniswapV3SwapCallback(
      amount0Delta: BigNumberish,
      amount1Delta: BigNumberish,
      arg2: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    updateGelatoParams(
      newRebalanceBPS: BigNumberish,
      newWithdrawBPS: BigNumberish,
      newSlippageBPS: BigNumberish,
      newSlippageInterval: BigNumberish,
      newTreasury: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    withdrawGelatoBalance(
      feeAmount: BigNumberish,
      feeToken: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    withdrawManagerBalance(
      feeAmount: BigNumberish,
      feeToken: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;
  };
}