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 interface VectorFinanceMasterChefInterface extends utils.Interface {
    functions: {
        'PoolManagers(address)': FunctionFragment;
        '__MasterChefVTX_init(address,uint256,uint256)': FunctionFragment;
        'add(uint256,address,address,address)': FunctionFragment;
        'addressToPoolInfo(address)': FunctionFragment;
        'allowEmergency()': FunctionFragment;
        'authorizeForLock(address)': FunctionFragment;
        'authorizeLocker(address)': FunctionFragment;
        'claimLock(address)': FunctionFragment;
        'createRewarder(address,address)': FunctionFragment;
        'deposit(address,uint256)': FunctionFragment;
        'depositFor(address,uint256,address)': FunctionFragment;
        'depositInfo(address,address)': FunctionFragment;
        'emergencyWithdraw(address)': FunctionFragment;
        'emergencyWithdrawWithReward(address)': FunctionFragment;
        'getPoolInfo(address)': FunctionFragment;
        'isAuthorizedForLock(address)': FunctionFragment;
        'lock(address,uint256,uint256,bool)': FunctionFragment;
        'lockFor(address,uint256,uint256,address,bool)': FunctionFragment;
        'massUpdatePools()': FunctionFragment;
        'multiUnlock(address,uint256[],uint256[])': FunctionFragment;
        'multiclaim(address[],address)': FunctionFragment;
        'owner()': FunctionFragment;
        'pendingTokens(address,address,address)': FunctionFragment;
        'poolLength()': FunctionFragment;
        'realEmergencyWithdraw(address)': FunctionFragment;
        'registeredToken(uint256)': FunctionFragment;
        'renounceOwnership()': FunctionFragment;
        'set(address,uint256,address,address,bool)': FunctionFragment;
        'setPoolHelper(address,address)': FunctionFragment;
        'setPoolManagerStatus(address,bool)': FunctionFragment;
        'startTimestamp()': FunctionFragment;
        'totalAllocPoint()': FunctionFragment;
        'transferOwnership(address)': FunctionFragment;
        'unlock(address,uint256,uint256)': FunctionFragment;
        'updateEmissionRate(uint256)': FunctionFragment;
        'updatePool(address)': FunctionFragment;
        'vtx()': FunctionFragment;
        'vtxPerSec()': FunctionFragment;
        'withdraw(address,uint256)': FunctionFragment;
        'withdrawFor(address,uint256,address)': FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: 'PoolManagers' | '__MasterChefVTX_init' | 'add' | 'addressToPoolInfo' | 'allowEmergency' | 'authorizeForLock' | 'authorizeLocker' | 'claimLock' | 'createRewarder' | 'deposit' | 'depositFor' | 'depositInfo' | 'emergencyWithdraw' | 'emergencyWithdrawWithReward' | 'getPoolInfo' | 'isAuthorizedForLock' | 'lock' | 'lockFor' | 'massUpdatePools' | 'multiUnlock' | 'multiclaim' | 'owner' | 'pendingTokens' | 'poolLength' | 'realEmergencyWithdraw' | 'registeredToken' | 'renounceOwnership' | 'set' | 'setPoolHelper' | 'setPoolManagerStatus' | 'startTimestamp' | 'totalAllocPoint' | 'transferOwnership' | 'unlock' | 'updateEmissionRate' | 'updatePool' | 'vtx' | 'vtxPerSec' | 'withdraw' | 'withdrawFor'): FunctionFragment;
    encodeFunctionData(functionFragment: 'PoolManagers', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: '__MasterChefVTX_init', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'add', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>, PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'addressToPoolInfo', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'allowEmergency', values?: undefined): string;
    encodeFunctionData(functionFragment: 'authorizeForLock', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'authorizeLocker', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'claimLock', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'createRewarder', values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'deposit', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'depositFor', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'depositInfo', values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'emergencyWithdraw', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'emergencyWithdrawWithReward', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'getPoolInfo', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'isAuthorizedForLock', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'lock', values: [
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<boolean>
    ]): string;
    encodeFunctionData(functionFragment: 'lockFor', values: [
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<string>,
        PromiseOrValue<boolean>
    ]): string;
    encodeFunctionData(functionFragment: 'massUpdatePools', values?: undefined): string;
    encodeFunctionData(functionFragment: 'multiUnlock', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>[], PromiseOrValue<BigNumberish>[]]): string;
    encodeFunctionData(functionFragment: 'multiclaim', values: [PromiseOrValue<string>[], PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'owner', values?: undefined): string;
    encodeFunctionData(functionFragment: 'pendingTokens', values: [PromiseOrValue<string>, PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'poolLength', values?: undefined): string;
    encodeFunctionData(functionFragment: 'realEmergencyWithdraw', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'registeredToken', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'renounceOwnership', values?: undefined): string;
    encodeFunctionData(functionFragment: 'set', values: [
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<boolean>
    ]): string;
    encodeFunctionData(functionFragment: 'setPoolHelper', values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'setPoolManagerStatus', values: [PromiseOrValue<string>, PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: 'startTimestamp', values?: undefined): string;
    encodeFunctionData(functionFragment: 'totalAllocPoint', values?: undefined): string;
    encodeFunctionData(functionFragment: 'transferOwnership', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'unlock', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'updateEmissionRate', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'updatePool', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'vtx', values?: undefined): string;
    encodeFunctionData(functionFragment: 'vtxPerSec', values?: undefined): string;
    encodeFunctionData(functionFragment: 'withdraw', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'withdrawFor', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
    decodeFunctionResult(functionFragment: 'PoolManagers', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: '__MasterChefVTX_init', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'add', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'addressToPoolInfo', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'allowEmergency', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'authorizeForLock', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'authorizeLocker', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'claimLock', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'createRewarder', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'deposit', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'depositFor', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'depositInfo', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'emergencyWithdraw', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'emergencyWithdrawWithReward', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getPoolInfo', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'isAuthorizedForLock', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'lock', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'lockFor', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'massUpdatePools', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'multiUnlock', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'multiclaim', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'pendingTokens', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'poolLength', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'realEmergencyWithdraw', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'registeredToken', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'renounceOwnership', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'set', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setPoolHelper', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setPoolManagerStatus', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'startTimestamp', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'totalAllocPoint', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'transferOwnership', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'unlock', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'updateEmissionRate', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'updatePool', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'vtx', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'vtxPerSec', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'withdraw', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'withdrawFor', data: BytesLike): Result;
    events: {
        'Add(uint256,address,address)': EventFragment;
        'Deposit(address,address,uint256)': EventFragment;
        'EmergencyWithdraw(address,address,uint256)': EventFragment;
        'Harvest(address,address,uint256)': EventFragment;
        'Locked(address,address,uint256)': EventFragment;
        'OwnershipTransferred(address,address)': EventFragment;
        'Set(address,uint256,address,address,bool)': EventFragment;
        'Unlocked(address,address,uint256)': EventFragment;
        'UpdateEmissionRate(address,uint256)': EventFragment;
        'UpdatePool(address,uint256,uint256,uint256)': EventFragment;
        'Withdraw(address,address,uint256)': EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: 'Add'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'Deposit'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'EmergencyWithdraw'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'Harvest'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'Locked'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'Set'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'Unlocked'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'UpdateEmissionRate'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'UpdatePool'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'Withdraw'): EventFragment;
}
export interface AddEventObject {
    allocPoint: BigNumber;
    lpToken: string;
    rewarder: string;
}
export declare type AddEvent = TypedEvent<[BigNumber, string, string], AddEventObject>;
export declare type AddEventFilter = TypedEventFilter<AddEvent>;
export interface DepositEventObject {
    user: string;
    lpToken: string;
    amount: BigNumber;
}
export declare type DepositEvent = TypedEvent<[string, string, BigNumber], DepositEventObject>;
export declare type DepositEventFilter = TypedEventFilter<DepositEvent>;
export interface EmergencyWithdrawEventObject {
    user: string;
    lpToken: string;
    amount: BigNumber;
}
export declare type EmergencyWithdrawEvent = TypedEvent<[string, string, BigNumber], EmergencyWithdrawEventObject>;
export declare type EmergencyWithdrawEventFilter = TypedEventFilter<EmergencyWithdrawEvent>;
export interface HarvestEventObject {
    user: string;
    lpToken: string;
    amount: BigNumber;
}
export declare type HarvestEvent = TypedEvent<[string, string, BigNumber], HarvestEventObject>;
export declare type HarvestEventFilter = TypedEventFilter<HarvestEvent>;
export interface LockedEventObject {
    user: string;
    lpToken: string;
    amount: BigNumber;
}
export declare type LockedEvent = TypedEvent<[string, string, BigNumber], LockedEventObject>;
export declare type LockedEventFilter = TypedEventFilter<LockedEvent>;
export interface OwnershipTransferredEventObject {
    previousOwner: string;
    newOwner: string;
}
export declare type OwnershipTransferredEvent = TypedEvent<[string, string], OwnershipTransferredEventObject>;
export declare type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
export interface SetEventObject {
    lpToken: string;
    allocPoint: BigNumber;
    rewarder: string;
    locker: string;
    overwrite: boolean;
}
export declare type SetEvent = TypedEvent<[string, BigNumber, string, string, boolean], SetEventObject>;
export declare type SetEventFilter = TypedEventFilter<SetEvent>;
export interface UnlockedEventObject {
    user: string;
    lpToken: string;
    amount: BigNumber;
}
export declare type UnlockedEvent = TypedEvent<[string, string, BigNumber], UnlockedEventObject>;
export declare type UnlockedEventFilter = TypedEventFilter<UnlockedEvent>;
export interface UpdateEmissionRateEventObject {
    user: string;
    _vtxPerSec: BigNumber;
}
export declare type UpdateEmissionRateEvent = TypedEvent<[string, BigNumber], UpdateEmissionRateEventObject>;
export declare type UpdateEmissionRateEventFilter = TypedEventFilter<UpdateEmissionRateEvent>;
export interface UpdatePoolEventObject {
    lpToken: string;
    lastRewardTimestamp: BigNumber;
    lpSupply: BigNumber;
    accVTXPerShare: BigNumber;
}
export declare type UpdatePoolEvent = TypedEvent<[string, BigNumber, BigNumber, BigNumber], UpdatePoolEventObject>;
export declare type UpdatePoolEventFilter = TypedEventFilter<UpdatePoolEvent>;
export interface WithdrawEventObject {
    user: string;
    lpToken: string;
    amount: BigNumber;
}
export declare type WithdrawEvent = TypedEvent<[string, string, BigNumber], WithdrawEventObject>;
export declare type WithdrawEventFilter = TypedEventFilter<WithdrawEvent>;
export interface VectorFinanceMasterChef extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: VectorFinanceMasterChefInterface;
    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: {
        PoolManagers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        __MasterChefVTX_init(_vtx: PromiseOrValue<string>, _vtxPerSec: PromiseOrValue<BigNumberish>, _startTimestamp: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        add(_allocPoint: PromiseOrValue<BigNumberish>, _lpToken: PromiseOrValue<string>, _rewarder: PromiseOrValue<string>, _helper: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        addressToPoolInfo(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            string,
            BigNumber,
            BigNumber,
            BigNumber,
            string,
            string,
            string
        ] & {
            lpToken: string;
            allocPoint: BigNumber;
            lastRewardTimestamp: BigNumber;
            accVTXPerShare: BigNumber;
            rewarder: string;
            helper: string;
            locker: string;
        }>;
        allowEmergency(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        authorizeForLock(_address: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        authorizeLocker(_locker: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        claimLock(_lp: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        createRewarder(_lpToken: PromiseOrValue<string>, mainRewardToken: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        deposit(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        depositFor(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, sender: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        depositInfo(_lp: PromiseOrValue<string>, _user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber] & {
            availableAmount: BigNumber;
        }>;
        emergencyWithdraw(_lp: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        emergencyWithdrawWithReward(_lp: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        getPoolInfo(token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            emission: BigNumber;
            allocpoint: BigNumber;
            sizeOfPool: BigNumber;
            totalPoint: BigNumber;
        }>;
        isAuthorizedForLock(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        lock(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _index: PromiseOrValue<BigNumberish>, force: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        lockFor(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _index: PromiseOrValue<BigNumberish>, _for: PromiseOrValue<string>, force: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        massUpdatePools(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        multiUnlock(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>[], _index: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        multiclaim(_lps: PromiseOrValue<string>[], user_address: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        owner(overrides?: CallOverrides): Promise<[string]>;
        pendingTokens(_lp: PromiseOrValue<string>, _user: PromiseOrValue<string>, token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            BigNumber,
            string,
            string,
            BigNumber
        ] & {
            pendingVTX: BigNumber;
            bonusTokenAddress: string;
            bonusTokenSymbol: string;
            pendingBonusToken: BigNumber;
        }>;
        poolLength(overrides?: CallOverrides): Promise<[BigNumber]>;
        realEmergencyWithdraw(_lp: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        registeredToken(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
        renounceOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        set(_lp: PromiseOrValue<string>, _allocPoint: PromiseOrValue<BigNumberish>, _rewarder: PromiseOrValue<string>, _locker: PromiseOrValue<string>, overwrite: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setPoolHelper(_lp: PromiseOrValue<string>, _helper: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setPoolManagerStatus(_address: PromiseOrValue<string>, _bool: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        startTimestamp(overrides?: CallOverrides): Promise<[BigNumber]>;
        totalAllocPoint(overrides?: CallOverrides): Promise<[BigNumber]>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        unlock(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _index: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        updateEmissionRate(_vtxPerSec: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        updatePool(_lp: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        vtx(overrides?: CallOverrides): Promise<[string]>;
        vtxPerSec(overrides?: CallOverrides): Promise<[BigNumber]>;
        withdraw(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdrawFor(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _sender: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
    };
    PoolManagers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    __MasterChefVTX_init(_vtx: PromiseOrValue<string>, _vtxPerSec: PromiseOrValue<BigNumberish>, _startTimestamp: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    add(_allocPoint: PromiseOrValue<BigNumberish>, _lpToken: PromiseOrValue<string>, _rewarder: PromiseOrValue<string>, _helper: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    addressToPoolInfo(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
        string,
        BigNumber,
        BigNumber,
        BigNumber,
        string,
        string,
        string
    ] & {
        lpToken: string;
        allocPoint: BigNumber;
        lastRewardTimestamp: BigNumber;
        accVTXPerShare: BigNumber;
        rewarder: string;
        helper: string;
        locker: string;
    }>;
    allowEmergency(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    authorizeForLock(_address: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    authorizeLocker(_locker: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    claimLock(_lp: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    createRewarder(_lpToken: PromiseOrValue<string>, mainRewardToken: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    deposit(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    depositFor(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, sender: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    depositInfo(_lp: PromiseOrValue<string>, _user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    emergencyWithdraw(_lp: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    emergencyWithdrawWithReward(_lp: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    getPoolInfo(token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        emission: BigNumber;
        allocpoint: BigNumber;
        sizeOfPool: BigNumber;
        totalPoint: BigNumber;
    }>;
    isAuthorizedForLock(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    lock(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _index: PromiseOrValue<BigNumberish>, force: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    lockFor(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _index: PromiseOrValue<BigNumberish>, _for: PromiseOrValue<string>, force: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    massUpdatePools(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    multiUnlock(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>[], _index: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    multiclaim(_lps: PromiseOrValue<string>[], user_address: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    owner(overrides?: CallOverrides): Promise<string>;
    pendingTokens(_lp: PromiseOrValue<string>, _user: PromiseOrValue<string>, token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
        BigNumber,
        string,
        string,
        BigNumber
    ] & {
        pendingVTX: BigNumber;
        bonusTokenAddress: string;
        bonusTokenSymbol: string;
        pendingBonusToken: BigNumber;
    }>;
    poolLength(overrides?: CallOverrides): Promise<BigNumber>;
    realEmergencyWithdraw(_lp: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    registeredToken(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
    renounceOwnership(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    set(_lp: PromiseOrValue<string>, _allocPoint: PromiseOrValue<BigNumberish>, _rewarder: PromiseOrValue<string>, _locker: PromiseOrValue<string>, overwrite: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setPoolHelper(_lp: PromiseOrValue<string>, _helper: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setPoolManagerStatus(_address: PromiseOrValue<string>, _bool: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    startTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
    totalAllocPoint(overrides?: CallOverrides): Promise<BigNumber>;
    transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    unlock(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _index: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    updateEmissionRate(_vtxPerSec: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    updatePool(_lp: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    vtx(overrides?: CallOverrides): Promise<string>;
    vtxPerSec(overrides?: CallOverrides): Promise<BigNumber>;
    withdraw(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdrawFor(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _sender: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    callStatic: {
        PoolManagers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        __MasterChefVTX_init(_vtx: PromiseOrValue<string>, _vtxPerSec: PromiseOrValue<BigNumberish>, _startTimestamp: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        add(_allocPoint: PromiseOrValue<BigNumberish>, _lpToken: PromiseOrValue<string>, _rewarder: PromiseOrValue<string>, _helper: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        addressToPoolInfo(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            string,
            BigNumber,
            BigNumber,
            BigNumber,
            string,
            string,
            string
        ] & {
            lpToken: string;
            allocPoint: BigNumber;
            lastRewardTimestamp: BigNumber;
            accVTXPerShare: BigNumber;
            rewarder: string;
            helper: string;
            locker: string;
        }>;
        allowEmergency(overrides?: CallOverrides): Promise<void>;
        authorizeForLock(_address: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        authorizeLocker(_locker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        claimLock(_lp: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        createRewarder(_lpToken: PromiseOrValue<string>, mainRewardToken: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
        deposit(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        depositFor(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, sender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        depositInfo(_lp: PromiseOrValue<string>, _user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        emergencyWithdraw(_lp: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        emergencyWithdrawWithReward(_lp: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        getPoolInfo(token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            emission: BigNumber;
            allocpoint: BigNumber;
            sizeOfPool: BigNumber;
            totalPoint: BigNumber;
        }>;
        isAuthorizedForLock(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        lock(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _index: PromiseOrValue<BigNumberish>, force: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        lockFor(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _index: PromiseOrValue<BigNumberish>, _for: PromiseOrValue<string>, force: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        massUpdatePools(overrides?: CallOverrides): Promise<void>;
        multiUnlock(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>[], _index: PromiseOrValue<BigNumberish>[], overrides?: CallOverrides): Promise<void>;
        multiclaim(_lps: PromiseOrValue<string>[], user_address: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        owner(overrides?: CallOverrides): Promise<string>;
        pendingTokens(_lp: PromiseOrValue<string>, _user: PromiseOrValue<string>, token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            BigNumber,
            string,
            string,
            BigNumber
        ] & {
            pendingVTX: BigNumber;
            bonusTokenAddress: string;
            bonusTokenSymbol: string;
            pendingBonusToken: BigNumber;
        }>;
        poolLength(overrides?: CallOverrides): Promise<BigNumber>;
        realEmergencyWithdraw(_lp: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        registeredToken(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
        renounceOwnership(overrides?: CallOverrides): Promise<void>;
        set(_lp: PromiseOrValue<string>, _allocPoint: PromiseOrValue<BigNumberish>, _rewarder: PromiseOrValue<string>, _locker: PromiseOrValue<string>, overwrite: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        setPoolHelper(_lp: PromiseOrValue<string>, _helper: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setPoolManagerStatus(_address: PromiseOrValue<string>, _bool: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        startTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
        totalAllocPoint(overrides?: CallOverrides): Promise<BigNumber>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        unlock(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        updateEmissionRate(_vtxPerSec: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        updatePool(_lp: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        vtx(overrides?: CallOverrides): Promise<string>;
        vtxPerSec(overrides?: CallOverrides): Promise<BigNumber>;
        withdraw(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        withdrawFor(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _sender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
    };
    filters: {
        'Add(uint256,address,address)'(allocPoint?: null, lpToken?: PromiseOrValue<string> | null, rewarder?: PromiseOrValue<string> | null): AddEventFilter;
        Add(allocPoint?: null, lpToken?: PromiseOrValue<string> | null, rewarder?: PromiseOrValue<string> | null): AddEventFilter;
        'Deposit(address,address,uint256)'(user?: PromiseOrValue<string> | null, lpToken?: PromiseOrValue<string> | null, amount?: null): DepositEventFilter;
        Deposit(user?: PromiseOrValue<string> | null, lpToken?: PromiseOrValue<string> | null, amount?: null): DepositEventFilter;
        'EmergencyWithdraw(address,address,uint256)'(user?: PromiseOrValue<string> | null, lpToken?: PromiseOrValue<string> | null, amount?: null): EmergencyWithdrawEventFilter;
        EmergencyWithdraw(user?: PromiseOrValue<string> | null, lpToken?: PromiseOrValue<string> | null, amount?: null): EmergencyWithdrawEventFilter;
        'Harvest(address,address,uint256)'(user?: PromiseOrValue<string> | null, lpToken?: PromiseOrValue<string> | null, amount?: null): HarvestEventFilter;
        Harvest(user?: PromiseOrValue<string> | null, lpToken?: PromiseOrValue<string> | null, amount?: null): HarvestEventFilter;
        'Locked(address,address,uint256)'(user?: PromiseOrValue<string> | null, lpToken?: PromiseOrValue<string> | null, amount?: null): LockedEventFilter;
        Locked(user?: PromiseOrValue<string> | null, lpToken?: PromiseOrValue<string> | null, amount?: null): LockedEventFilter;
        'OwnershipTransferred(address,address)'(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
        OwnershipTransferred(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
        'Set(address,uint256,address,address,bool)'(lpToken?: PromiseOrValue<string> | null, allocPoint?: null, rewarder?: PromiseOrValue<string> | null, locker?: PromiseOrValue<string> | null, overwrite?: null): SetEventFilter;
        Set(lpToken?: PromiseOrValue<string> | null, allocPoint?: null, rewarder?: PromiseOrValue<string> | null, locker?: PromiseOrValue<string> | null, overwrite?: null): SetEventFilter;
        'Unlocked(address,address,uint256)'(user?: PromiseOrValue<string> | null, lpToken?: PromiseOrValue<string> | null, amount?: null): UnlockedEventFilter;
        Unlocked(user?: PromiseOrValue<string> | null, lpToken?: PromiseOrValue<string> | null, amount?: null): UnlockedEventFilter;
        'UpdateEmissionRate(address,uint256)'(user?: PromiseOrValue<string> | null, _vtxPerSec?: null): UpdateEmissionRateEventFilter;
        UpdateEmissionRate(user?: PromiseOrValue<string> | null, _vtxPerSec?: null): UpdateEmissionRateEventFilter;
        'UpdatePool(address,uint256,uint256,uint256)'(lpToken?: PromiseOrValue<string> | null, lastRewardTimestamp?: null, lpSupply?: null, accVTXPerShare?: null): UpdatePoolEventFilter;
        UpdatePool(lpToken?: PromiseOrValue<string> | null, lastRewardTimestamp?: null, lpSupply?: null, accVTXPerShare?: null): UpdatePoolEventFilter;
        'Withdraw(address,address,uint256)'(user?: PromiseOrValue<string> | null, lpToken?: PromiseOrValue<string> | null, amount?: null): WithdrawEventFilter;
        Withdraw(user?: PromiseOrValue<string> | null, lpToken?: PromiseOrValue<string> | null, amount?: null): WithdrawEventFilter;
    };
    estimateGas: {
        PoolManagers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        __MasterChefVTX_init(_vtx: PromiseOrValue<string>, _vtxPerSec: PromiseOrValue<BigNumberish>, _startTimestamp: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        add(_allocPoint: PromiseOrValue<BigNumberish>, _lpToken: PromiseOrValue<string>, _rewarder: PromiseOrValue<string>, _helper: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        addressToPoolInfo(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        allowEmergency(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        authorizeForLock(_address: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        authorizeLocker(_locker: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        claimLock(_lp: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        createRewarder(_lpToken: PromiseOrValue<string>, mainRewardToken: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        deposit(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        depositFor(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, sender: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        depositInfo(_lp: PromiseOrValue<string>, _user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        emergencyWithdraw(_lp: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        emergencyWithdrawWithReward(_lp: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        getPoolInfo(token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        isAuthorizedForLock(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        lock(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _index: PromiseOrValue<BigNumberish>, force: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        lockFor(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _index: PromiseOrValue<BigNumberish>, _for: PromiseOrValue<string>, force: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        massUpdatePools(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        multiUnlock(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>[], _index: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        multiclaim(_lps: PromiseOrValue<string>[], user_address: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<BigNumber>;
        pendingTokens(_lp: PromiseOrValue<string>, _user: PromiseOrValue<string>, token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        poolLength(overrides?: CallOverrides): Promise<BigNumber>;
        realEmergencyWithdraw(_lp: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        registeredToken(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        renounceOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        set(_lp: PromiseOrValue<string>, _allocPoint: PromiseOrValue<BigNumberish>, _rewarder: PromiseOrValue<string>, _locker: PromiseOrValue<string>, overwrite: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setPoolHelper(_lp: PromiseOrValue<string>, _helper: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setPoolManagerStatus(_address: PromiseOrValue<string>, _bool: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        startTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
        totalAllocPoint(overrides?: CallOverrides): Promise<BigNumber>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        unlock(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _index: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        updateEmissionRate(_vtxPerSec: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        updatePool(_lp: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        vtx(overrides?: CallOverrides): Promise<BigNumber>;
        vtxPerSec(overrides?: CallOverrides): Promise<BigNumber>;
        withdraw(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        withdrawFor(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _sender: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        PoolManagers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        __MasterChefVTX_init(_vtx: PromiseOrValue<string>, _vtxPerSec: PromiseOrValue<BigNumberish>, _startTimestamp: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        add(_allocPoint: PromiseOrValue<BigNumberish>, _lpToken: PromiseOrValue<string>, _rewarder: PromiseOrValue<string>, _helper: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        addressToPoolInfo(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        allowEmergency(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        authorizeForLock(_address: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        authorizeLocker(_locker: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        claimLock(_lp: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        createRewarder(_lpToken: PromiseOrValue<string>, mainRewardToken: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        deposit(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        depositFor(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, sender: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        depositInfo(_lp: PromiseOrValue<string>, _user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        emergencyWithdraw(_lp: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        emergencyWithdrawWithReward(_lp: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        getPoolInfo(token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isAuthorizedForLock(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lock(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _index: PromiseOrValue<BigNumberish>, force: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        lockFor(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _index: PromiseOrValue<BigNumberish>, _for: PromiseOrValue<string>, force: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        massUpdatePools(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        multiUnlock(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>[], _index: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        multiclaim(_lps: PromiseOrValue<string>[], user_address: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        pendingTokens(_lp: PromiseOrValue<string>, _user: PromiseOrValue<string>, token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        poolLength(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        realEmergencyWithdraw(_lp: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        registeredToken(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        set(_lp: PromiseOrValue<string>, _allocPoint: PromiseOrValue<BigNumberish>, _rewarder: PromiseOrValue<string>, _locker: PromiseOrValue<string>, overwrite: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setPoolHelper(_lp: PromiseOrValue<string>, _helper: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setPoolManagerStatus(_address: PromiseOrValue<string>, _bool: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        startTimestamp(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalAllocPoint(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        unlock(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _index: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        updateEmissionRate(_vtxPerSec: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        updatePool(_lp: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        vtx(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        vtxPerSec(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        withdraw(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        withdrawFor(_lp: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _sender: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
    };
}
