/* 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 declare namespace IGovernorMiniBravo {
  export type ProposalStruct = {
    id: PromiseOrValue<BigNumberish>;
    params: PromiseOrValue<BytesLike>;
    forVotes: PromiseOrValue<BigNumberish>;
    open: PromiseOrValue<boolean>;
    timelockExpiry: PromiseOrValue<BigNumberish>;
  };

  export type ProposalStructOutput = [
    BigNumber,
    string,
    BigNumber,
    boolean,
    BigNumber
  ] & {
    id: BigNumber;
    params: string;
    forVotes: BigNumber;
    open: boolean;
    timelockExpiry: BigNumber;
  };
}

export interface IPoolManagerInterface extends utils.Interface {
  functions: {
    "FEE()": FunctionFragment;
    "IS_WETH_TOKEN0()": FunctionFragment;
    "POOL()": FunctionFragment;
    "POOL_MANAGER_FACTORY()": FunctionFragment;
    "QUORUM()": FunctionFragment;
    "TOKEN()": FunctionFragment;
    "WETH()": FunctionFragment;
    "acceptFeeManagerChange(address)": FunctionFragment;
    "acceptMigrate(address)": FunctionFragment;
    "acceptPriceOracleChange(address)": FunctionFragment;
    "burn(uint256)": FunctionFragment;
    "cancelProposal(uint256)": FunctionFragment;
    "cancelVote(uint256)": FunctionFragment;
    "claimRewards(address)": FunctionFragment;
    "claimable(address)": FunctionFragment;
    "collectFees()": FunctionFragment;
    "deprecateLockManager()": FunctionFragment;
    "deprecatedLockManagers(uint256)": FunctionFragment;
    "execute(uint256,bytes)": FunctionFragment;
    "executionTimelock()": FunctionFragment;
    "feeManager()": FunctionFragment;
    "getLatest(uint256)": FunctionFragment;
    "increaseFullRangePosition(address,uint128,uint160)": FunctionFragment;
    "increaseFullRangePosition(uint256,uint256)": FunctionFragment;
    "isExecutable(uint256)": FunctionFragment;
    "lockManager()": FunctionFragment;
    "mintLiquidityForFullRange(uint256,uint256)": FunctionFragment;
    "poolLiquidity()": FunctionFragment;
    "poolRewards()": FunctionFragment;
    "priceOracle()": FunctionFragment;
    "proposeFeeManagerChange(address)": FunctionFragment;
    "proposeMigrate(address)": FunctionFragment;
    "proposePriceOracleChange(address)": FunctionFragment;
    "queue(uint256,bytes)": FunctionFragment;
    "quorumReached(uint256)": FunctionFragment;
    "seederBalance(address)": FunctionFragment;
    "seederBurned(address)": FunctionFragment;
    "seederRewards(address)": FunctionFragment;
    "totalVotes()": FunctionFragment;
    "uniswapV3MintCallback(uint256,uint256,bytes)": FunctionFragment;
    "votingPower(address)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "FEE"
      | "IS_WETH_TOKEN0"
      | "POOL"
      | "POOL_MANAGER_FACTORY"
      | "QUORUM"
      | "TOKEN"
      | "WETH"
      | "acceptFeeManagerChange"
      | "acceptMigrate"
      | "acceptPriceOracleChange"
      | "burn"
      | "cancelProposal"
      | "cancelVote"
      | "claimRewards"
      | "claimable"
      | "collectFees"
      | "deprecateLockManager"
      | "deprecatedLockManagers"
      | "execute"
      | "executionTimelock"
      | "feeManager"
      | "getLatest"
      | "increaseFullRangePosition(address,uint128,uint160)"
      | "increaseFullRangePosition(uint256,uint256)"
      | "isExecutable"
      | "lockManager"
      | "mintLiquidityForFullRange"
      | "poolLiquidity"
      | "poolRewards"
      | "priceOracle"
      | "proposeFeeManagerChange"
      | "proposeMigrate"
      | "proposePriceOracleChange"
      | "queue"
      | "quorumReached"
      | "seederBalance"
      | "seederBurned"
      | "seederRewards"
      | "totalVotes"
      | "uniswapV3MintCallback"
      | "votingPower"
  ): FunctionFragment;

  encodeFunctionData(functionFragment: "FEE", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "IS_WETH_TOKEN0",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "POOL", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "POOL_MANAGER_FACTORY",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "QUORUM", values?: undefined): string;
  encodeFunctionData(functionFragment: "TOKEN", values?: undefined): string;
  encodeFunctionData(functionFragment: "WETH", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "acceptFeeManagerChange",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "acceptMigrate",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "acceptPriceOracleChange",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "burn",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "cancelProposal",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "cancelVote",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "claimRewards",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "claimable",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "collectFees",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "deprecateLockManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "deprecatedLockManagers",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "execute",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "executionTimelock",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "feeManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getLatest",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "increaseFullRangePosition(address,uint128,uint160)",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "increaseFullRangePosition(uint256,uint256)",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "isExecutable",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "lockManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "mintLiquidityForFullRange",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "poolLiquidity",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "poolRewards",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "priceOracle",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "proposeFeeManagerChange",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "proposeMigrate",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "proposePriceOracleChange",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "queue",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "quorumReached",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "seederBalance",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "seederBurned",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "seederRewards",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "totalVotes",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "uniswapV3MintCallback",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "votingPower",
    values: [PromiseOrValue<string>]
  ): string;

  decodeFunctionResult(functionFragment: "FEE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "IS_WETH_TOKEN0",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "POOL", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "POOL_MANAGER_FACTORY",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "QUORUM", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "TOKEN", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "WETH", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "acceptFeeManagerChange",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "acceptMigrate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "acceptPriceOracleChange",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "cancelProposal",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "cancelVote", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "claimRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "claimable", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "collectFees",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "deprecateLockManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "deprecatedLockManagers",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "executionTimelock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "feeManager", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getLatest", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "increaseFullRangePosition(address,uint128,uint160)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "increaseFullRangePosition(uint256,uint256)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isExecutable",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lockManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "mintLiquidityForFullRange",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "poolLiquidity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "poolRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "priceOracle",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "proposeFeeManagerChange",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "proposeMigrate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "proposePriceOracleChange",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "queue", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "quorumReached",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "seederBalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "seederBurned",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "seederRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "totalVotes", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "uniswapV3MintCallback",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "votingPower",
    data: BytesLike
  ): Result;

  events: {
    "ClaimedRewards(address,address,uint256,uint256)": EventFragment;
    "FeeManagerMigrated(address)": EventFragment;
    "FeesCollected(uint256,uint256)": EventFragment;
    "LockManagerDeprecated(address,address)": EventFragment;
    "NewProposal(uint256,uint256,bytes)": EventFragment;
    "NewVote(address,uint256,uint256,uint256)": EventFragment;
    "PriceOracleSet(address)": EventFragment;
    "ProposalCancelled(uint256,uint256,bytes)": EventFragment;
    "ProposalExecuted(uint256,uint256,bytes)": EventFragment;
    "ProposalQueued(uint256,uint256,bytes)": EventFragment;
    "RewardsAdded(uint256,uint256)": EventFragment;
    "SeederLiquidityBurned(uint256)": EventFragment;
    "VoteCancelled(address,uint256,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "ClaimedRewards"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FeeManagerMigrated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FeesCollected"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LockManagerDeprecated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewProposal"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewVote"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PriceOracleSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProposalCancelled"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProposalExecuted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProposalQueued"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewardsAdded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SeederLiquidityBurned"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "VoteCancelled"): EventFragment;
}

export interface ClaimedRewardsEventObject {
  _user: string;
  _to: string;
  _wethAmount: BigNumber;
  _tokenAmount: BigNumber;
}
export type ClaimedRewardsEvent = TypedEvent<
  [string, string, BigNumber, BigNumber],
  ClaimedRewardsEventObject
>;

export type ClaimedRewardsEventFilter = TypedEventFilter<ClaimedRewardsEvent>;

export interface FeeManagerMigratedEventObject {
  _newFeeManager: string;
}
export type FeeManagerMigratedEvent = TypedEvent<
  [string],
  FeeManagerMigratedEventObject
>;

export type FeeManagerMigratedEventFilter =
  TypedEventFilter<FeeManagerMigratedEvent>;

export interface FeesCollectedEventObject {
  _totalFeeWeth: BigNumber;
  _totalFeeToken: BigNumber;
}
export type FeesCollectedEvent = TypedEvent<
  [BigNumber, BigNumber],
  FeesCollectedEventObject
>;

export type FeesCollectedEventFilter = TypedEventFilter<FeesCollectedEvent>;

export interface LockManagerDeprecatedEventObject {
  _oldLockManager: string;
  _newLockManager: string;
}
export type LockManagerDeprecatedEvent = TypedEvent<
  [string, string],
  LockManagerDeprecatedEventObject
>;

export type LockManagerDeprecatedEventFilter =
  TypedEventFilter<LockManagerDeprecatedEvent>;

export interface NewProposalEventObject {
  _id: BigNumber;
  _method: BigNumber;
  _params: string;
}
export type NewProposalEvent = TypedEvent<
  [BigNumber, BigNumber, string],
  NewProposalEventObject
>;

export type NewProposalEventFilter = TypedEventFilter<NewProposalEvent>;

export interface NewVoteEventObject {
  _voter: string;
  _votes: BigNumber;
  _method: BigNumber;
  _id: BigNumber;
}
export type NewVoteEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber],
  NewVoteEventObject
>;

export type NewVoteEventFilter = TypedEventFilter<NewVoteEvent>;

export interface PriceOracleSetEventObject {
  _newPriceOracle: string;
}
export type PriceOracleSetEvent = TypedEvent<
  [string],
  PriceOracleSetEventObject
>;

export type PriceOracleSetEventFilter = TypedEventFilter<PriceOracleSetEvent>;

export interface ProposalCancelledEventObject {
  _id: BigNumber;
  _method: BigNumber;
  _params: string;
}
export type ProposalCancelledEvent = TypedEvent<
  [BigNumber, BigNumber, string],
  ProposalCancelledEventObject
>;

export type ProposalCancelledEventFilter =
  TypedEventFilter<ProposalCancelledEvent>;

export interface ProposalExecutedEventObject {
  _id: BigNumber;
  _method: BigNumber;
  _params: string;
}
export type ProposalExecutedEvent = TypedEvent<
  [BigNumber, BigNumber, string],
  ProposalExecutedEventObject
>;

export type ProposalExecutedEventFilter =
  TypedEventFilter<ProposalExecutedEvent>;

export interface ProposalQueuedEventObject {
  _id: BigNumber;
  _method: BigNumber;
  _params: string;
}
export type ProposalQueuedEvent = TypedEvent<
  [BigNumber, BigNumber, string],
  ProposalQueuedEventObject
>;

export type ProposalQueuedEventFilter = TypedEventFilter<ProposalQueuedEvent>;

export interface RewardsAddedEventObject {
  _wethAmount: BigNumber;
  _tokenAmount: BigNumber;
}
export type RewardsAddedEvent = TypedEvent<
  [BigNumber, BigNumber],
  RewardsAddedEventObject
>;

export type RewardsAddedEventFilter = TypedEventFilter<RewardsAddedEvent>;

export interface SeederLiquidityBurnedEventObject {
  _liquidity: BigNumber;
}
export type SeederLiquidityBurnedEvent = TypedEvent<
  [BigNumber],
  SeederLiquidityBurnedEventObject
>;

export type SeederLiquidityBurnedEventFilter =
  TypedEventFilter<SeederLiquidityBurnedEvent>;

export interface VoteCancelledEventObject {
  _voter: string;
  _method: BigNumber;
  _id: BigNumber;
}
export type VoteCancelledEvent = TypedEvent<
  [string, BigNumber, BigNumber],
  VoteCancelledEventObject
>;

export type VoteCancelledEventFilter = TypedEventFilter<VoteCancelledEvent>;

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

  interface: IPoolManagerInterface;

  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: {
    FEE(overrides?: CallOverrides): Promise<[number] & { _fee: number }>;

    IS_WETH_TOKEN0(
      overrides?: CallOverrides
    ): Promise<[boolean] & { _isWethToken0: boolean }>;

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

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

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

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

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

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

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

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

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

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

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

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

    claimable(
      _account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        _wethClaimable: BigNumber;
        _tokenClaimable: BigNumber;
      }
    >;

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

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

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

    execute(
      _method: PromiseOrValue<BigNumberish>,
      _parameters: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

    getLatest(
      _method: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [IGovernorMiniBravo.ProposalStructOutput] & {
        _proposal: IGovernorMiniBravo.ProposalStructOutput;
      }
    >;

    "increaseFullRangePosition(address,uint128,uint160)"(
      _donor: PromiseOrValue<string>,
      _liquidity: PromiseOrValue<BigNumberish>,
      _sqrtPriceX96: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    "increaseFullRangePosition(uint256,uint256)"(
      _wethAmount: PromiseOrValue<BigNumberish>,
      _tokenAmount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    isExecutable(
      _method: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[boolean] & { _availableToExecute: boolean }>;

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

    mintLiquidityForFullRange(
      _wethAmount: PromiseOrValue<BigNumberish>,
      _tokenAmount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

    poolRewards(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        wethPerSeededLiquidity: BigNumber;
        tokenPerSeededLiquidity: BigNumber;
      }
    >;

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

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

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

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

    queue(
      _method: PromiseOrValue<BigNumberish>,
      _parameters: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    quorumReached(
      _method: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[boolean] & { _quorumReached: boolean }>;

    seederBalance(
      _donor: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _seederBalance: BigNumber }>;

    seederBurned(
      _donor: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _seederBurned: BigNumber }>;

    seederRewards(
      _account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber] & {
        wethPaid: BigNumber;
        tokenPaid: BigNumber;
        wethAvailable: BigNumber;
        tokenAvailable: BigNumber;
      }
    >;

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

    uniswapV3MintCallback(
      _amount0Owed: PromiseOrValue<BigNumberish>,
      _amount1Owed: PromiseOrValue<BigNumberish>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    votingPower(
      _user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _balance: BigNumber }>;
  };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  claimable(
    _account: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & {
      _wethClaimable: BigNumber;
      _tokenClaimable: BigNumber;
    }
  >;

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

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

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

  execute(
    _method: PromiseOrValue<BigNumberish>,
    _parameters: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

  getLatest(
    _method: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<IGovernorMiniBravo.ProposalStructOutput>;

  "increaseFullRangePosition(address,uint128,uint160)"(
    _donor: PromiseOrValue<string>,
    _liquidity: PromiseOrValue<BigNumberish>,
    _sqrtPriceX96: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  "increaseFullRangePosition(uint256,uint256)"(
    _wethAmount: PromiseOrValue<BigNumberish>,
    _tokenAmount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  isExecutable(
    _method: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

  mintLiquidityForFullRange(
    _wethAmount: PromiseOrValue<BigNumberish>,
    _tokenAmount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

  poolRewards(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & {
      wethPerSeededLiquidity: BigNumber;
      tokenPerSeededLiquidity: BigNumber;
    }
  >;

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

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

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

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

  queue(
    _method: PromiseOrValue<BigNumberish>,
    _parameters: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  quorumReached(
    _method: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  seederBalance(
    _donor: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  seederBurned(
    _donor: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  seederRewards(
    _account: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, BigNumber] & {
      wethPaid: BigNumber;
      tokenPaid: BigNumber;
      wethAvailable: BigNumber;
      tokenAvailable: BigNumber;
    }
  >;

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

  uniswapV3MintCallback(
    _amount0Owed: PromiseOrValue<BigNumberish>,
    _amount1Owed: PromiseOrValue<BigNumberish>,
    _data: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  votingPower(
    _user: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  callStatic: {
    FEE(overrides?: CallOverrides): Promise<number>;

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

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

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

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

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

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

    acceptFeeManagerChange(
      _newFeeManager: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    acceptMigrate(
      _migrationContract: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    acceptPriceOracleChange(
      _newPriceOracle: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    burn(
      _liquidity: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    cancelProposal(
      _method: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    cancelVote(
      _method: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    claimRewards(
      _to: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        _rewardWeth: BigNumber;
        _rewardToken: BigNumber;
      }
    >;

    claimable(
      _account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        _wethClaimable: BigNumber;
        _tokenClaimable: BigNumber;
      }
    >;

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

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

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

    execute(
      _method: PromiseOrValue<BigNumberish>,
      _parameters: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    getLatest(
      _method: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<IGovernorMiniBravo.ProposalStructOutput>;

    "increaseFullRangePosition(address,uint128,uint160)"(
      _donor: PromiseOrValue<string>,
      _liquidity: PromiseOrValue<BigNumberish>,
      _sqrtPriceX96: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    "increaseFullRangePosition(uint256,uint256)"(
      _wethAmount: PromiseOrValue<BigNumberish>,
      _tokenAmount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        __amountWeth: BigNumber;
        __amountToken: BigNumber;
      }
    >;

    isExecutable(
      _method: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    mintLiquidityForFullRange(
      _wethAmount: PromiseOrValue<BigNumberish>,
      _tokenAmount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

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

    poolRewards(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        wethPerSeededLiquidity: BigNumber;
        tokenPerSeededLiquidity: BigNumber;
      }
    >;

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

    proposeFeeManagerChange(
      _newFeeManager: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    proposeMigrate(
      _migrationContract: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    proposePriceOracleChange(
      _newPriceOracle: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    queue(
      _method: PromiseOrValue<BigNumberish>,
      _parameters: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    quorumReached(
      _method: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    seederBalance(
      _donor: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    seederBurned(
      _donor: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    seederRewards(
      _account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber] & {
        wethPaid: BigNumber;
        tokenPaid: BigNumber;
        wethAvailable: BigNumber;
        tokenAvailable: BigNumber;
      }
    >;

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

    uniswapV3MintCallback(
      _amount0Owed: PromiseOrValue<BigNumberish>,
      _amount1Owed: PromiseOrValue<BigNumberish>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    votingPower(
      _user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;
  };

  filters: {
    "ClaimedRewards(address,address,uint256,uint256)"(
      _user?: null,
      _to?: null,
      _wethAmount?: null,
      _tokenAmount?: null
    ): ClaimedRewardsEventFilter;
    ClaimedRewards(
      _user?: null,
      _to?: null,
      _wethAmount?: null,
      _tokenAmount?: null
    ): ClaimedRewardsEventFilter;

    "FeeManagerMigrated(address)"(
      _newFeeManager?: null
    ): FeeManagerMigratedEventFilter;
    FeeManagerMigrated(_newFeeManager?: null): FeeManagerMigratedEventFilter;

    "FeesCollected(uint256,uint256)"(
      _totalFeeWeth?: null,
      _totalFeeToken?: null
    ): FeesCollectedEventFilter;
    FeesCollected(
      _totalFeeWeth?: null,
      _totalFeeToken?: null
    ): FeesCollectedEventFilter;

    "LockManagerDeprecated(address,address)"(
      _oldLockManager?: null,
      _newLockManager?: null
    ): LockManagerDeprecatedEventFilter;
    LockManagerDeprecated(
      _oldLockManager?: null,
      _newLockManager?: null
    ): LockManagerDeprecatedEventFilter;

    "NewProposal(uint256,uint256,bytes)"(
      _id?: null,
      _method?: null,
      _params?: null
    ): NewProposalEventFilter;
    NewProposal(
      _id?: null,
      _method?: null,
      _params?: null
    ): NewProposalEventFilter;

    "NewVote(address,uint256,uint256,uint256)"(
      _voter?: null,
      _votes?: null,
      _method?: null,
      _id?: null
    ): NewVoteEventFilter;
    NewVote(
      _voter?: null,
      _votes?: null,
      _method?: null,
      _id?: null
    ): NewVoteEventFilter;

    "PriceOracleSet(address)"(
      _newPriceOracle?: null
    ): PriceOracleSetEventFilter;
    PriceOracleSet(_newPriceOracle?: null): PriceOracleSetEventFilter;

    "ProposalCancelled(uint256,uint256,bytes)"(
      _id?: null,
      _method?: null,
      _params?: null
    ): ProposalCancelledEventFilter;
    ProposalCancelled(
      _id?: null,
      _method?: null,
      _params?: null
    ): ProposalCancelledEventFilter;

    "ProposalExecuted(uint256,uint256,bytes)"(
      _id?: null,
      _method?: null,
      _params?: null
    ): ProposalExecutedEventFilter;
    ProposalExecuted(
      _id?: null,
      _method?: null,
      _params?: null
    ): ProposalExecutedEventFilter;

    "ProposalQueued(uint256,uint256,bytes)"(
      _id?: null,
      _method?: null,
      _params?: null
    ): ProposalQueuedEventFilter;
    ProposalQueued(
      _id?: null,
      _method?: null,
      _params?: null
    ): ProposalQueuedEventFilter;

    "RewardsAdded(uint256,uint256)"(
      _wethAmount?: null,
      _tokenAmount?: null
    ): RewardsAddedEventFilter;
    RewardsAdded(
      _wethAmount?: null,
      _tokenAmount?: null
    ): RewardsAddedEventFilter;

    "SeederLiquidityBurned(uint256)"(
      _liquidity?: null
    ): SeederLiquidityBurnedEventFilter;
    SeederLiquidityBurned(_liquidity?: null): SeederLiquidityBurnedEventFilter;

    "VoteCancelled(address,uint256,uint256)"(
      _voter?: null,
      _method?: null,
      _id?: null
    ): VoteCancelledEventFilter;
    VoteCancelled(
      _voter?: null,
      _method?: null,
      _id?: null
    ): VoteCancelledEventFilter;
  };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    claimable(
      _account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    execute(
      _method: PromiseOrValue<BigNumberish>,
      _parameters: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

    getLatest(
      _method: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "increaseFullRangePosition(address,uint128,uint160)"(
      _donor: PromiseOrValue<string>,
      _liquidity: PromiseOrValue<BigNumberish>,
      _sqrtPriceX96: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    "increaseFullRangePosition(uint256,uint256)"(
      _wethAmount: PromiseOrValue<BigNumberish>,
      _tokenAmount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    isExecutable(
      _method: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    mintLiquidityForFullRange(
      _wethAmount: PromiseOrValue<BigNumberish>,
      _tokenAmount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

    queue(
      _method: PromiseOrValue<BigNumberish>,
      _parameters: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    quorumReached(
      _method: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    seederBalance(
      _donor: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    seederBurned(
      _donor: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    seederRewards(
      _account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    uniswapV3MintCallback(
      _amount0Owed: PromiseOrValue<BigNumberish>,
      _amount1Owed: PromiseOrValue<BigNumberish>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    votingPower(
      _user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;
  };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    claimable(
      _account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    execute(
      _method: PromiseOrValue<BigNumberish>,
      _parameters: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

    getLatest(
      _method: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "increaseFullRangePosition(address,uint128,uint160)"(
      _donor: PromiseOrValue<string>,
      _liquidity: PromiseOrValue<BigNumberish>,
      _sqrtPriceX96: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    "increaseFullRangePosition(uint256,uint256)"(
      _wethAmount: PromiseOrValue<BigNumberish>,
      _tokenAmount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    isExecutable(
      _method: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    mintLiquidityForFullRange(
      _wethAmount: PromiseOrValue<BigNumberish>,
      _tokenAmount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

    queue(
      _method: PromiseOrValue<BigNumberish>,
      _parameters: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    quorumReached(
      _method: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    seederBalance(
      _donor: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    seederBurned(
      _donor: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    seederRewards(
      _account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    uniswapV3MintCallback(
      _amount0Owed: PromiseOrValue<BigNumberish>,
      _amount1Owed: PromiseOrValue<BigNumberish>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    votingPower(
      _user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;
  };
}