/** A user_reward_manager farms pool_rewards to receive rewards proportional to their stake in the pool. */
import type { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
import { Option } from '../../_dependencies/std/option/structs';
import { TypeName } from '../../_dependencies/std/type-name/structs';
import { Bag } from '../../_dependencies/sui/bag/structs';
import { ID, UID } from '../../_dependencies/sui/object/structs';
import { PhantomReified, PhantomToTypeStr, PhantomTypeArgument, Reified, StructClass, ToField, ToJSON, ToPhantomTypeArgument, ToTypeStr } from '../../_framework/reified';
import { FieldsWithTypes } from '../../_framework/util';
import { Vector } from '../../_framework/vector';
import { Decimal } from '../decimal/structs';
export declare function isPoolRewardManager(type: string): boolean;
export interface PoolRewardManagerFields {
    id: ToField<UID>;
    totalShares: ToField<'u64'>;
    poolRewards: ToField<Vector<Option<PoolReward>>>;
    lastUpdateTimeMs: ToField<'u64'>;
}
export type PoolRewardManagerReified = Reified<PoolRewardManager, PoolRewardManagerFields>;
export type PoolRewardManagerJSONField = {
    id: string;
    totalShares: string;
    poolRewards: (ToJSON<PoolReward> | null)[];
    lastUpdateTimeMs: string;
};
export type PoolRewardManagerJSON = {
    $typeName: typeof PoolRewardManager.$typeName;
    $typeArgs: [];
} & PoolRewardManagerJSONField;
/** This struct manages all pool_rewards for a given stake pool. */
export declare class PoolRewardManager implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::liquidity_mining::PoolRewardManager`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof PoolRewardManager.$typeName;
    readonly $fullTypeName: `${string}::liquidity_mining::PoolRewardManager`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof PoolRewardManager.$isPhantom;
    readonly id: ToField<UID>;
    readonly totalShares: ToField<'u64'>;
    readonly poolRewards: ToField<Vector<Option<PoolReward>>>;
    readonly lastUpdateTimeMs: ToField<'u64'>;
    private constructor();
    static reified(): PoolRewardManagerReified;
    static get r(): PoolRewardManagerReified;
    static phantom(): PhantomReified<ToTypeStr<PoolRewardManager>>;
    static get p(): PhantomReified<ToTypeStr<PoolRewardManager>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof PoolRewardManager.instantiateBcs>;
    static fromFields(fields: Record<string, any>): PoolRewardManager;
    static fromFieldsWithTypes(item: FieldsWithTypes): PoolRewardManager;
    static fromBcs(data: Uint8Array): PoolRewardManager;
    toJSONField(): PoolRewardManagerJSONField;
    toJSON(): PoolRewardManagerJSON;
    static fromJSONField(field: any): PoolRewardManager;
    static fromJSON(json: Record<string, any>): PoolRewardManager;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): PoolRewardManager;
    static fetch(client: ClientWithCoreApi, id: string): Promise<PoolRewardManager>;
}
export declare function isPoolReward(type: string): boolean;
export interface PoolRewardFields {
    id: ToField<UID>;
    poolRewardManagerId: ToField<ID>;
    coinType: ToField<TypeName>;
    startTimeMs: ToField<'u64'>;
    endTimeMs: ToField<'u64'>;
    totalRewards: ToField<'u64'>;
    /** amount of rewards that have been earned by users */
    allocatedRewards: ToField<Decimal>;
    cumulativeRewardsPerShare: ToField<Decimal>;
    numUserRewardManagers: ToField<'u64'>;
    additionalFields: ToField<Bag>;
}
export type PoolRewardReified = Reified<PoolReward, PoolRewardFields>;
export type PoolRewardJSONField = {
    id: string;
    poolRewardManagerId: string;
    coinType: string;
    startTimeMs: string;
    endTimeMs: string;
    totalRewards: string;
    allocatedRewards: ToJSON<Decimal>;
    cumulativeRewardsPerShare: ToJSON<Decimal>;
    numUserRewardManagers: string;
    additionalFields: ToJSON<Bag>;
};
export type PoolRewardJSON = {
    $typeName: typeof PoolReward.$typeName;
    $typeArgs: [];
} & PoolRewardJSONField;
export declare class PoolReward implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::liquidity_mining::PoolReward`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof PoolReward.$typeName;
    readonly $fullTypeName: `${string}::liquidity_mining::PoolReward`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof PoolReward.$isPhantom;
    readonly id: ToField<UID>;
    readonly poolRewardManagerId: ToField<ID>;
    readonly coinType: ToField<TypeName>;
    readonly startTimeMs: ToField<'u64'>;
    readonly endTimeMs: ToField<'u64'>;
    readonly totalRewards: ToField<'u64'>;
    /** amount of rewards that have been earned by users */
    readonly allocatedRewards: ToField<Decimal>;
    readonly cumulativeRewardsPerShare: ToField<Decimal>;
    readonly numUserRewardManagers: ToField<'u64'>;
    readonly additionalFields: ToField<Bag>;
    private constructor();
    static reified(): PoolRewardReified;
    static get r(): PoolRewardReified;
    static phantom(): PhantomReified<ToTypeStr<PoolReward>>;
    static get p(): PhantomReified<ToTypeStr<PoolReward>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof PoolReward.instantiateBcs>;
    static fromFields(fields: Record<string, any>): PoolReward;
    static fromFieldsWithTypes(item: FieldsWithTypes): PoolReward;
    static fromBcs(data: Uint8Array): PoolReward;
    toJSONField(): PoolRewardJSONField;
    toJSON(): PoolRewardJSON;
    static fromJSONField(field: any): PoolReward;
    static fromJSON(json: Record<string, any>): PoolReward;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): PoolReward;
    static fetch(client: ClientWithCoreApi, id: string): Promise<PoolReward>;
}
export declare function isRewardBalance(type: string): boolean;
export interface RewardBalanceFields<T extends PhantomTypeArgument> {
    dummyField: ToField<'bool'>;
}
export type RewardBalanceReified<T extends PhantomTypeArgument> = Reified<RewardBalance<T>, RewardBalanceFields<T>>;
export type RewardBalanceJSONField<T extends PhantomTypeArgument> = {
    dummyField: boolean;
};
export type RewardBalanceJSON<T extends PhantomTypeArgument> = {
    $typeName: typeof RewardBalance.$typeName;
    $typeArgs: [PhantomToTypeStr<T>];
} & RewardBalanceJSONField<T>;
export declare class RewardBalance<T extends PhantomTypeArgument> implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::liquidity_mining::RewardBalance`;
    static readonly $numTypeParams = 1;
    static readonly $isPhantom: readonly [true];
    readonly $typeName: typeof RewardBalance.$typeName;
    readonly $fullTypeName: `${string}::liquidity_mining::RewardBalance<${PhantomToTypeStr<T>}>`;
    readonly $typeArgs: [PhantomToTypeStr<T>];
    readonly $isPhantom: typeof RewardBalance.$isPhantom;
    readonly dummyField: ToField<'bool'>;
    private constructor();
    static reified<T extends PhantomReified<PhantomTypeArgument>>(T: T): RewardBalanceReified<ToPhantomTypeArgument<T>>;
    static get r(): typeof RewardBalance.reified;
    static phantom<T extends PhantomReified<PhantomTypeArgument>>(T: T): PhantomReified<ToTypeStr<RewardBalance<ToPhantomTypeArgument<T>>>>;
    static get p(): typeof RewardBalance.phantom;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof RewardBalance.instantiateBcs>;
    static fromFields<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, fields: Record<string, any>): RewardBalance<ToPhantomTypeArgument<T>>;
    static fromFieldsWithTypes<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, item: FieldsWithTypes): RewardBalance<ToPhantomTypeArgument<T>>;
    static fromBcs<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, data: Uint8Array): RewardBalance<ToPhantomTypeArgument<T>>;
    toJSONField(): RewardBalanceJSONField<T>;
    toJSON(): RewardBalanceJSON<T>;
    static fromJSONField<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, field: any): RewardBalance<ToPhantomTypeArgument<T>>;
    static fromJSON<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, json: Record<string, any>): RewardBalance<ToPhantomTypeArgument<T>>;
    static fromCoreObject<T extends PhantomReified<PhantomTypeArgument>>(typeArg: T, obj: SuiClientTypes.Object<{
        content: true;
    }>): RewardBalance<ToPhantomTypeArgument<T>>;
    static fetch<T extends PhantomReified<PhantomTypeArgument>>(client: ClientWithCoreApi, typeArg: T, id: string): Promise<RewardBalance<ToPhantomTypeArgument<T>>>;
}
export declare function isUserRewardManager(type: string): boolean;
export interface UserRewardManagerFields {
    poolRewardManagerId: ToField<ID>;
    share: ToField<'u64'>;
    rewards: ToField<Vector<Option<UserReward>>>;
    lastUpdateTimeMs: ToField<'u64'>;
}
export type UserRewardManagerReified = Reified<UserRewardManager, UserRewardManagerFields>;
export type UserRewardManagerJSONField = {
    poolRewardManagerId: string;
    share: string;
    rewards: (ToJSON<UserReward> | null)[];
    lastUpdateTimeMs: string;
};
export type UserRewardManagerJSON = {
    $typeName: typeof UserRewardManager.$typeName;
    $typeArgs: [];
} & UserRewardManagerJSONField;
export declare class UserRewardManager implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::liquidity_mining::UserRewardManager`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof UserRewardManager.$typeName;
    readonly $fullTypeName: `${string}::liquidity_mining::UserRewardManager`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof UserRewardManager.$isPhantom;
    readonly poolRewardManagerId: ToField<ID>;
    readonly share: ToField<'u64'>;
    readonly rewards: ToField<Vector<Option<UserReward>>>;
    readonly lastUpdateTimeMs: ToField<'u64'>;
    private constructor();
    static reified(): UserRewardManagerReified;
    static get r(): UserRewardManagerReified;
    static phantom(): PhantomReified<ToTypeStr<UserRewardManager>>;
    static get p(): PhantomReified<ToTypeStr<UserRewardManager>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof UserRewardManager.instantiateBcs>;
    static fromFields(fields: Record<string, any>): UserRewardManager;
    static fromFieldsWithTypes(item: FieldsWithTypes): UserRewardManager;
    static fromBcs(data: Uint8Array): UserRewardManager;
    toJSONField(): UserRewardManagerJSONField;
    toJSON(): UserRewardManagerJSON;
    static fromJSONField(field: any): UserRewardManager;
    static fromJSON(json: Record<string, any>): UserRewardManager;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): UserRewardManager;
    static fetch(client: ClientWithCoreApi, id: string): Promise<UserRewardManager>;
}
export declare function isUserReward(type: string): boolean;
export interface UserRewardFields {
    poolRewardId: ToField<ID>;
    earnedRewards: ToField<Decimal>;
    cumulativeRewardsPerShare: ToField<Decimal>;
}
export type UserRewardReified = Reified<UserReward, UserRewardFields>;
export type UserRewardJSONField = {
    poolRewardId: string;
    earnedRewards: ToJSON<Decimal>;
    cumulativeRewardsPerShare: ToJSON<Decimal>;
};
export type UserRewardJSON = {
    $typeName: typeof UserReward.$typeName;
    $typeArgs: [];
} & UserRewardJSONField;
export declare class UserReward implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::liquidity_mining::UserReward`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof UserReward.$typeName;
    readonly $fullTypeName: `${string}::liquidity_mining::UserReward`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof UserReward.$isPhantom;
    readonly poolRewardId: ToField<ID>;
    readonly earnedRewards: ToField<Decimal>;
    readonly cumulativeRewardsPerShare: ToField<Decimal>;
    private constructor();
    static reified(): UserRewardReified;
    static get r(): UserRewardReified;
    static phantom(): PhantomReified<ToTypeStr<UserReward>>;
    static get p(): PhantomReified<ToTypeStr<UserReward>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof UserReward.instantiateBcs>;
    static fromFields(fields: Record<string, any>): UserReward;
    static fromFieldsWithTypes(item: FieldsWithTypes): UserReward;
    static fromBcs(data: Uint8Array): UserReward;
    toJSONField(): UserRewardJSONField;
    toJSON(): UserRewardJSON;
    static fromJSONField(field: any): UserReward;
    static fromJSON(json: Record<string, any>): UserReward;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): UserReward;
    static fetch(client: ClientWithCoreApi, id: string): Promise<UserReward>;
}