/** The reserve module holds the coins of a certain type for a given lending market. */
import type { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
import { PriceIdentifier } from '../../_dependencies/pyth-2/price-identifier/structs';
import { TypeName } from '../../_dependencies/std/type-name/structs';
import { Balance, Supply } from '../../_dependencies/sui/balance/structs';
import { ID, UID } from '../../_dependencies/sui/object/structs';
import { PhantomReified, PhantomToTypeStr, PhantomTypeArgument, Reified, StructClass, ToField, ToJSON, ToPhantomTypeArgument, ToTypeStr, ToTypeStr as ToPhantom } from '../../_framework/reified';
import { FieldsWithTypes } from '../../_framework/util';
import { Cell } from '../cell/structs';
import { Decimal } from '../decimal/structs';
import { PoolRewardManager } from '../liquidity-mining/structs';
import { ReserveConfig } from '../reserve-config/structs';
export declare function isReserve(type: string): boolean;
export interface ReserveFields<P extends PhantomTypeArgument> {
    id: ToField<UID>;
    lendingMarketId: ToField<ID>;
    arrayIndex: ToField<'u64'>;
    coinType: ToField<TypeName>;
    config: ToField<Cell<ReserveConfig>>;
    mintDecimals: ToField<'u8'>;
    priceIdentifier: ToField<PriceIdentifier>;
    price: ToField<Decimal>;
    smoothedPrice: ToField<Decimal>;
    priceLastUpdateTimestampS: ToField<'u64'>;
    availableAmount: ToField<'u64'>;
    ctokenSupply: ToField<'u64'>;
    borrowedAmount: ToField<Decimal>;
    cumulativeBorrowRate: ToField<Decimal>;
    interestLastUpdateTimestampS: ToField<'u64'>;
    unclaimedSpreadFees: ToField<Decimal>;
    /** unused */
    attributedBorrowValue: ToField<Decimal>;
    depositsPoolRewardManager: ToField<PoolRewardManager>;
    borrowsPoolRewardManager: ToField<PoolRewardManager>;
}
export type ReserveReified<P extends PhantomTypeArgument> = Reified<Reserve<P>, ReserveFields<P>>;
export type ReserveJSONField<P extends PhantomTypeArgument> = {
    id: string;
    lendingMarketId: string;
    arrayIndex: string;
    coinType: string;
    config: ToJSON<Cell<ReserveConfig>>;
    mintDecimals: number;
    priceIdentifier: ToJSON<PriceIdentifier>;
    price: ToJSON<Decimal>;
    smoothedPrice: ToJSON<Decimal>;
    priceLastUpdateTimestampS: string;
    availableAmount: string;
    ctokenSupply: string;
    borrowedAmount: ToJSON<Decimal>;
    cumulativeBorrowRate: ToJSON<Decimal>;
    interestLastUpdateTimestampS: string;
    unclaimedSpreadFees: ToJSON<Decimal>;
    attributedBorrowValue: ToJSON<Decimal>;
    depositsPoolRewardManager: ToJSON<PoolRewardManager>;
    borrowsPoolRewardManager: ToJSON<PoolRewardManager>;
};
export type ReserveJSON<P extends PhantomTypeArgument> = {
    $typeName: typeof Reserve.$typeName;
    $typeArgs: [PhantomToTypeStr<P>];
} & ReserveJSONField<P>;
export declare class Reserve<P extends PhantomTypeArgument> implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::reserve::Reserve`;
    static readonly $numTypeParams = 1;
    static readonly $isPhantom: readonly [true];
    readonly $typeName: typeof Reserve.$typeName;
    readonly $fullTypeName: `${string}::reserve::Reserve<${PhantomToTypeStr<P>}>`;
    readonly $typeArgs: [PhantomToTypeStr<P>];
    readonly $isPhantom: typeof Reserve.$isPhantom;
    readonly id: ToField<UID>;
    readonly lendingMarketId: ToField<ID>;
    readonly arrayIndex: ToField<'u64'>;
    readonly coinType: ToField<TypeName>;
    readonly config: ToField<Cell<ReserveConfig>>;
    readonly mintDecimals: ToField<'u8'>;
    readonly priceIdentifier: ToField<PriceIdentifier>;
    readonly price: ToField<Decimal>;
    readonly smoothedPrice: ToField<Decimal>;
    readonly priceLastUpdateTimestampS: ToField<'u64'>;
    readonly availableAmount: ToField<'u64'>;
    readonly ctokenSupply: ToField<'u64'>;
    readonly borrowedAmount: ToField<Decimal>;
    readonly cumulativeBorrowRate: ToField<Decimal>;
    readonly interestLastUpdateTimestampS: ToField<'u64'>;
    readonly unclaimedSpreadFees: ToField<Decimal>;
    /** unused */
    readonly attributedBorrowValue: ToField<Decimal>;
    readonly depositsPoolRewardManager: ToField<PoolRewardManager>;
    readonly borrowsPoolRewardManager: ToField<PoolRewardManager>;
    private constructor();
    static reified<P extends PhantomReified<PhantomTypeArgument>>(P: P): ReserveReified<ToPhantomTypeArgument<P>>;
    static get r(): typeof Reserve.reified;
    static phantom<P extends PhantomReified<PhantomTypeArgument>>(P: P): PhantomReified<ToTypeStr<Reserve<ToPhantomTypeArgument<P>>>>;
    static get p(): typeof Reserve.phantom;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof Reserve.instantiateBcs>;
    static fromFields<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, fields: Record<string, any>): Reserve<ToPhantomTypeArgument<P>>;
    static fromFieldsWithTypes<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, item: FieldsWithTypes): Reserve<ToPhantomTypeArgument<P>>;
    static fromBcs<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, data: Uint8Array): Reserve<ToPhantomTypeArgument<P>>;
    toJSONField(): ReserveJSONField<P>;
    toJSON(): ReserveJSON<P>;
    static fromJSONField<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, field: any): Reserve<ToPhantomTypeArgument<P>>;
    static fromJSON<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, json: Record<string, any>): Reserve<ToPhantomTypeArgument<P>>;
    static fromCoreObject<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, obj: SuiClientTypes.Object<{
        content: true;
    }>): Reserve<ToPhantomTypeArgument<P>>;
    static fetch<P extends PhantomReified<PhantomTypeArgument>>(client: ClientWithCoreApi, typeArg: P, id: string): Promise<Reserve<ToPhantomTypeArgument<P>>>;
}
export declare function isCToken(type: string): boolean;
export interface CTokenFields<P extends PhantomTypeArgument, T extends PhantomTypeArgument> {
    dummyField: ToField<'bool'>;
}
export type CTokenReified<P extends PhantomTypeArgument, T extends PhantomTypeArgument> = Reified<CToken<P, T>, CTokenFields<P, T>>;
export type CTokenJSONField<P extends PhantomTypeArgument, T extends PhantomTypeArgument> = {
    dummyField: boolean;
};
export type CTokenJSON<P extends PhantomTypeArgument, T extends PhantomTypeArgument> = {
    $typeName: typeof CToken.$typeName;
    $typeArgs: [PhantomToTypeStr<P>, PhantomToTypeStr<T>];
} & CTokenJSONField<P, T>;
/**
 * Interest bearing token on the underlying Coin<T>. The ctoken can be redeemed for
 * the underlying token + any interest earned.
 */
export declare class CToken<P extends PhantomTypeArgument, T extends PhantomTypeArgument> implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::reserve::CToken`;
    static readonly $numTypeParams = 2;
    static readonly $isPhantom: readonly [true, true];
    readonly $typeName: typeof CToken.$typeName;
    readonly $fullTypeName: `${string}::reserve::CToken<${PhantomToTypeStr<P>}, ${PhantomToTypeStr<T>}>`;
    readonly $typeArgs: [PhantomToTypeStr<P>, PhantomToTypeStr<T>];
    readonly $isPhantom: typeof CToken.$isPhantom;
    readonly dummyField: ToField<'bool'>;
    private constructor();
    static reified<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(P: P, T: T): CTokenReified<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static get r(): typeof CToken.reified;
    static phantom<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(P: P, T: T): PhantomReified<ToTypeStr<CToken<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>>>;
    static get p(): typeof CToken.phantom;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof CToken.instantiateBcs>;
    static fromFields<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], fields: Record<string, any>): CToken<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fromFieldsWithTypes<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], item: FieldsWithTypes): CToken<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fromBcs<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], data: Uint8Array): CToken<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    toJSONField(): CTokenJSONField<P, T>;
    toJSON(): CTokenJSON<P, T>;
    static fromJSONField<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], field: any): CToken<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fromJSON<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], json: Record<string, any>): CToken<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fromCoreObject<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], obj: SuiClientTypes.Object<{
        content: true;
    }>): CToken<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fetch<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(client: ClientWithCoreApi, typeArgs: [P, T], id: string): Promise<CToken<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>>;
}
export declare function isLiquidityRequest(type: string): boolean;
export interface LiquidityRequestFields<P extends PhantomTypeArgument, T extends PhantomTypeArgument> {
    amount: ToField<'u64'>;
    fee: ToField<'u64'>;
}
export type LiquidityRequestReified<P extends PhantomTypeArgument, T extends PhantomTypeArgument> = Reified<LiquidityRequest<P, T>, LiquidityRequestFields<P, T>>;
export type LiquidityRequestJSONField<P extends PhantomTypeArgument, T extends PhantomTypeArgument> = {
    amount: string;
    fee: string;
};
export type LiquidityRequestJSON<P extends PhantomTypeArgument, T extends PhantomTypeArgument> = {
    $typeName: typeof LiquidityRequest.$typeName;
    $typeArgs: [PhantomToTypeStr<P>, PhantomToTypeStr<T>];
} & LiquidityRequestJSONField<P, T>;
/** A request to withdraw liquidity from the reserve. This is a hot potato object. */
export declare class LiquidityRequest<P extends PhantomTypeArgument, T extends PhantomTypeArgument> implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::reserve::LiquidityRequest`;
    static readonly $numTypeParams = 2;
    static readonly $isPhantom: readonly [true, true];
    readonly $typeName: typeof LiquidityRequest.$typeName;
    readonly $fullTypeName: `${string}::reserve::LiquidityRequest<${PhantomToTypeStr<P>}, ${PhantomToTypeStr<T>}>`;
    readonly $typeArgs: [PhantomToTypeStr<P>, PhantomToTypeStr<T>];
    readonly $isPhantom: typeof LiquidityRequest.$isPhantom;
    readonly amount: ToField<'u64'>;
    readonly fee: ToField<'u64'>;
    private constructor();
    static reified<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(P: P, T: T): LiquidityRequestReified<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static get r(): typeof LiquidityRequest.reified;
    static phantom<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(P: P, T: T): PhantomReified<ToTypeStr<LiquidityRequest<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>>>;
    static get p(): typeof LiquidityRequest.phantom;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof LiquidityRequest.instantiateBcs>;
    static fromFields<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], fields: Record<string, any>): LiquidityRequest<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fromFieldsWithTypes<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], item: FieldsWithTypes): LiquidityRequest<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fromBcs<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], data: Uint8Array): LiquidityRequest<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    toJSONField(): LiquidityRequestJSONField<P, T>;
    toJSON(): LiquidityRequestJSON<P, T>;
    static fromJSONField<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], field: any): LiquidityRequest<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fromJSON<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], json: Record<string, any>): LiquidityRequest<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fromCoreObject<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], obj: SuiClientTypes.Object<{
        content: true;
    }>): LiquidityRequest<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fetch<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(client: ClientWithCoreApi, typeArgs: [P, T], id: string): Promise<LiquidityRequest<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>>;
}
export declare function isBalanceKey(type: string): boolean;
export interface BalanceKeyFields {
    dummyField: ToField<'bool'>;
}
export type BalanceKeyReified = Reified<BalanceKey, BalanceKeyFields>;
export type BalanceKeyJSONField = {
    dummyField: boolean;
};
export type BalanceKeyJSON = {
    $typeName: typeof BalanceKey.$typeName;
    $typeArgs: [];
} & BalanceKeyJSONField;
export declare class BalanceKey implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::reserve::BalanceKey`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof BalanceKey.$typeName;
    readonly $fullTypeName: `${string}::reserve::BalanceKey`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof BalanceKey.$isPhantom;
    readonly dummyField: ToField<'bool'>;
    private constructor();
    static reified(): BalanceKeyReified;
    static get r(): BalanceKeyReified;
    static phantom(): PhantomReified<ToTypeStr<BalanceKey>>;
    static get p(): PhantomReified<ToTypeStr<BalanceKey>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof BalanceKey.instantiateBcs>;
    static fromFields(fields: Record<string, any>): BalanceKey;
    static fromFieldsWithTypes(item: FieldsWithTypes): BalanceKey;
    static fromBcs(data: Uint8Array): BalanceKey;
    toJSONField(): BalanceKeyJSONField;
    toJSON(): BalanceKeyJSON;
    static fromJSONField(field: any): BalanceKey;
    static fromJSON(json: Record<string, any>): BalanceKey;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): BalanceKey;
    static fetch(client: ClientWithCoreApi, id: string): Promise<BalanceKey>;
}
export declare function isStakerKey(type: string): boolean;
export interface StakerKeyFields {
    dummyField: ToField<'bool'>;
}
export type StakerKeyReified = Reified<StakerKey, StakerKeyFields>;
export type StakerKeyJSONField = {
    dummyField: boolean;
};
export type StakerKeyJSON = {
    $typeName: typeof StakerKey.$typeName;
    $typeArgs: [];
} & StakerKeyJSONField;
export declare class StakerKey implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::reserve::StakerKey`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof StakerKey.$typeName;
    readonly $fullTypeName: `${string}::reserve::StakerKey`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof StakerKey.$isPhantom;
    readonly dummyField: ToField<'bool'>;
    private constructor();
    static reified(): StakerKeyReified;
    static get r(): StakerKeyReified;
    static phantom(): PhantomReified<ToTypeStr<StakerKey>>;
    static get p(): PhantomReified<ToTypeStr<StakerKey>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof StakerKey.instantiateBcs>;
    static fromFields(fields: Record<string, any>): StakerKey;
    static fromFieldsWithTypes(item: FieldsWithTypes): StakerKey;
    static fromBcs(data: Uint8Array): StakerKey;
    toJSONField(): StakerKeyJSONField;
    toJSON(): StakerKeyJSON;
    static fromJSONField(field: any): StakerKey;
    static fromJSON(json: Record<string, any>): StakerKey;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): StakerKey;
    static fetch(client: ClientWithCoreApi, id: string): Promise<StakerKey>;
}
export declare function isReservePauseKey(type: string): boolean;
export interface ReservePauseKeyFields {
    dummyField: ToField<'bool'>;
}
export type ReservePauseKeyReified = Reified<ReservePauseKey, ReservePauseKeyFields>;
export type ReservePauseKeyJSONField = {
    dummyField: boolean;
};
export type ReservePauseKeyJSON = {
    $typeName: typeof ReservePauseKey.$typeName;
    $typeArgs: [];
} & ReservePauseKeyJSONField;
export declare class ReservePauseKey implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::reserve::ReservePauseKey`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof ReservePauseKey.$typeName;
    readonly $fullTypeName: `${string}::reserve::ReservePauseKey`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof ReservePauseKey.$isPhantom;
    readonly dummyField: ToField<'bool'>;
    private constructor();
    static reified(): ReservePauseKeyReified;
    static get r(): ReservePauseKeyReified;
    static phantom(): PhantomReified<ToTypeStr<ReservePauseKey>>;
    static get p(): PhantomReified<ToTypeStr<ReservePauseKey>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof ReservePauseKey.instantiateBcs>;
    static fromFields(fields: Record<string, any>): ReservePauseKey;
    static fromFieldsWithTypes(item: FieldsWithTypes): ReservePauseKey;
    static fromBcs(data: Uint8Array): ReservePauseKey;
    toJSONField(): ReservePauseKeyJSONField;
    toJSON(): ReservePauseKeyJSON;
    static fromJSONField(field: any): ReservePauseKey;
    static fromJSON(json: Record<string, any>): ReservePauseKey;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): ReservePauseKey;
    static fetch(client: ClientWithCoreApi, id: string): Promise<ReservePauseKey>;
}
export declare function isPriceGuardKey(type: string): boolean;
export interface PriceGuardKeyFields {
    dummyField: ToField<'bool'>;
}
export type PriceGuardKeyReified = Reified<PriceGuardKey, PriceGuardKeyFields>;
export type PriceGuardKeyJSONField = {
    dummyField: boolean;
};
export type PriceGuardKeyJSON = {
    $typeName: typeof PriceGuardKey.$typeName;
    $typeArgs: [];
} & PriceGuardKeyJSONField;
export declare class PriceGuardKey implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::reserve::PriceGuardKey`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof PriceGuardKey.$typeName;
    readonly $fullTypeName: `${string}::reserve::PriceGuardKey`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof PriceGuardKey.$isPhantom;
    readonly dummyField: ToField<'bool'>;
    private constructor();
    static reified(): PriceGuardKeyReified;
    static get r(): PriceGuardKeyReified;
    static phantom(): PhantomReified<ToTypeStr<PriceGuardKey>>;
    static get p(): PhantomReified<ToTypeStr<PriceGuardKey>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof PriceGuardKey.instantiateBcs>;
    static fromFields(fields: Record<string, any>): PriceGuardKey;
    static fromFieldsWithTypes(item: FieldsWithTypes): PriceGuardKey;
    static fromBcs(data: Uint8Array): PriceGuardKey;
    toJSONField(): PriceGuardKeyJSONField;
    toJSON(): PriceGuardKeyJSON;
    static fromJSONField(field: any): PriceGuardKey;
    static fromJSON(json: Record<string, any>): PriceGuardKey;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): PriceGuardKey;
    static fetch(client: ClientWithCoreApi, id: string): Promise<PriceGuardKey>;
}
export declare function isConfidenceKey(type: string): boolean;
export interface ConfidenceKeyFields {
    dummyField: ToField<'bool'>;
}
export type ConfidenceKeyReified = Reified<ConfidenceKey, ConfidenceKeyFields>;
export type ConfidenceKeyJSONField = {
    dummyField: boolean;
};
export type ConfidenceKeyJSON = {
    $typeName: typeof ConfidenceKey.$typeName;
    $typeArgs: [];
} & ConfidenceKeyJSONField;
export declare class ConfidenceKey implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::reserve::ConfidenceKey`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof ConfidenceKey.$typeName;
    readonly $fullTypeName: `${string}::reserve::ConfidenceKey`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof ConfidenceKey.$isPhantom;
    readonly dummyField: ToField<'bool'>;
    private constructor();
    static reified(): ConfidenceKeyReified;
    static get r(): ConfidenceKeyReified;
    static phantom(): PhantomReified<ToTypeStr<ConfidenceKey>>;
    static get p(): PhantomReified<ToTypeStr<ConfidenceKey>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof ConfidenceKey.instantiateBcs>;
    static fromFields(fields: Record<string, any>): ConfidenceKey;
    static fromFieldsWithTypes(item: FieldsWithTypes): ConfidenceKey;
    static fromBcs(data: Uint8Array): ConfidenceKey;
    toJSONField(): ConfidenceKeyJSONField;
    toJSON(): ConfidenceKeyJSON;
    static fromJSONField(field: any): ConfidenceKey;
    static fromJSON(json: Record<string, any>): ConfidenceKey;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): ConfidenceKey;
    static fetch(client: ClientWithCoreApi, id: string): Promise<ConfidenceKey>;
}
export declare function isPriceGuard(type: string): boolean;
export interface PriceGuardFields {
    maxPriceChangeBps: ToField<'u64'>;
    minUpdateIntervalS: ToField<'u64'>;
    priceAnchor: ToField<Decimal>;
    smoothedPriceAnchor: ToField<Decimal>;
    anchorTimestampS: ToField<'u64'>;
}
export type PriceGuardReified = Reified<PriceGuard, PriceGuardFields>;
export type PriceGuardJSONField = {
    maxPriceChangeBps: string;
    minUpdateIntervalS: string;
    priceAnchor: ToJSON<Decimal>;
    smoothedPriceAnchor: ToJSON<Decimal>;
    anchorTimestampS: string;
};
export type PriceGuardJSON = {
    $typeName: typeof PriceGuard.$typeName;
    $typeArgs: [];
} & PriceGuardJSONField;
/**
 * Bounds how far `price` and `smoothed_price` may move per
 * `min_update_interval_s`. Each anchor moves at most one band per interval and is
 * advanced to the clamped value, so repeating a refresh inside one PTB cannot walk
 * either price further than a single band.
 */
