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

export declare namespace ApeCoinStaking {
  export type PairNftStruct = {
    mainTokenId: PromiseOrValue<BigNumberish>;
    bakcTokenId: PromiseOrValue<BigNumberish>;
  };

  export type PairNftStructOutput = [BigNumber, BigNumber] & {
    mainTokenId: BigNumber;
    bakcTokenId: BigNumber;
  };

  export type PairNftDepositWithAmountStruct = {
    mainTokenId: PromiseOrValue<BigNumberish>;
    bakcTokenId: PromiseOrValue<BigNumberish>;
    amount: PromiseOrValue<BigNumberish>;
  };

  export type PairNftDepositWithAmountStructOutput = [
    number,
    number,
    BigNumber
  ] & { mainTokenId: number; bakcTokenId: number; amount: BigNumber };

  export type SingleNftStruct = {
    tokenId: PromiseOrValue<BigNumberish>;
    amount: PromiseOrValue<BigNumberish>;
  };

  export type SingleNftStructOutput = [number, BigNumber] & {
    tokenId: number;
    amount: BigNumber;
  };

  export type DashboardPairStruct = {
    mainTokenId: PromiseOrValue<BigNumberish>;
    mainTypePoolId: PromiseOrValue<BigNumberish>;
  };

  export type DashboardPairStructOutput = [BigNumber, BigNumber] & {
    mainTokenId: BigNumber;
    mainTypePoolId: BigNumber;
  };

  export type DashboardStakeStruct = {
    poolId: PromiseOrValue<BigNumberish>;
    tokenId: PromiseOrValue<BigNumberish>;
    deposited: PromiseOrValue<BigNumberish>;
    unclaimed: PromiseOrValue<BigNumberish>;
    rewards24hr: PromiseOrValue<BigNumberish>;
    pair: ApeCoinStaking.DashboardPairStruct;
  };

  export type DashboardStakeStructOutput = [
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    ApeCoinStaking.DashboardPairStructOutput
  ] & {
    poolId: BigNumber;
    tokenId: BigNumber;
    deposited: BigNumber;
    unclaimed: BigNumber;
    rewards24hr: BigNumber;
    pair: ApeCoinStaking.DashboardPairStructOutput;
  };

  export type TimeRangeStruct = {
    startTimestampHour: PromiseOrValue<BigNumberish>;
    endTimestampHour: PromiseOrValue<BigNumberish>;
    rewardsPerHour: PromiseOrValue<BigNumberish>;
    capPerPosition: PromiseOrValue<BigNumberish>;
  };

  export type TimeRangeStructOutput = [number, number, BigNumber, BigNumber] & {
    startTimestampHour: number;
    endTimestampHour: number;
    rewardsPerHour: BigNumber;
    capPerPosition: BigNumber;
  };

  export type PoolUIStruct = {
    poolId: PromiseOrValue<BigNumberish>;
    stakedAmount: PromiseOrValue<BigNumberish>;
    currentTimeRange: ApeCoinStaking.TimeRangeStruct;
  };

  export type PoolUIStructOutput = [
    BigNumber,
    BigNumber,
    ApeCoinStaking.TimeRangeStructOutput
  ] & {
    poolId: BigNumber;
    stakedAmount: BigNumber;
    currentTimeRange: ApeCoinStaking.TimeRangeStructOutput;
  };

  export type PairNftWithdrawWithAmountStruct = {
    mainTokenId: PromiseOrValue<BigNumberish>;
    bakcTokenId: PromiseOrValue<BigNumberish>;
    amount: PromiseOrValue<BigNumberish>;
    isUncommit: PromiseOrValue<boolean>;
  };

  export type PairNftWithdrawWithAmountStructOutput = [
    number,
    number,
    BigNumber,
    boolean
  ] & {
    mainTokenId: number;
    bakcTokenId: number;
    amount: BigNumber;
    isUncommit: boolean;
  };
}

