// package: provenance.reward.v1
// file: provenance/reward/v1/reward.proto

/* tslint:disable */
/* eslint-disable */

import * as jspb from "google-protobuf";
import * as gogoproto_gogo_pb from "../../../gogoproto/gogo_pb";
import * as google_protobuf_timestamp_pb from "google-protobuf/google/protobuf/timestamp_pb";
import * as cosmos_base_v1beta1_coin_pb from "../../../cosmos/base/v1beta1/coin_pb";

export class RewardProgram extends jspb.Message { 
    getId(): number;
    setId(value: number): RewardProgram;
    getTitle(): string;
    setTitle(value: string): RewardProgram;
    getDescription(): string;
    setDescription(value: string): RewardProgram;
    getDistributeFromAddress(): string;
    setDistributeFromAddress(value: string): RewardProgram;

    hasTotalRewardPool(): boolean;
    clearTotalRewardPool(): void;
    getTotalRewardPool(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setTotalRewardPool(value?: cosmos_base_v1beta1_coin_pb.Coin): RewardProgram;

    hasRemainingPoolBalance(): boolean;
    clearRemainingPoolBalance(): void;
    getRemainingPoolBalance(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setRemainingPoolBalance(value?: cosmos_base_v1beta1_coin_pb.Coin): RewardProgram;

    hasClaimedAmount(): boolean;
    clearClaimedAmount(): void;
    getClaimedAmount(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setClaimedAmount(value?: cosmos_base_v1beta1_coin_pb.Coin): RewardProgram;

    hasMaxRewardByAddress(): boolean;
    clearMaxRewardByAddress(): void;
    getMaxRewardByAddress(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setMaxRewardByAddress(value?: cosmos_base_v1beta1_coin_pb.Coin): RewardProgram;

    hasMinimumRolloverAmount(): boolean;
    clearMinimumRolloverAmount(): void;
    getMinimumRolloverAmount(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setMinimumRolloverAmount(value?: cosmos_base_v1beta1_coin_pb.Coin): RewardProgram;
    getClaimPeriodSeconds(): number;
    setClaimPeriodSeconds(value: number): RewardProgram;

    hasProgramStartTime(): boolean;
    clearProgramStartTime(): void;
    getProgramStartTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setProgramStartTime(value?: google_protobuf_timestamp_pb.Timestamp): RewardProgram;

    hasExpectedProgramEndTime(): boolean;
    clearExpectedProgramEndTime(): void;
    getExpectedProgramEndTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setExpectedProgramEndTime(value?: google_protobuf_timestamp_pb.Timestamp): RewardProgram;

    hasProgramEndTimeMax(): boolean;
    clearProgramEndTimeMax(): void;
    getProgramEndTimeMax(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setProgramEndTimeMax(value?: google_protobuf_timestamp_pb.Timestamp): RewardProgram;

    hasClaimPeriodEndTime(): boolean;
    clearClaimPeriodEndTime(): void;
    getClaimPeriodEndTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setClaimPeriodEndTime(value?: google_protobuf_timestamp_pb.Timestamp): RewardProgram;

    hasActualProgramEndTime(): boolean;
    clearActualProgramEndTime(): void;
    getActualProgramEndTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setActualProgramEndTime(value?: google_protobuf_timestamp_pb.Timestamp): RewardProgram;
    getClaimPeriods(): number;
    setClaimPeriods(value: number): RewardProgram;
    getCurrentClaimPeriod(): number;
    setCurrentClaimPeriod(value: number): RewardProgram;
    getMaxRolloverClaimPeriods(): number;
    setMaxRolloverClaimPeriods(value: number): RewardProgram;
    getState(): RewardProgram.State;
    setState(value: RewardProgram.State): RewardProgram;
    getExpirationOffset(): number;
    setExpirationOffset(value: number): RewardProgram;
    clearQualifyingActionsList(): void;
    getQualifyingActionsList(): Array<QualifyingAction>;
    setQualifyingActionsList(value: Array<QualifyingAction>): RewardProgram;
    addQualifyingActions(value?: QualifyingAction, index?: number): QualifyingAction;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): RewardProgram.AsObject;
    static toObject(includeInstance: boolean, msg: RewardProgram): RewardProgram.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: RewardProgram, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): RewardProgram;
    static deserializeBinaryFromReader(message: RewardProgram, reader: jspb.BinaryReader): RewardProgram;
}

export namespace RewardProgram {
    export type AsObject = {
        id: number,
        title: string,
        description: string,
        distributeFromAddress: string,
        totalRewardPool?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
        remainingPoolBalance?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
        claimedAmount?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
        maxRewardByAddress?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
        minimumRolloverAmount?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
        claimPeriodSeconds: number,
        programStartTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        expectedProgramEndTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        programEndTimeMax?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        claimPeriodEndTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        actualProgramEndTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        claimPeriods: number,
        currentClaimPeriod: number,
        maxRolloverClaimPeriods: number,
        state: RewardProgram.State,
        expirationOffset: number,
        qualifyingActionsList: Array<QualifyingAction.AsObject>,
    }

    export enum State {
    STATE_UNSPECIFIED = 0,
    STATE_PENDING = 1,
    STATE_STARTED = 2,
    STATE_FINISHED = 3,
    STATE_EXPIRED = 4,
    }

}

export class ClaimPeriodRewardDistribution extends jspb.Message { 
    getClaimPeriodId(): number;
    setClaimPeriodId(value: number): ClaimPeriodRewardDistribution;
    getRewardProgramId(): number;
    setRewardProgramId(value: number): ClaimPeriodRewardDistribution;

    hasTotalRewardsPoolForClaimPeriod(): boolean;
    clearTotalRewardsPoolForClaimPeriod(): void;
    getTotalRewardsPoolForClaimPeriod(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setTotalRewardsPoolForClaimPeriod(value?: cosmos_base_v1beta1_coin_pb.Coin): ClaimPeriodRewardDistribution;

    hasRewardsPool(): boolean;
    clearRewardsPool(): void;
    getRewardsPool(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setRewardsPool(value?: cosmos_base_v1beta1_coin_pb.Coin): ClaimPeriodRewardDistribution;
    getTotalShares(): number;
    setTotalShares(value: number): ClaimPeriodRewardDistribution;
    getClaimPeriodEnded(): boolean;
    setClaimPeriodEnded(value: boolean): ClaimPeriodRewardDistribution;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ClaimPeriodRewardDistribution.AsObject;
    static toObject(includeInstance: boolean, msg: ClaimPeriodRewardDistribution): ClaimPeriodRewardDistribution.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ClaimPeriodRewardDistribution, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ClaimPeriodRewardDistribution;
    static deserializeBinaryFromReader(message: ClaimPeriodRewardDistribution, reader: jspb.BinaryReader): ClaimPeriodRewardDistribution;
}

export namespace ClaimPeriodRewardDistribution {
    export type AsObject = {
        claimPeriodId: number,
        rewardProgramId: number,
        totalRewardsPoolForClaimPeriod?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
        rewardsPool?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
        totalShares: number,
        claimPeriodEnded: boolean,
    }
}

export class RewardAccountState extends jspb.Message { 
    getRewardProgramId(): number;
    setRewardProgramId(value: number): RewardAccountState;
    getClaimPeriodId(): number;
    setClaimPeriodId(value: number): RewardAccountState;
    getAddress(): string;
    setAddress(value: string): RewardAccountState;
    clearActionCounterList(): void;
    getActionCounterList(): Array<ActionCounter>;
    setActionCounterList(value: Array<ActionCounter>): RewardAccountState;
    addActionCounter(value?: ActionCounter, index?: number): ActionCounter;
    getSharesEarned(): number;
    setSharesEarned(value: number): RewardAccountState;
    getClaimStatus(): RewardAccountState.ClaimStatus;
    setClaimStatus(value: RewardAccountState.ClaimStatus): RewardAccountState;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): RewardAccountState.AsObject;
    static toObject(includeInstance: boolean, msg: RewardAccountState): RewardAccountState.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: RewardAccountState, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): RewardAccountState;
    static deserializeBinaryFromReader(message: RewardAccountState, reader: jspb.BinaryReader): RewardAccountState;
}

export namespace RewardAccountState {
    export type AsObject = {
        rewardProgramId: number,
        claimPeriodId: number,
        address: string,
        actionCounterList: Array<ActionCounter.AsObject>,
        sharesEarned: number,
        claimStatus: RewardAccountState.ClaimStatus,
    }

    export enum ClaimStatus {
    CLAIM_STATUS_UNSPECIFIED = 0,
    CLAIM_STATUS_UNCLAIMABLE = 1,
    CLAIM_STATUS_CLAIMABLE = 2,
    CLAIM_STATUS_CLAIMED = 3,
    CLAIM_STATUS_EXPIRED = 4,
    }

}

export class QualifyingAction extends jspb.Message { 

    hasDelegate(): boolean;
    clearDelegate(): void;
    getDelegate(): ActionDelegate | undefined;
    setDelegate(value?: ActionDelegate): QualifyingAction;

    hasTransfer(): boolean;
    clearTransfer(): void;
    getTransfer(): ActionTransfer | undefined;
    setTransfer(value?: ActionTransfer): QualifyingAction;

    hasVote(): boolean;
    clearVote(): void;
    getVote(): ActionVote | undefined;
    setVote(value?: ActionVote): QualifyingAction;

    getTypeCase(): QualifyingAction.TypeCase;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): QualifyingAction.AsObject;
    static toObject(includeInstance: boolean, msg: QualifyingAction): QualifyingAction.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: QualifyingAction, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): QualifyingAction;
    static deserializeBinaryFromReader(message: QualifyingAction, reader: jspb.BinaryReader): QualifyingAction;
}

export namespace QualifyingAction {
    export type AsObject = {
        delegate?: ActionDelegate.AsObject,
        transfer?: ActionTransfer.AsObject,
        vote?: ActionVote.AsObject,
    }

    export enum TypeCase {
        TYPE_NOT_SET = 0,
        DELEGATE = 1,
        TRANSFER = 2,
        VOTE = 3,
    }

}

export class QualifyingActions extends jspb.Message { 
    clearQualifyingActionsList(): void;
    getQualifyingActionsList(): Array<QualifyingAction>;
    setQualifyingActionsList(value: Array<QualifyingAction>): QualifyingActions;
    addQualifyingActions(value?: QualifyingAction, index?: number): QualifyingAction;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): QualifyingActions.AsObject;
    static toObject(includeInstance: boolean, msg: QualifyingActions): QualifyingActions.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: QualifyingActions, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): QualifyingActions;
    static deserializeBinaryFromReader(message: QualifyingActions, reader: jspb.BinaryReader): QualifyingActions;
}

