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 {
    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>;
    };
    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;
    };
    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>;
    };
    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 declare type CApeClaimedEvent = TypedEvent<[
    string,
    string,
    BigNumber
], CApeClaimedEventObject>;
export declare type CApeClaimedEventFilter = TypedEventFilter<CApeClaimedEvent>;
export interface CompoundFeeUpdatedEventObject {
    oldFee: BigNumber;
    newFee: BigNumber;
}
export declare type CompoundFeeUpdatedEvent = TypedEvent<[
    BigNumber,
    BigNumber
], CompoundFeeUpdatedEventObject>;
export declare type CompoundFeeUpdatedEventFilter = TypedEventFilter<CompoundFeeUpdatedEvent>;
export interface InitializedEventObject {
    version: number;
}
export declare type InitializedEvent = TypedEvent<[number], InitializedEventObject>;
export declare type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
export interface MatchingOperatorUpdatedEventObject {
    oldOperator: string;
    newOperator: string;
}
export declare type MatchingOperatorUpdatedEvent = TypedEvent<[
    string,
    string
], MatchingOperatorUpdatedEventObject>;
export declare type MatchingOperatorUpdatedEventFilter = TypedEventFilter<MatchingOperatorUpdatedEvent>;
export interface OrderCancelledEventObject {
    orderHash: string;
    offerer: string;
}
export declare type OrderCancelledEvent = TypedEvent<[
    string,
    string
], OrderCancelledEventObject>;
export declare type OrderCancelledEventFilter = TypedEventFilter<OrderCancelledEvent>;
export interface OrderClaimedAndCompoundedEventObject {
    orderHash: string;
    totalReward: BigNumber;
}
export declare type OrderClaimedAndCompoundedEvent = TypedEvent<[
    string,
    BigNumber
], OrderClaimedAndCompoundedEventObject>;
export declare type OrderClaimedAndCompoundedEventFilter = TypedEventFilter<OrderClaimedAndCompoundedEvent>;
export interface OwnershipTransferredEventObject {
    previousOwner: string;
    newOwner: string;
}
export declare type OwnershipTransferredEvent = TypedEvent<[
    string,
    string
], OwnershipTransferredEventObject>;
export declare type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
export interface PairStakingBreakUpEventObject {
    orderHash: string;
}
export declare type PairStakingBreakUpEvent = TypedEvent<[
    string
], PairStakingBreakUpEventObject>;
export declare type PairStakingBreakUpEventFilter = TypedEventFilter<PairStakingBreakUpEvent>;
export interface PairStakingMatchedEventObject {
    orderHash: string;
}
export declare type PairStakingMatchedEvent = TypedEvent<[
    string
], PairStakingMatchedEventObject>;
export declare type PairStakingMatchedEventFilter = TypedEventFilter<PairStakingMatchedEvent>;
export interface RescueERC20EventObject {
    token: string;
    to: string;
    amount: BigNumber;
}
export declare type RescueERC20Event = TypedEvent<[
    string,
    string,
    BigNumber
], RescueERC20EventObject>;
export declare 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>;
    };
}
//# sourceMappingURL=P2PPairStaking.d.ts.map