export declare class PriceGuard implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::reserve::PriceGuard`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof PriceGuard.$typeName;
    readonly $fullTypeName: `${string}::reserve::PriceGuard`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof PriceGuard.$isPhantom;
    readonly maxPriceChangeBps: ToField<'u64'>;
    readonly minUpdateIntervalS: ToField<'u64'>;
    readonly priceAnchor: ToField<Decimal>;
    readonly smoothedPriceAnchor: ToField<Decimal>;
    readonly anchorTimestampS: ToField<'u64'>;
    private constructor();
    static reified(): PriceGuardReified;
    static get r(): PriceGuardReified;
    static phantom(): PhantomReified<ToTypeStr<PriceGuard>>;
    static get p(): PhantomReified<ToTypeStr<PriceGuard>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof PriceGuard.instantiateBcs>;
    static fromFields(fields: Record<string, any>): PriceGuard;
    static fromFieldsWithTypes(item: FieldsWithTypes): PriceGuard;
    static fromBcs(data: Uint8Array): PriceGuard;
    toJSONField(): PriceGuardJSONField;
    toJSON(): PriceGuardJSON;
    static fromJSONField(field: any): PriceGuard;
    static fromJSON(json: Record<string, any>): PriceGuard;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): PriceGuard;
    static fetch(client: ClientWithCoreApi, id: string): Promise<PriceGuard>;
}
export declare function isBalances(type: string): boolean;
export interface BalancesFields<P extends PhantomTypeArgument, T extends PhantomTypeArgument> {
    availableAmount: ToField<Balance<T>>;
    ctokenSupply: ToField<Supply<ToPhantom<CToken<P, T>>>>;
    fees: ToField<Balance<T>>;
    ctokenFees: ToField<Balance<ToPhantom<CToken<P, T>>>>;
    depositedCtokens: ToField<Balance<ToPhantom<CToken<P, T>>>>;
}
export type BalancesReified<P extends PhantomTypeArgument, T extends PhantomTypeArgument> = Reified<Balances<P, T>, BalancesFields<P, T>>;
export type BalancesJSONField<P extends PhantomTypeArgument, T extends PhantomTypeArgument> = {
    availableAmount: ToJSON<Balance<T>>;
    ctokenSupply: ToJSON<Supply<ToPhantom<CToken<P, T>>>>;
    fees: ToJSON<Balance<T>>;
    ctokenFees: ToJSON<Balance<ToPhantom<CToken<P, T>>>>;
    depositedCtokens: ToJSON<Balance<ToPhantom<CToken<P, T>>>>;
};
export type BalancesJSON<P extends PhantomTypeArgument, T extends PhantomTypeArgument> = {
    $typeName: typeof Balances.$typeName;
    $typeArgs: [PhantomToTypeStr<P>, PhantomToTypeStr<T>];
} & BalancesJSONField<P, T>;
/** Balances are stored in a dynamic field to avoid typing the Reserve with CoinType */
export declare class Balances<P extends PhantomTypeArgument, T extends PhantomTypeArgument> implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::reserve::Balances`;
    static readonly $numTypeParams = 2;
    static readonly $isPhantom: readonly [true, true];
    readonly $typeName: typeof Balances.$typeName;
    readonly $fullTypeName: `${string}::reserve::Balances<${PhantomToTypeStr<P>}, ${PhantomToTypeStr<T>}>`;
    readonly $typeArgs: [PhantomToTypeStr<P>, PhantomToTypeStr<T>];
    readonly $isPhantom: typeof Balances.$isPhantom;
    readonly availableAmount: ToField<Balance<T>>;
    readonly ctokenSupply: ToField<Supply<ToPhantom<CToken<P, T>>>>;
    readonly fees: ToField<Balance<T>>;
    readonly ctokenFees: ToField<Balance<ToPhantom<CToken<P, T>>>>;
    readonly depositedCtokens: ToField<Balance<ToPhantom<CToken<P, T>>>>;
    private constructor();
    static reified<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(P: P, T: T): BalancesReified<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static get r(): typeof Balances.reified;
    static phantom<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(P: P, T: T): PhantomReified<ToTypeStr<Balances<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>>>;
    static get p(): typeof Balances.phantom;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof Balances.instantiateBcs>;
    static fromFields<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], fields: Record<string, any>): Balances<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fromFieldsWithTypes<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], item: FieldsWithTypes): Balances<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fromBcs<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], data: Uint8Array): Balances<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    toJSONField(): BalancesJSONField<P, T>;
    toJSON(): BalancesJSON<P, T>;
    static fromJSONField<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], field: any): Balances<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fromJSON<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], json: Record<string, any>): Balances<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fromCoreObject<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], obj: SuiClientTypes.Object<{
        content: true;
    }>): Balances<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fetch<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(client: ClientWithCoreApi, typeArgs: [P, T], id: string): Promise<Balances<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>>;
}
export declare function isInterestUpdateEvent(type: string): boolean;
export interface InterestUpdateEventFields {
    lendingMarketId: ToField<'address'>;
    coinType: ToField<TypeName>;
    reserveId: ToField<'address'>;
    cumulativeBorrowRate: ToField<Decimal>;
    availableAmount: ToField<'u64'>;
    borrowedAmount: ToField<Decimal>;
    unclaimedSpreadFees: ToField<Decimal>;
    ctokenSupply: ToField<'u64'>;
    borrowInterestPaid: ToField<Decimal>;
    spreadFee: ToField<Decimal>;
    supplyInterestEarned: ToField<Decimal>;
    borrowInterestPaidUsdEstimate: ToField<Decimal>;
    protocolFeeUsdEstimate: ToField<Decimal>;
    supplyInterestEarnedUsdEstimate: ToField<Decimal>;
}
export type InterestUpdateEventReified = Reified<InterestUpdateEvent, InterestUpdateEventFields>;
export type InterestUpdateEventJSONField = {
    lendingMarketId: string;
    coinType: string;
    reserveId: string;
    cumulativeBorrowRate: ToJSON<Decimal>;
    availableAmount: string;
    borrowedAmount: ToJSON<Decimal>;
    unclaimedSpreadFees: ToJSON<Decimal>;
    ctokenSupply: string;
    borrowInterestPaid: ToJSON<Decimal>;
    spreadFee: ToJSON<Decimal>;
    supplyInterestEarned: ToJSON<Decimal>;
    borrowInterestPaidUsdEstimate: ToJSON<Decimal>;
    protocolFeeUsdEstimate: ToJSON<Decimal>;
    supplyInterestEarnedUsdEstimate: ToJSON<Decimal>;
};
export type InterestUpdateEventJSON = {
    $typeName: typeof InterestUpdateEvent.$typeName;
    $typeArgs: [];
} & InterestUpdateEventJSONField;
export declare class InterestUpdateEvent implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::reserve::InterestUpdateEvent`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof InterestUpdateEvent.$typeName;
    readonly $fullTypeName: `${string}::reserve::InterestUpdateEvent`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof InterestUpdateEvent.$isPhantom;
    readonly lendingMarketId: ToField<'address'>;
    readonly coinType: ToField<TypeName>;
    readonly reserveId: ToField<'address'>;
    readonly cumulativeBorrowRate: ToField<Decimal>;
    readonly availableAmount: ToField<'u64'>;
    readonly borrowedAmount: ToField<Decimal>;
    readonly unclaimedSpreadFees: ToField<Decimal>;
    readonly ctokenSupply: ToField<'u64'>;
    readonly borrowInterestPaid: ToField<Decimal>;
    readonly spreadFee: ToField<Decimal>;
    readonly supplyInterestEarned: ToField<Decimal>;
    readonly borrowInterestPaidUsdEstimate: ToField<Decimal>;
    readonly protocolFeeUsdEstimate: ToField<Decimal>;
    readonly supplyInterestEarnedUsdEstimate: ToField<Decimal>;
    private constructor();
    static reified(): InterestUpdateEventReified;
    static get r(): InterestUpdateEventReified;
    static phantom(): PhantomReified<ToTypeStr<InterestUpdateEvent>>;
    static get p(): PhantomReified<ToTypeStr<InterestUpdateEvent>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof InterestUpdateEvent.instantiateBcs>;
    static fromFields(fields: Record<string, any>): InterestUpdateEvent;
    static fromFieldsWithTypes(item: FieldsWithTypes): InterestUpdateEvent;
    static fromBcs(data: Uint8Array): InterestUpdateEvent;
    toJSONField(): InterestUpdateEventJSONField;
    toJSON(): InterestUpdateEventJSON;
    static fromJSONField(field: any): InterestUpdateEvent;
    static fromJSON(json: Record<string, any>): InterestUpdateEvent;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): InterestUpdateEvent;
    static fetch(client: ClientWithCoreApi, id: string): Promise<InterestUpdateEvent>;
}
export declare function isReserveAssetDataEvent(type: string): boolean;
export interface ReserveAssetDataEventFields {
    lendingMarketId: ToField<'address'>;
    coinType: ToField<TypeName>;
    reserveId: ToField<'address'>;
    availableAmount: ToField<Decimal>;
    supplyAmount: ToField<Decimal>;
    borrowedAmount: ToField<Decimal>;
    availableAmountUsdEstimate: ToField<Decimal>;
    supplyAmountUsdEstimate: ToField<Decimal>;
    borrowedAmountUsdEstimate: ToField<Decimal>;
    borrowApr: ToField<Decimal>;
    supplyApr: ToField<Decimal>;
    ctokenSupply: ToField<'u64'>;
    cumulativeBorrowRate: ToField<Decimal>;
    price: ToField<Decimal>;
    smoothedPrice: ToField<Decimal>;
    priceLastUpdateTimestampS: ToField<'u64'>;
}
export type ReserveAssetDataEventReified = Reified<ReserveAssetDataEvent, ReserveAssetDataEventFields>;
export type ReserveAssetDataEventJSONField = {
    lendingMarketId: string;
    coinType: string;
    reserveId: string;
    availableAmount: ToJSON<Decimal>;
    supplyAmount: ToJSON<Decimal>;
    borrowedAmount: ToJSON<Decimal>;
    availableAmountUsdEstimate: ToJSON<Decimal>;
    supplyAmountUsdEstimate: ToJSON<Decimal>;
    borrowedAmountUsdEstimate: ToJSON<Decimal>;
    borrowApr: ToJSON<Decimal>;
    supplyApr: ToJSON<Decimal>;
    ctokenSupply: string;
    cumulativeBorrowRate: ToJSON<Decimal>;
    price: ToJSON<Decimal>;
    smoothedPrice: ToJSON<Decimal>;
    priceLastUpdateTimestampS: string;
};
export type ReserveAssetDataEventJSON = {
    $typeName: typeof ReserveAssetDataEvent.$typeName;
    $typeArgs: [];
} & ReserveAssetDataEventJSONField;
/**
 * Deprecated: this struct's layout is frozen by Sui's upgrade-compatibility check, since
 * it is already published on mainnet. Use `events::suilend_reserve::ReserveAssetDataEventV2` instead, which carries
 * every field here plus `conf` and the unclamped prices.
 */
export declare class ReserveAssetDataEvent implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::reserve::ReserveAssetDataEvent`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof ReserveAssetDataEvent.$typeName;
    readonly $fullTypeName: `${string}::reserve::ReserveAssetDataEvent`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof ReserveAssetDataEvent.$isPhantom;
    readonly lendingMarketId: ToField<'address'>;
    readonly coinType: ToField<TypeName>;
    readonly reserveId: ToField<'address'>;
    readonly availableAmount: ToField<Decimal>;
    readonly supplyAmount: ToField<Decimal>;
    readonly borrowedAmount: ToField<Decimal>;
    readonly availableAmountUsdEstimate: ToField<Decimal>;
    readonly supplyAmountUsdEstimate: ToField<Decimal>;
    readonly borrowedAmountUsdEstimate: ToField<Decimal>;
    readonly borrowApr: ToField<Decimal>;
    readonly supplyApr: ToField<Decimal>;
    readonly ctokenSupply: ToField<'u64'>;
    readonly cumulativeBorrowRate: ToField<Decimal>;
    readonly price: ToField<Decimal>;
    readonly smoothedPrice: ToField<Decimal>;
    readonly priceLastUpdateTimestampS: ToField<'u64'>;
    private constructor();
    static reified(): ReserveAssetDataEventReified;
    static get r(): ReserveAssetDataEventReified;
    static phantom(): PhantomReified<ToTypeStr<ReserveAssetDataEvent>>;
    static get p(): PhantomReified<ToTypeStr<ReserveAssetDataEvent>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof ReserveAssetDataEvent.instantiateBcs>;
    static fromFields(fields: Record<string, any>): ReserveAssetDataEvent;
    static fromFieldsWithTypes(item: FieldsWithTypes): ReserveAssetDataEvent;
    static fromBcs(data: Uint8Array): ReserveAssetDataEvent;
    toJSONField(): ReserveAssetDataEventJSONField;
    toJSON(): ReserveAssetDataEventJSON;
    static fromJSONField(field: any): ReserveAssetDataEvent;
    static fromJSON(json: Record<string, any>): ReserveAssetDataEvent;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): ReserveAssetDataEvent;
    static fetch(client: ClientWithCoreApi, id: string): Promise<ReserveAssetDataEvent>;
}
export declare function isClaimStakingRewardsEvent(type: string): boolean;
export interface ClaimStakingRewardsEventFields {
    lendingMarketId: ToField<'address'>;
    coinType: ToField<TypeName>;
    reserveId: ToField<'address'>;
    amount: ToField<'u64'>;
}
export type ClaimStakingRewardsEventReified = Reified<ClaimStakingRewardsEvent, ClaimStakingRewardsEventFields>;
export type ClaimStakingRewardsEventJSONField = {
    lendingMarketId: string;
    coinType: string;
    reserveId: string;
    amount: string;
};
export type ClaimStakingRewardsEventJSON = {
    $typeName: typeof ClaimStakingRewardsEvent.$typeName;
    $typeArgs: [];
} & ClaimStakingRewardsEventJSONField;
export declare class ClaimStakingRewardsEvent implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::reserve::ClaimStakingRewardsEvent`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof ClaimStakingRewardsEvent.$typeName;
    readonly $fullTypeName: `${string}::reserve::ClaimStakingRewardsEvent`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof ClaimStakingRewardsEvent.$isPhantom;
    readonly lendingMarketId: ToField<'address'>;
    readonly coinType: ToField<TypeName>;
    readonly reserveId: ToField<'address'>;
    readonly amount: ToField<'u64'>;
    private constructor();
    static reified(): ClaimStakingRewardsEventReified;
    static get r(): ClaimStakingRewardsEventReified;
    static phantom(): PhantomReified<ToTypeStr<ClaimStakingRewardsEvent>>;
    static get p(): PhantomReified<ToTypeStr<ClaimStakingRewardsEvent>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof ClaimStakingRewardsEvent.instantiateBcs>;
    static fromFields(fields: Record<string, any>): ClaimStakingRewardsEvent;
    static fromFieldsWithTypes(item: FieldsWithTypes): ClaimStakingRewardsEvent;
    static fromBcs(data: Uint8Array): ClaimStakingRewardsEvent;
    toJSONField(): ClaimStakingRewardsEventJSONField;
    toJSON(): ClaimStakingRewardsEventJSON;
    static fromJSONField(field: any): ClaimStakingRewardsEvent;
    static fromJSON(json: Record<string, any>): ClaimStakingRewardsEvent;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): ClaimStakingRewardsEvent;
    static fetch(client: ClientWithCoreApi, id: string): Promise<ClaimStakingRewardsEvent>;
}