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 CommunalFarm {
    type LockedStakeStruct = {
        kek_id: PromiseOrValue<BytesLike>;
        start_timestamp: PromiseOrValue<BigNumberish>;
        liquidity: PromiseOrValue<BigNumberish>;
        ending_timestamp: PromiseOrValue<BigNumberish>;
        lock_multiplier: PromiseOrValue<BigNumberish>;
    };
    type LockedStakeStructOutput = [string, BigNumber, BigNumber, BigNumber, BigNumber] & {
        kek_id: string;
        start_timestamp: BigNumber;
        liquidity: BigNumber;
        ending_timestamp: BigNumber;
        lock_multiplier: BigNumber;
    };
}
export interface SaddleCommunalFarmInterface extends utils.Interface {
    functions: {
        'acceptOwnership()': FunctionFragment;
        'calcCurCombinedWeight(address)': FunctionFragment;
        'changeTokenManager(address,address)': FunctionFragment;
        'combinedWeightOf(address)': FunctionFragment;
        'earned(address)': FunctionFragment;
        'getAllRewardTokens()': FunctionFragment;
        'getReward()': FunctionFragment;
        'getRewardForDuration()': FunctionFragment;
        'getRewardSymbols()': FunctionFragment;
        'greylist(address)': FunctionFragment;
        'greylistAddress(address)': FunctionFragment;
        'initializeDefault()': FunctionFragment;
        'isTokenManagerFor(address,address)': FunctionFragment;
        'lastUpdateTime()': FunctionFragment;
        'lockMultiplier(uint256)': FunctionFragment;
        'lock_max_multiplier()': FunctionFragment;
        'lock_time_for_max_multiplier()': FunctionFragment;
        'lock_time_min()': FunctionFragment;
        'lockedLiquidityOf(address)': FunctionFragment;
        'lockedStakesOf(address)': FunctionFragment;
        'nominateNewOwner(address)': FunctionFragment;
        'nominatedOwner()': FunctionFragment;
        'owner()': FunctionFragment;
        'periodFinish()': FunctionFragment;
        'recoverERC20(address,uint256)': FunctionFragment;
        'rewardManagers(address)': FunctionFragment;
        'rewardRates(uint256)': FunctionFragment;
        'rewardSymbols(uint256)': FunctionFragment;
        'rewardTokenAddrToIdx(address)': FunctionFragment;
        'rewardTokens(uint256)': FunctionFragment;
        'rewardsCollectionPaused()': FunctionFragment;
        'rewardsDuration()': FunctionFragment;
        'rewardsPerToken()': FunctionFragment;
        'setLockedStakeTimeForMinAndMaxMultiplier(uint256,uint256)': FunctionFragment;
        'setMultipliers(uint256)': FunctionFragment;
        'setRewardRate(address,uint256,bool)': FunctionFragment;
        'setRewardsDuration(uint256)': FunctionFragment;
        'stakeLocked(uint256,uint256)': FunctionFragment;
        'stakesUnlocked()': FunctionFragment;
        'stakingPaused()': FunctionFragment;
        'sync()': FunctionFragment;
        'toggleRewardsCollection()': FunctionFragment;
        'toggleStaking()': FunctionFragment;
        'toggleWithdrawals()': FunctionFragment;
        'totalCombinedWeight()': FunctionFragment;
        'totalLiquidityLocked()': FunctionFragment;
        'unlockStakes()': FunctionFragment;
        'withdrawLocked(bytes32)': FunctionFragment;
        'withdrawalsPaused()': FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: 'acceptOwnership' | 'calcCurCombinedWeight' | 'changeTokenManager' | 'combinedWeightOf' | 'earned' | 'getAllRewardTokens' | 'getReward' | 'getRewardForDuration' | 'getRewardSymbols' | 'greylist' | 'greylistAddress' | 'initializeDefault' | 'isTokenManagerFor' | 'lastUpdateTime' | 'lockMultiplier' | 'lock_max_multiplier' | 'lock_time_for_max_multiplier' | 'lock_time_min' | 'lockedLiquidityOf' | 'lockedStakesOf' | 'nominateNewOwner' | 'nominatedOwner' | 'owner' | 'periodFinish' | 'recoverERC20' | 'rewardManagers' | 'rewardRates' | 'rewardSymbols' | 'rewardTokenAddrToIdx' | 'rewardTokens' | 'rewardsCollectionPaused' | 'rewardsDuration' | 'rewardsPerToken' | 'setLockedStakeTimeForMinAndMaxMultiplier' | 'setMultipliers' | 'setRewardRate' | 'setRewardsDuration' | 'stakeLocked' | 'stakesUnlocked' | 'stakingPaused' | 'sync' | 'toggleRewardsCollection' | 'toggleStaking' | 'toggleWithdrawals' | 'totalCombinedWeight' | 'totalLiquidityLocked' | 'unlockStakes' | 'withdrawLocked' | 'withdrawalsPaused'): FunctionFragment;
    encodeFunctionData(functionFragment: 'acceptOwnership', values?: undefined): string;
    encodeFunctionData(functionFragment: 'calcCurCombinedWeight', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'changeTokenManager', values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'combinedWeightOf', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'earned', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'getAllRewardTokens', values?: undefined): string;
    encodeFunctionData(functionFragment: 'getReward', values?: undefined): string;
    encodeFunctionData(functionFragment: 'getRewardForDuration', values?: undefined): string;
    encodeFunctionData(functionFragment: 'getRewardSymbols', values?: undefined): string;
    encodeFunctionData(functionFragment: 'greylist', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'greylistAddress', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'initializeDefault', values?: undefined): string;
    encodeFunctionData(functionFragment: 'isTokenManagerFor', values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'lastUpdateTime', values?: undefined): string;
    encodeFunctionData(functionFragment: 'lockMultiplier', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'lock_max_multiplier', values?: undefined): string;
    encodeFunctionData(functionFragment: 'lock_time_for_max_multiplier', values?: undefined): string;
    encodeFunctionData(functionFragment: 'lock_time_min', values?: undefined): string;
    encodeFunctionData(functionFragment: 'lockedLiquidityOf', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'lockedStakesOf', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'nominateNewOwner', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'nominatedOwner', values?: undefined): string;
    encodeFunctionData(functionFragment: 'owner', values?: undefined): string;
    encodeFunctionData(functionFragment: 'periodFinish', values?: undefined): string;
    encodeFunctionData(functionFragment: 'recoverERC20', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'rewardManagers', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'rewardRates', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'rewardSymbols', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'rewardTokenAddrToIdx', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'rewardTokens', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'rewardsCollectionPaused', values?: undefined): string;
    encodeFunctionData(functionFragment: 'rewardsDuration', values?: undefined): string;
    encodeFunctionData(functionFragment: 'rewardsPerToken', values?: undefined): string;
    encodeFunctionData(functionFragment: 'setLockedStakeTimeForMinAndMaxMultiplier', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setMultipliers', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setRewardRate', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>, PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: 'setRewardsDuration', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'stakeLocked', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'stakesUnlocked', values?: undefined): string;
    encodeFunctionData(functionFragment: 'stakingPaused', values?: undefined): string;
    encodeFunctionData(functionFragment: 'sync', values?: undefined): string;
    encodeFunctionData(functionFragment: 'toggleRewardsCollection', values?: undefined): string;
    encodeFunctionData(functionFragment: 'toggleStaking', values?: undefined): string;
    encodeFunctionData(functionFragment: 'toggleWithdrawals', values?: undefined): string;
    encodeFunctionData(functionFragment: 'totalCombinedWeight', values?: undefined): string;
    encodeFunctionData(functionFragment: 'totalLiquidityLocked', values?: undefined): string;
    encodeFunctionData(functionFragment: 'unlockStakes', values?: undefined): string;
    encodeFunctionData(functionFragment: 'withdrawLocked', values: [PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: 'withdrawalsPaused', values?: undefined): string;
    decodeFunctionResult(functionFragment: 'acceptOwnership', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'calcCurCombinedWeight', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'changeTokenManager', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'combinedWeightOf', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'earned', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getAllRewardTokens', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getReward', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getRewardForDuration', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getRewardSymbols', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'greylist', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'greylistAddress', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'initializeDefault', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'isTokenManagerFor', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'lastUpdateTime', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'lockMultiplier', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'lock_max_multiplier', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'lock_time_for_max_multiplier', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'lock_time_min', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'lockedLiquidityOf', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'lockedStakesOf', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'nominateNewOwner', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'nominatedOwner', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'periodFinish', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'recoverERC20', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'rewardManagers', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'rewardRates', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'rewardSymbols', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'rewardTokenAddrToIdx', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'rewardTokens', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'rewardsCollectionPaused', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'rewardsDuration', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'rewardsPerToken', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setLockedStakeTimeForMinAndMaxMultiplier', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setMultipliers', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setRewardRate', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setRewardsDuration', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'stakeLocked', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'stakesUnlocked', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'stakingPaused', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'sync', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'toggleRewardsCollection', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'toggleStaking', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'toggleWithdrawals', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'totalCombinedWeight', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'totalLiquidityLocked', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'unlockStakes', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'withdrawLocked', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'withdrawalsPaused', data: BytesLike): Result;
    events: {
        'DefaultInitialization()': EventFragment;
        'LockedStakeMaxMultiplierUpdated(uint256)': EventFragment;
        'LockedStakeMinTime(uint256)': EventFragment;
        'LockedStakeTimeForMaxMultiplier(uint256)': EventFragment;
        'OwnerChanged(address,address)': EventFragment;
        'OwnerNominated(address)': EventFragment;
        'Recovered(address,address,uint256)': EventFragment;
        'RewardPaid(address,uint256,address,address)': EventFragment;
        'RewardsDurationUpdated(uint256)': EventFragment;
        'RewardsPeriodRenewed(address)': EventFragment;
        'StakeLocked(address,uint256,uint256,bytes32,address)': EventFragment;
        'WithdrawLocked(address,uint256,bytes32,address)': EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: 'DefaultInitialization'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LockedStakeMaxMultiplierUpdated'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LockedStakeMinTime'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'LockedStakeTimeForMaxMultiplier'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'OwnerChanged'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'OwnerNominated'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'Recovered'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'RewardPaid'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'RewardsDurationUpdated'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'RewardsPeriodRenewed'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'StakeLocked'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'WithdrawLocked'): EventFragment;
}
export interface DefaultInitializationEventObject {
}
export declare type DefaultInitializationEvent = TypedEvent<[], DefaultInitializationEventObject>;
export declare type DefaultInitializationEventFilter = TypedEventFilter<DefaultInitializationEvent>;
export interface LockedStakeMaxMultiplierUpdatedEventObject {
    multiplier: BigNumber;
}
export declare type LockedStakeMaxMultiplierUpdatedEvent = TypedEvent<[BigNumber], LockedStakeMaxMultiplierUpdatedEventObject>;
export declare type LockedStakeMaxMultiplierUpdatedEventFilter = TypedEventFilter<LockedStakeMaxMultiplierUpdatedEvent>;
export interface LockedStakeMinTimeEventObject {
    secs: BigNumber;
}
export declare type LockedStakeMinTimeEvent = TypedEvent<[BigNumber], LockedStakeMinTimeEventObject>;
export declare type LockedStakeMinTimeEventFilter = TypedEventFilter<LockedStakeMinTimeEvent>;
export interface LockedStakeTimeForMaxMultiplierEventObject {
    secs: BigNumber;
}
export declare type LockedStakeTimeForMaxMultiplierEvent = TypedEvent<[BigNumber], LockedStakeTimeForMaxMultiplierEventObject>;
export declare type LockedStakeTimeForMaxMultiplierEventFilter = TypedEventFilter<LockedStakeTimeForMaxMultiplierEvent>;
export interface OwnerChangedEventObject {
    oldOwner: string;
    newOwner: string;
}
export declare type OwnerChangedEvent = TypedEvent<[string, string], OwnerChangedEventObject>;
export declare type OwnerChangedEventFilter = TypedEventFilter<OwnerChangedEvent>;
export interface OwnerNominatedEventObject {
    newOwner: string;
}
export declare type OwnerNominatedEvent = TypedEvent<[string], OwnerNominatedEventObject>;
export declare type OwnerNominatedEventFilter = TypedEventFilter<OwnerNominatedEvent>;
export interface RecoveredEventObject {
    destination_address: string;
    token: string;
    amount: BigNumber;
}
export declare type RecoveredEvent = TypedEvent<[string, string, BigNumber], RecoveredEventObject>;
export declare type RecoveredEventFilter = TypedEventFilter<RecoveredEvent>;
export interface RewardPaidEventObject {
    user: string;
    reward: BigNumber;
    token_address: string;
    destination_address: string;
}
export declare type RewardPaidEvent = TypedEvent<[string, BigNumber, string, string], RewardPaidEventObject>;
export declare type RewardPaidEventFilter = TypedEventFilter<RewardPaidEvent>;
export interface RewardsDurationUpdatedEventObject {
    newDuration: BigNumber;
}
export declare type RewardsDurationUpdatedEvent = TypedEvent<[BigNumber], RewardsDurationUpdatedEventObject>;
export declare type RewardsDurationUpdatedEventFilter = TypedEventFilter<RewardsDurationUpdatedEvent>;
export interface RewardsPeriodRenewedEventObject {
    token: string;
}
export declare type RewardsPeriodRenewedEvent = TypedEvent<[string], RewardsPeriodRenewedEventObject>;
export declare type RewardsPeriodRenewedEventFilter = TypedEventFilter<RewardsPeriodRenewedEvent>;
export interface StakeLockedEventObject {
    user: string;
    amount: BigNumber;
    secs: BigNumber;
    kek_id: string;
    source_address: string;
}
export declare type StakeLockedEvent = TypedEvent<[string, BigNumber, BigNumber, string, string], StakeLockedEventObject>;
export declare type StakeLockedEventFilter = TypedEventFilter<StakeLockedEvent>;
export interface WithdrawLockedEventObject {
    user: string;
    amount: BigNumber;
    kek_id: string;
    destination_address: string;
}
export declare type WithdrawLockedEvent = TypedEvent<[string, BigNumber, string, string], WithdrawLockedEventObject>;
export declare type WithdrawLockedEventFilter = TypedEventFilter<WithdrawLockedEvent>;
export interface SaddleCommunalFarm extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: SaddleCommunalFarmInterface;
    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: {
        acceptOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        calcCurCombinedWeight(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber
        ] & {
            old_combined_weight: BigNumber;
            new_combined_weight: BigNumber;
        }>;
        changeTokenManager(reward_token_address: PromiseOrValue<string>, new_manager_address: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        combinedWeightOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        earned(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber[]] & {
            new_earned: BigNumber[];
        }>;
        getAllRewardTokens(overrides?: CallOverrides): Promise<[string[]]>;
        getReward(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        getRewardForDuration(overrides?: CallOverrides): Promise<[BigNumber[]] & {
            rewards_per_duration_arr: BigNumber[];
        }>;
        getRewardSymbols(overrides?: CallOverrides): Promise<[string[]]>;
        greylist(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        greylistAddress(_address: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        initializeDefault(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        isTokenManagerFor(caller_addr: PromiseOrValue<string>, reward_token_addr: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        lastUpdateTime(overrides?: CallOverrides): Promise<[BigNumber]>;
        lockMultiplier(secs: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
        lock_max_multiplier(overrides?: CallOverrides): Promise<[BigNumber]>;
        lock_time_for_max_multiplier(overrides?: CallOverrides): Promise<[BigNumber]>;
        lock_time_min(overrides?: CallOverrides): Promise<[BigNumber]>;
        lockedLiquidityOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        lockedStakesOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[CommunalFarm.LockedStakeStructOutput[]]>;
        nominateNewOwner(_owner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        nominatedOwner(overrides?: CallOverrides): Promise<[string]>;
        owner(overrides?: CallOverrides): Promise<[string]>;
        periodFinish(overrides?: CallOverrides): Promise<[BigNumber]>;
        recoverERC20(tokenAddress: PromiseOrValue<string>, tokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        rewardManagers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[string]>;
        rewardRates(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
        rewardSymbols(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
        rewardTokenAddrToIdx(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        rewardTokens(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
        rewardsCollectionPaused(overrides?: CallOverrides): Promise<[boolean]>;
        rewardsDuration(overrides?: CallOverrides): Promise<[BigNumber]>;
        rewardsPerToken(overrides?: CallOverrides): Promise<[BigNumber[]] & {
            newRewardsPerTokenStored: BigNumber[];
        }>;
        setLockedStakeTimeForMinAndMaxMultiplier(_lock_time_for_max_multiplier: PromiseOrValue<BigNumberish>, _lock_time_min: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setMultipliers(_lock_max_multiplier: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setRewardRate(reward_token_address: PromiseOrValue<string>, new_rate: PromiseOrValue<BigNumberish>, sync_too: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setRewardsDuration(_rewardsDuration: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        stakeLocked(liquidity: PromiseOrValue<BigNumberish>, secs: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        stakesUnlocked(overrides?: CallOverrides): Promise<[boolean]>;
        stakingPaused(overrides?: CallOverrides): Promise<[boolean]>;
        sync(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        toggleRewardsCollection(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        toggleStaking(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        toggleWithdrawals(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        totalCombinedWeight(overrides?: CallOverrides): Promise<[BigNumber]>;
        totalLiquidityLocked(overrides?: CallOverrides): Promise<[BigNumber]>;
        unlockStakes(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdrawLocked(kek_id: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdrawalsPaused(overrides?: CallOverrides): Promise<[boolean]>;
    };
    acceptOwnership(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    calcCurCombinedWeight(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
        BigNumber,
        BigNumber
    ] & {
        old_combined_weight: BigNumber;
        new_combined_weight: BigNumber;
    }>;
    changeTokenManager(reward_token_address: PromiseOrValue<string>, new_manager_address: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    combinedWeightOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    earned(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber[]>;
    getAllRewardTokens(overrides?: CallOverrides): Promise<string[]>;
    getReward(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    getRewardForDuration(overrides?: CallOverrides): Promise<BigNumber[]>;
    getRewardSymbols(overrides?: CallOverrides): Promise<string[]>;
    greylist(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    greylistAddress(_address: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    initializeDefault(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    isTokenManagerFor(caller_addr: PromiseOrValue<string>, reward_token_addr: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    lastUpdateTime(overrides?: CallOverrides): Promise<BigNumber>;
    lockMultiplier(secs: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
    lock_max_multiplier(overrides?: CallOverrides): Promise<BigNumber>;
    lock_time_for_max_multiplier(overrides?: CallOverrides): Promise<BigNumber>;
    lock_time_min(overrides?: CallOverrides): Promise<BigNumber>;
    lockedLiquidityOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    lockedStakesOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<CommunalFarm.LockedStakeStructOutput[]>;
    nominateNewOwner(_owner: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    nominatedOwner(overrides?: CallOverrides): Promise<string>;
    owner(overrides?: CallOverrides): Promise<string>;
    periodFinish(overrides?: CallOverrides): Promise<BigNumber>;
    recoverERC20(tokenAddress: PromiseOrValue<string>, tokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    rewardManagers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
    rewardRates(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
    rewardSymbols(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
    rewardTokenAddrToIdx(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    rewardTokens(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
    rewardsCollectionPaused(overrides?: CallOverrides): Promise<boolean>;
    rewardsDuration(overrides?: CallOverrides): Promise<BigNumber>;
    rewardsPerToken(overrides?: CallOverrides): Promise<BigNumber[]>;
    setLockedStakeTimeForMinAndMaxMultiplier(_lock_time_for_max_multiplier: PromiseOrValue<BigNumberish>, _lock_time_min: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setMultipliers(_lock_max_multiplier: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setRewardRate(reward_token_address: PromiseOrValue<string>, new_rate: PromiseOrValue<BigNumberish>, sync_too: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setRewardsDuration(_rewardsDuration: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    stakeLocked(liquidity: PromiseOrValue<BigNumberish>, secs: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    stakesUnlocked(overrides?: CallOverrides): Promise<boolean>;
    stakingPaused(overrides?: CallOverrides): Promise<boolean>;
    sync(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    toggleRewardsCollection(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    toggleStaking(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    toggleWithdrawals(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    totalCombinedWeight(overrides?: CallOverrides): Promise<BigNumber>;
    totalLiquidityLocked(overrides?: CallOverrides): Promise<BigNumber>;
    unlockStakes(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdrawLocked(kek_id: PromiseOrValue<BytesLike>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdrawalsPaused(overrides?: CallOverrides): Promise<boolean>;
    callStatic: {
        acceptOwnership(overrides?: CallOverrides): Promise<void>;
        calcCurCombinedWeight(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber
        ] & {
            old_combined_weight: BigNumber;
            new_combined_weight: BigNumber;
        }>;
        changeTokenManager(reward_token_address: PromiseOrValue<string>, new_manager_address: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        combinedWeightOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        earned(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber[]>;
        getAllRewardTokens(overrides?: CallOverrides): Promise<string[]>;
        getReward(overrides?: CallOverrides): Promise<BigNumber[]>;
        getRewardForDuration(overrides?: CallOverrides): Promise<BigNumber[]>;
        getRewardSymbols(overrides?: CallOverrides): Promise<string[]>;
        greylist(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        greylistAddress(_address: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        initializeDefault(overrides?: CallOverrides): Promise<void>;
        isTokenManagerFor(caller_addr: PromiseOrValue<string>, reward_token_addr: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        lastUpdateTime(overrides?: CallOverrides): Promise<BigNumber>;
        lockMultiplier(secs: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        lock_max_multiplier(overrides?: CallOverrides): Promise<BigNumber>;
        lock_time_for_max_multiplier(overrides?: CallOverrides): Promise<BigNumber>;
        lock_time_min(overrides?: CallOverrides): Promise<BigNumber>;
        lockedLiquidityOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        lockedStakesOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<CommunalFarm.LockedStakeStructOutput[]>;
        nominateNewOwner(_owner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        nominatedOwner(overrides?: CallOverrides): Promise<string>;
        owner(overrides?: CallOverrides): Promise<string>;
        periodFinish(overrides?: CallOverrides): Promise<BigNumber>;
        recoverERC20(tokenAddress: PromiseOrValue<string>, tokenAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        rewardManagers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
        rewardRates(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        rewardSymbols(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
        rewardTokenAddrToIdx(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        rewardTokens(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
        rewardsCollectionPaused(overrides?: CallOverrides): Promise<boolean>;
        rewardsDuration(overrides?: CallOverrides): Promise<BigNumber>;
        rewardsPerToken(overrides?: CallOverrides): Promise<BigNumber[]>;
        setLockedStakeTimeForMinAndMaxMultiplier(_lock_time_for_max_multiplier: PromiseOrValue<BigNumberish>, _lock_time_min: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setMultipliers(_lock_max_multiplier: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setRewardRate(reward_token_address: PromiseOrValue<string>, new_rate: PromiseOrValue<BigNumberish>, sync_too: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        setRewardsDuration(_rewardsDuration: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        stakeLocked(liquidity: PromiseOrValue<BigNumberish>, secs: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        stakesUnlocked(overrides?: CallOverrides): Promise<boolean>;
        stakingPaused(overrides?: CallOverrides): Promise<boolean>;
        sync(overrides?: CallOverrides): Promise<void>;
        toggleRewardsCollection(overrides?: CallOverrides): Promise<void>;
        toggleStaking(overrides?: CallOverrides): Promise<void>;
        toggleWithdrawals(overrides?: CallOverrides): Promise<void>;
        totalCombinedWeight(overrides?: CallOverrides): Promise<BigNumber>;
        totalLiquidityLocked(overrides?: CallOverrides): Promise<BigNumber>;
        unlockStakes(overrides?: CallOverrides): Promise<void>;
        withdrawLocked(kek_id: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
        withdrawalsPaused(overrides?: CallOverrides): Promise<boolean>;
    };
    filters: {
        'DefaultInitialization()'(): DefaultInitializationEventFilter;
        DefaultInitialization(): DefaultInitializationEventFilter;
        'LockedStakeMaxMultiplierUpdated(uint256)'(multiplier?: null): LockedStakeMaxMultiplierUpdatedEventFilter;
        LockedStakeMaxMultiplierUpdated(multiplier?: null): LockedStakeMaxMultiplierUpdatedEventFilter;
        'LockedStakeMinTime(uint256)'(secs?: null): LockedStakeMinTimeEventFilter;
        LockedStakeMinTime(secs?: null): LockedStakeMinTimeEventFilter;
        'LockedStakeTimeForMaxMultiplier(uint256)'(secs?: null): LockedStakeTimeForMaxMultiplierEventFilter;
        LockedStakeTimeForMaxMultiplier(secs?: null): LockedStakeTimeForMaxMultiplierEventFilter;
        'OwnerChanged(address,address)'(oldOwner?: null, newOwner?: null): OwnerChangedEventFilter;
        OwnerChanged(oldOwner?: null, newOwner?: null): OwnerChangedEventFilter;
        'OwnerNominated(address)'(newOwner?: null): OwnerNominatedEventFilter;
        OwnerNominated(newOwner?: null): OwnerNominatedEventFilter;
        'Recovered(address,address,uint256)'(destination_address?: null, token?: null, amount?: null): RecoveredEventFilter;
        Recovered(destination_address?: null, token?: null, amount?: null): RecoveredEventFilter;
        'RewardPaid(address,uint256,address,address)'(user?: PromiseOrValue<string> | null, reward?: null, token_address?: null, destination_address?: null): RewardPaidEventFilter;
        RewardPaid(user?: PromiseOrValue<string> | null, reward?: null, token_address?: null, destination_address?: null): RewardPaidEventFilter;
        'RewardsDurationUpdated(uint256)'(newDuration?: null): RewardsDurationUpdatedEventFilter;
        RewardsDurationUpdated(newDuration?: null): RewardsDurationUpdatedEventFilter;
        'RewardsPeriodRenewed(address)'(token?: null): RewardsPeriodRenewedEventFilter;
        RewardsPeriodRenewed(token?: null): RewardsPeriodRenewedEventFilter;
        'StakeLocked(address,uint256,uint256,bytes32,address)'(user?: PromiseOrValue<string> | null, amount?: null, secs?: null, kek_id?: null, source_address?: null): StakeLockedEventFilter;
        StakeLocked(user?: PromiseOrValue<string> | null, amount?: null, secs?: null, kek_id?: null, source_address?: null): StakeLockedEventFilter;
        'WithdrawLocked(address,uint256,bytes32,address)'(user?: PromiseOrValue<string> | null, amount?: null, kek_id?: null, destination_address?: null): WithdrawLockedEventFilter;
        WithdrawLocked(user?: PromiseOrValue<string> | null, amount?: null, kek_id?: null, destination_address?: null): WithdrawLockedEventFilter;
    };
    estimateGas: {
        acceptOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        calcCurCombinedWeight(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        changeTokenManager(reward_token_address: PromiseOrValue<string>, new_manager_address: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        combinedWeightOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        earned(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getAllRewardTokens(overrides?: CallOverrides): Promise<BigNumber>;
        getReward(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        getRewardForDuration(overrides?: CallOverrides): Promise<BigNumber>;
        getRewardSymbols(overrides?: CallOverrides): Promise<BigNumber>;
        greylist(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        greylistAddress(_address: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        initializeDefault(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        isTokenManagerFor(caller_addr: PromiseOrValue<string>, reward_token_addr: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        lastUpdateTime(overrides?: CallOverrides): Promise<BigNumber>;
        lockMultiplier(secs: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        lock_max_multiplier(overrides?: CallOverrides): Promise<BigNumber>;
        lock_time_for_max_multiplier(overrides?: CallOverrides): Promise<BigNumber>;
        lock_time_min(overrides?: CallOverrides): Promise<BigNumber>;
        lockedLiquidityOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        lockedStakesOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        nominateNewOwner(_owner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        nominatedOwner(overrides?: CallOverrides): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<BigNumber>;
        periodFinish(overrides?: CallOverrides): Promise<BigNumber>;
        recoverERC20(tokenAddress: PromiseOrValue<string>, tokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        rewardManagers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        rewardRates(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        rewardSymbols(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        rewardTokenAddrToIdx(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        rewardTokens(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        rewardsCollectionPaused(overrides?: CallOverrides): Promise<BigNumber>;
        rewardsDuration(overrides?: CallOverrides): Promise<BigNumber>;
        rewardsPerToken(overrides?: CallOverrides): Promise<BigNumber>;
        setLockedStakeTimeForMinAndMaxMultiplier(_lock_time_for_max_multiplier: PromiseOrValue<BigNumberish>, _lock_time_min: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setMultipliers(_lock_max_multiplier: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setRewardRate(reward_token_address: PromiseOrValue<string>, new_rate: PromiseOrValue<BigNumberish>, sync_too: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setRewardsDuration(_rewardsDuration: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        stakeLocked(liquidity: PromiseOrValue<BigNumberish>, secs: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        stakesUnlocked(overrides?: CallOverrides): Promise<BigNumber>;
        stakingPaused(overrides?: CallOverrides): Promise<BigNumber>;
        sync(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        toggleRewardsCollection(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        toggleStaking(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        toggleWithdrawals(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        totalCombinedWeight(overrides?: CallOverrides): Promise<BigNumber>;
        totalLiquidityLocked(overrides?: CallOverrides): Promise<BigNumber>;
        unlockStakes(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        withdrawLocked(kek_id: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        withdrawalsPaused(overrides?: CallOverrides): Promise<BigNumber>;
    };
    populateTransaction: {
        acceptOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        calcCurCombinedWeight(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        changeTokenManager(reward_token_address: PromiseOrValue<string>, new_manager_address: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        combinedWeightOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        earned(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getAllRewardTokens(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getReward(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        getRewardForDuration(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getRewardSymbols(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        greylist(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        greylistAddress(_address: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        initializeDefault(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        isTokenManagerFor(caller_addr: PromiseOrValue<string>, reward_token_addr: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lastUpdateTime(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lockMultiplier(secs: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lock_max_multiplier(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lock_time_for_max_multiplier(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lock_time_min(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lockedLiquidityOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lockedStakesOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        nominateNewOwner(_owner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        nominatedOwner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        periodFinish(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        recoverERC20(tokenAddress: PromiseOrValue<string>, tokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        rewardManagers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        rewardRates(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        rewardSymbols(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        rewardTokenAddrToIdx(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        rewardTokens(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        rewardsCollectionPaused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        rewardsDuration(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        rewardsPerToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        setLockedStakeTimeForMinAndMaxMultiplier(_lock_time_for_max_multiplier: PromiseOrValue<BigNumberish>, _lock_time_min: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setMultipliers(_lock_max_multiplier: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setRewardRate(reward_token_address: PromiseOrValue<string>, new_rate: PromiseOrValue<BigNumberish>, sync_too: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setRewardsDuration(_rewardsDuration: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        stakeLocked(liquidity: PromiseOrValue<BigNumberish>, secs: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        stakesUnlocked(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        stakingPaused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        sync(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        toggleRewardsCollection(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        toggleStaking(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        toggleWithdrawals(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        totalCombinedWeight(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalLiquidityLocked(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        unlockStakes(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        withdrawLocked(kek_id: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        withdrawalsPaused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
    };
}
