/* 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 IStrategy {
  export type LiquidityPositionStruct = {
    lowerTick: PromiseOrValue<BigNumberish>;
    upperTick: PromiseOrValue<BigNumberish>;
    liquidity: PromiseOrValue<BigNumberish>;
  };

  export type LiquidityPositionStructOutput = [number, number, BigNumber] & {
    lowerTick: number;
    upperTick: number;
    liquidity: BigNumber;
  };

  export type PositionStruct = {
    lowerTick: PromiseOrValue<BigNumberish>;
    upperTick: PromiseOrValue<BigNumberish>;
  };

  export type PositionStructOutput = [number, number] & {
    lowerTick: number;
    upperTick: number;
  };
}

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 ILockManagerInterface extends utils.Interface {
  functions: {
    "DOMAIN_SEPARATOR()": FunctionFragment;
    "FEE()": FunctionFragment;
    "IS_WETH_TOKEN0()": FunctionFragment;
    "POOL()": FunctionFragment;
    "POOL_MANAGER()": FunctionFragment;
    "POOL_MANAGER_FACTORY()": FunctionFragment;
    "QUORUM()": FunctionFragment;
    "STRATEGY()": FunctionFragment;
    "TOKEN()": FunctionFragment;
    "WETH()": FunctionFragment;
    "acceptDeprecate()": FunctionFragment;
    "addRewards(uint256,uint256)": FunctionFragment;
    "allowance(address,address)": FunctionFragment;
    "approve(address,uint256)": FunctionFragment;
    "balanceOf(address)": FunctionFragment;
    "burn(uint256)": FunctionFragment;
    "burnPosition((int24,int24))": FunctionFragment;
    "cancelProposal(uint256)": FunctionFragment;
    "cancelVote(uint256)": FunctionFragment;
    "claimRewards(address)": FunctionFragment;
    "claimable(address)": FunctionFragment;
    "collectFees((int24,int24)[])": FunctionFragment;
    "concentratedWeth()": FunctionFragment;
    "decimals()": FunctionFragment;
    "deprecated()": FunctionFragment;
    "execute(uint256,bytes)": FunctionFragment;
    "executionTimelock()": FunctionFragment;
    "getLatest(uint256)": FunctionFragment;
    "getPositionToBurn((int24,int24))": FunctionFragment;
    "getPositionToMint()": FunctionFragment;
    "getPositionsCount()": FunctionFragment;
    "isExecutable(uint256)": FunctionFragment;
    "lock(uint256)": FunctionFragment;
    "mintPosition()": FunctionFragment;
    "name()": FunctionFragment;
    "nonces(address)": FunctionFragment;
    "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)": FunctionFragment;
    "poolRewards()": FunctionFragment;
    "positionsList(uint256,uint256)": FunctionFragment;
    "queue(uint256,bytes)": FunctionFragment;
    "quorumReached(uint256)": FunctionFragment;
    "symbol()": FunctionFragment;
    "totalSupply()": FunctionFragment;
    "totalVotes()": FunctionFragment;
    "transfer(address,uint256)": FunctionFragment;
    "transferFrom(address,address,uint256)": FunctionFragment;
    "uniswapV3MintCallback(uint256,uint256,bytes)": FunctionFragment;
    "unwind(uint256)": FunctionFragment;
    "userRewards(address)": FunctionFragment;
    "votingPower(address)": FunctionFragment;
    "withdraw(address)": FunctionFragment;
    "withdrawalData()": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "DOMAIN_SEPARATOR"
      | "FEE"
      | "IS_WETH_TOKEN0"
      | "POOL"
      | "POOL_MANAGER"
      | "POOL_MANAGER_FACTORY"
      | "QUORUM"
      | "STRATEGY"
      | "TOKEN"
      | "WETH"
      | "acceptDeprecate"
      | "addRewards"
      | "allowance"
      | "approve"
      | "balanceOf"
      | "burn"
      | "burnPosition"
      | "cancelProposal"
      | "cancelVote"
      | "claimRewards"
      | "claimable"
      | "collectFees"
      | "concentratedWeth"
      | "decimals"
      | "deprecated"
      | "execute"
      | "executionTimelock"
      | "getLatest"
      | "getPositionToBurn"
      | "getPositionToMint"
      | "getPositionsCount"
      | "isExecutable"
      | "lock"
      | "mintPosition"
      | "name"
      | "nonces"
      | "permit"
      | "poolRewards"
      | "positionsList"
      | "queue"
      | "quorumReached"
      | "symbol"
      | "totalSupply"
      | "totalVotes"
      | "transfer"
      | "transferFrom"
      | "uniswapV3MintCallback"
      | "unwind"
      | "userRewards"
      | "votingPower"
      | "withdraw"
      | "withdrawalData"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "DOMAIN_SEPARATOR",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "FEE", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "IS_WETH_TOKEN0",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "POOL", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "POOL_MANAGER",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "POOL_MANAGER_FACTORY",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "QUORUM", values?: undefined): string;
  encodeFunctionData(functionFragment: "STRATEGY", values?: undefined): string;
  encodeFunctionData(functionFragment: "TOKEN", values?: undefined): string;
  encodeFunctionData(functionFragment: "WETH", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "acceptDeprecate",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "addRewards",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "allowance",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "approve",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "balanceOf",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "burn",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "burnPosition",
    values: [IStrategy.PositionStruct]
  ): 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: [IStrategy.PositionStruct[]]
  ): string;
  encodeFunctionData(
    functionFragment: "concentratedWeth",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "deprecated",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "execute",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "executionTimelock",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getLatest",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "getPositionToBurn",
    values: [IStrategy.PositionStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "getPositionToMint",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getPositionsCount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isExecutable",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "lock",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "mintPosition",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "name", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "nonces",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "permit",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "poolRewards",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "positionsList",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "queue",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "quorumReached",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "totalSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalVotes",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transfer",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "transferFrom",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "uniswapV3MintCallback",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "unwind",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "userRewards",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "votingPower",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawalData",
    values?: undefined
  ): string;

  decodeFunctionResult(
    functionFragment: "DOMAIN_SEPARATOR",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "FEE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "IS_WETH_TOKEN0",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "POOL", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "POOL_MANAGER",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "POOL_MANAGER_FACTORY",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "QUORUM", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "STRATEGY", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "TOKEN", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "WETH", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "acceptDeprecate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "addRewards", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "burnPosition",
    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: "concentratedWeth",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "deprecated", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "executionTimelock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getLatest", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getPositionToBurn",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPositionToMint",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPositionsCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isExecutable",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "lock", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "mintPosition",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "nonces", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "permit", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "poolRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "positionsList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "queue", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "quorumReached",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "totalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "totalVotes", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "uniswapV3MintCallback",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unwind", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "userRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "votingPower",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "withdrawalData",
    data: BytesLike
  ): Result;

  events: {
    "Approval(address,address,uint256)": EventFragment;
    "Burned(uint256)": EventFragment;
    "ClaimedRewards(address,address,uint256,uint256)": EventFragment;
    "FeesCollected(uint256,uint256)": EventFragment;
    "Locked(uint256)": EventFragment;
    "NewProposal(uint256,uint256,bytes)": EventFragment;
    "NewVote(address,uint256,uint256,uint256)": EventFragment;
    "PositionBurned(tuple,uint256,uint256)": EventFragment;
    "PositionMinted(tuple,uint256,uint256)": EventFragment;
    "ProposalCancelled(uint256,uint256,bytes)": EventFragment;
    "ProposalExecuted(uint256,uint256,bytes)": EventFragment;
    "ProposalQueued(uint256,uint256,bytes)": EventFragment;
    "RewardsAdded(uint256,uint256)": EventFragment;
    "Transfer(address,address,uint256)": EventFragment;
    "VoteCancelled(address,uint256,uint256)": EventFragment;
    "WithdrawalsEnabled()": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Burned"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ClaimedRewards"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FeesCollected"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Locked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewProposal"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewVote"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PositionBurned"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PositionMinted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProposalCancelled"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProposalExecuted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProposalQueued"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewardsAdded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "VoteCancelled"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "WithdrawalsEnabled"): EventFragment;
}

export interface ApprovalEventObject {
  owner: string;
  spender: string;
  amount: BigNumber;
}
export type ApprovalEvent = TypedEvent<
  [string, string, BigNumber],
  ApprovalEventObject
>;

export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;

export interface BurnedEventObject {
  _wethAmount: BigNumber;
}
export type BurnedEvent = TypedEvent<[BigNumber], BurnedEventObject>;

export type BurnedEventFilter = TypedEventFilter<BurnedEvent>;

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 FeesCollectedEventObject {
  _wethFees: BigNumber;
  _tokenFees: BigNumber;
}
export type FeesCollectedEvent = TypedEvent<
  [BigNumber, BigNumber],
  FeesCollectedEventObject
>;

export type FeesCollectedEventFilter = TypedEventFilter<FeesCollectedEvent>;

export interface LockedEventObject {
  _wethAmount: BigNumber;
}
export type LockedEvent = TypedEvent<[BigNumber], LockedEventObject>;

export type LockedEventFilter = TypedEventFilter<LockedEvent>;

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 PositionBurnedEventObject {
  _position: IStrategy.LiquidityPositionStructOutput;
  _amount0: BigNumber;
  _amount1: BigNumber;
}
export type PositionBurnedEvent = TypedEvent<
  [IStrategy.LiquidityPositionStructOutput, BigNumber, BigNumber],
  PositionBurnedEventObject
>;

export type PositionBurnedEventFilter = TypedEventFilter<PositionBurnedEvent>;

export interface PositionMintedEventObject {
  _position: IStrategy.LiquidityPositionStructOutput;
  _amount0: BigNumber;
  _amount1: BigNumber;
}
export type PositionMintedEvent = TypedEvent<
  [IStrategy.LiquidityPositionStructOutput, BigNumber, BigNumber],
  PositionMintedEventObject
>;

export type PositionMintedEventFilter = TypedEventFilter<PositionMintedEvent>;

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 TransferEventObject {
  from: string;
  to: string;
  amount: BigNumber;
}
export type TransferEvent = TypedEvent<
  [string, string, BigNumber],
  TransferEventObject
>;

export type TransferEventFilter = TypedEventFilter<TransferEvent>;

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

export type VoteCancelledEventFilter = TypedEventFilter<VoteCancelledEvent>;

export interface WithdrawalsEnabledEventObject {}
export type WithdrawalsEnabledEvent = TypedEvent<
  [],
  WithdrawalsEnabledEventObject
>;

export type WithdrawalsEnabledEventFilter =
  TypedEventFilter<WithdrawalsEnabledEvent>;

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

  interface: ILockManagerInterface;

  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: {
    DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<[string]>;

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

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

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

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

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

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

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

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

    allowance(
      _owner: PromiseOrValue<string>,
      _spender: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

    burnPosition(
      _position: IStrategy.PositionStruct,
      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(
      _positions: IStrategy.PositionStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

    decimals(
      overrides?: CallOverrides
    ): Promise<[number] & { _decimals: number }>;

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

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

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

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

    getPositionToBurn(
      _position: IStrategy.PositionStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

    permit(
      owner: PromiseOrValue<string>,
      spender: PromiseOrValue<string>,
      value: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      v: PromiseOrValue<BigNumberish>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

    positionsList(
      _startFrom: PromiseOrValue<BigNumberish>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [IStrategy.LiquidityPositionStructOutput[]] & {
        _positions: IStrategy.LiquidityPositionStructOutput[];
      }
    >;

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

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

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

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

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

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

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

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

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

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

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

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

    withdrawalData(
      overrides?: CallOverrides
    ): Promise<
      [boolean, BigNumber, BigNumber] & {
        withdrawalsEnabled: boolean;
        totalWeth: BigNumber;
        totalToken: BigNumber;
      }
    >;
  };

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

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

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

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

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

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

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

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

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

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

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

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

  allowance(
    _owner: PromiseOrValue<string>,
    _spender: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

  burnPosition(
    _position: IStrategy.PositionStruct,
    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(
    _positions: IStrategy.PositionStruct[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

  getPositionToBurn(
    _position: IStrategy.PositionStruct,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

  permit(
    owner: PromiseOrValue<string>,
    spender: PromiseOrValue<string>,
    value: PromiseOrValue<BigNumberish>,
    deadline: PromiseOrValue<BigNumberish>,
    v: PromiseOrValue<BigNumberish>,
    r: PromiseOrValue<BytesLike>,
    s: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

  positionsList(
    _startFrom: PromiseOrValue<BigNumberish>,
    _amount: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<IStrategy.LiquidityPositionStructOutput[]>;

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

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

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

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

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

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

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

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

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

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

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

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

  withdrawalData(
    overrides?: CallOverrides
  ): Promise<
    [boolean, BigNumber, BigNumber] & {
      withdrawalsEnabled: boolean;
      totalWeth: BigNumber;
      totalToken: BigNumber;
    }
  >;

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

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

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

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

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

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

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

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

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

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

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

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

    allowance(
      _owner: PromiseOrValue<string>,
      _spender: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    burnPosition(
      _position: IStrategy.PositionStruct,
      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(
      _positions: IStrategy.PositionStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

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

    getPositionToBurn(
      _position: IStrategy.PositionStruct,
      overrides?: CallOverrides
    ): Promise<IStrategy.LiquidityPositionStructOutput>;

    getPositionToMint(
      overrides?: CallOverrides
    ): Promise<IStrategy.LiquidityPositionStructOutput>;

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

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

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

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

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

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

    permit(
      owner: PromiseOrValue<string>,
      spender: PromiseOrValue<string>,
      value: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      v: PromiseOrValue<BigNumberish>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

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

    positionsList(
      _startFrom: PromiseOrValue<BigNumberish>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<IStrategy.LiquidityPositionStructOutput[]>;

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

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

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

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

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

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

    transferFrom(
      from: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    unwind(
      _positions: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    withdraw(
      _receiver: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawalData(
      overrides?: CallOverrides
    ): Promise<
      [boolean, BigNumber, BigNumber] & {
        withdrawalsEnabled: boolean;
        totalWeth: BigNumber;
        totalToken: BigNumber;
      }
    >;
  };

  filters: {
    "Approval(address,address,uint256)"(
      owner?: PromiseOrValue<string> | null,
      spender?: PromiseOrValue<string> | null,
      amount?: null
    ): ApprovalEventFilter;
    Approval(
      owner?: PromiseOrValue<string> | null,
      spender?: PromiseOrValue<string> | null,
      amount?: null
    ): ApprovalEventFilter;

    "Burned(uint256)"(_wethAmount?: null): BurnedEventFilter;
    Burned(_wethAmount?: null): BurnedEventFilter;

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

    "FeesCollected(uint256,uint256)"(
      _wethFees?: null,
      _tokenFees?: null
    ): FeesCollectedEventFilter;
    FeesCollected(
      _wethFees?: null,
      _tokenFees?: null
    ): FeesCollectedEventFilter;

    "Locked(uint256)"(_wethAmount?: null): LockedEventFilter;
    Locked(_wethAmount?: null): LockedEventFilter;

    "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;

    "PositionBurned(tuple,uint256,uint256)"(
      _position?: null,
      _amount0?: null,
      _amount1?: null
    ): PositionBurnedEventFilter;
    PositionBurned(
      _position?: null,
      _amount0?: null,
      _amount1?: null
    ): PositionBurnedEventFilter;

    "PositionMinted(tuple,uint256,uint256)"(
      _position?: null,
      _amount0?: null,
      _amount1?: null
    ): PositionMintedEventFilter;
    PositionMinted(
      _position?: null,
      _amount0?: null,
      _amount1?: null
    ): PositionMintedEventFilter;

    "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;

    "Transfer(address,address,uint256)"(
      from?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null,
      amount?: null
    ): TransferEventFilter;
    Transfer(
      from?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null,
      amount?: null
    ): TransferEventFilter;

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

    "WithdrawalsEnabled()"(): WithdrawalsEnabledEventFilter;
    WithdrawalsEnabled(): WithdrawalsEnabledEventFilter;
  };

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

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

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

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

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

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

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

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

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

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

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

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

    allowance(
      _owner: PromiseOrValue<string>,
      _spender: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    burnPosition(
      _position: IStrategy.PositionStruct,
      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(
      _positions: IStrategy.PositionStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

    getPositionToBurn(
      _position: IStrategy.PositionStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    permit(
      owner: PromiseOrValue<string>,
      spender: PromiseOrValue<string>,
      value: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      v: PromiseOrValue<BigNumberish>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    withdrawalData(overrides?: CallOverrides): Promise<BigNumber>;
  };

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

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

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

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

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

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

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

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

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

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

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

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

    allowance(
      _owner: PromiseOrValue<string>,
      _spender: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    burnPosition(
      _position: IStrategy.PositionStruct,
      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(
      _positions: IStrategy.PositionStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

    getPositionToBurn(
      _position: IStrategy.PositionStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

    permit(
      owner: PromiseOrValue<string>,
      spender: PromiseOrValue<string>,
      value: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      v: PromiseOrValue<BigNumberish>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    withdrawalData(overrides?: CallOverrides): Promise<PopulatedTransaction>;
  };
}