@price-oracle/v1-core-interfaces/ethers-v5/IPoolManagerFactory.ts

Price Oracle v1 Core Interfaces and needed integration files

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

export interface IPoolManagerFactoryInterface extends utils.Interface {
  functions: {
    "FACTORY_SETTER_ROLE()": FunctionFragment;
    "FEE_COLLECTOR_SETTER_ROLE()": FunctionFragment;
    "FEE_MANAGER_SETTER_ROLE()": FunctionFragment;
    "MIGRATOR_SETTER_ROLE()": FunctionFragment;
    "MIN_ETH_AMOUNT_SETTER_ROLE()": FunctionFragment;
    "POOL_MANAGER_BYTECODE_HASH()": FunctionFragment;
    "POOL_MANAGER_DEPLOYER()": FunctionFragment;
    "PRICE_ORACLE_SETTER_ROLE()": FunctionFragment;
    "STRATEGY_SETTER_ROLE()": FunctionFragment;
    "WETH()": FunctionFragment;
    "acceptOwnership()": FunctionFragment;
    "children(uint256)": FunctionFragment;
    "childrenCount()": FunctionFragment;
    "constructorArguments()": FunctionFragment;
    "createPoolManager(address,uint24,uint128,uint160)": FunctionFragment;
    "defaultTokenFee(address)": FunctionFragment;
    "feeCollectorJob()": FunctionFragment;
    "feeManager()": FunctionFragment;
    "getPoolManagerAddress(address,uint24)": FunctionFragment;
    "getPoolManagers(address,uint24[])": FunctionFragment;
    "getWethPoolAddress(address,uint24)": FunctionFragment;
    "isChild(address)": FunctionFragment;
    "isSupportedPool(address)": FunctionFragment;
    "isSupportedToken(address)": FunctionFragment;
    "isSupportedTokenPair(address,address)": FunctionFragment;
    "listChildren(uint256,uint256)": FunctionFragment;
    "lockManagerFactory()": FunctionFragment;
    "minEthAmount()": FunctionFragment;
    "nominateOwner(address)": FunctionFragment;
    "owner()": FunctionFragment;
    "pendingOwner()": FunctionFragment;
    "poolManagerMigrator()": FunctionFragment;
    "poolManagers(address)": FunctionFragment;
    "priceOracle()": FunctionFragment;
    "setDefaultTokenFee(address,uint24)": FunctionFragment;
    "setFeeCollectorJob(address)": FunctionFragment;
    "setFeeManager(address)": FunctionFragment;
    "setLockManagerFactory(address)": FunctionFragment;
    "setMinEthAmount(uint256)": FunctionFragment;
    "setPoolManagerMigrator(address)": FunctionFragment;
    "setPriceOracle(address)": FunctionFragment;
    "setStrategy(address)": FunctionFragment;
    "strategy()": FunctionFragment;
    "tokenFees(address)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "FACTORY_SETTER_ROLE"
      | "FEE_COLLECTOR_SETTER_ROLE"
      | "FEE_MANAGER_SETTER_ROLE"
      | "MIGRATOR_SETTER_ROLE"
      | "MIN_ETH_AMOUNT_SETTER_ROLE"
      | "POOL_MANAGER_BYTECODE_HASH"
      | "POOL_MANAGER_DEPLOYER"
      | "PRICE_ORACLE_SETTER_ROLE"
      | "STRATEGY_SETTER_ROLE"
      | "WETH"
      | "acceptOwnership"
      | "children"
      | "childrenCount"
      | "constructorArguments"
      | "createPoolManager"
      | "defaultTokenFee"
      | "feeCollectorJob"
      | "feeManager"
      | "getPoolManagerAddress"
      | "getPoolManagers"
      | "getWethPoolAddress"
      | "isChild"
      | "isSupportedPool"
      | "isSupportedToken"
      | "isSupportedTokenPair"
      | "listChildren"
      | "lockManagerFactory"
      | "minEthAmount"
      | "nominateOwner"
      | "owner"
      | "pendingOwner"
      | "poolManagerMigrator"
      | "poolManagers"
      | "priceOracle"
      | "setDefaultTokenFee"
      | "setFeeCollectorJob"
      | "setFeeManager"
      | "setLockManagerFactory"
      | "setMinEthAmount"
      | "setPoolManagerMigrator"
      | "setPriceOracle"
      | "setStrategy"
      | "strategy"
      | "tokenFees"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "FACTORY_SETTER_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "FEE_COLLECTOR_SETTER_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "FEE_MANAGER_SETTER_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MIGRATOR_SETTER_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MIN_ETH_AMOUNT_SETTER_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "POOL_MANAGER_BYTECODE_HASH",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "POOL_MANAGER_DEPLOYER",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "PRICE_ORACLE_SETTER_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "STRATEGY_SETTER_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "WETH", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "acceptOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "children",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "childrenCount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "constructorArguments",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "createPoolManager",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "defaultTokenFee",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "feeCollectorJob",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "feeManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getPoolManagerAddress",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "getPoolManagers",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>[]]
  ): string;
  encodeFunctionData(
    functionFragment: "getWethPoolAddress",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "isChild",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "isSupportedPool",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "isSupportedToken",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "isSupportedTokenPair",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "listChildren",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "lockManagerFactory",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "minEthAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "nominateOwner",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "pendingOwner",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "poolManagerMigrator",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "poolManagers",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "priceOracle",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setDefaultTokenFee",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setFeeCollectorJob",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setFeeManager",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setLockManagerFactory",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setMinEthAmount",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setPoolManagerMigrator",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setPriceOracle",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setStrategy",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(functionFragment: "strategy", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "tokenFees",
    values: [PromiseOrValue<string>]
  ): string;

