@collabland/staking-contracts/dist/types/RivalBearsStaking.d.ts

Staking contracts supported by Collab.Land

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 } from "./common.js";
export declare namespace Interface_Rival_Bears_Staking {
    type UserStakeStruct = {
        nft: string;
        tokenId: BigNumberish;
        timestamp: BigNumberish;
        lastHarvest: BigNumberish;
        lastHarvestStakingSeasonIndex: BigNumberish;
    };
    type UserStakeStructOutput = [
        string,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        nft: string;
        tokenId: BigNumber;
        timestamp: BigNumber;
        lastHarvest: BigNumber;
        lastHarvestStakingSeasonIndex: BigNumber;
    };
}
export interface RivalBearsStakingInterface extends utils.Interface {
    functions: {
        "beginNewStakingSeason(address,uint256,uint256)": FunctionFragment;
        "emergencyUnstake(uint256)": FunctionFragment;
        "endStakingSeason(address)": FunctionFragment;
        "harvestAllStakes()": FunctionFragment;
        "harvestStake(uint256)": FunctionFragment;
        "redeem(uint256)": FunctionFragment;
        "renounceOwnership()": FunctionFragment;
        "setRedeemFunction(string)": FunctionFragment;
        "setRedeemLocation(address)": FunctionFragment;
        "setStakingPercentMultiplier(address,uint256,uint256)": FunctionFragment;
        "setStakingPercentMultiplierMultiple(address[],uint256[],uint256[])": FunctionFragment;
        "setTokenStakingDisabled(address,uint256,bool)": FunctionFragment;
        "setTokenStakingDisabledMultiple(address[],uint256[],bool)": FunctionFragment;
        "stake(address,uint256)": FunctionFragment;
        "stakeMultiple(address[],uint256[])": FunctionFragment;
        "transferOwnership(address)": FunctionFragment;
        "transferOwnershipRedeemLocation(address)": FunctionFragment;
        "unstake(uint256)": FunctionFragment;
        "unstakeMultiple(uint256[])": FunctionFragment;
        "updateStakingSeasonEndTime(address,uint256)": FunctionFragment;
        "getAccumulatedHarvestedPoints()": FunctionFragment;
        "getAccumulatedRedeemedPoints()": FunctionFragment;
        "getAllowednfts()": FunctionFragment;
        "getAllStakers()": FunctionFragment;
        "getCurrentStakingSeasonEndTime(address)": FunctionFragment;
        "getEarnedPointsFromStake(address,uint256)": FunctionFragment;
        "getRedeemFunction()": FunctionFragment;
        "getRedeemLocation()": FunctionFragment;
        "getStaker(address,uint256)": FunctionFragment;
        "getStakerAccumulatedHarvestedPoints(address)": FunctionFragment;
        "getStakerAccumulatedRedeemedPoints(address)": FunctionFragment;
        "getStakerUnharvestedPoints(address)": FunctionFragment;
        "getStakes(address)": FunctionFragment;
        "getStakingPercentMultiplier(address,uint256,uint256)": FunctionFragment;
        "getStakingPercentMultiplierMultiple(address[],uint256[],uint256[])": FunctionFragment;
        "getStakingSeason(address)": FunctionFragment;
        "getStakingSeasonEndTime(address,uint256)": FunctionFragment;
        "getTotalStaked()": FunctionFragment;
        "owner()": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "beginNewStakingSeason" | "emergencyUnstake" | "endStakingSeason" | "harvestAllStakes" | "harvestStake" | "redeem" | "renounceOwnership" | "setRedeemFunction" | "setRedeemLocation" | "setStakingPercentMultiplier" | "setStakingPercentMultiplierMultiple" | "setTokenStakingDisabled" | "setTokenStakingDisabledMultiple" | "stake" | "stakeMultiple" | "transferOwnership" | "transferOwnershipRedeemLocation" | "unstake" | "unstakeMultiple" | "updateStakingSeasonEndTime" | "getAccumulatedHarvestedPoints" | "getAccumulatedRedeemedPoints" | "getAllowednfts" | "getAllStakers" | "getCurrentStakingSeasonEndTime" | "getEarnedPointsFromStake" | "getRedeemFunction" | "getRedeemLocation" | "getStaker" | "getStakerAccumulatedHarvestedPoints" | "getStakerAccumulatedRedeemedPoints" | "getStakerUnharvestedPoints" | "getStakes" | "getStakingPercentMultiplier" | "getStakingPercentMultiplierMultiple" | "getStakingSeason" | "getStakingSeasonEndTime" | "getTotalStaked" | "owner"): FunctionFragment;
    encodeFunctionData(functionFragment: "beginNewStakingSeason", values: [string, BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "emergencyUnstake", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "endStakingSeason", values: [string]): string;
    encodeFunctionData(functionFragment: "harvestAllStakes", values?: undefined): string;
    encodeFunctionData(functionFragment: "harvestStake", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "redeem", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
    encodeFunctionData(functionFragment: "setRedeemFunction", values: [string]): string;
    encodeFunctionData(functionFragment: "setRedeemLocation", values: [string]): string;
    encodeFunctionData(functionFragment: "setStakingPercentMultiplier", values: [string, BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "setStakingPercentMultiplierMultiple", values: [string[], BigNumberish[], BigNumberish[]]): string;
    encodeFunctionData(functionFragment: "setTokenStakingDisabled", values: [string, BigNumberish, boolean]): string;
    encodeFunctionData(functionFragment: "setTokenStakingDisabledMultiple", values: [string[], BigNumberish[], boolean]): string;
    encodeFunctionData(functionFragment: "stake", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "stakeMultiple", values: [string[], BigNumberish[]]): string;
    encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
    encodeFunctionData(functionFragment: "transferOwnershipRedeemLocation", values: [string]): string;
    encodeFunctionData(functionFragment: "unstake", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "unstakeMultiple", values: [BigNumberish[]]): string;
    encodeFunctionData(functionFragment: "updateStakingSeasonEndTime", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "getAccumulatedHarvestedPoints", values?: undefined): string;
    encodeFunctionData(functionFragment: "getAccumulatedRedeemedPoints", values?: undefined): string;
    encodeFunctionData(functionFragment: "getAllowednfts", values?: undefined): string;
    encodeFunctionData(functionFragment: "getAllStakers", values?: undefined): string;
    encodeFunctionData(functionFragment: "getCurrentStakingSeasonEndTime", values: [string]): string;
    encodeFunctionData(functionFragment: "getEarnedPointsFromStake", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "getRedeemFunction", values?: undefined): string;
    encodeFunctionData(functionFragment: "getRedeemLocation", values?: undefined): string;
    encodeFunctionData(functionFragment: "getStaker", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "getStakerAccumulatedHarvestedPoints", values: [string]): string;
    encodeFunctionData(functionFragment: "getStakerAccumulatedRedeemedPoints", values: [string]): string;
    encodeFunctionData(functionFragment: "getStakerUnharvestedPoints", values: [string]): string;
    encodeFunctionData(functionFragment: "getStakes", values: [string]): string;
    encodeFunctionData(functionFragment: "getStakingPercentMultiplier", values: [string, BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "getStakingPercentMultiplierMultiple", values: [string[], BigNumberish[], BigNumberish[]]): string;
    encodeFunctionData(functionFragment: "getStakingSeason", values: [string]): string;
    encodeFunctionData(functionFragment: "getStakingSeasonEndTime", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "getTotalStaked", values?: undefined): string;
    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
    decodeFunctionResult(functionFragment: "beginNewStakingSeason", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "emergencyUnstake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "endStakingSeason", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "harvestAllStakes", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "harvestStake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "redeem", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setRedeemFunction", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setRedeemLocation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setStakingPercentMultiplier", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setStakingPercentMultiplierMultiple", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setTokenStakingDisabled", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setTokenStakingDisabledMultiple", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stakeMultiple", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferOwnershipRedeemLocation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unstake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unstakeMultiple", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "updateStakingSeasonEndTime", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getAccumulatedHarvestedPoints", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getAccumulatedRedeemedPoints", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getAllowednfts", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getAllStakers", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getCurrentStakingSeasonEndTime", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getEarnedPointsFromStake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getRedeemFunction", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getRedeemLocation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getStaker", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getStakerAccumulatedHarvestedPoints", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getStakerAccumulatedRedeemedPoints", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getStakerUnharvestedPoints", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getStakes", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getStakingPercentMultiplier", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getStakingPercentMultiplierMultiple", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getStakingSeason", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getStakingSeasonEndTime", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getTotalStaked", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
    events: {
        "BeginStakingSeason(address,uint256,uint256)": EventFragment;
        "DisableStaking(address,uint256)": EventFragment;
        "EnableStaking(address,uint256)": EventFragment;
        "Harvest(address,uint256)": EventFragment;
        "OwnershipTransferred(address,address)": EventFragment;
        "Redeem(address,uint256,address)": EventFragment;
        "SetRedeemLocation(address)": EventFragment;
        "SetStakingPercentMultiplier(address,uint256,uint256,uint256)": EventFragment;
        "Stake(address,address,uint256)": EventFragment;
        "Unstake(address,address,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "BeginStakingSeason"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "DisableStaking"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "EnableStaking"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Harvest"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Redeem"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SetRedeemLocation"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SetStakingPercentMultiplier"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Stake"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Unstake"): EventFragment;
}
export interface BeginStakingSeasonEventObject {
    nft: string;
    dailyPoints: BigNumber;
    endTime: BigNumber;
}
export type BeginStakingSeasonEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber
], BeginStakingSeasonEventObject>;
export type BeginStakingSeasonEventFilter = TypedEventFilter<BeginStakingSeasonEvent>;
export interface DisableStakingEventObject {
    nft: string;
    tokenId: BigNumber;
}
export type DisableStakingEvent = TypedEvent<[
    string,
    BigNumber
], DisableStakingEventObject>;
export type DisableStakingEventFilter = TypedEventFilter<DisableStakingEvent>;
export interface EnableStakingEventObject {
    nft: string;
    tokenId: BigNumber;
}
export type EnableStakingEvent = TypedEvent<[
    string,
    BigNumber
], EnableStakingEventObject>;
export type EnableStakingEventFilter = TypedEventFilter<EnableStakingEvent>;
export interface HarvestEventObject {
    staker: string;
    points: BigNumber;
}
export type HarvestEvent = TypedEvent<[string, BigNumber], HarvestEventObject>;
export type HarvestEventFilter = TypedEventFilter<HarvestEvent>;
export interface OwnershipTransferredEventObject {
    oldOwner: string;
    newOwner: string;
}
export type OwnershipTransferredEvent = TypedEvent<[
    string,
    string
], OwnershipTransferredEventObject>;
export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
export interface RedeemEventObject {
    staker: string;
    points: BigNumber;
    redeemLocation: string;
}
export type RedeemEvent = TypedEvent<[
    string,
    BigNumber,
    string
], RedeemEventObject>;
export type RedeemEventFilter = TypedEventFilter<RedeemEvent>;
export interface SetRedeemLocationEventObject {
    location: string;
}
export type SetRedeemLocationEvent = TypedEvent<[
    string
], SetRedeemLocationEventObject>;
export type SetRedeemLocationEventFilter = TypedEventFilter<SetRedeemLocationEvent>;
export interface SetStakingPercentMultiplierEventObject {
    nft: string;
    tokenId: BigNumber;
    stakingSeason: BigNumber;
    multiplier: BigNumber;
}
export type SetStakingPercentMultiplierEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber,
    BigNumber
], SetStakingPercentMultiplierEventObject>;
export type SetStakingPercentMultiplierEventFilter = TypedEventFilter<SetStakingPercentMultiplierEvent>;
export interface StakeEventObject {
    staker: string;
    nft: string;
    tokenId: BigNumber;
}
export type StakeEvent = TypedEvent<[
    string,
    string,
    BigNumber
], StakeEventObject>;
export type StakeEventFilter = TypedEventFilter<StakeEvent>;
export interface UnstakeEventObject {
    staker: string;
    nft: string;
    tokenId: BigNumber;
}
export type UnstakeEvent = TypedEvent<[
    string,
    string,
    BigNumber
], UnstakeEventObject>;
export type UnstakeEventFilter = TypedEventFilter<UnstakeEvent>;
export interface RivalBearsStaking extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: RivalBearsStakingInterface;
    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: {
        beginNewStakingSeason(nft: string, dailyPoints: BigNumberish, endTime: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        emergencyUnstake(stakingIndex: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        endStakingSeason(nft: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        harvestAllStakes(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        harvestStake(stakingIndex: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        redeem(_points: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setRedeemFunction(_redeemFunction: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setRedeemLocation(_redeemLocation: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setStakingPercentMultiplier(nft: string, tokenId: BigNumberish, stakingPercentMultiplier: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setStakingPercentMultiplierMultiple(nft: string[], tokenId: BigNumberish[], stakingPercentMultiplier: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setTokenStakingDisabled(nft: string, tokenId: BigNumberish, disabled: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setTokenStakingDisabledMultiple(nft: string[], tokenId: BigNumberish[], disabled: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        stake(nft: string, tokenId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        stakeMultiple(nft: string[], tokenId: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        transferOwnershipRedeemLocation(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        unstake(stakingIndex: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        unstakeMultiple(stakingIndex: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        updateStakingSeasonEndTime(nft: string, endTime: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        getAccumulatedHarvestedPoints(overrides?: CallOverrides): Promise<[BigNumber]>;
        getAccumulatedRedeemedPoints(overrides?: CallOverrides): Promise<[BigNumber]>;
        getAllowednfts(overrides?: CallOverrides): Promise<[string[]]>;
        getAllStakers(overrides?: CallOverrides): Promise<[string[]] & {
            staker: string[];
        }>;
        getCurrentStakingSeasonEndTime(nft: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        getEarnedPointsFromStake(staker: string, stakingIndex: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
        getRedeemFunction(overrides?: CallOverrides): Promise<[string]>;
        getRedeemLocation(overrides?: CallOverrides): Promise<[string]>;
        getStaker(nft: string, tokenId: BigNumberish, overrides?: CallOverrides): Promise<[string] & {
            staker: string;
        }>;
        getStakerAccumulatedHarvestedPoints(staker: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        getStakerAccumulatedRedeemedPoints(staker: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        getStakerUnharvestedPoints(staker: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        getStakes(staker: string, overrides?: CallOverrides): Promise<[Interface_Rival_Bears_Staking.UserStakeStructOutput[]]>;
        getStakingPercentMultiplier(nft: string, tokenId: BigNumberish, stakingSeasonIndex: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
        getStakingPercentMultiplierMultiple(nft: string[], tokenId: BigNumberish[], stakingSeasonIndex: BigNumberish[], overrides?: CallOverrides): Promise<[BigNumber[]]>;
        getStakingSeason(nft: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        getStakingSeasonEndTime(nft: string, stakingSeasonIndex: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
        getTotalStaked(overrides?: CallOverrides): Promise<[BigNumber]>;
        owner(overrides?: CallOverrides): Promise<[string]>;
    };
    beginNewStakingSeason(nft: string, dailyPoints: BigNumberish, endTime: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    emergencyUnstake(stakingIndex: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    endStakingSeason(nft: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    harvestAllStakes(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    harvestStake(stakingIndex: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    redeem(_points: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    renounceOwnership(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setRedeemFunction(_redeemFunction: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setRedeemLocation(_redeemLocation: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setStakingPercentMultiplier(nft: string, tokenId: BigNumberish, stakingPercentMultiplier: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setStakingPercentMultiplierMultiple(nft: string[], tokenId: BigNumberish[], stakingPercentMultiplier: BigNumberish[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setTokenStakingDisabled(nft: string, tokenId: BigNumberish, disabled: boolean, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setTokenStakingDisabledMultiple(nft: string[], tokenId: BigNumberish[], disabled: boolean, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    stake(nft: string, tokenId: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    stakeMultiple(nft: string[], tokenId: BigNumberish[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    transferOwnership(newOwner: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    transferOwnershipRedeemLocation(newOwner: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    unstake(stakingIndex: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    unstakeMultiple(stakingIndex: BigNumberish[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    updateStakingSeasonEndTime(nft: string, endTime: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    getAccumulatedHarvestedPoints(overrides?: CallOverrides): Promise<BigNumber>;
    getAccumulatedRedeemedPoints(overrides?: CallOverrides): Promise<BigNumber>;
    getAllowednfts(overrides?: CallOverrides): Promise<string[]>;
    getAllStakers(overrides?: CallOverrides): Promise<string[]>;
    getCurrentStakingSeasonEndTime(nft: string, overrides?: CallOverrides): Promise<BigNumber>;
    getEarnedPointsFromStake(staker: string, stakingIndex: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    getRedeemFunction(overrides?: CallOverrides): Promise<string>;
    getRedeemLocation(overrides?: CallOverrides): Promise<string>;
    getStaker(nft: string, tokenId: BigNumberish, overrides?: CallOverrides): Promise<string>;
    getStakerAccumulatedHarvestedPoints(staker: string, overrides?: CallOverrides): Promise<BigNumber>;
    getStakerAccumulatedRedeemedPoints(staker: string, overrides?: CallOverrides): Promise<BigNumber>;
    getStakerUnharvestedPoints(staker: string, overrides?: CallOverrides): Promise<BigNumber>;
    getStakes(staker: string, overrides?: CallOverrides): Promise<Interface_Rival_Bears_Staking.UserStakeStructOutput[]>;
    getStakingPercentMultiplier(nft: string, tokenId: BigNumberish, stakingSeasonIndex: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    getStakingPercentMultiplierMultiple(nft: string[], tokenId: BigNumberish[], stakingSeasonIndex: BigNumberish[], overrides?: CallOverrides): Promise<BigNumber[]>;
    getStakingSeason(nft: string, overrides?: CallOverrides): Promise<BigNumber>;
    getStakingSeasonEndTime(nft: string, stakingSeasonIndex: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    getTotalStaked(overrides?: CallOverrides): Promise<BigNumber>;
    owner(overrides?: CallOverrides): Promise<string>;
    callStatic: {
        beginNewStakingSeason(nft: string, dailyPoints: BigNumberish, endTime: BigNumberish, overrides?: CallOverrides): Promise<void>;
        emergencyUnstake(stakingIndex: BigNumberish, overrides?: CallOverrides): Promise<void>;
        endStakingSeason(nft: string, overrides?: CallOverrides): Promise<void>;
        harvestAllStakes(overrides?: CallOverrides): Promise<void>;
        harvestStake(stakingIndex: BigNumberish, overrides?: CallOverrides): Promise<void>;
        redeem(_points: BigNumberish, overrides?: CallOverrides): Promise<void>;
        renounceOwnership(overrides?: CallOverrides): Promise<void>;
        setRedeemFunction(_redeemFunction: string, overrides?: CallOverrides): Promise<void>;
        setRedeemLocation(_redeemLocation: string, overrides?: CallOverrides): Promise<void>;
        setStakingPercentMultiplier(nft: string, tokenId: BigNumberish, stakingPercentMultiplier: BigNumberish, overrides?: CallOverrides): Promise<void>;
        setStakingPercentMultiplierMultiple(nft: string[], tokenId: BigNumberish[], stakingPercentMultiplier: BigNumberish[], overrides?: CallOverrides): Promise<void>;
        setTokenStakingDisabled(nft: string, tokenId: BigNumberish, disabled: boolean, overrides?: CallOverrides): Promise<void>;
        setTokenStakingDisabledMultiple(nft: string[], tokenId: BigNumberish[], disabled: boolean, overrides?: CallOverrides): Promise<void>;
        stake(nft: string, tokenId: BigNumberish, overrides?: CallOverrides): Promise<void>;
        stakeMultiple(nft: string[], tokenId: BigNumberish[], overrides?: CallOverrides): Promise<void>;
        transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
        transferOwnershipRedeemLocation(newOwner: string, overrides?: CallOverrides): Promise<void>;
        unstake(stakingIndex: BigNumberish, overrides?: CallOverrides): Promise<void>;
        unstakeMultiple(stakingIndex: BigNumberish[], overrides?: CallOverrides): Promise<void>;
        updateStakingSeasonEndTime(nft: string, endTime: BigNumberish, overrides?: CallOverrides): Promise<void>;
        getAccumulatedHarvestedPoints(overrides?: CallOverrides): Promise<BigNumber>;
        getAccumulatedRedeemedPoints(overrides?: CallOverrides): Promise<BigNumber>;
        getAllowednfts(overrides?: CallOverrides): Promise<string[]>;
        getAllStakers(overrides?: CallOverrides): Promise<string[]>;
        getCurrentStakingSeasonEndTime(nft: string, overrides?: CallOverrides): Promise<BigNumber>;
        getEarnedPointsFromStake(staker: string, stakingIndex: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        getRedeemFunction(overrides?: CallOverrides): Promise<string>;
        getRedeemLocation(overrides?: CallOverrides): Promise<string>;
        getStaker(nft: string, tokenId: BigNumberish, overrides?: CallOverrides): Promise<string>;
        getStakerAccumulatedHarvestedPoints(staker: string, overrides?: CallOverrides): Promise<BigNumber>;
        getStakerAccumulatedRedeemedPoints(staker: string, overrides?: CallOverrides): Promise<BigNumber>;
        getStakerUnharvestedPoints(staker: string, overrides?: CallOverrides): Promise<BigNumber>;
        getStakes(staker: string, overrides?: CallOverrides): Promise<Interface_Rival_Bears_Staking.UserStakeStructOutput[]>;
        getStakingPercentMultiplier(nft: string, tokenId: BigNumberish, stakingSeasonIndex: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        getStakingPercentMultiplierMultiple(nft: string[], tokenId: BigNumberish[], stakingSeasonIndex: BigNumberish[], overrides?: CallOverrides): Promise<BigNumber[]>;
        getStakingSeason(nft: string, overrides?: CallOverrides): Promise<BigNumber>;
        getStakingSeasonEndTime(nft: string, stakingSeasonIndex: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        getTotalStaked(overrides?: CallOverrides): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<string>;
    };
    filters: {
        "BeginStakingSeason(address,uint256,uint256)"(nft?: string | null, dailyPoints?: null, endTime?: null): BeginStakingSeasonEventFilter;
        BeginStakingSeason(nft?: string | null, dailyPoints?: null, endTime?: null): BeginStakingSeasonEventFilter;
        "DisableStaking(address,uint256)"(nft?: string | null, tokenId?: BigNumberish | null): DisableStakingEventFilter;
        DisableStaking(nft?: string | null, tokenId?: BigNumberish | null): DisableStakingEventFilter;
        "EnableStaking(address,uint256)"(nft?: string | null, tokenId?: BigNumberish | null): EnableStakingEventFilter;
        EnableStaking(nft?: string | null, tokenId?: BigNumberish | null): EnableStakingEventFilter;
        "Harvest(address,uint256)"(staker?: string | null, points?: null): HarvestEventFilter;
        Harvest(staker?: string | null, points?: null): HarvestEventFilter;
        "OwnershipTransferred(address,address)"(oldOwner?: null, newOwner?: null): OwnershipTransferredEventFilter;
        OwnershipTransferred(oldOwner?: null, newOwner?: null): OwnershipTransferredEventFilter;
        "Redeem(address,uint256,address)"(staker?: string | null, points?: null, redeemLocation?: string | null): RedeemEventFilter;
        Redeem(staker?: string | null, points?: null, redeemLocation?: string | null): RedeemEventFilter;
        "SetRedeemLocation(address)"(location?: null): SetRedeemLocationEventFilter;
        SetRedeemLocation(location?: null): SetRedeemLocationEventFilter;
        "SetStakingPercentMultiplier(address,uint256,uint256,uint256)"(nft?: string | null, tokenId?: BigNumberish | null, stakingSeason?: BigNumberish | null, multiplier?: null): SetStakingPercentMultiplierEventFilter;
        SetStakingPercentMultiplier(nft?: string | null, tokenId?: BigNumberish | null, stakingSeason?: BigNumberish | null, multiplier?: null): SetStakingPercentMultiplierEventFilter;
        "Stake(address,address,uint256)"(staker?: string | null, nft?: string | null, tokenId?: BigNumberish | null): StakeEventFilter;
        Stake(staker?: string | null, nft?: string | null, tokenId?: BigNumberish | null): StakeEventFilter;
        "Unstake(address,address,uint256)"(staker?: string | null, nft?: string | null, tokenId?: BigNumberish | null): UnstakeEventFilter;
        Unstake(staker?: string | null, nft?: string | null, tokenId?: BigNumberish | null): UnstakeEventFilter;
    };
    estimateGas: {
        beginNewStakingSeason(nft: string, dailyPoints: BigNumberish, endTime: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        emergencyUnstake(stakingIndex: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        endStakingSeason(nft: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        harvestAllStakes(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        harvestStake(stakingIndex: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        redeem(_points: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setRedeemFunction(_redeemFunction: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setRedeemLocation(_redeemLocation: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setStakingPercentMultiplier(nft: string, tokenId: BigNumberish, stakingPercentMultiplier: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setStakingPercentMultiplierMultiple(nft: string[], tokenId: BigNumberish[], stakingPercentMultiplier: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setTokenStakingDisabled(nft: string, tokenId: BigNumberish, disabled: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setTokenStakingDisabledMultiple(nft: string[], tokenId: BigNumberish[], disabled: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        stake(nft: string, tokenId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        stakeMultiple(nft: string[], tokenId: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        transferOwnershipRedeemLocation(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        unstake(stakingIndex: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        unstakeMultiple(stakingIndex: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        updateStakingSeasonEndTime(nft: string, endTime: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        getAccumulatedHarvestedPoints(overrides?: CallOverrides): Promise<BigNumber>;
        getAccumulatedRedeemedPoints(overrides?: CallOverrides): Promise<BigNumber>;
        getAllowednfts(overrides?: CallOverrides): Promise<BigNumber>;
        getAllStakers(overrides?: CallOverrides): Promise<BigNumber>;
        getCurrentStakingSeasonEndTime(nft: string, overrides?: CallOverrides): Promise<BigNumber>;
        getEarnedPointsFromStake(staker: string, stakingIndex: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        getRedeemFunction(overrides?: CallOverrides): Promise<BigNumber>;
        getRedeemLocation(overrides?: CallOverrides): Promise<BigNumber>;
        getStaker(nft: string, tokenId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        getStakerAccumulatedHarvestedPoints(staker: string, overrides?: CallOverrides): Promise<BigNumber>;
        getStakerAccumulatedRedeemedPoints(staker: string, overrides?: CallOverrides): Promise<BigNumber>;
        getStakerUnharvestedPoints(staker: string, overrides?: CallOverrides): Promise<BigNumber>;
        getStakes(staker: string, overrides?: CallOverrides): Promise<BigNumber>;
        getStakingPercentMultiplier(nft: string, tokenId: BigNumberish, stakingSeasonIndex: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        getStakingPercentMultiplierMultiple(nft: string[], tokenId: BigNumberish[], stakingSeasonIndex: BigNumberish[], overrides?: CallOverrides): Promise<BigNumber>;
        getStakingSeason(nft: string, overrides?: CallOverrides): Promise<BigNumber>;
        getStakingSeasonEndTime(nft: string, stakingSeasonIndex: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        getTotalStaked(overrides?: CallOverrides): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<BigNumber>;
    };
    populateTransaction: {
        beginNewStakingSeason(nft: string, dailyPoints: BigNumberish, endTime: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        emergencyUnstake(stakingIndex: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        endStakingSeason(nft: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        harvestAllStakes(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        harvestStake(stakingIndex: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        redeem(_points: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setRedeemFunction(_redeemFunction: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setRedeemLocation(_redeemLocation: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setStakingPercentMultiplier(nft: string, tokenId: BigNumberish, stakingPercentMultiplier: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setStakingPercentMultiplierMultiple(nft: string[], tokenId: BigNumberish[], stakingPercentMultiplier: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setTokenStakingDisabled(nft: string, tokenId: BigNumberish, disabled: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setTokenStakingDisabledMultiple(nft: string[], tokenId: BigNumberish[], disabled: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        stake(nft: string, tokenId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        stakeMultiple(nft: string[], tokenId: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        transferOwnershipRedeemLocation(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        unstake(stakingIndex: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        unstakeMultiple(stakingIndex: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        updateStakingSeasonEndTime(nft: string, endTime: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        getAccumulatedHarvestedPoints(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getAccumulatedRedeemedPoints(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getAllowednfts(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getAllStakers(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getCurrentStakingSeasonEndTime(nft: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getEarnedPointsFromStake(staker: string, stakingIndex: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getRedeemFunction(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getRedeemLocation(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getStaker(nft: string, tokenId: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getStakerAccumulatedHarvestedPoints(staker: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getStakerAccumulatedRedeemedPoints(staker: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getStakerUnharvestedPoints(staker: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getStakes(staker: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getStakingPercentMultiplier(nft: string, tokenId: BigNumberish, stakingSeasonIndex: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getStakingPercentMultiplierMultiple(nft: string[], tokenId: BigNumberish[], stakingSeasonIndex: BigNumberish[], overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getStakingSeason(nft: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getStakingSeasonEndTime(nft: string, stakingSeasonIndex: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getTotalStaked(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
    };
}