export interface ApeCoinStakingInterface extends utils.Interface {
  functions: {
    "addTimeRange(uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
    "addressPosition(address)": FunctionFragment;
    "apeCoin()": FunctionFragment;
    "bakcToMain(uint256,uint256)": FunctionFragment;
    "claimApeCoin(address)": FunctionFragment;
    "claimBAKC((uint128,uint128)[],(uint128,uint128)[],address)": FunctionFragment;
    "claimBAYC(uint256[],address)": FunctionFragment;
    "claimMAYC(uint256[],address)": FunctionFragment;
    "claimSelfApeCoin()": FunctionFragment;
    "claimSelfBAKC((uint128,uint128)[],(uint128,uint128)[])": FunctionFragment;
    "claimSelfBAYC(uint256[])": FunctionFragment;
    "claimSelfMAYC(uint256[])": FunctionFragment;
    "depositApeCoin(uint256,address)": FunctionFragment;
    "depositBAKC((uint32,uint32,uint184)[],(uint32,uint32,uint184)[])": FunctionFragment;
    "depositBAYC((uint32,uint224)[])": FunctionFragment;
    "depositMAYC((uint32,uint224)[])": FunctionFragment;
    "depositSelfApeCoin(uint256)": FunctionFragment;
    "getAllStakes(address)": FunctionFragment;
    "getApeCoinStake(address)": FunctionFragment;
    "getBakcStakes(address)": FunctionFragment;
    "getBaycStakes(address)": FunctionFragment;
    "getMaycStakes(address)": FunctionFragment;
    "getPoolsUI()": FunctionFragment;
    "getSplitStakes(address)": FunctionFragment;
    "getTimeRangeBy(uint256,uint256)": FunctionFragment;
    "mainToBakc(uint256,uint256)": FunctionFragment;
    "nftContracts(uint256)": FunctionFragment;
    "nftPosition(uint256,uint256)": FunctionFragment;
    "owner()": FunctionFragment;
    "pendingRewards(uint256,address,uint256)": FunctionFragment;
    "pools(uint256)": FunctionFragment;
    "removeLastTimeRange(uint256)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "rewardsBy(uint256,uint256,uint256)": FunctionFragment;
    "stakedTotal(address)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "updatePool(uint256)": FunctionFragment;
    "withdrawApeCoin(uint256,address)": FunctionFragment;
    "withdrawBAKC((uint32,uint32,uint184,bool)[],(uint32,uint32,uint184,bool)[])": FunctionFragment;
    "withdrawBAYC((uint32,uint224)[],address)": FunctionFragment;
    "withdrawMAYC((uint32,uint224)[],address)": FunctionFragment;
    "withdrawSelfApeCoin(uint256)": FunctionFragment;
    "withdrawSelfBAYC((uint32,uint224)[])": FunctionFragment;
    "withdrawSelfMAYC((uint32,uint224)[])": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "addTimeRange"
      | "addressPosition"
      | "apeCoin"
      | "bakcToMain"
      | "claimApeCoin"
      | "claimBAKC"
      | "claimBAYC"
      | "claimMAYC"
      | "claimSelfApeCoin"
      | "claimSelfBAKC"
      | "claimSelfBAYC"
      | "claimSelfMAYC"
      | "depositApeCoin"
      | "depositBAKC"
      | "depositBAYC"
      | "depositMAYC"
      | "depositSelfApeCoin"
      | "getAllStakes"
      | "getApeCoinStake"
      | "getBakcStakes"
      | "getBaycStakes"
      | "getMaycStakes"
      | "getPoolsUI"
      | "getSplitStakes"
      | "getTimeRangeBy"
      | "mainToBakc"
      | "nftContracts"
      | "nftPosition"
      | "owner"
      | "pendingRewards"
      | "pools"
      | "removeLastTimeRange"
      | "renounceOwnership"
      | "rewardsBy"
      | "stakedTotal"
      | "transferOwnership"
      | "updatePool"
      | "withdrawApeCoin"
      | "withdrawBAKC"
      | "withdrawBAYC"
      | "withdrawMAYC"
      | "withdrawSelfApeCoin"
      | "withdrawSelfBAYC"
      | "withdrawSelfMAYC"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "addTimeRange",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "addressPosition",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(functionFragment: "apeCoin", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "bakcToMain",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "claimApeCoin",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "claimBAKC",
    values: [
      ApeCoinStaking.PairNftStruct[],
      ApeCoinStaking.PairNftStruct[],
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "claimBAYC",
    values: [PromiseOrValue<BigNumberish>[], PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "claimMAYC",
    values: [PromiseOrValue<BigNumberish>[], PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "claimSelfApeCoin",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "claimSelfBAKC",
    values: [ApeCoinStaking.PairNftStruct[], ApeCoinStaking.PairNftStruct[]]
  ): string;
  encodeFunctionData(
    functionFragment: "claimSelfBAYC",
    values: [PromiseOrValue<BigNumberish>[]]
  ): string;
  encodeFunctionData(
    functionFragment: "claimSelfMAYC",
    values: [PromiseOrValue<BigNumberish>[]]
  ): string;
  encodeFunctionData(
    functionFragment: "depositApeCoin",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "depositBAKC",
    values: [
      ApeCoinStaking.PairNftDepositWithAmountStruct[],
      ApeCoinStaking.PairNftDepositWithAmountStruct[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "depositBAYC",
    values: [ApeCoinStaking.SingleNftStruct[]]
  ): string;
  encodeFunctionData(
    functionFragment: "depositMAYC",
    values: [ApeCoinStaking.SingleNftStruct[]]
  ): string;
  encodeFunctionData(
    functionFragment: "depositSelfApeCoin",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "getAllStakes",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getApeCoinStake",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getBakcStakes",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getBaycStakes",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getMaycStakes",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getPoolsUI",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getSplitStakes",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getTimeRangeBy",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "mainToBakc",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "nftContracts",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "nftPosition",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "pendingRewards",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "pools",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "removeLastTimeRange",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "rewardsBy",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "stakedTotal",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "updatePool",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawApeCoin",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawBAKC",
    values: [
      ApeCoinStaking.PairNftWithdrawWithAmountStruct[],
      ApeCoinStaking.PairNftWithdrawWithAmountStruct[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawBAYC",
    values: [ApeCoinStaking.SingleNftStruct[], PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawMAYC",
    values: [ApeCoinStaking.SingleNftStruct[], PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawSelfApeCoin",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawSelfBAYC",
    values: [ApeCoinStaking.SingleNftStruct[]]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawSelfMAYC",
    values: [ApeCoinStaking.SingleNftStruct[]]
  ): string;

  decodeFunctionResult(
    functionFragment: "addTimeRange",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "addressPosition",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "apeCoin", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "bakcToMain", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "claimApeCoin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "claimBAKC", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "claimBAYC", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "claimMAYC", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "claimSelfApeCoin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimSelfBAKC",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimSelfBAYC",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimSelfMAYC",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "depositApeCoin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "depositBAKC",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "depositBAYC",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "depositMAYC",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "depositSelfApeCoin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getAllStakes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getApeCoinStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getBakcStakes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getBaycStakes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getMaycStakes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getPoolsUI", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getSplitStakes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTimeRangeBy",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "mainToBakc", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "nftContracts",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "nftPosition",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "pendingRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "pools", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "removeLastTimeRange",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "rewardsBy", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "stakedTotal",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "updatePool", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "withdrawApeCoin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawBAKC",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawBAYC",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawMAYC",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawSelfApeCoin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawSelfBAYC",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawSelfMAYC",
    data: BytesLike
  ): Result;

  events: {
    "ClaimRewards(address,uint256,address)": EventFragment;
    "ClaimRewardsNft(address,uint256,uint256,uint256)": EventFragment;
    "ClaimRewardsPairNft(address,uint256,uint256,uint256,uint256)": EventFragment;
    "Deposit(address,uint256,address)": EventFragment;
    "DepositNft(address,uint256,uint256,uint256)": EventFragment;
    "DepositPairNft(address,uint256,uint256,uint256,uint256)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "UpdatePool(uint256,uint256,uint256,uint256)": EventFragment;
    "Withdraw(address,uint256,address)": EventFragment;
    "WithdrawNft(address,uint256,uint256,address,uint256)": EventFragment;
    "WithdrawPairNft(address,uint256,uint256,uint256,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "ClaimRewards"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ClaimRewardsNft"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ClaimRewardsPairNft"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DepositNft"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DepositPairNft"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UpdatePool"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "WithdrawNft"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "WithdrawPairNft"): EventFragment;
}

export interface ClaimRewardsEventObject {
  user: string;
  amount: BigNumber;
  recipient: string;
}
export type ClaimRewardsEvent = TypedEvent<
  [string, BigNumber, string],
  ClaimRewardsEventObject
>;

export type ClaimRewardsEventFilter = TypedEventFilter<ClaimRewardsEvent>;

export interface ClaimRewardsNftEventObject {
  user: string;
  poolId: BigNumber;
  amount: BigNumber;
  tokenId: BigNumber;
}
export type ClaimRewardsNftEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber],
  ClaimRewardsNftEventObject
>;

export type ClaimRewardsNftEventFilter = TypedEventFilter<ClaimRewardsNftEvent>;

export interface ClaimRewardsPairNftEventObject {
  user: string;
  amount: BigNumber;
  mainTypePoolId: BigNumber;
  mainTokenId: BigNumber;
  bakcTokenId: BigNumber;
}
export type ClaimRewardsPairNftEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber, BigNumber],
  ClaimRewardsPairNftEventObject
>;

export type ClaimRewardsPairNftEventFilter =
  TypedEventFilter<ClaimRewardsPairNftEvent>;

export interface DepositEventObject {
  user: string;
  amount: BigNumber;
  recipient: string;
}
export type DepositEvent = TypedEvent<
  [string, BigNumber, string],
  DepositEventObject
>;

export type DepositEventFilter = TypedEventFilter<DepositEvent>;

export interface DepositNftEventObject {
  user: string;
  poolId: BigNumber;
  amount: BigNumber;
  tokenId: BigNumber;
}
export type DepositNftEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber],
  DepositNftEventObject
>;

export type DepositNftEventFilter = TypedEventFilter<DepositNftEvent>;

export interface DepositPairNftEventObject {
  user: string;
  amount: BigNumber;
  mainTypePoolId: BigNumber;
  mainTokenId: BigNumber;
  bakcTokenId: BigNumber;
}
export type DepositPairNftEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber, BigNumber],
  DepositPairNftEventObject
>;

export type DepositPairNftEventFilter = TypedEventFilter<DepositPairNftEvent>;

export interface OwnershipTransferredEventObject {
  previousOwner: string;
  newOwner: string;
}
export type OwnershipTransferredEvent = TypedEvent<
  [string, string],
  OwnershipTransferredEventObject
>;

export type OwnershipTransferredEventFilter =
  TypedEventFilter<OwnershipTransferredEvent>;

export interface UpdatePoolEventObject {
  poolId: BigNumber;
  lastRewardedBlock: BigNumber;
  stakedAmount: BigNumber;
  accumulatedRewardsPerShare: BigNumber;
}
export type UpdatePoolEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber, BigNumber],
  UpdatePoolEventObject
>;

export type UpdatePoolEventFilter = TypedEventFilter<UpdatePoolEvent>;

export interface WithdrawEventObject {
  user: string;
  amount: BigNumber;
  recipient: string;
}
export type WithdrawEvent = TypedEvent<
  [string, BigNumber, string],
  WithdrawEventObject
>;

export type WithdrawEventFilter = TypedEventFilter<WithdrawEvent>;

export interface WithdrawNftEventObject {
  user: string;
  poolId: BigNumber;
  amount: BigNumber;
  recipient: string;
  tokenId: BigNumber;
}
export type WithdrawNftEvent = TypedEvent<
  [string, BigNumber, BigNumber, string, BigNumber],
  WithdrawNftEventObject
>;

export type WithdrawNftEventFilter = TypedEventFilter<WithdrawNftEvent>;

export interface WithdrawPairNftEventObject {
  user: string;
  amount: BigNumber;
  mainTypePoolId: BigNumber;
  mainTokenId: BigNumber;
  bakcTokenId: BigNumber;
}
export type WithdrawPairNftEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber, BigNumber],
  WithdrawPairNftEventObject
>;

export type WithdrawPairNftEventFilter = TypedEventFilter<WithdrawPairNftEvent>;

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

  interface: ApeCoinStakingInterface;

  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: {
    addTimeRange(
      _poolId: PromiseOrValue<BigNumberish>,
      _amount: PromiseOrValue<BigNumberish>,
      _startTimestamp: PromiseOrValue<BigNumberish>,
      _endTimeStamp: PromiseOrValue<BigNumberish>,
      _capPerPosition: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    addressPosition(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        stakedAmount: BigNumber;
        rewardsDebt: BigNumber;
      }
    >;

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

    bakcToMain(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, boolean] & { tokenId: BigNumber; isPaired: boolean }
    >;

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

    claimBAKC(
      _baycPairs: ApeCoinStaking.PairNftStruct[],
      _maycPairs: ApeCoinStaking.PairNftStruct[],
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    claimBAYC(
      _nfts: PromiseOrValue<BigNumberish>[],
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    claimMAYC(
      _nfts: PromiseOrValue<BigNumberish>[],
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

    claimSelfBAKC(
      _baycPairs: ApeCoinStaking.PairNftStruct[],
      _maycPairs: ApeCoinStaking.PairNftStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    claimSelfBAYC(
      _nfts: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    claimSelfMAYC(
      _nfts: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    depositApeCoin(
      _amount: PromiseOrValue<BigNumberish>,
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    depositBAKC(
      _baycPairs: ApeCoinStaking.PairNftDepositWithAmountStruct[],
      _maycPairs: ApeCoinStaking.PairNftDepositWithAmountStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    depositBAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    depositMAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

    getAllStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[ApeCoinStaking.DashboardStakeStructOutput[]]>;

    getApeCoinStake(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[ApeCoinStaking.DashboardStakeStructOutput]>;

    getBakcStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[ApeCoinStaking.DashboardStakeStructOutput[]]>;

    getBaycStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[ApeCoinStaking.DashboardStakeStructOutput[]]>;

    getMaycStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[ApeCoinStaking.DashboardStakeStructOutput[]]>;

    getPoolsUI(
      overrides?: CallOverrides
    ): Promise<
      [
        ApeCoinStaking.PoolUIStructOutput,
        ApeCoinStaking.PoolUIStructOutput,
        ApeCoinStaking.PoolUIStructOutput,
        ApeCoinStaking.PoolUIStructOutput
      ]
    >;

    getSplitStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[ApeCoinStaking.DashboardStakeStructOutput[]]>;

    getTimeRangeBy(
      _poolId: PromiseOrValue<BigNumberish>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[ApeCoinStaking.TimeRangeStructOutput]>;

    mainToBakc(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, boolean] & { tokenId: BigNumber; isPaired: boolean }
    >;

    nftContracts(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string]>;

    nftPosition(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        stakedAmount: BigNumber;
        rewardsDebt: BigNumber;
      }
    >;

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

    pendingRewards(
      _poolId: PromiseOrValue<BigNumberish>,
      _address: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    pools(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [number, number, BigNumber, BigNumber] & {
        lastRewardedTimestampHour: number;
        lastRewardsRangeIndex: number;
        stakedAmount: BigNumber;
        accumulatedRewardsPerShare: BigNumber;
      }
    >;

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

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

    rewardsBy(
      _poolId: PromiseOrValue<BigNumberish>,
      _from: PromiseOrValue<BigNumberish>,
      _to: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber]>;

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

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

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

    withdrawApeCoin(
      _amount: PromiseOrValue<BigNumberish>,
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    withdrawBAKC(
      _baycPairs: ApeCoinStaking.PairNftWithdrawWithAmountStruct[],
      _maycPairs: ApeCoinStaking.PairNftWithdrawWithAmountStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    withdrawBAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    withdrawMAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

    withdrawSelfBAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    withdrawSelfMAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;
  };

  addTimeRange(
    _poolId: PromiseOrValue<BigNumberish>,
    _amount: PromiseOrValue<BigNumberish>,
    _startTimestamp: PromiseOrValue<BigNumberish>,
    _endTimeStamp: PromiseOrValue<BigNumberish>,
    _capPerPosition: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  addressPosition(
    arg0: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & { stakedAmount: BigNumber; rewardsDebt: BigNumber }
  >;

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

  bakcToMain(
    arg0: PromiseOrValue<BigNumberish>,
    arg1: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<[BigNumber, boolean] & { tokenId: BigNumber; isPaired: boolean }>;

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

  claimBAKC(
    _baycPairs: ApeCoinStaking.PairNftStruct[],
    _maycPairs: ApeCoinStaking.PairNftStruct[],
    _recipient: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  claimBAYC(
    _nfts: PromiseOrValue<BigNumberish>[],
    _recipient: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  claimMAYC(
    _nfts: PromiseOrValue<BigNumberish>[],
    _recipient: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

  claimSelfBAKC(
    _baycPairs: ApeCoinStaking.PairNftStruct[],
    _maycPairs: ApeCoinStaking.PairNftStruct[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  claimSelfBAYC(
    _nfts: PromiseOrValue<BigNumberish>[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  claimSelfMAYC(
    _nfts: PromiseOrValue<BigNumberish>[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  depositApeCoin(
    _amount: PromiseOrValue<BigNumberish>,
    _recipient: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  depositBAKC(
    _baycPairs: ApeCoinStaking.PairNftDepositWithAmountStruct[],
    _maycPairs: ApeCoinStaking.PairNftDepositWithAmountStruct[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  depositBAYC(
    _nfts: ApeCoinStaking.SingleNftStruct[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  depositMAYC(
    _nfts: ApeCoinStaking.SingleNftStruct[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

  getAllStakes(
    _address: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<ApeCoinStaking.DashboardStakeStructOutput[]>;

  getApeCoinStake(
    _address: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<ApeCoinStaking.DashboardStakeStructOutput>;

  getBakcStakes(
    _address: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<ApeCoinStaking.DashboardStakeStructOutput[]>;

  getBaycStakes(
    _address: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<ApeCoinStaking.DashboardStakeStructOutput[]>;

  getMaycStakes(
    _address: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<ApeCoinStaking.DashboardStakeStructOutput[]>;

  getPoolsUI(
    overrides?: CallOverrides
  ): Promise<
    [
      ApeCoinStaking.PoolUIStructOutput,
      ApeCoinStaking.PoolUIStructOutput,
      ApeCoinStaking.PoolUIStructOutput,
      ApeCoinStaking.PoolUIStructOutput
    ]
  >;

  getSplitStakes(
    _address: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<ApeCoinStaking.DashboardStakeStructOutput[]>;

  getTimeRangeBy(
    _poolId: PromiseOrValue<BigNumberish>,
    _index: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<ApeCoinStaking.TimeRangeStructOutput>;

  mainToBakc(
    arg0: PromiseOrValue<BigNumberish>,
    arg1: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<[BigNumber, boolean] & { tokenId: BigNumber; isPaired: boolean }>;

  nftContracts(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string>;

  nftPosition(
    arg0: PromiseOrValue<BigNumberish>,
    arg1: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & { stakedAmount: BigNumber; rewardsDebt: BigNumber }
  >;

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

  pendingRewards(
    _poolId: PromiseOrValue<BigNumberish>,
    _address: PromiseOrValue<string>,
    _tokenId: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  pools(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<
    [number, number, BigNumber, BigNumber] & {
      lastRewardedTimestampHour: number;
      lastRewardsRangeIndex: number;
      stakedAmount: BigNumber;
      accumulatedRewardsPerShare: BigNumber;
    }
  >;

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

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

  rewardsBy(
    _poolId: PromiseOrValue<BigNumberish>,
    _from: PromiseOrValue<BigNumberish>,
    _to: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber]>;

  stakedTotal(
    _address: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

  withdrawApeCoin(
    _amount: PromiseOrValue<BigNumberish>,
    _recipient: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  withdrawBAKC(
    _baycPairs: ApeCoinStaking.PairNftWithdrawWithAmountStruct[],
    _maycPairs: ApeCoinStaking.PairNftWithdrawWithAmountStruct[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  withdrawBAYC(
    _nfts: ApeCoinStaking.SingleNftStruct[],
    _recipient: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  withdrawMAYC(
    _nfts: ApeCoinStaking.SingleNftStruct[],
    _recipient: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

  withdrawSelfBAYC(
    _nfts: ApeCoinStaking.SingleNftStruct[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  withdrawSelfMAYC(
    _nfts: ApeCoinStaking.SingleNftStruct[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  callStatic: {
    addTimeRange(
      _poolId: PromiseOrValue<BigNumberish>,
      _amount: PromiseOrValue<BigNumberish>,
      _startTimestamp: PromiseOrValue<BigNumberish>,
      _endTimeStamp: PromiseOrValue<BigNumberish>,
      _capPerPosition: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    addressPosition(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        stakedAmount: BigNumber;
        rewardsDebt: BigNumber;
      }
    >;

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

    bakcToMain(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, boolean] & { tokenId: BigNumber; isPaired: boolean }
    >;

    claimApeCoin(
      _recipient: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    claimBAKC(
      _baycPairs: ApeCoinStaking.PairNftStruct[],
      _maycPairs: ApeCoinStaking.PairNftStruct[],
      _recipient: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    claimBAYC(
      _nfts: PromiseOrValue<BigNumberish>[],
      _recipient: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    claimMAYC(
      _nfts: PromiseOrValue<BigNumberish>[],
      _recipient: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

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

    claimSelfBAKC(
      _baycPairs: ApeCoinStaking.PairNftStruct[],
      _maycPairs: ApeCoinStaking.PairNftStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

    claimSelfBAYC(
      _nfts: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<void>;

    claimSelfMAYC(
      _nfts: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<void>;

    depositApeCoin(
      _amount: PromiseOrValue<BigNumberish>,
      _recipient: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    depositBAKC(
      _baycPairs: ApeCoinStaking.PairNftDepositWithAmountStruct[],
      _maycPairs: ApeCoinStaking.PairNftDepositWithAmountStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

    depositBAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

    depositMAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

    depositSelfApeCoin(
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    getAllStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<ApeCoinStaking.DashboardStakeStructOutput[]>;

    getApeCoinStake(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<ApeCoinStaking.DashboardStakeStructOutput>;

    getBakcStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<ApeCoinStaking.DashboardStakeStructOutput[]>;

    getBaycStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<ApeCoinStaking.DashboardStakeStructOutput[]>;

    getMaycStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<ApeCoinStaking.DashboardStakeStructOutput[]>;

    getPoolsUI(
      overrides?: CallOverrides
    ): Promise<
      [
        ApeCoinStaking.PoolUIStructOutput,
        ApeCoinStaking.PoolUIStructOutput,
        ApeCoinStaking.PoolUIStructOutput,
        ApeCoinStaking.PoolUIStructOutput
      ]
    >;

    getSplitStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<ApeCoinStaking.DashboardStakeStructOutput[]>;

    getTimeRangeBy(
      _poolId: PromiseOrValue<BigNumberish>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<ApeCoinStaking.TimeRangeStructOutput>;

    mainToBakc(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, boolean] & { tokenId: BigNumber; isPaired: boolean }
    >;

    nftContracts(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

    nftPosition(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        stakedAmount: BigNumber;
        rewardsDebt: BigNumber;
      }
    >;

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

    pendingRewards(
      _poolId: PromiseOrValue<BigNumberish>,
      _address: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    pools(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [number, number, BigNumber, BigNumber] & {
        lastRewardedTimestampHour: number;
        lastRewardsRangeIndex: number;
        stakedAmount: BigNumber;
        accumulatedRewardsPerShare: BigNumber;
      }
    >;

    removeLastTimeRange(
      _poolId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

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

    rewardsBy(
      _poolId: PromiseOrValue<BigNumberish>,
      _from: PromiseOrValue<BigNumberish>,
      _to: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber]>;

    stakedTotal(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    updatePool(
      _poolId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawApeCoin(
      _amount: PromiseOrValue<BigNumberish>,
      _recipient: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawBAKC(
      _baycPairs: ApeCoinStaking.PairNftWithdrawWithAmountStruct[],
      _maycPairs: ApeCoinStaking.PairNftWithdrawWithAmountStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawBAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      _recipient: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawMAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      _recipient: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawSelfApeCoin(
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawSelfBAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawSelfMAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "ClaimRewards(address,uint256,address)"(
      user?: PromiseOrValue<string> | null,
      amount?: null,
      recipient?: null
    ): ClaimRewardsEventFilter;
    ClaimRewards(
      user?: PromiseOrValue<string> | null,
      amount?: null,
      recipient?: null
    ): ClaimRewardsEventFilter;

    "ClaimRewardsNft(address,uint256,uint256,uint256)"(
      user?: PromiseOrValue<string> | null,
      poolId?: PromiseOrValue<BigNumberish> | null,
      amount?: null,
      tokenId?: null
    ): ClaimRewardsNftEventFilter;
    ClaimRewardsNft(
      user?: PromiseOrValue<string> | null,
      poolId?: PromiseOrValue<BigNumberish> | null,
      amount?: null,
      tokenId?: null
    ): ClaimRewardsNftEventFilter;

    "ClaimRewardsPairNft(address,uint256,uint256,uint256,uint256)"(
      user?: PromiseOrValue<string> | null,
      amount?: null,
      mainTypePoolId?: null,
      mainTokenId?: null,
      bakcTokenId?: null
    ): ClaimRewardsPairNftEventFilter;
    ClaimRewardsPairNft(
      user?: PromiseOrValue<string> | null,
      amount?: null,
      mainTypePoolId?: null,
      mainTokenId?: null,
      bakcTokenId?: null
    ): ClaimRewardsPairNftEventFilter;

    "Deposit(address,uint256,address)"(
      user?: PromiseOrValue<string> | null,
      amount?: null,
      recipient?: null
    ): DepositEventFilter;
    Deposit(
      user?: PromiseOrValue<string> | null,
      amount?: null,
      recipient?: null
    ): DepositEventFilter;

    "DepositNft(address,uint256,uint256,uint256)"(
      user?: PromiseOrValue<string> | null,
      poolId?: PromiseOrValue<BigNumberish> | null,
      amount?: null,
      tokenId?: null
    ): DepositNftEventFilter;
    DepositNft(
      user?: PromiseOrValue<string> | null,
      poolId?: PromiseOrValue<BigNumberish> | null,
      amount?: null,
      tokenId?: null
    ): DepositNftEventFilter;

    "DepositPairNft(address,uint256,uint256,uint256,uint256)"(
      user?: PromiseOrValue<string> | null,
      amount?: null,
      mainTypePoolId?: null,
      mainTokenId?: null,
      bakcTokenId?: null
    ): DepositPairNftEventFilter;
    DepositPairNft(
      user?: PromiseOrValue<string> | null,
      amount?: null,
      mainTypePoolId?: null,
      mainTokenId?: null,
      bakcTokenId?: null
    ): DepositPairNftEventFilter;

    "OwnershipTransferred(address,address)"(
      previousOwner?: PromiseOrValue<string> | null,
      newOwner?: PromiseOrValue<string> | null
    ): OwnershipTransferredEventFilter;
    OwnershipTransferred(
      previousOwner?: PromiseOrValue<string> | null,
      newOwner?: PromiseOrValue<string> | null
    ): OwnershipTransferredEventFilter;

    "UpdatePool(uint256,uint256,uint256,uint256)"(
      poolId?: PromiseOrValue<BigNumberish> | null,
      lastRewardedBlock?: null,
      stakedAmount?: null,
      accumulatedRewardsPerShare?: null
    ): UpdatePoolEventFilter;
    UpdatePool(
      poolId?: PromiseOrValue<BigNumberish> | null,
      lastRewardedBlock?: null,
      stakedAmount?: null,
      accumulatedRewardsPerShare?: null
    ): UpdatePoolEventFilter;

    "Withdraw(address,uint256,address)"(
      user?: PromiseOrValue<string> | null,
      amount?: null,
      recipient?: null
    ): WithdrawEventFilter;
    Withdraw(
      user?: PromiseOrValue<string> | null,
      amount?: null,
      recipient?: null
    ): WithdrawEventFilter;

    "WithdrawNft(address,uint256,uint256,address,uint256)"(
      user?: PromiseOrValue<string> | null,
      poolId?: PromiseOrValue<BigNumberish> | null,
      amount?: null,
      recipient?: null,
      tokenId?: null
    ): WithdrawNftEventFilter;
    WithdrawNft(
      user?: PromiseOrValue<string> | null,
      poolId?: PromiseOrValue<BigNumberish> | null,
      amount?: null,
      recipient?: null,
      tokenId?: null
    ): WithdrawNftEventFilter;

    "WithdrawPairNft(address,uint256,uint256,uint256,uint256)"(
      user?: PromiseOrValue<string> | null,
      amount?: null,
      mainTypePoolId?: null,
      mainTokenId?: null,
      bakcTokenId?: null
    ): WithdrawPairNftEventFilter;
    WithdrawPairNft(
      user?: PromiseOrValue<string> | null,
      amount?: null,
      mainTypePoolId?: null,
      mainTokenId?: null,
      bakcTokenId?: null
    ): WithdrawPairNftEventFilter;
  };

  estimateGas: {
    addTimeRange(
      _poolId: PromiseOrValue<BigNumberish>,
      _amount: PromiseOrValue<BigNumberish>,
      _startTimestamp: PromiseOrValue<BigNumberish>,
      _endTimeStamp: PromiseOrValue<BigNumberish>,
      _capPerPosition: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    addressPosition(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    bakcToMain(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    claimBAKC(
      _baycPairs: ApeCoinStaking.PairNftStruct[],
      _maycPairs: ApeCoinStaking.PairNftStruct[],
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    claimBAYC(
      _nfts: PromiseOrValue<BigNumberish>[],
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    claimMAYC(
      _nfts: PromiseOrValue<BigNumberish>[],
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

    claimSelfBAKC(
      _baycPairs: ApeCoinStaking.PairNftStruct[],
      _maycPairs: ApeCoinStaking.PairNftStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    claimSelfBAYC(
      _nfts: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    claimSelfMAYC(
      _nfts: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    depositApeCoin(
      _amount: PromiseOrValue<BigNumberish>,
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    depositBAKC(
      _baycPairs: ApeCoinStaking.PairNftDepositWithAmountStruct[],
      _maycPairs: ApeCoinStaking.PairNftDepositWithAmountStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    depositBAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    depositMAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

    getAllStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getApeCoinStake(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getBakcStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getBaycStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getMaycStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getSplitStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    mainToBakc(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    nftPosition(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    pendingRewards(
      _poolId: PromiseOrValue<BigNumberish>,
      _address: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    rewardsBy(
      _poolId: PromiseOrValue<BigNumberish>,
      _from: PromiseOrValue<BigNumberish>,
      _to: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    stakedTotal(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    withdrawApeCoin(
      _amount: PromiseOrValue<BigNumberish>,
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    withdrawBAKC(
      _baycPairs: ApeCoinStaking.PairNftWithdrawWithAmountStruct[],
      _maycPairs: ApeCoinStaking.PairNftWithdrawWithAmountStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    withdrawBAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    withdrawMAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

    withdrawSelfBAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    withdrawSelfMAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    addTimeRange(
      _poolId: PromiseOrValue<BigNumberish>,
      _amount: PromiseOrValue<BigNumberish>,
      _startTimestamp: PromiseOrValue<BigNumberish>,
      _endTimeStamp: PromiseOrValue<BigNumberish>,
      _capPerPosition: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    addressPosition(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    bakcToMain(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    claimBAKC(
      _baycPairs: ApeCoinStaking.PairNftStruct[],
      _maycPairs: ApeCoinStaking.PairNftStruct[],
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    claimBAYC(
      _nfts: PromiseOrValue<BigNumberish>[],
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    claimMAYC(
      _nfts: PromiseOrValue<BigNumberish>[],
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

    claimSelfBAKC(
      _baycPairs: ApeCoinStaking.PairNftStruct[],
      _maycPairs: ApeCoinStaking.PairNftStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    claimSelfBAYC(
      _nfts: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    claimSelfMAYC(
      _nfts: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    depositApeCoin(
      _amount: PromiseOrValue<BigNumberish>,
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    depositBAKC(
      _baycPairs: ApeCoinStaking.PairNftDepositWithAmountStruct[],
      _maycPairs: ApeCoinStaking.PairNftDepositWithAmountStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    depositBAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    depositMAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

    getAllStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getApeCoinStake(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getBakcStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getBaycStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getMaycStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    getSplitStakes(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    mainToBakc(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    nftPosition(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    pendingRewards(
      _poolId: PromiseOrValue<BigNumberish>,
      _address: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    rewardsBy(
      _poolId: PromiseOrValue<BigNumberish>,
      _from: PromiseOrValue<BigNumberish>,
      _to: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    stakedTotal(
      _address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    withdrawApeCoin(
      _amount: PromiseOrValue<BigNumberish>,
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    withdrawBAKC(
      _baycPairs: ApeCoinStaking.PairNftWithdrawWithAmountStruct[],
      _maycPairs: ApeCoinStaking.PairNftWithdrawWithAmountStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    withdrawBAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    withdrawMAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      _recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

    withdrawSelfBAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    withdrawSelfMAYC(
      _nfts: ApeCoinStaking.SingleNftStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;
  };
}