  decodeFunctionResult(
    functionFragment: "FACTORY_SETTER_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "FEE_COLLECTOR_SETTER_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "FEE_MANAGER_SETTER_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MIGRATOR_SETTER_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MIN_ETH_AMOUNT_SETTER_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "POOL_MANAGER_BYTECODE_HASH",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "POOL_MANAGER_DEPLOYER",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "PRICE_ORACLE_SETTER_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "STRATEGY_SETTER_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "WETH", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "acceptOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "children", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "childrenCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "constructorArguments",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "createPoolManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "defaultTokenFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "feeCollectorJob",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "feeManager", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getPoolManagerAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPoolManagers",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getWethPoolAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isChild", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isSupportedPool",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isSupportedToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isSupportedTokenPair",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "listChildren",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lockManagerFactory",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "minEthAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "nominateOwner",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "pendingOwner",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "poolManagerMigrator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "poolManagers",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "priceOracle",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDefaultTokenFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setFeeCollectorJob",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setFeeManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setLockManagerFactory",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMinEthAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPoolManagerMigrator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPriceOracle",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setStrategy",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "strategy", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "tokenFees", data: BytesLike): Result;

  events: {
    "FeeCollectorJobChanged(address)": EventFragment;
    "FeeManagerChanged(address)": EventFragment;
    "LockManagerFactoryChanged(address)": EventFragment;
    "MinEthAmountChanged(uint256)": EventFragment;
    "OwnerChanged(address)": EventFragment;
    "OwnerNominated(address)": EventFragment;
    "PoolManagerCreated(address)": EventFragment;
    "PoolManagerMigratorChanged(address)": EventFragment;
    "PriceOracleChanged(address)": EventFragment;
    "StrategyChanged(address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "FeeCollectorJobChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FeeManagerChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LockManagerFactoryChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MinEthAmountChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnerChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnerNominated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PoolManagerCreated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PoolManagerMigratorChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PriceOracleChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StrategyChanged"): EventFragment;
}

export interface FeeCollectorJobChangedEventObject {
  _feeCollectorJob: string;
}
export type FeeCollectorJobChangedEvent = TypedEvent<
  [string],
  FeeCollectorJobChangedEventObject
>;

export type FeeCollectorJobChangedEventFilter =
  TypedEventFilter<FeeCollectorJobChangedEvent>;

export interface FeeManagerChangedEventObject {
  _feeManager: string;
}
export type FeeManagerChangedEvent = TypedEvent<
  [string],
  FeeManagerChangedEventObject
>;

export type FeeManagerChangedEventFilter =
  TypedEventFilter<FeeManagerChangedEvent>;

export interface LockManagerFactoryChangedEventObject {
  _lockManagerFactory: string;
}
export type LockManagerFactoryChangedEvent = TypedEvent<
  [string],
  LockManagerFactoryChangedEventObject
>;

export type LockManagerFactoryChangedEventFilter =
  TypedEventFilter<LockManagerFactoryChangedEvent>;

export interface MinEthAmountChangedEventObject {
  _minEthAmount: BigNumber;
}
export type MinEthAmountChangedEvent = TypedEvent<
  [BigNumber],
  MinEthAmountChangedEventObject
>;

export type MinEthAmountChangedEventFilter =
  TypedEventFilter<MinEthAmountChangedEvent>;

export interface OwnerChangedEventObject {
  _owner: string;
}
export type OwnerChangedEvent = TypedEvent<[string], OwnerChangedEventObject>;

export type OwnerChangedEventFilter = TypedEventFilter<OwnerChangedEvent>;

export interface OwnerNominatedEventObject {
  _owner: string;
}
export type OwnerNominatedEvent = TypedEvent<
  [string],
  OwnerNominatedEventObject
>;

export type OwnerNominatedEventFilter = TypedEventFilter<OwnerNominatedEvent>;

export interface PoolManagerCreatedEventObject {
  _poolManager: string;
}
export type PoolManagerCreatedEvent = TypedEvent<
  [string],
  PoolManagerCreatedEventObject
>;

export type PoolManagerCreatedEventFilter =
  TypedEventFilter<PoolManagerCreatedEvent>;

export interface PoolManagerMigratorChangedEventObject {
  _poolManagerMigrator: string;
}
export type PoolManagerMigratorChangedEvent = TypedEvent<
  [string],
  PoolManagerMigratorChangedEventObject
>;

export type PoolManagerMigratorChangedEventFilter =
  TypedEventFilter<PoolManagerMigratorChangedEvent>;

export interface PriceOracleChangedEventObject {
  _priceOracle: string;
}
export type PriceOracleChangedEvent = TypedEvent<
  [string],
  PriceOracleChangedEventObject
>;

export type PriceOracleChangedEventFilter =
  TypedEventFilter<PriceOracleChangedEvent>;

export interface StrategyChangedEventObject {
  _strategy: string;
}
export type StrategyChangedEvent = TypedEvent<
  [string],
  StrategyChangedEventObject
>;

export type StrategyChangedEventFilter = TypedEventFilter<StrategyChangedEvent>;

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

