/* Autogenerated file. Do not edit manually. */
/* 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 "../../types/common";

export declare namespace IP2PPairStaking {
  export type ListingOrderStruct = {
    stakingType: PromiseOrValue<BigNumberish>;
    offerer: PromiseOrValue<string>;
    token: PromiseOrValue<string>;
    tokenId: PromiseOrValue<BigNumberish>;
    share: PromiseOrValue<BigNumberish>;
    startTime: PromiseOrValue<BigNumberish>;
    endTime: PromiseOrValue<BigNumberish>;
    v: PromiseOrValue<BigNumberish>;
    r: PromiseOrValue<BytesLike>;
    s: PromiseOrValue<BytesLike>;
  };

  export type ListingOrderStructOutput = [
    number,
    string,
    string,
    number,
    number,
    BigNumber,
    BigNumber,
    number,
    string,
    string
  ] & {
    stakingType: number;
    offerer: string;
    token: string;
    tokenId: number;
    share: number;
    startTime: BigNumber;
    endTime: BigNumber;
    v: number;
    r: string;
    s: string;
  };

  export type MatchedOrderStruct = {
    stakingType: PromiseOrValue<BigNumberish>;
    apeToken: PromiseOrValue<string>;
    apeTokenId: PromiseOrValue<BigNumberish>;
    apeShare: PromiseOrValue<BigNumberish>;
    bakcTokenId: PromiseOrValue<BigNumberish>;
    bakcShare: PromiseOrValue<BigNumberish>;
    apeCoinOfferer: PromiseOrValue<string>;
    apeCoinShare: PromiseOrValue<BigNumberish>;
    apePrincipleAmount: PromiseOrValue<BigNumberish>;
    apeCoinListingOrderHash: PromiseOrValue<BytesLike>;
  };

  export type MatchedOrderStructOutput = [
    number,
    string,
    number,
    number,
    number,
    number,
    string,
    number,
    BigNumber,
    string
  ] & {
    stakingType: number;
    apeToken: string;
    apeTokenId: number;
    apeShare: number;
    bakcTokenId: number;
    bakcShare: number;
    apeCoinOfferer: string;
    apeCoinShare: number;
    apePrincipleAmount: BigNumber;
    apeCoinListingOrderHash: string;
  };
}

export interface P2PPairStakingInterface extends utils.Interface {
  functions: {
    "breakUpMatchedOrder(bytes32)": FunctionFragment;
    "cancelListing((uint8,address,address,uint32,uint32,uint256,uint256,uint8,bytes32,bytes32))": FunctionFragment;
    "claimCApeReward(address)": FunctionFragment;
    "claimCompoundFee(address)": FunctionFragment;
    "claimForMatchedOrderAndCompound(bytes32[])": FunctionFragment;
    "compoundFee()": FunctionFragment;
    "getApeCoinStakingCap(uint8)": FunctionFragment;
    "getListingOrderHash((uint8,address,address,uint32,uint32,uint256,uint256,uint8,bytes32,bytes32))": FunctionFragment;
    "getMatchedOrderHash((uint8,address,uint32,uint32,uint32,uint32,address,uint32,uint256,bytes32))": FunctionFragment;
    "initialize()": FunctionFragment;
    "listingOrderStatus(bytes32)": FunctionFragment;
    "matchBAKCPairStakingList((uint8,address,address,uint32,uint32,uint256,uint256,uint8,bytes32,bytes32),(uint8,address,address,uint32,uint32,uint256,uint256,uint8,bytes32,bytes32),(uint8,address,address,uint32,uint32,uint256,uint256,uint8,bytes32,bytes32))": FunctionFragment;
    "matchPairStakingList((uint8,address,address,uint32,uint32,uint256,uint256,uint8,bytes32,bytes32),(uint8,address,address,uint32,uint32,uint256,uint256,uint8,bytes32,bytes32))": FunctionFragment;
    "matchedOrders(bytes32)": FunctionFragment;
    "matchingOperator()": FunctionFragment;
    "onERC721Received(address,address,uint256,bytes)": FunctionFragment;
    "owner()": FunctionFragment;
    "pendingCApeReward(address)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "rescueERC20(address,address,uint256)": FunctionFragment;
    "setCompoundFee(uint256)": FunctionFragment;
    "setMatchingOperator(address)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "updateApeCoinStakingCap()": FunctionFragment;
    "validateOrderSignature(address,bytes32,uint8,bytes32,bytes32)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "breakUpMatchedOrder"
      | "cancelListing"
      | "claimCApeReward"
      | "claimCompoundFee"
      | "claimForMatchedOrderAndCompound"
      | "compoundFee"
      | "getApeCoinStakingCap"
      | "getListingOrderHash"
      | "getMatchedOrderHash"
      | "initialize"
      | "listingOrderStatus"
      | "matchBAKCPairStakingList"
      | "matchPairStakingList"
      | "matchedOrders"
      | "matchingOperator"
      | "onERC721Received"
      | "owner"
      | "pendingCApeReward"
      | "renounceOwnership"
      | "rescueERC20"
      | "setCompoundFee"
      | "setMatchingOperator"
      | "transferOwnership"
      | "updateApeCoinStakingCap"
      | "validateOrderSignature"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "breakUpMatchedOrder",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "cancelListing",
    values: [IP2PPairStaking.ListingOrderStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "claimCApeReward",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "claimCompoundFee",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "claimForMatchedOrderAndCompound",
    values: [PromiseOrValue<BytesLike>[]]
  ): string;
  encodeFunctionData(
    functionFragment: "compoundFee",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getApeCoinStakingCap",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "getListingOrderHash",
    values: [IP2PPairStaking.ListingOrderStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "getMatchedOrderHash",
    values: [IP2PPairStaking.MatchedOrderStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "listingOrderStatus",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "matchBAKCPairStakingList",
    values: [
      IP2PPairStaking.ListingOrderStruct,
      IP2PPairStaking.ListingOrderStruct,
      IP2PPairStaking.ListingOrderStruct
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "matchPairStakingList",
    values: [
      IP2PPairStaking.ListingOrderStruct,
      IP2PPairStaking.ListingOrderStruct
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "matchedOrders",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "matchingOperator",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "onERC721Received",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "pendingCApeReward",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "rescueERC20",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "setCompoundFee",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setMatchingOperator",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "updateApeCoinStakingCap",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "validateOrderSignature",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BytesLike>
    ]
  ): string;

  decodeFunctionResult(
    functionFragment: "breakUpMatchedOrder",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "cancelListing",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimCApeReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimCompoundFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimForMatchedOrderAndCompound",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "compoundFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getApeCoinStakingCap",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getListingOrderHash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getMatchedOrderHash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "listingOrderStatus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "matchBAKCPairStakingList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "matchPairStakingList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "matchedOrders",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "matchingOperator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "onERC721Received",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "pendingCApeReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "rescueERC20",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setCompoundFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMatchingOperator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateApeCoinStakingCap",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "validateOrderSignature",
    data: BytesLike
  ): Result;

  events: {
    "CApeClaimed(address,address,uint256)": EventFragment;
    "CompoundFeeUpdated(uint256,uint256)": EventFragment;
    "Initialized(uint8)": EventFragment;
    "MatchingOperatorUpdated(address,address)": EventFragment;
    "OrderCancelled(bytes32,address)": EventFragment;
    "OrderClaimedAndCompounded(bytes32,uint256)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "PairStakingBreakUp(bytes32)": EventFragment;
    "PairStakingMatched(bytes32)": EventFragment;
    "RescueERC20(address,address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "CApeClaimed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "CompoundFeeUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MatchingOperatorUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OrderCancelled"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OrderClaimedAndCompounded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PairStakingBreakUp"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PairStakingMatched"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RescueERC20"): EventFragment;
}

export interface CApeClaimedEventObject {
  user: string;
  receiver: string;
  amount: BigNumber;
}
export type CApeClaimedEvent = TypedEvent<
  [string, string, BigNumber],
  CApeClaimedEventObject
>;

export type CApeClaimedEventFilter = TypedEventFilter<CApeClaimedEvent>;

export interface CompoundFeeUpdatedEventObject {
  oldFee: BigNumber;
  newFee: BigNumber;
}
export type CompoundFeeUpdatedEvent = TypedEvent<
  [BigNumber, BigNumber],
  CompoundFeeUpdatedEventObject
>;

export type CompoundFeeUpdatedEventFilter =
  TypedEventFilter<CompoundFeeUpdatedEvent>;

export interface InitializedEventObject {
  version: number;
}
export type InitializedEvent = TypedEvent<[number], InitializedEventObject>;

export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;

export interface MatchingOperatorUpdatedEventObject {
  oldOperator: string;
  newOperator: string;
}
export type MatchingOperatorUpdatedEvent = TypedEvent<
  [string, string],
  MatchingOperatorUpdatedEventObject
>;

export type MatchingOperatorUpdatedEventFilter =
  TypedEventFilter<MatchingOperatorUpdatedEvent>;

export interface OrderCancelledEventObject {
  orderHash: string;
  offerer: string;
}
export type OrderCancelledEvent = TypedEvent<
  [string, string],
  OrderCancelledEventObject
>;

export type OrderCancelledEventFilter = TypedEventFilter<OrderCancelledEvent>;

export interface OrderClaimedAndCompoundedEventObject {
  orderHash: string;
  totalReward: BigNumber;
}
export type OrderClaimedAndCompoundedEvent = TypedEvent<
  [string, BigNumber],
  OrderClaimedAndCompoundedEventObject
>;

export type OrderClaimedAndCompoundedEventFilter =
  TypedEventFilter<OrderClaimedAndCompoundedEvent>;

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

export type OwnershipTransferredEventFilter =
  TypedEventFilter<OwnershipTransferredEvent>;

export interface PairStakingBreakUpEventObject {
  orderHash: string;
}
export type PairStakingBreakUpEvent = TypedEvent<
  [string],
  PairStakingBreakUpEventObject
>;

export type PairStakingBreakUpEventFilter =
  TypedEventFilter<PairStakingBreakUpEvent>;

export interface PairStakingMatchedEventObject {
  orderHash: string;
}
export type PairStakingMatchedEvent = TypedEvent<
  [string],
  PairStakingMatchedEventObject
>;

export type PairStakingMatchedEventFilter =
  TypedEventFilter<PairStakingMatchedEvent>;

export interface RescueERC20EventObject {
  token: string;
  to: string;
  amount: BigNumber;
}
export type RescueERC20Event = TypedEvent<
  [string, string, BigNumber],
  RescueERC20EventObject
>;

export type RescueERC20EventFilter = TypedEventFilter<RescueERC20Event>;

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

  interface: P2PPairStakingInterface;

  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: {
    breakUpMatchedOrder(
      orderHash: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    cancelListing(
      listingOrder: IP2PPairStaking.ListingOrderStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

    claimForMatchedOrderAndCompound(
      orderHashes: PromiseOrValue<BytesLike>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

    getApeCoinStakingCap(
      stakingType: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getListingOrderHash(
      order: IP2PPairStaking.ListingOrderStruct,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getMatchedOrderHash(
      order: IP2PPairStaking.MatchedOrderStruct,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

    listingOrderStatus(
      arg0: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<[number]>;

    matchBAKCPairStakingList(
      apeOrder: IP2PPairStaking.ListingOrderStruct,
      bakcOrder: IP2PPairStaking.ListingOrderStruct,
      apeCoinOrder: IP2PPairStaking.ListingOrderStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    matchPairStakingList(
      apeOrder: IP2PPairStaking.ListingOrderStruct,
      apeCoinOrder: IP2PPairStaking.ListingOrderStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    matchedOrders(
      arg0: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<
      [
        number,
        string,
        number,
        number,
        number,
        number,
        string,
        number,
        BigNumber,
        string
      ] & {
      stakingType: number;
      apeToken: string;
      apeTokenId: number;
      apeShare: number;
      bakcTokenId: number;
      bakcShare: number;
      apeCoinOfferer: string;
      apeCoinShare: number;
      apePrincipleAmount: BigNumber;
      apeCoinListingOrderHash: string;
    }
    >;

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

    onERC721Received(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      arg2: PromiseOrValue<BigNumberish>,
      arg3: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

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

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

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

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

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

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

    validateOrderSignature(
      signer: PromiseOrValue<string>,
      orderHash: PromiseOrValue<BytesLike>,
      v: PromiseOrValue<BigNumberish>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;
  };

  breakUpMatchedOrder(
    orderHash: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  cancelListing(
    listingOrder: IP2PPairStaking.ListingOrderStruct,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

  claimForMatchedOrderAndCompound(
    orderHashes: PromiseOrValue<BytesLike>[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

  getApeCoinStakingCap(
    stakingType: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getListingOrderHash(
    order: IP2PPairStaking.ListingOrderStruct,
    overrides?: CallOverrides
  ): Promise<string>;

  getMatchedOrderHash(
    order: IP2PPairStaking.MatchedOrderStruct,
    overrides?: CallOverrides
  ): Promise<string>;

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

  listingOrderStatus(
    arg0: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<number>;

  matchBAKCPairStakingList(
    apeOrder: IP2PPairStaking.ListingOrderStruct,
    bakcOrder: IP2PPairStaking.ListingOrderStruct,
    apeCoinOrder: IP2PPairStaking.ListingOrderStruct,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  matchPairStakingList(
    apeOrder: IP2PPairStaking.ListingOrderStruct,
    apeCoinOrder: IP2PPairStaking.ListingOrderStruct,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  matchedOrders(
    arg0: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<
    [
      number,
      string,
      number,
      number,
      number,
      number,
      string,
      number,
      BigNumber,
      string
    ] & {
    stakingType: number;
    apeToken: string;
    apeTokenId: number;
    apeShare: number;
    bakcTokenId: number;
    bakcShare: number;
    apeCoinOfferer: string;
    apeCoinShare: number;
    apePrincipleAmount: BigNumber;
    apeCoinListingOrderHash: string;
  }
  >;

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

  onERC721Received(
    arg0: PromiseOrValue<string>,
    arg1: PromiseOrValue<string>,
    arg2: PromiseOrValue<BigNumberish>,
    arg3: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<string>;

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

  pendingCApeReward(
    user: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

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

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

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

  validateOrderSignature(
    signer: PromiseOrValue<string>,
    orderHash: PromiseOrValue<BytesLike>,
    v: PromiseOrValue<BigNumberish>,
    r: PromiseOrValue<BytesLike>,
    s: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  callStatic: {
    breakUpMatchedOrder(
      orderHash: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    cancelListing(
      listingOrder: IP2PPairStaking.ListingOrderStruct,
      overrides?: CallOverrides
    ): Promise<void>;

    claimCApeReward(
      receiver: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    claimCompoundFee(
      receiver: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    claimForMatchedOrderAndCompound(
      orderHashes: PromiseOrValue<BytesLike>[],
      overrides?: CallOverrides
    ): Promise<void>;

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

    getApeCoinStakingCap(
      stakingType: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getListingOrderHash(
      order: IP2PPairStaking.ListingOrderStruct,
      overrides?: CallOverrides
    ): Promise<string>;

    getMatchedOrderHash(
      order: IP2PPairStaking.MatchedOrderStruct,
      overrides?: CallOverrides
    ): Promise<string>;

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

    listingOrderStatus(
      arg0: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<number>;

    matchBAKCPairStakingList(
      apeOrder: IP2PPairStaking.ListingOrderStruct,
      bakcOrder: IP2PPairStaking.ListingOrderStruct,
      apeCoinOrder: IP2PPairStaking.ListingOrderStruct,
      overrides?: CallOverrides
    ): Promise<string>;

    matchPairStakingList(
      apeOrder: IP2PPairStaking.ListingOrderStruct,
      apeCoinOrder: IP2PPairStaking.ListingOrderStruct,
      overrides?: CallOverrides
    ): Promise<string>;

    matchedOrders(
      arg0: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<
      [
        number,
        string,
        number,
        number,
        number,
        number,
        string,
        number,
        BigNumber,
        string
      ] & {
      stakingType: number;
      apeToken: string;
      apeTokenId: number;
      apeShare: number;
      bakcTokenId: number;
      bakcShare: number;
      apeCoinOfferer: string;
      apeCoinShare: number;
      apePrincipleAmount: BigNumber;
      apeCoinListingOrderHash: string;
    }
    >;

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

    onERC721Received(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      arg2: PromiseOrValue<BigNumberish>,
      arg3: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<string>;

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

    pendingCApeReward(
      user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    rescueERC20(
      token: PromiseOrValue<string>,
      to: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setCompoundFee(
      _compoundFee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setMatchingOperator(
      _matchingOperator: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    validateOrderSignature(
      signer: PromiseOrValue<string>,
      orderHash: PromiseOrValue<BytesLike>,
      v: PromiseOrValue<BigNumberish>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<boolean>;
  };

  filters: {
    "CApeClaimed(address,address,uint256)"(
      user?: null,
      receiver?: null,
      amount?: null
    ): CApeClaimedEventFilter;
    CApeClaimed(
      user?: null,
      receiver?: null,
      amount?: null
    ): CApeClaimedEventFilter;

    "CompoundFeeUpdated(uint256,uint256)"(
      oldFee?: null,
      newFee?: null
    ): CompoundFeeUpdatedEventFilter;
    CompoundFeeUpdated(
      oldFee?: null,
      newFee?: null
    ): CompoundFeeUpdatedEventFilter;

    "Initialized(uint8)"(version?: null): InitializedEventFilter;
    Initialized(version?: null): InitializedEventFilter;

    "MatchingOperatorUpdated(address,address)"(
      oldOperator?: null,
      newOperator?: null
    ): MatchingOperatorUpdatedEventFilter;
    MatchingOperatorUpdated(
      oldOperator?: null,
      newOperator?: null
    ): MatchingOperatorUpdatedEventFilter;

    "OrderCancelled(bytes32,address)"(
      orderHash?: null,
      offerer?: PromiseOrValue<string> | null
    ): OrderCancelledEventFilter;
    OrderCancelled(
      orderHash?: null,
      offerer?: PromiseOrValue<string> | null
    ): OrderCancelledEventFilter;

    "OrderClaimedAndCompounded(bytes32,uint256)"(
      orderHash?: null,
      totalReward?: null
    ): OrderClaimedAndCompoundedEventFilter;
    OrderClaimedAndCompounded(
      orderHash?: null,
      totalReward?: null
    ): OrderClaimedAndCompoundedEventFilter;

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

    "PairStakingBreakUp(bytes32)"(
      orderHash?: null
    ): PairStakingBreakUpEventFilter;
    PairStakingBreakUp(orderHash?: null): PairStakingBreakUpEventFilter;

    "PairStakingMatched(bytes32)"(
      orderHash?: null
    ): PairStakingMatchedEventFilter;
    PairStakingMatched(orderHash?: null): PairStakingMatchedEventFilter;

    "RescueERC20(address,address,uint256)"(
      token?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null,
      amount?: null
    ): RescueERC20EventFilter;
    RescueERC20(
      token?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null,
      amount?: null
    ): RescueERC20EventFilter;
  };

  estimateGas: {
    breakUpMatchedOrder(
      orderHash: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    cancelListing(
      listingOrder: IP2PPairStaking.ListingOrderStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

    claimForMatchedOrderAndCompound(
      orderHashes: PromiseOrValue<BytesLike>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

    getApeCoinStakingCap(
      stakingType: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getListingOrderHash(
      order: IP2PPairStaking.ListingOrderStruct,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getMatchedOrderHash(
      order: IP2PPairStaking.MatchedOrderStruct,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    listingOrderStatus(
      arg0: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    matchBAKCPairStakingList(
      apeOrder: IP2PPairStaking.ListingOrderStruct,
      bakcOrder: IP2PPairStaking.ListingOrderStruct,
      apeCoinOrder: IP2PPairStaking.ListingOrderStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    matchPairStakingList(
      apeOrder: IP2PPairStaking.ListingOrderStruct,
      apeCoinOrder: IP2PPairStaking.ListingOrderStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    matchedOrders(
      arg0: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    onERC721Received(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      arg2: PromiseOrValue<BigNumberish>,
      arg3: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    pendingCApeReward(
      user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

    validateOrderSignature(
      signer: PromiseOrValue<string>,
      orderHash: PromiseOrValue<BytesLike>,
      v: PromiseOrValue<BigNumberish>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    breakUpMatchedOrder(
      orderHash: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    cancelListing(
      listingOrder: IP2PPairStaking.ListingOrderStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

    claimForMatchedOrderAndCompound(
      orderHashes: PromiseOrValue<BytesLike>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

    getApeCoinStakingCap(
      stakingType: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getListingOrderHash(
      order: IP2PPairStaking.ListingOrderStruct,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getMatchedOrderHash(
      order: IP2PPairStaking.MatchedOrderStruct,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    listingOrderStatus(
      arg0: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    matchBAKCPairStakingList(
      apeOrder: IP2PPairStaking.ListingOrderStruct,
      bakcOrder: IP2PPairStaking.ListingOrderStruct,
      apeCoinOrder: IP2PPairStaking.ListingOrderStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    matchPairStakingList(
      apeOrder: IP2PPairStaking.ListingOrderStruct,
      apeCoinOrder: IP2PPairStaking.ListingOrderStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    matchedOrders(
      arg0: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    onERC721Received(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      arg2: PromiseOrValue<BigNumberish>,
      arg3: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    pendingCApeReward(
      user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

    validateOrderSignature(
      signer: PromiseOrValue<string>,
      orderHash: PromiseOrValue<BytesLike>,
      v: PromiseOrValue<BigNumberish>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;
  };
}