import BigNumber from 'bignumber.js';
import { Address, Hash } from '../commonTypes';
import { ArcTransactionResult, IContractWrapperFactory } from '../iContractWrapperBase';
import { SchemeWrapperBase } from '../schemeWrapperBase';
import { TxGeneratingFunctionOptions } from '../transactionService';
import { EntityFetcherFactory, EventFetcherFactory, EventFetcherFilterObject } from '../web3EventService';
export declare abstract class Locking4ReputationWrapper extends SchemeWrapperBase {
    name: string;
    friendlyName: string;
    factory: IContractWrapperFactory<Locking4ReputationWrapper>;
    Redeem: EventFetcherFactory<Locking4ReputationRedeemEventResult>;
    Release: EventFetcherFactory<Locking4ReputationReleaseEventResult>;
    Lock: EventFetcherFactory<Locking4ReputationLockEventResult>;
    /**
     * Redeem reputation
     * @param options
     * @returns null ArcTransactionResult if there is nothing to redeem due to locker having no score
     */
    redeem(options: RedeemOptions & TxGeneratingFunctionOptions): Promise<ArcTransactionResult>;
    /**
     * Returns reason why can't redeem, or else null if can redeem
     * @param lockerAddress
     */
    getRedeemBlocker(lockerAddress: Address): Promise<string | null>;
    /**
     * Returns error message else null if can release
     * @param lockerAddress
     * @param lockId
     */
    getReleaseBlocker(lockerAddress: Address, lockId: Hash): Promise<string | null>;
    /**
     * Returns reason why can't lock, else null if can lock
     */
    getLockBlocker(options: LockingOptions): Promise<string | null>;
    getUserEarnedReputation(options: RedeemOptions): Promise<BigNumber>;
    getLockerScore(lockerAddress: Address): Promise<BigNumber>;
    lockerHasLocked(lockerAddress: Address): Promise<boolean>;
    /**
     * Get a promise of the first date/time when anything can be redeemed
     */
    getRedeemEnableTime(): Promise<Date>;
    getTotalLocked(): Promise<BigNumber>;
    getTotalLockedLeft(): Promise<BigNumber>;
    getTotalScore(): Promise<BigNumber>;
    /**
     * get total number of locks
     */
    getLockCount(): Promise<number>;
    /**
     * get the total reputation this contract will reward
     */
    getReputationReward(): Promise<BigNumber>;
    /**
     * get the total reputation this contract has not yet rewarded
     */
    getReputationRewardLeft(): Promise<BigNumber>;
    getLockingEndTime(): Promise<Date>;
    getLockingStartTime(): Promise<Date>;
    getMaxLockingPeriod(): Promise<number>;
    getAvatar(): Promise<Address>;
    /**
     * Returns promise of information about a locked amount for the given locker and lockerId.
     * @param lockerAddress
     * @param lockId
     */
    getLockInfo(lockerAddress: Address, lockId: Hash): Promise<LockInfo>;
    /**
     * Returns the amount originally locked (which one can't obtain other than via
     * Release events once the lock is released).  Returns 0 if not released or event otherwise
     * not found.
     * @param lockerAddress
     * @param lockId
     */
    getReleasedAmount(lockerAddress: Address, lockId: Hash): Promise<BigNumber>;
    /**
     * Returns promise of information about the given locker, including the locker's score.
     * Score determines the proportion of total reputation that can be redeemed by the locker.
     *
     * @param lockerAddress
     */
    getLockerInfo(lockerAddress: Address): Promise<LockerInfo>;
    /**
     * Returns EntityEventFetcher that returns `LockInfo` for each `Lock` event.
     * Note this includes released locks.
     */
    getLocks(): EntityFetcherFactory<LockEventInfo, Locking4ReputationLockEventResult>;
    /**
     * Returns EntityEventFetcher that returns `ReleaseInfo` for each `Release` event.
     */
    getReleases(): EntityFetcherFactory<ReleaseInfo, Locking4ReputationReleaseEventResult>;
    /**
     * Returns EntityEventFetcher that returns `LockerInfo` for each account that has created a lock.
     * It is fired for an account whenever a `Lock`, `Redeem` or `Release` event is emitted.
     */
    getLockers(options?: GetLockersOptions): Promise<Array<LockerInfo>>;
    protected _initialize(options: Partial<InitializeOptions>, checkmaxLockingPeriod?: boolean): Promise<void>;
    protected _release(options: ReleaseOptions): Promise<void>;
    protected hydrated(): void;
}
export interface Locking4ReputationRedeemEventResult {
    /**
     * indexed
     */
    _beneficiary: Address;
    /**
     * in Wei
     */
    _amount: BigNumber;
}
export interface Locking4ReputationReleaseEventResult {
    /**
     * indexed
     */
    _lockingId: Hash;
    /**
     * indexed
     */
    _beneficiary: Address;
    /**
     * in Wei
     */
    _amount: BigNumber;
}
export interface Locking4ReputationLockEventResult {
    /**
     * indexed
     */
    _lockingId: Hash;
    /**
     * in Wei
     */
    _amount: BigNumber;
    _period: BigNumber;
    /**
     * indexed
     */
    _locker: Address;
}
export interface InitializeOptions {
    avatarAddress: Address;
    lockingEndTime: Date;
    lockingStartTime: Date;
    /**
     * maximum period length in seconds
     */
    maxLockingPeriod: number;
    /**
     * Reputation cannot be redeemed until after this time, even if redeeming has been enabled.
     */
    redeemEnableTime: Date;
    reputationReward: BigNumber | string;
}
export interface LockInfo {
    lockerAddress: Address;
    /**
     * in Wei
     */
    amount: BigNumber;
    lockId: Hash;
    released: boolean;
    releaseTime: Date;
}
export interface ReleaseInfo {
    lockerAddress: Address;
    /**
     * in Wei
     */
    amount: BigNumber;
    lockId: Hash;
}
export interface LockerInfo {
    lockerAddress: Address;
    score: BigNumber;
}
export interface RedeemOptions {
    lockerAddress: Address;
}
export interface ReleaseOptions {
    lockerAddress: Address;
    lockId: Hash;
}
export interface LockingOptions {
    /**
     * in Wei
     */
    amount: BigNumber | string;
    /**
     * the number of seconds the amount should be locked
     */
    period: number;
    lockerAddress: Address;
}
export interface GetLockersOptions {
    lockerAddress?: Address;
    lockingId?: Hash;
    /**
     * Web3 event filter options.  Typically something like `{ fromBlock: 0 }`.
     * Note if you don't want Arc.js to suppress duplicate events, set `suppressDups` to false.
     */
    filterObject?: EventFetcherFilterObject;
}
export interface LockEventInfo extends LockInfo {
    transationHash: Hash;
}
