import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from 'ethers';
import type { FunctionFragment, Result, EventFragment } from '@ethersproject/abi';
import type { Listener, Provider } from '@ethersproject/providers';
import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from './common';
export declare namespace StakerStructs {
    type PoolInfoStruct = {
        accGroPerShare: PromiseOrValue<BigNumberish>;
        allocPoint: PromiseOrValue<BigNumberish>;
        lastRewardBlock: PromiseOrValue<BigNumberish>;
        lpToken: PromiseOrValue<string>;
    };
    type PoolInfoStructOutput = [BigNumber, BigNumber, BigNumber, string] & {
        accGroPerShare: BigNumber;
        allocPoint: BigNumber;
        lastRewardBlock: BigNumber;
        lpToken: string;
    };
}
export interface GroLpTokenStakerInterface extends utils.Interface {
    functions: {
        'PWRD()': FunctionFragment;
        'TIME_LOCK()': FunctionFragment;
        'activeLpTokens(address)': FunctionFragment;
        'add(uint256,address)': FunctionFragment;
        'claim(bool,uint256)': FunctionFragment;
        'claimable(uint256,address)': FunctionFragment;
        'deposit(uint256,uint256)': FunctionFragment;
        'emergencyWithdraw(uint256)': FunctionFragment;
        'getUserPwrd(address)': FunctionFragment;
        'groPerBlock()': FunctionFragment;
        'initialize()': FunctionFragment;
        'initialized()': FunctionFragment;
        'manager()': FunctionFragment;
        'massUpdatePools(uint256[])': FunctionFragment;
        'maxGroPerBlock()': FunctionFragment;
        'migrate(uint256[])': FunctionFragment;
        'migrateFrom(uint256[])': FunctionFragment;
        'migrateFromV1()': FunctionFragment;
        'migrateUser(address,uint256[])': FunctionFragment;
        'migratedFromV1()': FunctionFragment;
        'multiClaim(bool,uint256[])': FunctionFragment;
        'multiWithdraw(uint256[],uint256[])': FunctionFragment;
        'multiWithdrawAndClaim(bool,uint256[],uint256[])': FunctionFragment;
        'newStaker()': FunctionFragment;
        'oldStaker()': FunctionFragment;
        'owner()': FunctionFragment;
        'pPid()': FunctionFragment;
        'paused()': FunctionFragment;
        'poolInfo(uint256)': FunctionFragment;
        'poolLength()': FunctionFragment;
        'renounceOwnership()': FunctionFragment;
        'set(uint256,uint256)': FunctionFragment;
        'setGroPerBlock(uint256)': FunctionFragment;
        'setManager(address)': FunctionFragment;
        'setMaxGroPerBlock(uint256)': FunctionFragment;
        'setNewStaker(address)': FunctionFragment;
        'setOldStaker(address)': FunctionFragment;
        'setPwrdPid(uint256)': FunctionFragment;
        'setStatus(bool)': FunctionFragment;
        'setVesting(address)': FunctionFragment;
        'totalAllocPoint()': FunctionFragment;
        'transferOwnership(address)': FunctionFragment;
        'updatePool(uint256)': FunctionFragment;
        'userInfo(uint256,address)': FunctionFragment;
        'userMigrated(address,uint256)': FunctionFragment;
        'vesting()': FunctionFragment;
        'withdraw(uint256,uint256)': FunctionFragment;
        'withdrawAndClaim(bool,uint256,uint256)': FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: 'PWRD' | 'TIME_LOCK' | 'activeLpTokens' | 'add' | 'claim' | 'claimable' | 'deposit' | 'emergencyWithdraw' | 'getUserPwrd' | 'groPerBlock' | 'initialize' | 'initialized' | 'manager' | 'massUpdatePools' | 'maxGroPerBlock' | 'migrate' | 'migrateFrom' | 'migrateFromV1' | 'migrateUser' | 'migratedFromV1' | 'multiClaim' | 'multiWithdraw' | 'multiWithdrawAndClaim' | 'newStaker' | 'oldStaker' | 'owner' | 'pPid' | 'paused' | 'poolInfo' | 'poolLength' | 'renounceOwnership' | 'set' | 'setGroPerBlock' | 'setManager' | 'setMaxGroPerBlock' | 'setNewStaker' | 'setOldStaker' | 'setPwrdPid' | 'setStatus' | 'setVesting' | 'totalAllocPoint' | 'transferOwnership' | 'updatePool' | 'userInfo' | 'userMigrated' | 'vesting' | 'withdraw' | 'withdrawAndClaim'): FunctionFragment;
    encodeFunctionData(functionFragment: 'PWRD', values?: undefined): string;
    encodeFunctionData(functionFragment: 'TIME_LOCK', values?: undefined): string;
    encodeFunctionData(functionFragment: 'activeLpTokens', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'add', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'claim', values: [PromiseOrValue<boolean>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'claimable', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'deposit', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'emergencyWithdraw', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'getUserPwrd', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'groPerBlock', values?: undefined): string;
    encodeFunctionData(functionFragment: 'initialize', values?: undefined): string;
    encodeFunctionData(functionFragment: 'initialized', values?: undefined): string;
    encodeFunctionData(functionFragment: 'manager', values?: undefined): string;
    encodeFunctionData(functionFragment: 'massUpdatePools', values: [PromiseOrValue<BigNumberish>[]]): string;
    encodeFunctionData(functionFragment: 'maxGroPerBlock', values?: undefined): string;
    encodeFunctionData(functionFragment: 'migrate', values: [PromiseOrValue<BigNumberish>[]]): string;
    encodeFunctionData(functionFragment: 'migrateFrom', values: [PromiseOrValue<BigNumberish>[]]): string;
    encodeFunctionData(functionFragment: 'migrateFromV1', values?: undefined): string;
    encodeFunctionData(functionFragment: 'migrateUser', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>[]]): string;
    encodeFunctionData(functionFragment: 'migratedFromV1', values?: undefined): string;
    encodeFunctionData(functionFragment: 'multiClaim', values: [PromiseOrValue<boolean>, PromiseOrValue<BigNumberish>[]]): string;
    encodeFunctionData(functionFragment: 'multiWithdraw', values: [PromiseOrValue<BigNumberish>[], PromiseOrValue<BigNumberish>[]]): string;
    encodeFunctionData(functionFragment: 'multiWithdrawAndClaim', values: [PromiseOrValue<boolean>, PromiseOrValue<BigNumberish>[], PromiseOrValue<BigNumberish>[]]): string;
    encodeFunctionData(functionFragment: 'newStaker', values?: undefined): string;
    encodeFunctionData(functionFragment: 'oldStaker', values?: undefined): string;
    encodeFunctionData(functionFragment: 'owner', values?: undefined): string;
    encodeFunctionData(functionFragment: 'pPid', values?: undefined): string;
    encodeFunctionData(functionFragment: 'paused', values?: undefined): string;
    encodeFunctionData(functionFragment: 'poolInfo', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'poolLength', values?: undefined): string;
    encodeFunctionData(functionFragment: 'renounceOwnership', values?: undefined): string;
    encodeFunctionData(functionFragment: 'set', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setGroPerBlock', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setManager', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'setMaxGroPerBlock', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setNewStaker', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'setOldStaker', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'setPwrdPid', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setStatus', values: [PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: 'setVesting', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'totalAllocPoint', values?: undefined): string;
    encodeFunctionData(functionFragment: 'transferOwnership', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'updatePool', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'userInfo', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'userMigrated', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'vesting', values?: undefined): string;
    encodeFunctionData(functionFragment: 'withdraw', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'withdrawAndClaim', values: [PromiseOrValue<boolean>, PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    decodeFunctionResult(functionFragment: 'PWRD', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'TIME_LOCK', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'activeLpTokens', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'add', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'claim', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'claimable', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'deposit', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'emergencyWithdraw', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getUserPwrd', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'groPerBlock', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'initialize', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'initialized', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'manager', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'massUpdatePools', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'maxGroPerBlock', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'migrate', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'migrateFrom', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'migrateFromV1', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'migrateUser', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'migratedFromV1', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'multiClaim', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'multiWithdraw', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'multiWithdrawAndClaim', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'newStaker', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'oldStaker', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'pPid', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'paused', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'poolInfo', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'poolLength', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'renounceOwnership', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'set', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setGroPerBlock', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setManager', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setMaxGroPerBlock', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setNewStaker', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setOldStaker', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setPwrdPid', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setStatus', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setVesting', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'totalAllocPoint', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'transferOwnership', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'updatePool', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'userInfo', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'userMigrated', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'vesting', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'withdraw', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'withdrawAndClaim', data: BytesLike): Result;
    events: {
        'LogAddPool(uint256,uint256,address)': EventFragment;
        'LogClaim(address,bool,uint256,uint256)': EventFragment;
        'LogDeposit(address,uint256,uint256)': EventFragment;
        'LogEmergencyWithdraw(address,uint256,uint256)': EventFragment;
        'LogGroPerBlock(uint256)': EventFragment;
        'LogLpTokenAdded(address)': EventFragment;
        'LogMaxGroPerBlock(uint256)': EventFragment;
        'LogMigrate(uint256[])': EventFragment;
        'LogMigrateFrom(uint256[])': EventFragment;
        'LogMigrateFromV1(address)': EventFragment;
        'LogMigrateUser(address,uint256[])': EventFragment;
        'LogMultiClaim(address,bool,uint256[],uint256)': EventFragment;
        'LogMultiWithdraw(address,uint256[],uint256[])': EventFragment;
        'LogNewManagment(address)': EventFragment;
        'LogNewPwrdPid(uint256)': EventFragment;
        'LogNewStaker(address)': EventFragment;
        'LogNewVester(address)': EventFragment;
        'LogOldStaker(address)': EventFragment;
        'LogSetPool(uint256,uint256)': EventFragment;
        'LogSetStatus(bool)': EventFragment;
        'LogSetTimelock(address)': EventFragment;
        'LogUpdatePool(uint256,uint256,uint256,uint256)': EventFragment;
        'LogUserMigrateFromV1(address,address)': EventFragment;
        'LogWithdraw(address,uint256,uint256)': EventFragment;
        'OwnershipTransferred(address,address)': EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: 'LogAddPool'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogClaim'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogDeposit'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogEmergencyWithdraw'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogGroPerBlock'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogLpTokenAdded'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogMaxGroPerBlock'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogMigrate'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogMigrateFrom'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogMigrateFromV1'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogMigrateUser'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogMultiClaim'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogMultiWithdraw'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogNewManagment'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogNewPwrdPid'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogNewStaker'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogNewVester'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogOldStaker'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogSetPool'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogSetStatus'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogSetTimelock'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogUpdatePool'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogUserMigrateFromV1'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LogWithdraw'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment;
}
export interface LogAddPoolEventObject {
    pid: BigNumber;
    allocPoint: BigNumber;
    lpToken: string;
}
export declare type LogAddPoolEvent = TypedEvent<[BigNumber, BigNumber, string], LogAddPoolEventObject>;
export declare type LogAddPoolEventFilter = TypedEventFilter<LogAddPoolEvent>;
export interface LogClaimEventObject {
    user: string;
    vest: boolean;
    pid: BigNumber;
    amount: BigNumber;
}
export declare type LogClaimEvent = TypedEvent<[string, boolean, BigNumber, BigNumber], LogClaimEventObject>;
export declare type LogClaimEventFilter = TypedEventFilter<LogClaimEvent>;
export interface LogDepositEventObject {
    user: string;
    pid: BigNumber;
    amount: BigNumber;
}
export declare type LogDepositEvent = TypedEvent<[string, BigNumber, BigNumber], LogDepositEventObject>;
export declare type LogDepositEventFilter = TypedEventFilter<LogDepositEvent>;
export interface LogEmergencyWithdrawEventObject {
    user: string;
    pid: BigNumber;
    amount: BigNumber;
}
export declare type LogEmergencyWithdrawEvent = TypedEvent<[string, BigNumber, BigNumber], LogEmergencyWithdrawEventObject>;
export declare type LogEmergencyWithdrawEventFilter = TypedEventFilter<LogEmergencyWithdrawEvent>;
export interface LogGroPerBlockEventObject {
    newGro: BigNumber;
}
export declare type LogGroPerBlockEvent = TypedEvent<[BigNumber], LogGroPerBlockEventObject>;
export declare type LogGroPerBlockEventFilter = TypedEventFilter<LogGroPerBlockEvent>;
export interface LogLpTokenAddedEventObject {
    token: string;
}
export declare type LogLpTokenAddedEvent = TypedEvent<[string], LogLpTokenAddedEventObject>;
export declare type LogLpTokenAddedEventFilter = TypedEventFilter<LogLpTokenAddedEvent>;
export interface LogMaxGroPerBlockEventObject {
    newMax: BigNumber;
}
export declare type LogMaxGroPerBlockEvent = TypedEvent<[BigNumber], LogMaxGroPerBlockEventObject>;
export declare type LogMaxGroPerBlockEventFilter = TypedEventFilter<LogMaxGroPerBlockEvent>;
export interface LogMigrateEventObject {
    pids: BigNumber[];
}
export declare type LogMigrateEvent = TypedEvent<[BigNumber[]], LogMigrateEventObject>;
export declare type LogMigrateEventFilter = TypedEventFilter<LogMigrateEvent>;
export interface LogMigrateFromEventObject {
    pids: BigNumber[];
}
export declare type LogMigrateFromEvent = TypedEvent<[BigNumber[]], LogMigrateFromEventObject>;
export declare type LogMigrateFromEventFilter = TypedEventFilter<LogMigrateFromEvent>;
export interface LogMigrateFromV1EventObject {
    staker: string;
}
export declare type LogMigrateFromV1Event = TypedEvent<[string], LogMigrateFromV1EventObject>;
export declare type LogMigrateFromV1EventFilter = TypedEventFilter<LogMigrateFromV1Event>;
export interface LogMigrateUserEventObject {
    account: string;
    pids: BigNumber[];
}
export declare type LogMigrateUserEvent = TypedEvent<[string, BigNumber[]], LogMigrateUserEventObject>;
export declare type LogMigrateUserEventFilter = TypedEventFilter<LogMigrateUserEvent>;
export interface LogMultiClaimEventObject {
    user: string;
    vest: boolean;
    pids: BigNumber[];
    amount: BigNumber;
}
export declare type LogMultiClaimEvent = TypedEvent<[string, boolean, BigNumber[], BigNumber], LogMultiClaimEventObject>;
export declare type LogMultiClaimEventFilter = TypedEventFilter<LogMultiClaimEvent>;
export interface LogMultiWithdrawEventObject {
    user: string;
    pids: BigNumber[];
    amounts: BigNumber[];
}
export declare type LogMultiWithdrawEvent = TypedEvent<[string, BigNumber[], BigNumber[]], LogMultiWithdrawEventObject>;
export declare type LogMultiWithdrawEventFilter = TypedEventFilter<LogMultiWithdrawEvent>;
export interface LogNewManagmentEventObject {
    newManager: string;
}
export declare type LogNewManagmentEvent = TypedEvent<[string], LogNewManagmentEventObject>;
export declare type LogNewManagmentEventFilter = TypedEventFilter<LogNewManagmentEvent>;
export interface LogNewPwrdPidEventObject {
    pPid: BigNumber;
}
export declare type LogNewPwrdPidEvent = TypedEvent<[BigNumber], LogNewPwrdPidEventObject>;
export declare type LogNewPwrdPidEventFilter = TypedEventFilter<LogNewPwrdPidEvent>;
export interface LogNewStakerEventObject {
    staker: string;
}
export declare type LogNewStakerEvent = TypedEvent<[string], LogNewStakerEventObject>;
export declare type LogNewStakerEventFilter = TypedEventFilter<LogNewStakerEvent>;
export interface LogNewVesterEventObject {
    newVester: string;
}
export declare type LogNewVesterEvent = TypedEvent<[string], LogNewVesterEventObject>;
export declare type LogNewVesterEventFilter = TypedEventFilter<LogNewVesterEvent>;
export interface LogOldStakerEventObject {
    staker: string;
}
export declare type LogOldStakerEvent = TypedEvent<[string], LogOldStakerEventObject>;
export declare type LogOldStakerEventFilter = TypedEventFilter<LogOldStakerEvent>;
export interface LogSetPoolEventObject {
    pid: BigNumber;
    allocPoint: BigNumber;
}
export declare type LogSetPoolEvent = TypedEvent<[BigNumber, BigNumber], LogSetPoolEventObject>;
export declare type LogSetPoolEventFilter = TypedEventFilter<LogSetPoolEvent>;
export interface LogSetStatusEventObject {
    pause: boolean;
}
export declare type LogSetStatusEvent = TypedEvent<[boolean], LogSetStatusEventObject>;
export declare type LogSetStatusEventFilter = TypedEventFilter<LogSetStatusEvent>;
export interface LogSetTimelockEventObject {
    timelock: string;
}
export declare type LogSetTimelockEvent = TypedEvent<[string], LogSetTimelockEventObject>;
export declare type LogSetTimelockEventFilter = TypedEventFilter<LogSetTimelockEvent>;
export interface LogUpdatePoolEventObject {
    pid: BigNumber;
    lastRewardBlock: BigNumber;
    lpSupply: BigNumber;
    accGroPerShare: BigNumber;
}
export declare type LogUpdatePoolEvent = TypedEvent<[BigNumber, BigNumber, BigNumber, BigNumber], LogUpdatePoolEventObject>;
export declare type LogUpdatePoolEventFilter = TypedEventFilter<LogUpdatePoolEvent>;
export interface LogUserMigrateFromV1EventObject {
    account: string;
    staker: string;
}
export declare type LogUserMigrateFromV1Event = TypedEvent<[string, string], LogUserMigrateFromV1EventObject>;
export declare type LogUserMigrateFromV1EventFilter = TypedEventFilter<LogUserMigrateFromV1Event>;
export interface LogWithdrawEventObject {
    user: string;
    pid: BigNumber;
    amount: BigNumber;
}
export declare type LogWithdrawEvent = TypedEvent<[string, BigNumber, BigNumber], LogWithdrawEventObject>;
export declare type LogWithdrawEventFilter = TypedEventFilter<LogWithdrawEvent>;
export interface OwnershipTransferredEventObject {
    previousOwner: string;
    newOwner: string;
}
export declare type OwnershipTransferredEvent = TypedEvent<[string, string], OwnershipTransferredEventObject>;
export declare type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
export interface GroLpTokenStaker extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: GroLpTokenStakerInterface;
    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: {
        PWRD(overrides?: CallOverrides): Promise<[string]>;
        TIME_LOCK(overrides?: CallOverrides): Promise<[string]>;
        activeLpTokens(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        add(allocPoint: PromiseOrValue<BigNumberish>, _lpToken: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        claim(vest: PromiseOrValue<boolean>, pid: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        claimable(_pid: PromiseOrValue<BigNumberish>, _user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        deposit(pid: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        emergencyWithdraw(pid: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        getUserPwrd(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        groPerBlock(overrides?: CallOverrides): Promise<[BigNumber]>;
        initialize(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        initialized(overrides?: CallOverrides): Promise<[boolean]>;
        manager(overrides?: CallOverrides): Promise<[string]>;
        massUpdatePools(pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        maxGroPerBlock(overrides?: CallOverrides): Promise<[BigNumber]>;
        migrate(pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        migrateFrom(pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        migrateFromV1(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        migrateUser(account: PromiseOrValue<string>, pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        migratedFromV1(overrides?: CallOverrides): Promise<[boolean]>;
        multiClaim(vest: PromiseOrValue<boolean>, pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        multiWithdraw(pids: PromiseOrValue<BigNumberish>[], amounts: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        multiWithdrawAndClaim(vest: PromiseOrValue<boolean>, pids: PromiseOrValue<BigNumberish>[], amounts: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        newStaker(overrides?: CallOverrides): Promise<[string]>;
        oldStaker(overrides?: CallOverrides): Promise<[string]>;
        owner(overrides?: CallOverrides): Promise<[string]>;
        pPid(overrides?: CallOverrides): Promise<[BigNumber]>;
        paused(overrides?: CallOverrides): Promise<[boolean]>;
        poolInfo(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber,
            string
        ] & {
            accGroPerShare: BigNumber;
            allocPoint: BigNumber;
            lastRewardBlock: BigNumber;
            lpToken: string;
        }>;
        poolLength(overrides?: CallOverrides): Promise<[BigNumber] & {
            pools: BigNumber;
        }>;
        renounceOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        set(_pid: PromiseOrValue<BigNumberish>, _allocPoint: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setGroPerBlock(_groPerBlock: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setManager(_manager: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setMaxGroPerBlock(_maxGroPerBlock: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setNewStaker(staker: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setOldStaker(staker: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setPwrdPid(_pPid: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setStatus(pause: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setVesting(_vesting: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        totalAllocPoint(overrides?: CallOverrides): Promise<[BigNumber]>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        updatePool(pid: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        userInfo(arg0: PromiseOrValue<BigNumberish>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber, BigNumber] & {
            amount: BigNumber;
            rewardDebt: BigNumber;
        }>;
        userMigrated(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[boolean]>;
        vesting(overrides?: CallOverrides): Promise<[string]>;
        withdraw(pid: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdrawAndClaim(vest: PromiseOrValue<boolean>, pid: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
    };
    PWRD(overrides?: CallOverrides): Promise<string>;
    TIME_LOCK(overrides?: CallOverrides): Promise<string>;
    activeLpTokens(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    add(allocPoint: PromiseOrValue<BigNumberish>, _lpToken: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    claim(vest: PromiseOrValue<boolean>, pid: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    claimable(_pid: PromiseOrValue<BigNumberish>, _user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    deposit(pid: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    emergencyWithdraw(pid: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    getUserPwrd(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    groPerBlock(overrides?: CallOverrides): Promise<BigNumber>;
    initialize(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    initialized(overrides?: CallOverrides): Promise<boolean>;
    manager(overrides?: CallOverrides): Promise<string>;
    massUpdatePools(pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    maxGroPerBlock(overrides?: CallOverrides): Promise<BigNumber>;
    migrate(pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    migrateFrom(pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    migrateFromV1(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    migrateUser(account: PromiseOrValue<string>, pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    migratedFromV1(overrides?: CallOverrides): Promise<boolean>;
    multiClaim(vest: PromiseOrValue<boolean>, pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    multiWithdraw(pids: PromiseOrValue<BigNumberish>[], amounts: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    multiWithdrawAndClaim(vest: PromiseOrValue<boolean>, pids: PromiseOrValue<BigNumberish>[], amounts: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    newStaker(overrides?: CallOverrides): Promise<string>;
    oldStaker(overrides?: CallOverrides): Promise<string>;
    owner(overrides?: CallOverrides): Promise<string>;
    pPid(overrides?: CallOverrides): Promise<BigNumber>;
    paused(overrides?: CallOverrides): Promise<boolean>;
    poolInfo(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
        BigNumber,
        BigNumber,
        BigNumber,
        string
    ] & {
        accGroPerShare: BigNumber;
        allocPoint: BigNumber;
        lastRewardBlock: BigNumber;
        lpToken: string;
    }>;
    poolLength(overrides?: CallOverrides): Promise<BigNumber>;
    renounceOwnership(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    set(_pid: PromiseOrValue<BigNumberish>, _allocPoint: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setGroPerBlock(_groPerBlock: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setManager(_manager: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setMaxGroPerBlock(_maxGroPerBlock: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setNewStaker(staker: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setOldStaker(staker: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setPwrdPid(_pPid: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setStatus(pause: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setVesting(_vesting: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    totalAllocPoint(overrides?: CallOverrides): Promise<BigNumber>;
    transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    updatePool(pid: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    userInfo(arg0: PromiseOrValue<BigNumberish>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber, BigNumber] & {
        amount: BigNumber;
        rewardDebt: BigNumber;
    }>;
    userMigrated(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
    vesting(overrides?: CallOverrides): Promise<string>;
    withdraw(pid: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdrawAndClaim(vest: PromiseOrValue<boolean>, pid: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    callStatic: {
        PWRD(overrides?: CallOverrides): Promise<string>;
        TIME_LOCK(overrides?: CallOverrides): Promise<string>;
        activeLpTokens(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        add(allocPoint: PromiseOrValue<BigNumberish>, _lpToken: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        claim(vest: PromiseOrValue<boolean>, pid: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        claimable(_pid: PromiseOrValue<BigNumberish>, _user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        deposit(pid: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        emergencyWithdraw(pid: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        getUserPwrd(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        groPerBlock(overrides?: CallOverrides): Promise<BigNumber>;
        initialize(overrides?: CallOverrides): Promise<void>;
        initialized(overrides?: CallOverrides): Promise<boolean>;
        manager(overrides?: CallOverrides): Promise<string>;
        massUpdatePools(pids: PromiseOrValue<BigNumberish>[], overrides?: CallOverrides): Promise<void>;
        maxGroPerBlock(overrides?: CallOverrides): Promise<BigNumber>;
        migrate(pids: PromiseOrValue<BigNumberish>[], overrides?: CallOverrides): Promise<void>;
        migrateFrom(pids: PromiseOrValue<BigNumberish>[], overrides?: CallOverrides): Promise<void>;
        migrateFromV1(overrides?: CallOverrides): Promise<void>;
        migrateUser(account: PromiseOrValue<string>, pids: PromiseOrValue<BigNumberish>[], overrides?: CallOverrides): Promise<void>;
        migratedFromV1(overrides?: CallOverrides): Promise<boolean>;
        multiClaim(vest: PromiseOrValue<boolean>, pids: PromiseOrValue<BigNumberish>[], overrides?: CallOverrides): Promise<void>;
        multiWithdraw(pids: PromiseOrValue<BigNumberish>[], amounts: PromiseOrValue<BigNumberish>[], overrides?: CallOverrides): Promise<void>;
        multiWithdrawAndClaim(vest: PromiseOrValue<boolean>, pids: PromiseOrValue<BigNumberish>[], amounts: PromiseOrValue<BigNumberish>[], overrides?: CallOverrides): Promise<void>;
        newStaker(overrides?: CallOverrides): Promise<string>;
        oldStaker(overrides?: CallOverrides): Promise<string>;
        owner(overrides?: CallOverrides): Promise<string>;
        pPid(overrides?: CallOverrides): Promise<BigNumber>;
        paused(overrides?: CallOverrides): Promise<boolean>;
        poolInfo(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber,
            string
        ] & {
            accGroPerShare: BigNumber;
            allocPoint: BigNumber;
            lastRewardBlock: BigNumber;
            lpToken: string;
        }>;
        poolLength(overrides?: CallOverrides): Promise<BigNumber>;
        renounceOwnership(overrides?: CallOverrides): Promise<void>;
        set(_pid: PromiseOrValue<BigNumberish>, _allocPoint: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setGroPerBlock(_groPerBlock: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setManager(_manager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setMaxGroPerBlock(_maxGroPerBlock: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setNewStaker(staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setOldStaker(staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setPwrdPid(_pPid: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setStatus(pause: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        setVesting(_vesting: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        totalAllocPoint(overrides?: CallOverrides): Promise<BigNumber>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        updatePool(pid: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<StakerStructs.PoolInfoStructOutput>;
        userInfo(arg0: PromiseOrValue<BigNumberish>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber, BigNumber] & {
            amount: BigNumber;
            rewardDebt: BigNumber;
        }>;
        userMigrated(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
        vesting(overrides?: CallOverrides): Promise<string>;
        withdraw(pid: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        withdrawAndClaim(vest: PromiseOrValue<boolean>, pid: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
    };
    filters: {
        'LogAddPool(uint256,uint256,address)'(pid?: PromiseOrValue<BigNumberish> | null, allocPoint?: null, lpToken?: PromiseOrValue<string> | null): LogAddPoolEventFilter;
        LogAddPool(pid?: PromiseOrValue<BigNumberish> | null, allocPoint?: null, lpToken?: PromiseOrValue<string> | null): LogAddPoolEventFilter;
        'LogClaim(address,bool,uint256,uint256)'(user?: PromiseOrValue<string> | null, vest?: null, pid?: PromiseOrValue<BigNumberish> | null, amount?: null): LogClaimEventFilter;
        LogClaim(user?: PromiseOrValue<string> | null, vest?: null, pid?: PromiseOrValue<BigNumberish> | null, amount?: null): LogClaimEventFilter;
        'LogDeposit(address,uint256,uint256)'(user?: PromiseOrValue<string> | null, pid?: PromiseOrValue<BigNumberish> | null, amount?: null): LogDepositEventFilter;
        LogDeposit(user?: PromiseOrValue<string> | null, pid?: PromiseOrValue<BigNumberish> | null, amount?: null): LogDepositEventFilter;
        'LogEmergencyWithdraw(address,uint256,uint256)'(user?: PromiseOrValue<string> | null, pid?: PromiseOrValue<BigNumberish> | null, amount?: null): LogEmergencyWithdrawEventFilter;
        LogEmergencyWithdraw(user?: PromiseOrValue<string> | null, pid?: PromiseOrValue<BigNumberish> | null, amount?: null): LogEmergencyWithdrawEventFilter;
        'LogGroPerBlock(uint256)'(newGro?: null): LogGroPerBlockEventFilter;
        LogGroPerBlock(newGro?: null): LogGroPerBlockEventFilter;
        'LogLpTokenAdded(address)'(token?: null): LogLpTokenAddedEventFilter;
        LogLpTokenAdded(token?: null): LogLpTokenAddedEventFilter;
        'LogMaxGroPerBlock(uint256)'(newMax?: null): LogMaxGroPerBlockEventFilter;
        LogMaxGroPerBlock(newMax?: null): LogMaxGroPerBlockEventFilter;
        'LogMigrate(uint256[])'(pids?: null): LogMigrateEventFilter;
        LogMigrate(pids?: null): LogMigrateEventFilter;
        'LogMigrateFrom(uint256[])'(pids?: null): LogMigrateFromEventFilter;
        LogMigrateFrom(pids?: null): LogMigrateFromEventFilter;
        'LogMigrateFromV1(address)'(staker?: null): LogMigrateFromV1EventFilter;
        LogMigrateFromV1(staker?: null): LogMigrateFromV1EventFilter;
        'LogMigrateUser(address,uint256[])'(account?: PromiseOrValue<string> | null, pids?: null): LogMigrateUserEventFilter;
        LogMigrateUser(account?: PromiseOrValue<string> | null, pids?: null): LogMigrateUserEventFilter;
        'LogMultiClaim(address,bool,uint256[],uint256)'(user?: PromiseOrValue<string> | null, vest?: null, pids?: null, amount?: null): LogMultiClaimEventFilter;
        LogMultiClaim(user?: PromiseOrValue<string> | null, vest?: null, pids?: null, amount?: null): LogMultiClaimEventFilter;
        'LogMultiWithdraw(address,uint256[],uint256[])'(user?: PromiseOrValue<string> | null, pids?: null, amounts?: null): LogMultiWithdrawEventFilter;
        LogMultiWithdraw(user?: PromiseOrValue<string> | null, pids?: null, amounts?: null): LogMultiWithdrawEventFilter;
        'LogNewManagment(address)'(newManager?: null): LogNewManagmentEventFilter;
        LogNewManagment(newManager?: null): LogNewManagmentEventFilter;
        'LogNewPwrdPid(uint256)'(pPid?: null): LogNewPwrdPidEventFilter;
        LogNewPwrdPid(pPid?: null): LogNewPwrdPidEventFilter;
        'LogNewStaker(address)'(staker?: null): LogNewStakerEventFilter;
        LogNewStaker(staker?: null): LogNewStakerEventFilter;
        'LogNewVester(address)'(newVester?: null): LogNewVesterEventFilter;
        LogNewVester(newVester?: null): LogNewVesterEventFilter;
        'LogOldStaker(address)'(staker?: null): LogOldStakerEventFilter;
        LogOldStaker(staker?: null): LogOldStakerEventFilter;
        'LogSetPool(uint256,uint256)'(pid?: PromiseOrValue<BigNumberish> | null, allocPoint?: null): LogSetPoolEventFilter;
        LogSetPool(pid?: PromiseOrValue<BigNumberish> | null, allocPoint?: null): LogSetPoolEventFilter;
        'LogSetStatus(bool)'(pause?: null): LogSetStatusEventFilter;
        LogSetStatus(pause?: null): LogSetStatusEventFilter;
        'LogSetTimelock(address)'(timelock?: null): LogSetTimelockEventFilter;
        LogSetTimelock(timelock?: null): LogSetTimelockEventFilter;
        'LogUpdatePool(uint256,uint256,uint256,uint256)'(pid?: PromiseOrValue<BigNumberish> | null, lastRewardBlock?: null, lpSupply?: null, accGroPerShare?: null): LogUpdatePoolEventFilter;
        LogUpdatePool(pid?: PromiseOrValue<BigNumberish> | null, lastRewardBlock?: null, lpSupply?: null, accGroPerShare?: null): LogUpdatePoolEventFilter;
        'LogUserMigrateFromV1(address,address)'(account?: PromiseOrValue<string> | null, staker?: null): LogUserMigrateFromV1EventFilter;
        LogUserMigrateFromV1(account?: PromiseOrValue<string> | null, staker?: null): LogUserMigrateFromV1EventFilter;
        'LogWithdraw(address,uint256,uint256)'(user?: PromiseOrValue<string> | null, pid?: PromiseOrValue<BigNumberish> | null, amount?: null): LogWithdrawEventFilter;
        LogWithdraw(user?: PromiseOrValue<string> | null, pid?: PromiseOrValue<BigNumberish> | null, amount?: null): LogWithdrawEventFilter;
        'OwnershipTransferred(address,address)'(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
        OwnershipTransferred(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
    };
    estimateGas: {
        PWRD(overrides?: CallOverrides): Promise<BigNumber>;
        TIME_LOCK(overrides?: CallOverrides): Promise<BigNumber>;
        activeLpTokens(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        add(allocPoint: PromiseOrValue<BigNumberish>, _lpToken: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        claim(vest: PromiseOrValue<boolean>, pid: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        claimable(_pid: PromiseOrValue<BigNumberish>, _user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        deposit(pid: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        emergencyWithdraw(pid: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        getUserPwrd(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        groPerBlock(overrides?: CallOverrides): Promise<BigNumber>;
        initialize(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        initialized(overrides?: CallOverrides): Promise<BigNumber>;
        manager(overrides?: CallOverrides): Promise<BigNumber>;
        massUpdatePools(pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        maxGroPerBlock(overrides?: CallOverrides): Promise<BigNumber>;
        migrate(pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        migrateFrom(pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        migrateFromV1(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        migrateUser(account: PromiseOrValue<string>, pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        migratedFromV1(overrides?: CallOverrides): Promise<BigNumber>;
        multiClaim(vest: PromiseOrValue<boolean>, pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        multiWithdraw(pids: PromiseOrValue<BigNumberish>[], amounts: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        multiWithdrawAndClaim(vest: PromiseOrValue<boolean>, pids: PromiseOrValue<BigNumberish>[], amounts: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        newStaker(overrides?: CallOverrides): Promise<BigNumber>;
        oldStaker(overrides?: CallOverrides): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<BigNumber>;
        pPid(overrides?: CallOverrides): Promise<BigNumber>;
        paused(overrides?: CallOverrides): Promise<BigNumber>;
        poolInfo(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        poolLength(overrides?: CallOverrides): Promise<BigNumber>;
        renounceOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        set(_pid: PromiseOrValue<BigNumberish>, _allocPoint: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setGroPerBlock(_groPerBlock: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setManager(_manager: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setMaxGroPerBlock(_maxGroPerBlock: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setNewStaker(staker: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setOldStaker(staker: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setPwrdPid(_pPid: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setStatus(pause: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setVesting(_vesting: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        totalAllocPoint(overrides?: CallOverrides): Promise<BigNumber>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        updatePool(pid: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        userInfo(arg0: PromiseOrValue<BigNumberish>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        userMigrated(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        vesting(overrides?: CallOverrides): Promise<BigNumber>;
        withdraw(pid: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        withdrawAndClaim(vest: PromiseOrValue<boolean>, pid: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        PWRD(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        TIME_LOCK(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        activeLpTokens(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        add(allocPoint: PromiseOrValue<BigNumberish>, _lpToken: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        claim(vest: PromiseOrValue<boolean>, pid: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        claimable(_pid: PromiseOrValue<BigNumberish>, _user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        deposit(pid: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        emergencyWithdraw(pid: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        getUserPwrd(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        groPerBlock(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        initialize(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        initialized(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        manager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        massUpdatePools(pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        maxGroPerBlock(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        migrate(pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        migrateFrom(pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        migrateFromV1(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        migrateUser(account: PromiseOrValue<string>, pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        migratedFromV1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        multiClaim(vest: PromiseOrValue<boolean>, pids: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        multiWithdraw(pids: PromiseOrValue<BigNumberish>[], amounts: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        multiWithdrawAndClaim(vest: PromiseOrValue<boolean>, pids: PromiseOrValue<BigNumberish>[], amounts: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        newStaker(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        oldStaker(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        pPid(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        paused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        poolInfo(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        poolLength(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        set(_pid: PromiseOrValue<BigNumberish>, _allocPoint: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setGroPerBlock(_groPerBlock: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setManager(_manager: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setMaxGroPerBlock(_maxGroPerBlock: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setNewStaker(staker: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setOldStaker(staker: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setPwrdPid(_pPid: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setStatus(pause: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setVesting(_vesting: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        totalAllocPoint(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        updatePool(pid: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        userInfo(arg0: PromiseOrValue<BigNumberish>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        userMigrated(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        vesting(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        withdraw(pid: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        withdrawAndClaim(vest: PromiseOrValue<boolean>, pid: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
    };
}
