import BigNumber from 'bignumber.js';
import { Address, Hash } from '../commonTypes';
import { ContractWrapperFactory } from '../contractWrapperFactory';
import { ArcTransactionResult, IContractWrapperFactory } from '../iContractWrapperBase';
import { TxGeneratingFunctionOptions } from '../transactionService';
import { Locking4ReputationWrapper } from './locking4Reputation';
export declare class ExternalLocking4ReputationWrapper extends Locking4ReputationWrapper {
    name: string;
    friendlyName: string;
    factory: IContractWrapperFactory<ExternalLocking4ReputationWrapper>;
    initialize(options: ExternalLockingInitializeOptions & TxGeneratingFunctionOptions): Promise<ArcTransactionResult>;
    getLockBlocker(options: ExternalLockingClaimOptions): Promise<string | null>;
    /**
     * Claim the MGN tokens and lock them.  Provide `lockerAddress` to claim on their behalf,
     * otherwise claims on behalf of the caller.
     * @param options
     */
    lock(options: ExternalLockingClaimOptions & TxGeneratingFunctionOptions): Promise<ArcTransactionResult>;
    /**
     * The caller is giving permission to the contract to allow someone else to claim
     * on their behalf.
     */
    register(options: RegisterOptions & TxGeneratingFunctionOptions): Promise<ArcTransactionResult>;
    /**
     * Returns promise of whether the given locker has tokens that can be activated in the given MGN token contract.
     * Assumes that MGN token API is:  `lockedTokenBalances(address)`.
     *
     * @param lockerAddress
     * @param mgnTokenAddress
     */
    hasTokenToActivate(lockerAddress: Address): Promise<boolean>;
    /**
     * Returns the user's token balance
     * @param lockerAddress
     */
    accountTokenBalance(lockerAddress: Address): Promise<BigNumber>;
    /**
     * Returns promise of a boolean indicating whether the given address has registered
     * to have their tokens claimed for them (see `register`).
     * @param lockerAddress
     */
    isRegistered(lockerAddress: Address): Promise<boolean>;
    getExternalLockingContract(): Promise<Address>;
    getGetBalanceFuncSignature(): Promise<string>;
    /**
     * Promise of `true` if the given account has already executed a lock
     */
    getAccountHasLocked(lockerAddress: Address): Promise<boolean>;
}
export declare class ExternalLocking4ReputationType extends ContractWrapperFactory<ExternalLocking4ReputationWrapper> {
    deployed(): Promise<ExternalLocking4ReputationWrapper>;
}
export declare const ExternalLocking4ReputationFactory: ExternalLocking4ReputationType;
export interface ExternalLockingInitializeOptions {
    avatarAddress: Address;
    externalLockingContract: Address;
    getBalanceFuncSignature: string;
    lockingEndTime: Date;
    lockingStartTime: Date;
    /**
     * Reputation cannot be redeemed until after this time, even if redeeming has been enabled.
     */
    redeemEnableTime: Date;
    reputationReward: BigNumber | string;
}
export interface ExternalLockingClaimOptions {
    legalContractHash: Hash;
    lockerAddress?: Address;
}
export interface RegisterOptions {
    legalContractHash: Hash;
}
