import { QueryCondition, QueryConditionAmino, QueryConditionSDKType } from '../lockup/lock';
import { Coin, CoinAmino, CoinSDKType } from '../../cosmos/base/v1beta1/coin';
import { Duration, DurationAmino, DurationSDKType } from '../../../google/protobuf/duration';
import { BinaryReader, BinaryWriter } from '../../../binary';
/**
 * Gauge is an object that stores and distributes yields to recipients who
 * satisfy certain conditions. Currently gauges support conditions around the
 * duration for which a given denom is locked.
 */
export interface Gauge {
    /** id is the unique ID of a Gauge */
    id: bigint;
    /**
     * is_perpetual is a flag to show if it's a perpetual or non-perpetual gauge
     * Non-perpetual gauges distribute their tokens equally per epoch while the
     * gauge is in the active period. Perpetual gauges distribute all their tokens
     * at a single time and only distribute their tokens again once the gauge is
     * refilled, Intended for use with incentives that get refilled daily.
     */
    isPerpetual: boolean;
    /**
     * distribute_to is where the gauge rewards are distributed to.
     * This is queried via lock duration or by timestamp
     */
    distributeTo: QueryCondition;
    /**
     * coins is the total amount of coins that have been in the gauge
     * Can distribute multiple coin denoms
     */
    coins: Coin[];
    /** start_time is the distribution start time */
    startTime: Date;
    /**
     * num_epochs_paid_over is the number of total epochs distribution will be
     * completed over
     */
    numEpochsPaidOver: bigint;
    /**
     * filled_epochs is the number of epochs distribution has been completed on
     * already
     */
    filledEpochs: bigint;
    /** distributed_coins are coins that have been distributed already */
    distributedCoins: Coin[];
}
export interface GaugeProtoMsg {
    typeUrl: '/osmosis.incentives.Gauge';
    value: Uint8Array;
}
/**
 * Gauge is an object that stores and distributes yields to recipients who
 * satisfy certain conditions. Currently gauges support conditions around the
 * duration for which a given denom is locked.
 */
export interface GaugeAmino {
    /** id is the unique ID of a Gauge */
    id?: string;
    /**
     * is_perpetual is a flag to show if it's a perpetual or non-perpetual gauge
     * Non-perpetual gauges distribute their tokens equally per epoch while the
     * gauge is in the active period. Perpetual gauges distribute all their tokens
     * at a single time and only distribute their tokens again once the gauge is
     * refilled, Intended for use with incentives that get refilled daily.
     */
    is_perpetual?: boolean;
    /**
     * distribute_to is where the gauge rewards are distributed to.
     * This is queried via lock duration or by timestamp
     */
    distribute_to?: QueryConditionAmino;
    /**
     * coins is the total amount of coins that have been in the gauge
     * Can distribute multiple coin denoms
     */
    coins?: CoinAmino[];
    /** start_time is the distribution start time */
    start_time?: string;
    /**
     * num_epochs_paid_over is the number of total epochs distribution will be
     * completed over
     */
    num_epochs_paid_over?: string;
    /**
     * filled_epochs is the number of epochs distribution has been completed on
     * already
     */
    filled_epochs?: string;
    /** distributed_coins are coins that have been distributed already */
    distributed_coins?: CoinAmino[];
}
export interface GaugeAminoMsg {
    type: 'osmosis/incentives/gauge';
    value: GaugeAmino;
}
/**
 * Gauge is an object that stores and distributes yields to recipients who
 * satisfy certain conditions. Currently gauges support conditions around the
 * duration for which a given denom is locked.
 */
export interface GaugeSDKType {
    id: bigint;
    is_perpetual: boolean;
    distribute_to: QueryConditionSDKType;
    coins: CoinSDKType[];
    start_time: Date;
    num_epochs_paid_over: bigint;
    filled_epochs: bigint;
    distributed_coins: CoinSDKType[];
}
export interface LockableDurationsInfo {
    /** List of incentivised durations that gauges will pay out to */
    lockableDurations: Duration[];
}
export interface LockableDurationsInfoProtoMsg {
    typeUrl: '/osmosis.incentives.LockableDurationsInfo';
    value: Uint8Array;
}
export interface LockableDurationsInfoAmino {
    /** List of incentivised durations that gauges will pay out to */
    lockable_durations?: DurationAmino[];
}
export interface LockableDurationsInfoAminoMsg {
    type: 'osmosis/incentives/lockable-durations-info';
    value: LockableDurationsInfoAmino;
}
export interface LockableDurationsInfoSDKType {
    lockable_durations: DurationSDKType[];
}
export declare const Gauge: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is Gauge;
    isSDK(o: any): o is GaugeSDKType;
    isAmino(o: any): o is GaugeAmino;
    encode(message: Gauge, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Gauge;
    fromPartial(object: Partial<Gauge>): Gauge;
    fromAmino(object: GaugeAmino): Gauge;
    toAmino(message: Gauge): GaugeAmino;
    fromAminoMsg(object: GaugeAminoMsg): Gauge;
    toAminoMsg(message: Gauge): GaugeAminoMsg;
    fromProtoMsg(message: GaugeProtoMsg): Gauge;
    toProto(message: Gauge): Uint8Array;
    toProtoMsg(message: Gauge): GaugeProtoMsg;
};
export declare const LockableDurationsInfo: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is LockableDurationsInfo;
    isSDK(o: any): o is LockableDurationsInfoSDKType;
    isAmino(o: any): o is LockableDurationsInfoAmino;
    encode(message: LockableDurationsInfo, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): LockableDurationsInfo;
    fromPartial(object: Partial<LockableDurationsInfo>): LockableDurationsInfo;
    fromAmino(object: LockableDurationsInfoAmino): LockableDurationsInfo;
    toAmino(message: LockableDurationsInfo): LockableDurationsInfoAmino;
    fromAminoMsg(object: LockableDurationsInfoAminoMsg): LockableDurationsInfo;
    toAminoMsg(message: LockableDurationsInfo): LockableDurationsInfoAminoMsg;
    fromProtoMsg(message: LockableDurationsInfoProtoMsg): LockableDurationsInfo;
    toProto(message: LockableDurationsInfo): Uint8Array;
    toProtoMsg(message: LockableDurationsInfo): LockableDurationsInfoProtoMsg;
};