export namespace QualifyingActions {
    export type AsObject = {
        qualifyingActionsList: Array<QualifyingAction.AsObject>,
    }
}

export class ActionDelegate extends jspb.Message { 
    getMinimumActions(): number;
    setMinimumActions(value: number): ActionDelegate;
    getMaximumActions(): number;
    setMaximumActions(value: number): ActionDelegate;

    hasMinimumDelegationAmount(): boolean;
    clearMinimumDelegationAmount(): void;
    getMinimumDelegationAmount(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setMinimumDelegationAmount(value?: cosmos_base_v1beta1_coin_pb.Coin): ActionDelegate;

    hasMaximumDelegationAmount(): boolean;
    clearMaximumDelegationAmount(): void;
    getMaximumDelegationAmount(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setMaximumDelegationAmount(value?: cosmos_base_v1beta1_coin_pb.Coin): ActionDelegate;
    getMinimumActiveStakePercentile(): string;
    setMinimumActiveStakePercentile(value: string): ActionDelegate;
    getMaximumActiveStakePercentile(): string;
    setMaximumActiveStakePercentile(value: string): ActionDelegate;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ActionDelegate.AsObject;
    static toObject(includeInstance: boolean, msg: ActionDelegate): ActionDelegate.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ActionDelegate, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ActionDelegate;
    static deserializeBinaryFromReader(message: ActionDelegate, reader: jspb.BinaryReader): ActionDelegate;
}

export namespace ActionDelegate {
    export type AsObject = {
        minimumActions: number,
        maximumActions: number,
        minimumDelegationAmount?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
        maximumDelegationAmount?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
        minimumActiveStakePercentile: string,
        maximumActiveStakePercentile: string,
    }
}

export class ActionTransfer extends jspb.Message { 
    getMinimumActions(): number;
    setMinimumActions(value: number): ActionTransfer;
    getMaximumActions(): number;
    setMaximumActions(value: number): ActionTransfer;

    hasMinimumDelegationAmount(): boolean;
    clearMinimumDelegationAmount(): void;
    getMinimumDelegationAmount(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setMinimumDelegationAmount(value?: cosmos_base_v1beta1_coin_pb.Coin): ActionTransfer;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ActionTransfer.AsObject;
    static toObject(includeInstance: boolean, msg: ActionTransfer): ActionTransfer.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ActionTransfer, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ActionTransfer;
    static deserializeBinaryFromReader(message: ActionTransfer, reader: jspb.BinaryReader): ActionTransfer;
}

export namespace ActionTransfer {
    export type AsObject = {
        minimumActions: number,
        maximumActions: number,
        minimumDelegationAmount?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
    }
}

export class ActionVote extends jspb.Message { 
    getMinimumActions(): number;
    setMinimumActions(value: number): ActionVote;
    getMaximumActions(): number;
    setMaximumActions(value: number): ActionVote;

    hasMinimumDelegationAmount(): boolean;
    clearMinimumDelegationAmount(): void;
    getMinimumDelegationAmount(): cosmos_base_v1beta1_coin_pb.Coin | undefined;
    setMinimumDelegationAmount(value?: cosmos_base_v1beta1_coin_pb.Coin): ActionVote;
    getValidatorMultiplier(): number;
    setValidatorMultiplier(value: number): ActionVote;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ActionVote.AsObject;
    static toObject(includeInstance: boolean, msg: ActionVote): ActionVote.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ActionVote, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ActionVote;
    static deserializeBinaryFromReader(message: ActionVote, reader: jspb.BinaryReader): ActionVote;
}

export namespace ActionVote {
    export type AsObject = {
        minimumActions: number,
        maximumActions: number,
        minimumDelegationAmount?: cosmos_base_v1beta1_coin_pb.Coin.AsObject,
        validatorMultiplier: number,
    }
}

export class ActionCounter extends jspb.Message { 
    getActionType(): string;
    setActionType(value: string): ActionCounter;
    getNumberOfActions(): number;
    setNumberOfActions(value: number): ActionCounter;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ActionCounter.AsObject;
    static toObject(includeInstance: boolean, msg: ActionCounter): ActionCounter.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ActionCounter, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ActionCounter;
    static deserializeBinaryFromReader(message: ActionCounter, reader: jspb.BinaryReader): ActionCounter;
}

export namespace ActionCounter {
    export type AsObject = {
        actionType: string,
        numberOfActions: number,
    }
}