  interface: IPoolManagerFactoryInterface;

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

  listeners<TEvent extends TypedEvent>(
    eventFilter?: TypedEventFilter<TEvent>
  ): Array<TypedListener<TEvent>>;
  listeners(eventName?: string): Array<Listener>;
  removeAllListeners<TEvent extends TypedEvent>(
    eventFilter: TypedEventFilter<TEvent>
  ): this;
  removeAllListeners(eventName?: string): this;
  off: OnEvent<this>;
  on: OnEvent<this>;
  once: OnEvent<this>;
  removeListener: OnEvent<this>;

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

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

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

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

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

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

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

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

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

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

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

    children(
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string] & { _poolManager: string }>;

    childrenCount(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _childrenCount: BigNumber }>;

    constructorArguments(
      overrides?: CallOverrides
    ): Promise<
      [string, string, string, string, number, BigNumber] & {
        otherToken: string;
        feeManager: string;
        priceOracle: string;
        owner: string;
        fee: number;
        sqrtPriceX96: BigNumber;
      }
    >;

    createPoolManager(
      _token: PromiseOrValue<string>,
      _fee: PromiseOrValue<BigNumberish>,
      _liquidity: PromiseOrValue<BigNumberish>,
      _sqrtPriceX96: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    defaultTokenFee(
      _token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[number] & { _fee: number }>;

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

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

    getPoolManagerAddress(
      _token: PromiseOrValue<string>,
      _fee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string] & { _theoreticalPoolManagerAddress: string }>;

    getPoolManagers(
      _token: PromiseOrValue<string>,
      _feeTiers: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<[string[]] & { _poolManagerAddresses: string[] }>;

    getWethPoolAddress(
      _token: PromiseOrValue<string>,
      _fee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [string, boolean] & {
        _theoreticalAddress: string;
        _isWethToken0: boolean;
      }
    >;

    isChild(
      _poolManager: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean] & { _isChild: boolean }>;

    isSupportedPool(
      _pool: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean] & { _isSupportedPool: boolean }>;

    isSupportedToken(
      _token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean] & { _isValid: boolean }>;

    isSupportedTokenPair(
      _tokenA: PromiseOrValue<string>,
      _tokenB: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean] & { _isSupported: boolean }>;

    listChildren(
      _startFrom: PromiseOrValue<BigNumberish>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string[]] & { _list: string[] }>;

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

    minEthAmount(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _minEthAmount: BigNumber }>;

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

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

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

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

    poolManagers(
      _pool: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[string] & { _poolManager: string }>;

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

    setDefaultTokenFee(
      _token: PromiseOrValue<string>,
      _fee: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

    tokenFees(
      _token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[number[]] & { _fees: number[] }>;
  };

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

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

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

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

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

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

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

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

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

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

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

  children(
    _index: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string>;

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

  constructorArguments(
    overrides?: CallOverrides
  ): Promise<
    [string, string, string, string, number, BigNumber] & {
      otherToken: string;
      feeManager: string;
      priceOracle: string;
      owner: string;
      fee: number;
      sqrtPriceX96: BigNumber;
    }
  >;

  createPoolManager(
    _token: PromiseOrValue<string>,
    _fee: PromiseOrValue<BigNumberish>,
    _liquidity: PromiseOrValue<BigNumberish>,
    _sqrtPriceX96: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  defaultTokenFee(
    _token: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<number>;

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

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

  getPoolManagerAddress(
    _token: PromiseOrValue<string>,
    _fee: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string>;

  getPoolManagers(
    _token: PromiseOrValue<string>,
    _feeTiers: PromiseOrValue<BigNumberish>[],
    overrides?: CallOverrides
  ): Promise<string[]>;

  getWethPoolAddress(
    _token: PromiseOrValue<string>,
    _fee: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<
    [string, boolean] & { _theoreticalAddress: string; _isWethToken0: boolean }
  >;

  isChild(
    _poolManager: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isSupportedPool(
    _pool: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isSupportedToken(
    _token: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isSupportedTokenPair(
    _tokenA: PromiseOrValue<string>,
    _tokenB: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  listChildren(
    _startFrom: PromiseOrValue<BigNumberish>,
    _amount: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string[]>;

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

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

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

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

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

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

  poolManagers(
    _pool: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<string>;

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

  setDefaultTokenFee(
    _token: PromiseOrValue<string>,
    _fee: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    children(
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

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

    constructorArguments(
      overrides?: CallOverrides
    ): Promise<
      [string, string, string, string, number, BigNumber] & {
        otherToken: string;
        feeManager: string;
        priceOracle: string;
        owner: string;
        fee: number;
        sqrtPriceX96: BigNumber;
      }
    >;

    createPoolManager(
      _token: PromiseOrValue<string>,
      _fee: PromiseOrValue<BigNumberish>,
      _liquidity: PromiseOrValue<BigNumberish>,
      _sqrtPriceX96: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

    defaultTokenFee(
      _token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<number>;

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

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

    getPoolManagerAddress(
      _token: PromiseOrValue<string>,
      _fee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

    getPoolManagers(
      _token: PromiseOrValue<string>,
      _feeTiers: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<string[]>;

    getWethPoolAddress(
      _token: PromiseOrValue<string>,
      _fee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [string, boolean] & {
        _theoreticalAddress: string;
        _isWethToken0: boolean;
      }
    >;

    isChild(
      _poolManager: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isSupportedPool(
      _pool: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isSupportedToken(
      _token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isSupportedTokenPair(
      _tokenA: PromiseOrValue<string>,
      _tokenB: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    listChildren(
      _startFrom: PromiseOrValue<BigNumberish>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string[]>;

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

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

    nominateOwner(
      _newOwner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    poolManagers(
      _pool: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<string>;

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

    setDefaultTokenFee(
      _token: PromiseOrValue<string>,
      _fee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setFeeCollectorJob(
      _feeCollectorJob: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setFeeManager(
      _feeManager: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setLockManagerFactory(
      _lockManagerFactory: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setMinEthAmount(
      _minEthAmount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setPoolManagerMigrator(
      _poolManagerMigrator: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setPriceOracle(
      _priceOracle: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setStrategy(
      _strategy: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

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

    tokenFees(
      _token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<number[]>;
  };

  filters: {
    "FeeCollectorJobChanged(address)"(
      _feeCollectorJob?: null
    ): FeeCollectorJobChangedEventFilter;
    FeeCollectorJobChanged(
      _feeCollectorJob?: null
    ): FeeCollectorJobChangedEventFilter;

    "FeeManagerChanged(address)"(
      _feeManager?: null
    ): FeeManagerChangedEventFilter;
    FeeManagerChanged(_feeManager?: null): FeeManagerChangedEventFilter;

    "LockManagerFactoryChanged(address)"(
      _lockManagerFactory?: null
    ): LockManagerFactoryChangedEventFilter;
    LockManagerFactoryChanged(
      _lockManagerFactory?: null
    ): LockManagerFactoryChangedEventFilter;

    "MinEthAmountChanged(uint256)"(
      _minEthAmount?: null
    ): MinEthAmountChangedEventFilter;
    MinEthAmountChanged(_minEthAmount?: null): MinEthAmountChangedEventFilter;

    "OwnerChanged(address)"(_owner?: null): OwnerChangedEventFilter;
    OwnerChanged(_owner?: null): OwnerChangedEventFilter;

    "OwnerNominated(address)"(_owner?: null): OwnerNominatedEventFilter;
    OwnerNominated(_owner?: null): OwnerNominatedEventFilter;

    "PoolManagerCreated(address)"(
      _poolManager?: null
    ): PoolManagerCreatedEventFilter;
    PoolManagerCreated(_poolManager?: null): PoolManagerCreatedEventFilter;

    "PoolManagerMigratorChanged(address)"(
      _poolManagerMigrator?: null
    ): PoolManagerMigratorChangedEventFilter;
    PoolManagerMigratorChanged(
      _poolManagerMigrator?: null
    ): PoolManagerMigratorChangedEventFilter;

    "PriceOracleChanged(address)"(
      _priceOracle?: null
    ): PriceOracleChangedEventFilter;
    PriceOracleChanged(_priceOracle?: null): PriceOracleChangedEventFilter;

    "StrategyChanged(address)"(_strategy?: null): StrategyChangedEventFilter;
    StrategyChanged(_strategy?: null): StrategyChangedEventFilter;
  };

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

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

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

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

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

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

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

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

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

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

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

    children(
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    createPoolManager(
      _token: PromiseOrValue<string>,
      _fee: PromiseOrValue<BigNumberish>,
      _liquidity: PromiseOrValue<BigNumberish>,
      _sqrtPriceX96: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    defaultTokenFee(
      _token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getPoolManagerAddress(
      _token: PromiseOrValue<string>,
      _fee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getPoolManagers(
      _token: PromiseOrValue<string>,
      _feeTiers: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getWethPoolAddress(
      _token: PromiseOrValue<string>,
      _fee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isChild(
      _poolManager: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isSupportedPool(
      _pool: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isSupportedToken(
      _token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isSupportedTokenPair(
      _tokenA: PromiseOrValue<string>,
      _tokenB: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    listChildren(
      _startFrom: PromiseOrValue<BigNumberish>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

    poolManagers(
      _pool: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    setDefaultTokenFee(
      _token: PromiseOrValue<string>,
      _fee: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

    tokenFees(
      _token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;
  };

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

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

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

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

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

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

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

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

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

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

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

    children(
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    createPoolManager(
      _token: PromiseOrValue<string>,
      _fee: PromiseOrValue<BigNumberish>,
      _liquidity: PromiseOrValue<BigNumberish>,
      _sqrtPriceX96: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    defaultTokenFee(
      _token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    getPoolManagerAddress(
      _token: PromiseOrValue<string>,
      _fee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getPoolManagers(
      _token: PromiseOrValue<string>,
      _feeTiers: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getWethPoolAddress(
      _token: PromiseOrValue<string>,
      _fee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isChild(
      _poolManager: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isSupportedPool(
      _pool: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isSupportedToken(
      _token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isSupportedTokenPair(
      _tokenA: PromiseOrValue<string>,
      _tokenB: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    listChildren(
      _startFrom: PromiseOrValue<BigNumberish>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

    poolManagers(
      _pool: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    setDefaultTokenFee(
      _token: PromiseOrValue<string>,
      _fee: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

    tokenFees(
      _token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;
  };
}