import { DecodedLogEntryEvent, DecodedLogEntry, DecodedTransactionReceipt } from "@joincivil/typescript-types";
import "rxjs/add/operator/distinctUntilChanged";
import { TransactionConfig } from "web3-core";
import { EthAddress } from "@joincivil/typescript-types";
import { EthApi } from "@joincivil/ethapi";
import { BaseContract } from "../../basecontract";
declare type BigNumber = string;
export declare class CivilParameterizerContract extends BaseContract {
    static singletonTrusted(ethApi: EthApi): Promise<CivilParameterizerContract | undefined>;
    static atUntrusted(ethApi: EthApi, address: EthAddress): CivilParameterizerContract;
    static deployTrusted: {
        sendTransactionAsync(ethApi: EthApi, tokenAddr: string, plcrAddr: string, parameters: string[], options: TransactionConfig): Promise<string>;
        estimateGasAsync(ethApi: EthApi, tokenAddr: string, plcrAddr: string, parameters: string[]): Promise<number>;
    };
    PROCESSBY: {
        callAsync(): Promise<string>;
    };
    processProposal: {
        sendTransactionAsync(_propID: string, txData?: TransactionConfig | undefined): Promise<string>;
        estimateGasAsync(_propID: string, txData?: TransactionConfig | undefined): Promise<number>;
        getRaw(_propID: string, txData?: TransactionConfig | undefined): Promise<TransactionConfig>;
    };
    proposals: {
        callAsync(index_0: string): Promise<[string, string, string, string, string, string, string]>;
    };
    propExists: {
        callAsync(_propID: string): Promise<boolean>;
    };
    challengeWinnerReward: {
        callAsync(_challengeID: string): Promise<string>;
    };
    claimRewards: {
        sendTransactionAsync(_challengeIDs: string[], _salts: string[], txData?: TransactionConfig | undefined): Promise<string>;
        estimateGasAsync(_challengeIDs: string[], _salts: string[], txData?: TransactionConfig | undefined): Promise<number>;
        getRaw(_challengeIDs: string[], _salts: string[], txData?: TransactionConfig | undefined): Promise<TransactionConfig>;
    };
    get: {
        callAsync(_name: string): Promise<string>;
    };
    challengeCanBeResolved: {
        callAsync(_propID: string): Promise<boolean>;
    };
    challengeReparameterization: {
        sendTransactionAsync(_propID: string, txData?: TransactionConfig | undefined): Promise<string>;
        estimateGasAsync(_propID: string, txData?: TransactionConfig | undefined): Promise<number>;
        getRaw(_propID: string, txData?: TransactionConfig | undefined): Promise<TransactionConfig>;
    };
    claimReward: {
        sendTransactionAsync(_challengeID: string, _salt: string, txData?: TransactionConfig | undefined): Promise<string>;
        estimateGasAsync(_challengeID: string, _salt: string, txData?: TransactionConfig | undefined): Promise<number>;
        getRaw(_challengeID: string, _salt: string, txData?: TransactionConfig | undefined): Promise<TransactionConfig>;
    };
    challenges: {
        callAsync(index_0: string): Promise<[string, string, boolean, string, string]>;
    };
    tokenClaims: {
        callAsync(_challengeID: string, _voter: string): Promise<boolean>;
    };
    voterReward: {
        callAsync(_voter: string, _challengeID: string, _salt: string): Promise<string>;
    };
    proposeReparameterization: {
        sendTransactionAsync(_name: string, _value: string, txData?: TransactionConfig | undefined): Promise<string>;
        estimateGasAsync(_name: string, _value: string, txData?: TransactionConfig | undefined): Promise<number>;
        getRaw(_name: string, _value: string, txData?: TransactionConfig | undefined): Promise<TransactionConfig>;
    };
    canBeSet: {
        callAsync(_propID: string): Promise<boolean>;
    };
    params: {
        callAsync(index_0: string): Promise<string>;
    };
    token: {
        callAsync(): Promise<string>;
    };
    voting: {
        callAsync(): Promise<string>;
    };
    _ReparameterizationProposalStream: (paramFilters?: import("../../utils/contracts").TypedEventFilter<any> | undefined, filterObject?: import("../../utils/contracts").EventOptions | undefined) => import("rxjs").Observable<DecodedLogEntryEvent<CivilParameterizer.Args._ReparameterizationProposal, CivilParameterizer.Events._ReparameterizationProposal>>;
    _NewChallengeStream: (paramFilters?: import("../../utils/contracts").TypedEventFilter<any> | undefined, filterObject?: import("../../utils/contracts").EventOptions | undefined) => import("rxjs").Observable<DecodedLogEntryEvent<CivilParameterizer.Args._NewChallenge, CivilParameterizer.Events._NewChallenge>>;
    _ProposalAcceptedStream: (paramFilters?: import("../../utils/contracts").TypedEventFilter<any> | undefined, filterObject?: import("../../utils/contracts").EventOptions | undefined) => import("rxjs").Observable<DecodedLogEntryEvent<CivilParameterizer.Args._ProposalAccepted, CivilParameterizer.Events._ProposalAccepted>>;
    _ProposalExpiredStream: (paramFilters?: import("../../utils/contracts").TypedEventFilter<any> | undefined, filterObject?: import("../../utils/contracts").EventOptions | undefined) => import("rxjs").Observable<DecodedLogEntryEvent<CivilParameterizer.Args._ProposalExpired, CivilParameterizer.Events._ProposalExpired>>;
    _ChallengeSucceededStream: (paramFilters?: import("../../utils/contracts").TypedEventFilter<any> | undefined, filterObject?: import("../../utils/contracts").EventOptions | undefined) => import("rxjs").Observable<DecodedLogEntryEvent<CivilParameterizer.Args._ChallengeSucceeded, CivilParameterizer.Events._ChallengeSucceeded>>;
    _ChallengeFailedStream: (paramFilters?: import("../../utils/contracts").TypedEventFilter<any> | undefined, filterObject?: import("../../utils/contracts").EventOptions | undefined) => import("rxjs").Observable<DecodedLogEntryEvent<CivilParameterizer.Args._ChallengeFailed, CivilParameterizer.Events._ChallengeFailed>>;
    _RewardClaimedStream: (paramFilters?: import("../../utils/contracts").TypedEventFilter<any> | undefined, filterObject?: import("../../utils/contracts").EventOptions | undefined) => import("rxjs").Observable<DecodedLogEntryEvent<CivilParameterizer.Args._RewardClaimed, CivilParameterizer.Events._RewardClaimed>>;
    private constructor();
}
export declare namespace CivilParameterizer {
    enum Events {
        _ReparameterizationProposal = "_ReparameterizationProposal",
        _NewChallenge = "_NewChallenge",
        _ProposalAccepted = "_ProposalAccepted",
        _ProposalExpired = "_ProposalExpired",
        _ChallengeSucceeded = "_ChallengeSucceeded",
        _ChallengeFailed = "_ChallengeFailed",
        _RewardClaimed = "_RewardClaimed"
    }
    namespace Args {
        interface _ReparameterizationProposal {
            name: string;
            value: BigNumber;
            propID: string;
            deposit: BigNumber;
            appEndDate: BigNumber;
            proposer: string;
        }
        interface _NewChallenge {
            propID: string;
            challengeID: BigNumber;
            commitEndDate: BigNumber;
            revealEndDate: BigNumber;
            challenger: string;
        }
        interface _ProposalAccepted {
            propID: string;
            name: string;
            value: BigNumber;
        }
        interface _ProposalExpired {
            propID: string;
        }
        interface _ChallengeSucceeded {
            propID: string;
            challengeID: BigNumber;
            rewardPool: BigNumber;
            totalTokens: BigNumber;
        }
        interface _ChallengeFailed {
            propID: string;
            challengeID: BigNumber;
            rewardPool: BigNumber;
            totalTokens: BigNumber;
        }
        interface _RewardClaimed {
            challengeID: BigNumber;
            reward: BigNumber;
            voter: string;
        }
    }
    namespace Logs {
        type _ReparameterizationProposal = DecodedLogEntry<Args._ReparameterizationProposal, Events._ReparameterizationProposal>;
        type _NewChallenge = DecodedLogEntry<Args._NewChallenge, Events._NewChallenge>;
        type _ProposalAccepted = DecodedLogEntry<Args._ProposalAccepted, Events._ProposalAccepted>;
        type _ProposalExpired = DecodedLogEntry<Args._ProposalExpired, Events._ProposalExpired>;
        type _ChallengeSucceeded = DecodedLogEntry<Args._ChallengeSucceeded, Events._ChallengeSucceeded>;
        type _ChallengeFailed = DecodedLogEntry<Args._ChallengeFailed, Events._ChallengeFailed>;
        type _RewardClaimed = DecodedLogEntry<Args._RewardClaimed, Events._RewardClaimed>;
        type All = Logs._ReparameterizationProposal | Logs._NewChallenge | Logs._ProposalAccepted | Logs._ProposalExpired | Logs._ChallengeSucceeded | Logs._ChallengeFailed | Logs._RewardClaimed;
    }
    namespace LogEvents {
        type _ReparameterizationProposal = DecodedLogEntryEvent<Args._ReparameterizationProposal, Events._ReparameterizationProposal>;
        type _NewChallenge = DecodedLogEntryEvent<Args._NewChallenge, Events._NewChallenge>;
        type _ProposalAccepted = DecodedLogEntryEvent<Args._ProposalAccepted, Events._ProposalAccepted>;
        type _ProposalExpired = DecodedLogEntryEvent<Args._ProposalExpired, Events._ProposalExpired>;
        type _ChallengeSucceeded = DecodedLogEntryEvent<Args._ChallengeSucceeded, Events._ChallengeSucceeded>;
        type _ChallengeFailed = DecodedLogEntryEvent<Args._ChallengeFailed, Events._ChallengeFailed>;
        type _RewardClaimed = DecodedLogEntryEvent<Args._RewardClaimed, Events._RewardClaimed>;
        type All = LogEvents._ReparameterizationProposal | LogEvents._NewChallenge | LogEvents._ProposalAccepted | LogEvents._ProposalExpired | LogEvents._ChallengeSucceeded | LogEvents._ChallengeFailed | LogEvents._RewardClaimed;
    }
    type Receipt = DecodedTransactionReceipt<Logs.All>;
    type EventReceipt = DecodedTransactionReceipt<LogEvents.All>;
}
export {};