import type { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
import { TypeName } from '../../_dependencies/std/type-name/structs';
import { ObjectTable } from '../../_dependencies/sui/object-table/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 { Vector } from '../../_framework/vector';
import { Decimal } from '../decimal/structs';
import { Obligation } from '../obligation/structs';
import { RateLimiter } from '../rate-limiter/structs';
import { Reserve } from '../reserve/structs';
export declare function isLENDING_MARKET(type: string): boolean;
export interface LENDING_MARKETFields {
    dummyField: ToField<'bool'>;
}
export type LENDING_MARKETReified = Reified<LENDING_MARKET, LENDING_MARKETFields>;
export type LENDING_MARKETJSONField = {
    dummyField: boolean;
};
export type LENDING_MARKETJSON = {
    $typeName: typeof LENDING_MARKET.$typeName;
    $typeArgs: [];
} & LENDING_MARKETJSONField;
export declare class LENDING_MARKET implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::LENDING_MARKET`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof LENDING_MARKET.$typeName;
    readonly $fullTypeName: `${string}::lending_market::LENDING_MARKET`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof LENDING_MARKET.$isPhantom;
    readonly dummyField: ToField<'bool'>;
    private constructor();
    static reified(): LENDING_MARKETReified;
    static get r(): LENDING_MARKETReified;
    static phantom(): PhantomReified<ToTypeStr<LENDING_MARKET>>;
    static get p(): PhantomReified<ToTypeStr<LENDING_MARKET>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof LENDING_MARKET.instantiateBcs>;
    static fromFields(fields: Record<string, any>): LENDING_MARKET;
    static fromFieldsWithTypes(item: FieldsWithTypes): LENDING_MARKET;
    static fromBcs(data: Uint8Array): LENDING_MARKET;
    toJSONField(): LENDING_MARKETJSONField;
    toJSON(): LENDING_MARKETJSON;
    static fromJSONField(field: any): LENDING_MARKET;
    static fromJSON(json: Record<string, any>): LENDING_MARKET;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): LENDING_MARKET;
    static fetch(client: ClientWithCoreApi, id: string): Promise<LENDING_MARKET>;
}
export declare function isLendingMarket(type: string): boolean;
export interface LendingMarketFields<P extends PhantomTypeArgument> {
    id: ToField<UID>;
    version: ToField<'u64'>;
    reserves: ToField<Vector<Reserve<P>>>;
    obligations: ToField<ObjectTable<ToPhantom<ID>, ToPhantom<Obligation<P>>>>;
    rateLimiter: ToField<RateLimiter>;
    feeReceiver: ToField<'address'>;
    /** unused */
    badDebtUsd: ToField<Decimal>;
    /** unused */
    badDebtLimitUsd: ToField<Decimal>;
}
export type LendingMarketReified<P extends PhantomTypeArgument> = Reified<LendingMarket<P>, LendingMarketFields<P>>;
export type LendingMarketJSONField<P extends PhantomTypeArgument> = {
    id: string;
    version: string;
    reserves: ToJSON<Reserve<P>>[];
    obligations: ToJSON<ObjectTable<ToPhantom<ID>, ToPhantom<Obligation<P>>>>;
    rateLimiter: ToJSON<RateLimiter>;
    feeReceiver: string;
    badDebtUsd: ToJSON<Decimal>;
    badDebtLimitUsd: ToJSON<Decimal>;
};
export type LendingMarketJSON<P extends PhantomTypeArgument> = {
    $typeName: typeof LendingMarket.$typeName;
    $typeArgs: [PhantomToTypeStr<P>];
} & LendingMarketJSONField<P>;
export declare class LendingMarket<P extends PhantomTypeArgument> implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::LendingMarket`;
    static readonly $numTypeParams = 1;
    static readonly $isPhantom: readonly [true];
    readonly $typeName: typeof LendingMarket.$typeName;
    readonly $fullTypeName: `${string}::lending_market::LendingMarket<${PhantomToTypeStr<P>}>`;
    readonly $typeArgs: [PhantomToTypeStr<P>];
    readonly $isPhantom: typeof LendingMarket.$isPhantom;
    readonly id: ToField<UID>;
    readonly version: ToField<'u64'>;
    readonly reserves: ToField<Vector<Reserve<P>>>;
    readonly obligations: ToField<ObjectTable<ToPhantom<ID>, ToPhantom<Obligation<P>>>>;
    readonly rateLimiter: ToField<RateLimiter>;
    readonly feeReceiver: ToField<'address'>;
    /** unused */
    readonly badDebtUsd: ToField<Decimal>;
    /** unused */
    readonly badDebtLimitUsd: ToField<Decimal>;
    private constructor();
    static reified<P extends PhantomReified<PhantomTypeArgument>>(P: P): LendingMarketReified<ToPhantomTypeArgument<P>>;
    static get r(): typeof LendingMarket.reified;
    static phantom<P extends PhantomReified<PhantomTypeArgument>>(P: P): PhantomReified<ToTypeStr<LendingMarket<ToPhantomTypeArgument<P>>>>;
    static get p(): typeof LendingMarket.phantom;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof LendingMarket.instantiateBcs>;
    static fromFields<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, fields: Record<string, any>): LendingMarket<ToPhantomTypeArgument<P>>;
    static fromFieldsWithTypes<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, item: FieldsWithTypes): LendingMarket<ToPhantomTypeArgument<P>>;
    static fromBcs<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, data: Uint8Array): LendingMarket<ToPhantomTypeArgument<P>>;
    toJSONField(): LendingMarketJSONField<P>;
    toJSON(): LendingMarketJSON<P>;
    static fromJSONField<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, field: any): LendingMarket<ToPhantomTypeArgument<P>>;
    static fromJSON<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, json: Record<string, any>): LendingMarket<ToPhantomTypeArgument<P>>;
    static fromCoreObject<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, obj: SuiClientTypes.Object<{
        content: true;
    }>): LendingMarket<ToPhantomTypeArgument<P>>;
    static fetch<P extends PhantomReified<PhantomTypeArgument>>(client: ClientWithCoreApi, typeArg: P, id: string): Promise<LendingMarket<ToPhantomTypeArgument<P>>>;
}
export declare function isLendingMarketOwnerCap(type: string): boolean;
export interface LendingMarketOwnerCapFields<P extends PhantomTypeArgument> {
    id: ToField<UID>;
    lendingMarketId: ToField<ID>;
}
export type LendingMarketOwnerCapReified<P extends PhantomTypeArgument> = Reified<LendingMarketOwnerCap<P>, LendingMarketOwnerCapFields<P>>;
export type LendingMarketOwnerCapJSONField<P extends PhantomTypeArgument> = {
    id: string;
    lendingMarketId: string;
};
export type LendingMarketOwnerCapJSON<P extends PhantomTypeArgument> = {
    $typeName: typeof LendingMarketOwnerCap.$typeName;
    $typeArgs: [PhantomToTypeStr<P>];
} & LendingMarketOwnerCapJSONField<P>;
export declare class LendingMarketOwnerCap<P extends PhantomTypeArgument> implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::LendingMarketOwnerCap`;
    static readonly $numTypeParams = 1;
    static readonly $isPhantom: readonly [true];
    readonly $typeName: typeof LendingMarketOwnerCap.$typeName;
    readonly $fullTypeName: `${string}::lending_market::LendingMarketOwnerCap<${PhantomToTypeStr<P>}>`;
    readonly $typeArgs: [PhantomToTypeStr<P>];
    readonly $isPhantom: typeof LendingMarketOwnerCap.$isPhantom;
    readonly id: ToField<UID>;
    readonly lendingMarketId: ToField<ID>;
    private constructor();
    static reified<P extends PhantomReified<PhantomTypeArgument>>(P: P): LendingMarketOwnerCapReified<ToPhantomTypeArgument<P>>;
    static get r(): typeof LendingMarketOwnerCap.reified;
    static phantom<P extends PhantomReified<PhantomTypeArgument>>(P: P): PhantomReified<ToTypeStr<LendingMarketOwnerCap<ToPhantomTypeArgument<P>>>>;
    static get p(): typeof LendingMarketOwnerCap.phantom;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof LendingMarketOwnerCap.instantiateBcs>;
    static fromFields<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, fields: Record<string, any>): LendingMarketOwnerCap<ToPhantomTypeArgument<P>>;
    static fromFieldsWithTypes<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, item: FieldsWithTypes): LendingMarketOwnerCap<ToPhantomTypeArgument<P>>;
    static fromBcs<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, data: Uint8Array): LendingMarketOwnerCap<ToPhantomTypeArgument<P>>;
    toJSONField(): LendingMarketOwnerCapJSONField<P>;
    toJSON(): LendingMarketOwnerCapJSON<P>;
    static fromJSONField<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, field: any): LendingMarketOwnerCap<ToPhantomTypeArgument<P>>;
    static fromJSON<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, json: Record<string, any>): LendingMarketOwnerCap<ToPhantomTypeArgument<P>>;
    static fromCoreObject<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, obj: SuiClientTypes.Object<{
        content: true;
    }>): LendingMarketOwnerCap<ToPhantomTypeArgument<P>>;
    static fetch<P extends PhantomReified<PhantomTypeArgument>>(client: ClientWithCoreApi, typeArg: P, id: string): Promise<LendingMarketOwnerCap<ToPhantomTypeArgument<P>>>;
}
export declare function isObligationOwnerCap(type: string): boolean;
export interface ObligationOwnerCapFields<P extends PhantomTypeArgument> {
    id: ToField<UID>;
    obligationId: ToField<ID>;
}
export type ObligationOwnerCapReified<P extends PhantomTypeArgument> = Reified<ObligationOwnerCap<P>, ObligationOwnerCapFields<P>>;
export type ObligationOwnerCapJSONField<P extends PhantomTypeArgument> = {
    id: string;
    obligationId: string;
};
export type ObligationOwnerCapJSON<P extends PhantomTypeArgument> = {
    $typeName: typeof ObligationOwnerCap.$typeName;
    $typeArgs: [PhantomToTypeStr<P>];
} & ObligationOwnerCapJSONField<P>;
export declare class ObligationOwnerCap<P extends PhantomTypeArgument> implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::ObligationOwnerCap`;
    static readonly $numTypeParams = 1;
    static readonly $isPhantom: readonly [true];
    readonly $typeName: typeof ObligationOwnerCap.$typeName;
    readonly $fullTypeName: `${string}::lending_market::ObligationOwnerCap<${PhantomToTypeStr<P>}>`;
    readonly $typeArgs: [PhantomToTypeStr<P>];
    readonly $isPhantom: typeof ObligationOwnerCap.$isPhantom;
    readonly id: ToField<UID>;
    readonly obligationId: ToField<ID>;
    private constructor();
    static reified<P extends PhantomReified<PhantomTypeArgument>>(P: P): ObligationOwnerCapReified<ToPhantomTypeArgument<P>>;
    static get r(): typeof ObligationOwnerCap.reified;
    static phantom<P extends PhantomReified<PhantomTypeArgument>>(P: P): PhantomReified<ToTypeStr<ObligationOwnerCap<ToPhantomTypeArgument<P>>>>;
    static get p(): typeof ObligationOwnerCap.phantom;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof ObligationOwnerCap.instantiateBcs>;
    static fromFields<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, fields: Record<string, any>): ObligationOwnerCap<ToPhantomTypeArgument<P>>;
    static fromFieldsWithTypes<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, item: FieldsWithTypes): ObligationOwnerCap<ToPhantomTypeArgument<P>>;
    static fromBcs<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, data: Uint8Array): ObligationOwnerCap<ToPhantomTypeArgument<P>>;
    toJSONField(): ObligationOwnerCapJSONField<P>;
    toJSON(): ObligationOwnerCapJSON<P>;
    static fromJSONField<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, field: any): ObligationOwnerCap<ToPhantomTypeArgument<P>>;
    static fromJSON<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, json: Record<string, any>): ObligationOwnerCap<ToPhantomTypeArgument<P>>;
    static fromCoreObject<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, obj: SuiClientTypes.Object<{
        content: true;
    }>): ObligationOwnerCap<ToPhantomTypeArgument<P>>;
    static fetch<P extends PhantomReified<PhantomTypeArgument>>(client: ClientWithCoreApi, typeArg: P, id: string): Promise<ObligationOwnerCap<ToPhantomTypeArgument<P>>>;
}
export declare function isEmergencyPauseCap(type: string): boolean;
export interface EmergencyPauseCapFields<P extends PhantomTypeArgument> {
    id: ToField<UID>;
    lendingMarketId: ToField<ID>;
    generation: ToField<'u64'>;
}
export type EmergencyPauseCapReified<P extends PhantomTypeArgument> = Reified<EmergencyPauseCap<P>, EmergencyPauseCapFields<P>>;
export type EmergencyPauseCapJSONField<P extends PhantomTypeArgument> = {
    id: string;
    lendingMarketId: string;
    generation: string;
};
export type EmergencyPauseCapJSON<P extends PhantomTypeArgument> = {
    $typeName: typeof EmergencyPauseCap.$typeName;
    $typeArgs: [PhantomToTypeStr<P>];
} & EmergencyPauseCapJSONField<P>;
/**
 * No `store`: can only be held directly by an address, never wrapped into another
 * object, and can never satisfy a `&LendingMarketOwnerCap<P>` parameter -- so it is
 * compile-time incapable of minting an `ObligationOwnerCap` or touching reserve
 * config/price feeds. Revocation is minting the next generation via `new_pause_cap`,
 * no package upgrade needed.
 */
export declare class EmergencyPauseCap<P extends PhantomTypeArgument> implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::EmergencyPauseCap`;
    static readonly $numTypeParams = 1;
    static readonly $isPhantom: readonly [true];
    readonly $typeName: typeof EmergencyPauseCap.$typeName;
    readonly $fullTypeName: `${string}::lending_market::EmergencyPauseCap<${PhantomToTypeStr<P>}>`;
    readonly $typeArgs: [PhantomToTypeStr<P>];
    readonly $isPhantom: typeof EmergencyPauseCap.$isPhantom;
    readonly id: ToField<UID>;
    readonly lendingMarketId: ToField<ID>;
    readonly generation: ToField<'u64'>;
    private constructor();
    static reified<P extends PhantomReified<PhantomTypeArgument>>(P: P): EmergencyPauseCapReified<ToPhantomTypeArgument<P>>;
    static get r(): typeof EmergencyPauseCap.reified;
    static phantom<P extends PhantomReified<PhantomTypeArgument>>(P: P): PhantomReified<ToTypeStr<EmergencyPauseCap<ToPhantomTypeArgument<P>>>>;
    static get p(): typeof EmergencyPauseCap.phantom;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof EmergencyPauseCap.instantiateBcs>;
    static fromFields<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, fields: Record<string, any>): EmergencyPauseCap<ToPhantomTypeArgument<P>>;
    static fromFieldsWithTypes<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, item: FieldsWithTypes): EmergencyPauseCap<ToPhantomTypeArgument<P>>;
    static fromBcs<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, data: Uint8Array): EmergencyPauseCap<ToPhantomTypeArgument<P>>;
    toJSONField(): EmergencyPauseCapJSONField<P>;
    toJSON(): EmergencyPauseCapJSON<P>;
    static fromJSONField<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, field: any): EmergencyPauseCap<ToPhantomTypeArgument<P>>;
    static fromJSON<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, json: Record<string, any>): EmergencyPauseCap<ToPhantomTypeArgument<P>>;
    static fromCoreObject<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, obj: SuiClientTypes.Object<{
        content: true;
    }>): EmergencyPauseCap<ToPhantomTypeArgument<P>>;
    static fetch<P extends PhantomReified<PhantomTypeArgument>>(client: ClientWithCoreApi, typeArg: P, id: string): Promise<EmergencyPauseCap<ToPhantomTypeArgument<P>>>;
}
export declare function isFeeReceiversKey(type: string): boolean;
export interface FeeReceiversKeyFields {
    dummyField: ToField<'bool'>;
}
export type FeeReceiversKeyReified = Reified<FeeReceiversKey, FeeReceiversKeyFields>;
export type FeeReceiversKeyJSONField = {
    dummyField: boolean;
};
export type FeeReceiversKeyJSON = {
    $typeName: typeof FeeReceiversKey.$typeName;
    $typeArgs: [];
} & FeeReceiversKeyJSONField;
export declare class FeeReceiversKey implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::FeeReceiversKey`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof FeeReceiversKey.$typeName;
    readonly $fullTypeName: `${string}::lending_market::FeeReceiversKey`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof FeeReceiversKey.$isPhantom;
    readonly dummyField: ToField<'bool'>;
    private constructor();
    static reified(): FeeReceiversKeyReified;
    static get r(): FeeReceiversKeyReified;
    static phantom(): PhantomReified<ToTypeStr<FeeReceiversKey>>;
    static get p(): PhantomReified<ToTypeStr<FeeReceiversKey>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof FeeReceiversKey.instantiateBcs>;
    static fromFields(fields: Record<string, any>): FeeReceiversKey;
    static fromFieldsWithTypes(item: FieldsWithTypes): FeeReceiversKey;
    static fromBcs(data: Uint8Array): FeeReceiversKey;
    toJSONField(): FeeReceiversKeyJSONField;
    toJSON(): FeeReceiversKeyJSON;
    static fromJSONField(field: any): FeeReceiversKey;
    static fromJSON(json: Record<string, any>): FeeReceiversKey;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): FeeReceiversKey;
    static fetch(client: ClientWithCoreApi, id: string): Promise<FeeReceiversKey>;
}
export declare function isPauseKey(type: string): boolean;
export interface PauseKeyFields {
    dummyField: ToField<'bool'>;
}
export type PauseKeyReified = Reified<PauseKey, PauseKeyFields>;
export type PauseKeyJSONField = {
    dummyField: boolean;
};
export type PauseKeyJSON = {
    $typeName: typeof PauseKey.$typeName;
    $typeArgs: [];
} & PauseKeyJSONField;
export declare class PauseKey implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::PauseKey`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof PauseKey.$typeName;
    readonly $fullTypeName: `${string}::lending_market::PauseKey`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof PauseKey.$isPhantom;
    readonly dummyField: ToField<'bool'>;
    private constructor();
    static reified(): PauseKeyReified;
    static get r(): PauseKeyReified;
    static phantom(): PhantomReified<ToTypeStr<PauseKey>>;
    static get p(): PhantomReified<ToTypeStr<PauseKey>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof PauseKey.instantiateBcs>;
    static fromFields(fields: Record<string, any>): PauseKey;
    static fromFieldsWithTypes(item: FieldsWithTypes): PauseKey;
    static fromBcs(data: Uint8Array): PauseKey;
    toJSONField(): PauseKeyJSONField;
    toJSON(): PauseKeyJSON;
    static fromJSONField(field: any): PauseKey;
    static fromJSON(json: Record<string, any>): PauseKey;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): PauseKey;
    static fetch(client: ClientWithCoreApi, id: string): Promise<PauseKey>;
}
export declare function isPauseCapGenerationKey(type: string): boolean;
export interface PauseCapGenerationKeyFields {
    dummyField: ToField<'bool'>;
}
export type PauseCapGenerationKeyReified = Reified<PauseCapGenerationKey, PauseCapGenerationKeyFields>;
export type PauseCapGenerationKeyJSONField = {
    dummyField: boolean;
};
export type PauseCapGenerationKeyJSON = {
    $typeName: typeof PauseCapGenerationKey.$typeName;
    $typeArgs: [];
} & PauseCapGenerationKeyJSONField;
export declare class PauseCapGenerationKey implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::PauseCapGenerationKey`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof PauseCapGenerationKey.$typeName;
    readonly $fullTypeName: `${string}::lending_market::PauseCapGenerationKey`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof PauseCapGenerationKey.$isPhantom;
    readonly dummyField: ToField<'bool'>;
    private constructor();
    static reified(): PauseCapGenerationKeyReified;
    static get r(): PauseCapGenerationKeyReified;
    static phantom(): PhantomReified<ToTypeStr<PauseCapGenerationKey>>;
    static get p(): PhantomReified<ToTypeStr<PauseCapGenerationKey>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof PauseCapGenerationKey.instantiateBcs>;
    static fromFields(fields: Record<string, any>): PauseCapGenerationKey;
    static fromFieldsWithTypes(item: FieldsWithTypes): PauseCapGenerationKey;
    static fromBcs(data: Uint8Array): PauseCapGenerationKey;
    toJSONField(): PauseCapGenerationKeyJSONField;
    toJSON(): PauseCapGenerationKeyJSON;
    static fromJSONField(field: any): PauseCapGenerationKey;
    static fromJSON(json: Record<string, any>): PauseCapGenerationKey;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): PauseCapGenerationKey;
    static fetch(client: ClientWithCoreApi, id: string): Promise<PauseCapGenerationKey>;
}
export declare function isFeeReceivers(type: string): boolean;
export interface FeeReceiversFields {
    receivers: ToField<Vector<'address'>>;
    weights: ToField<Vector<'u64'>>;
    totalWeight: ToField<'u64'>;
}
export type FeeReceiversReified = Reified<FeeReceivers, FeeReceiversFields>;
export type FeeReceiversJSONField = {
    receivers: string[];
    weights: string[];
    totalWeight: string;
};
export type FeeReceiversJSON = {
    $typeName: typeof FeeReceivers.$typeName;
    $typeArgs: [];
} & FeeReceiversJSONField;
export declare class FeeReceivers implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::FeeReceivers`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof FeeReceivers.$typeName;
    readonly $fullTypeName: `${string}::lending_market::FeeReceivers`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof FeeReceivers.$isPhantom;
    readonly receivers: ToField<Vector<'address'>>;
    readonly weights: ToField<Vector<'u64'>>;
    readonly totalWeight: ToField<'u64'>;
    private constructor();
    static reified(): FeeReceiversReified;
    static get r(): FeeReceiversReified;
    static phantom(): PhantomReified<ToTypeStr<FeeReceivers>>;
    static get p(): PhantomReified<ToTypeStr<FeeReceivers>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof FeeReceivers.instantiateBcs>;
    static fromFields(fields: Record<string, any>): FeeReceivers;
    static fromFieldsWithTypes(item: FieldsWithTypes): FeeReceivers;
    static fromBcs(data: Uint8Array): FeeReceivers;
    toJSONField(): FeeReceiversJSONField;
    toJSON(): FeeReceiversJSON;
    static fromJSONField(field: any): FeeReceivers;
    static fromJSON(json: Record<string, any>): FeeReceivers;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): FeeReceivers;
    static fetch(client: ClientWithCoreApi, id: string): Promise<FeeReceivers>;
}
export declare function isRateLimiterExemption(type: string): boolean;
export interface RateLimiterExemptionFields<P extends PhantomTypeArgument, T extends PhantomTypeArgument> {
    amount: ToField<'u64'>;
}
export type RateLimiterExemptionReified<P extends PhantomTypeArgument, T extends PhantomTypeArgument> = Reified<RateLimiterExemption<P, T>, RateLimiterExemptionFields<P, T>>;
export type RateLimiterExemptionJSONField<P extends PhantomTypeArgument, T extends PhantomTypeArgument> = {
    amount: string;
};
export type RateLimiterExemptionJSON<P extends PhantomTypeArgument, T extends PhantomTypeArgument> = {
    $typeName: typeof RateLimiterExemption.$typeName;
    $typeArgs: [PhantomToTypeStr<P>, PhantomToTypeStr<T>];
} & RateLimiterExemptionJSONField<P, T>;
export declare class RateLimiterExemption<P extends PhantomTypeArgument, T extends PhantomTypeArgument> implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::RateLimiterExemption`;
    static readonly $numTypeParams = 2;
    static readonly $isPhantom: readonly [true, true];
    readonly $typeName: typeof RateLimiterExemption.$typeName;
    readonly $fullTypeName: `${string}::lending_market::RateLimiterExemption<${PhantomToTypeStr<P>}, ${PhantomToTypeStr<T>}>`;
    readonly $typeArgs: [PhantomToTypeStr<P>, PhantomToTypeStr<T>];
    readonly $isPhantom: typeof RateLimiterExemption.$isPhantom;
    readonly amount: ToField<'u64'>;
    private constructor();
    static reified<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(P: P, T: T): RateLimiterExemptionReified<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static get r(): typeof RateLimiterExemption.reified;
    static phantom<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(P: P, T: T): PhantomReified<ToTypeStr<RateLimiterExemption<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>>>;
    static get p(): typeof RateLimiterExemption.phantom;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof RateLimiterExemption.instantiateBcs>;
    static fromFields<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], fields: Record<string, any>): RateLimiterExemption<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fromFieldsWithTypes<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], item: FieldsWithTypes): RateLimiterExemption<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fromBcs<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], data: Uint8Array): RateLimiterExemption<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    toJSONField(): RateLimiterExemptionJSONField<P, T>;
    toJSON(): RateLimiterExemptionJSON<P, T>;
    static fromJSONField<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], field: any): RateLimiterExemption<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fromJSON<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], json: Record<string, any>): RateLimiterExemption<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fromCoreObject<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(typeArgs: [P, T], obj: SuiClientTypes.Object<{
        content: true;
    }>): RateLimiterExemption<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>;
    static fetch<P extends PhantomReified<PhantomTypeArgument>, T extends PhantomReified<PhantomTypeArgument>>(client: ClientWithCoreApi, typeArgs: [P, T], id: string): Promise<RateLimiterExemption<ToPhantomTypeArgument<P>, ToPhantomTypeArgument<T>>>;
}
export declare function isMintEvent(type: string): boolean;
export interface MintEventFields {
    lendingMarketId: ToField<'address'>;
    coinType: ToField<TypeName>;
    reserveId: ToField<'address'>;
    liquidityAmount: ToField<'u64'>;
    ctokenAmount: ToField<'u64'>;
}
export type MintEventReified = Reified<MintEvent, MintEventFields>;
export type MintEventJSONField = {
    lendingMarketId: string;
    coinType: string;
    reserveId: string;
    liquidityAmount: string;
    ctokenAmount: string;
};
export type MintEventJSON = {
    $typeName: typeof MintEvent.$typeName;
    $typeArgs: [];
} & MintEventJSONField;
export declare class MintEvent implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::MintEvent`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof MintEvent.$typeName;
    readonly $fullTypeName: `${string}::lending_market::MintEvent`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof MintEvent.$isPhantom;
    readonly lendingMarketId: ToField<'address'>;
    readonly coinType: ToField<TypeName>;
    readonly reserveId: ToField<'address'>;
    readonly liquidityAmount: ToField<'u64'>;
    readonly ctokenAmount: ToField<'u64'>;
    private constructor();
    static reified(): MintEventReified;
    static get r(): MintEventReified;
    static phantom(): PhantomReified<ToTypeStr<MintEvent>>;
    static get p(): PhantomReified<ToTypeStr<MintEvent>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof MintEvent.instantiateBcs>;
    static fromFields(fields: Record<string, any>): MintEvent;
    static fromFieldsWithTypes(item: FieldsWithTypes): MintEvent;
    static fromBcs(data: Uint8Array): MintEvent;
    toJSONField(): MintEventJSONField;
    toJSON(): MintEventJSON;
    static fromJSONField(field: any): MintEvent;
    static fromJSON(json: Record<string, any>): MintEvent;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): MintEvent;
    static fetch(client: ClientWithCoreApi, id: string): Promise<MintEvent>;
}
export declare function isRedeemEvent(type: string): boolean;
export interface RedeemEventFields {
    lendingMarketId: ToField<'address'>;
    coinType: ToField<TypeName>;
    reserveId: ToField<'address'>;
    ctokenAmount: ToField<'u64'>;
    liquidityAmount: ToField<'u64'>;
}
export type RedeemEventReified = Reified<RedeemEvent, RedeemEventFields>;
export type RedeemEventJSONField = {
    lendingMarketId: string;
    coinType: string;
    reserveId: string;
    ctokenAmount: string;
    liquidityAmount: string;
};
export type RedeemEventJSON = {
    $typeName: typeof RedeemEvent.$typeName;
    $typeArgs: [];
} & RedeemEventJSONField;
export declare class RedeemEvent implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::RedeemEvent`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof RedeemEvent.$typeName;
    readonly $fullTypeName: `${string}::lending_market::RedeemEvent`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof RedeemEvent.$isPhantom;
    readonly lendingMarketId: ToField<'address'>;
    readonly coinType: ToField<TypeName>;
    readonly reserveId: ToField<'address'>;
    readonly ctokenAmount: ToField<'u64'>;
    readonly liquidityAmount: ToField<'u64'>;
    private constructor();
    static reified(): RedeemEventReified;
    static get r(): RedeemEventReified;
    static phantom(): PhantomReified<ToTypeStr<RedeemEvent>>;
    static get p(): PhantomReified<ToTypeStr<RedeemEvent>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof RedeemEvent.instantiateBcs>;
    static fromFields(fields: Record<string, any>): RedeemEvent;
    static fromFieldsWithTypes(item: FieldsWithTypes): RedeemEvent;
    static fromBcs(data: Uint8Array): RedeemEvent;
    toJSONField(): RedeemEventJSONField;
    toJSON(): RedeemEventJSON;
    static fromJSONField(field: any): RedeemEvent;
    static fromJSON(json: Record<string, any>): RedeemEvent;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): RedeemEvent;
    static fetch(client: ClientWithCoreApi, id: string): Promise<RedeemEvent>;
}
export declare function isDepositEvent(type: string): boolean;
export interface DepositEventFields {
    lendingMarketId: ToField<'address'>;
    coinType: ToField<TypeName>;
    reserveId: ToField<'address'>;
    obligationId: ToField<'address'>;
    ctokenAmount: ToField<'u64'>;
}
export type DepositEventReified = Reified<DepositEvent, DepositEventFields>;
export type DepositEventJSONField = {
    lendingMarketId: string;
    coinType: string;
    reserveId: string;
    obligationId: string;
    ctokenAmount: string;
};
export type DepositEventJSON = {
    $typeName: typeof DepositEvent.$typeName;
    $typeArgs: [];
} & DepositEventJSONField;
export declare class DepositEvent implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::DepositEvent`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof DepositEvent.$typeName;
    readonly $fullTypeName: `${string}::lending_market::DepositEvent`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof DepositEvent.$isPhantom;
    readonly lendingMarketId: ToField<'address'>;
    readonly coinType: ToField<TypeName>;
    readonly reserveId: ToField<'address'>;
    readonly obligationId: ToField<'address'>;
    readonly ctokenAmount: ToField<'u64'>;
    private constructor();
    static reified(): DepositEventReified;
    static get r(): DepositEventReified;
    static phantom(): PhantomReified<ToTypeStr<DepositEvent>>;
    static get p(): PhantomReified<ToTypeStr<DepositEvent>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof DepositEvent.instantiateBcs>;
    static fromFields(fields: Record<string, any>): DepositEvent;
    static fromFieldsWithTypes(item: FieldsWithTypes): DepositEvent;
    static fromBcs(data: Uint8Array): DepositEvent;
    toJSONField(): DepositEventJSONField;
    toJSON(): DepositEventJSON;
    static fromJSONField(field: any): DepositEvent;
    static fromJSON(json: Record<string, any>): DepositEvent;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): DepositEvent;
    static fetch(client: ClientWithCoreApi, id: string): Promise<DepositEvent>;
}
export declare function isWithdrawEvent(type: string): boolean;
export interface WithdrawEventFields {
    lendingMarketId: ToField<'address'>;
    coinType: ToField<TypeName>;
    reserveId: ToField<'address'>;
    obligationId: ToField<'address'>;
    ctokenAmount: ToField<'u64'>;
}
export type WithdrawEventReified = Reified<WithdrawEvent, WithdrawEventFields>;
export type WithdrawEventJSONField = {
    lendingMarketId: string;
    coinType: string;
    reserveId: string;
    obligationId: string;
    ctokenAmount: string;
};
export type WithdrawEventJSON = {
    $typeName: typeof WithdrawEvent.$typeName;
    $typeArgs: [];
} & WithdrawEventJSONField;
export declare class WithdrawEvent implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::WithdrawEvent`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof WithdrawEvent.$typeName;
    readonly $fullTypeName: `${string}::lending_market::WithdrawEvent`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof WithdrawEvent.$isPhantom;
    readonly lendingMarketId: ToField<'address'>;
    readonly coinType: ToField<TypeName>;
    readonly reserveId: ToField<'address'>;
    readonly obligationId: ToField<'address'>;
    readonly ctokenAmount: ToField<'u64'>;
    private constructor();
    static reified(): WithdrawEventReified;
    static get r(): WithdrawEventReified;
    static phantom(): PhantomReified<ToTypeStr<WithdrawEvent>>;
    static get p(): PhantomReified<ToTypeStr<WithdrawEvent>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof WithdrawEvent.instantiateBcs>;
    static fromFields(fields: Record<string, any>): WithdrawEvent;
    static fromFieldsWithTypes(item: FieldsWithTypes): WithdrawEvent;
    static fromBcs(data: Uint8Array): WithdrawEvent;
    toJSONField(): WithdrawEventJSONField;
    toJSON(): WithdrawEventJSON;
    static fromJSONField(field: any): WithdrawEvent;
    static fromJSON(json: Record<string, any>): WithdrawEvent;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): WithdrawEvent;
    static fetch(client: ClientWithCoreApi, id: string): Promise<WithdrawEvent>;
}
export declare function isBorrowEvent(type: string): boolean;
export interface BorrowEventFields {
    lendingMarketId: ToField<'address'>;
    coinType: ToField<TypeName>;
    reserveId: ToField<'address'>;
    obligationId: ToField<'address'>;
    liquidityAmount: ToField<'u64'>;
    originationFeeAmount: ToField<'u64'>;
}
export type BorrowEventReified = Reified<BorrowEvent, BorrowEventFields>;
export type BorrowEventJSONField = {
    lendingMarketId: string;
    coinType: string;
    reserveId: string;
    obligationId: string;
    liquidityAmount: string;
    originationFeeAmount: string;
};
export type BorrowEventJSON = {
    $typeName: typeof BorrowEvent.$typeName;
    $typeArgs: [];
} & BorrowEventJSONField;
export declare class BorrowEvent implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::BorrowEvent`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof BorrowEvent.$typeName;
    readonly $fullTypeName: `${string}::lending_market::BorrowEvent`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof BorrowEvent.$isPhantom;
    readonly lendingMarketId: ToField<'address'>;
    readonly coinType: ToField<TypeName>;
    readonly reserveId: ToField<'address'>;
    readonly obligationId: ToField<'address'>;
    readonly liquidityAmount: ToField<'u64'>;
    readonly originationFeeAmount: ToField<'u64'>;
    private constructor();
    static reified(): BorrowEventReified;
    static get r(): BorrowEventReified;
    static phantom(): PhantomReified<ToTypeStr<BorrowEvent>>;
    static get p(): PhantomReified<ToTypeStr<BorrowEvent>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof BorrowEvent.instantiateBcs>;
    static fromFields(fields: Record<string, any>): BorrowEvent;
    static fromFieldsWithTypes(item: FieldsWithTypes): BorrowEvent;
    static fromBcs(data: Uint8Array): BorrowEvent;
    toJSONField(): BorrowEventJSONField;
    toJSON(): BorrowEventJSON;
    static fromJSONField(field: any): BorrowEvent;
    static fromJSON(json: Record<string, any>): BorrowEvent;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): BorrowEvent;
    static fetch(client: ClientWithCoreApi, id: string): Promise<BorrowEvent>;
}
export declare function isRepayEvent(type: string): boolean;
export interface RepayEventFields {
    lendingMarketId: ToField<'address'>;
    coinType: ToField<TypeName>;
    reserveId: ToField<'address'>;
    obligationId: ToField<'address'>;
    liquidityAmount: ToField<'u64'>;
}
export type RepayEventReified = Reified<RepayEvent, RepayEventFields>;
export type RepayEventJSONField = {
    lendingMarketId: string;
    coinType: string;
    reserveId: string;
    obligationId: string;
    liquidityAmount: string;
};
export type RepayEventJSON = {
    $typeName: typeof RepayEvent.$typeName;
    $typeArgs: [];
} & RepayEventJSONField;
export declare class RepayEvent implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::RepayEvent`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof RepayEvent.$typeName;
    readonly $fullTypeName: `${string}::lending_market::RepayEvent`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof RepayEvent.$isPhantom;
    readonly lendingMarketId: ToField<'address'>;
    readonly coinType: ToField<TypeName>;
    readonly reserveId: ToField<'address'>;
    readonly obligationId: ToField<'address'>;
    readonly liquidityAmount: ToField<'u64'>;
    private constructor();
    static reified(): RepayEventReified;
    static get r(): RepayEventReified;
    static phantom(): PhantomReified<ToTypeStr<RepayEvent>>;
    static get p(): PhantomReified<ToTypeStr<RepayEvent>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof RepayEvent.instantiateBcs>;
    static fromFields(fields: Record<string, any>): RepayEvent;
    static fromFieldsWithTypes(item: FieldsWithTypes): RepayEvent;
    static fromBcs(data: Uint8Array): RepayEvent;
    toJSONField(): RepayEventJSONField;
    toJSON(): RepayEventJSON;
    static fromJSONField(field: any): RepayEvent;
    static fromJSON(json: Record<string, any>): RepayEvent;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): RepayEvent;
    static fetch(client: ClientWithCoreApi, id: string): Promise<RepayEvent>;
}
export declare function isForgiveEvent(type: string): boolean;
export interface ForgiveEventFields {
    lendingMarketId: ToField<'address'>;
    coinType: ToField<TypeName>;
    reserveId: ToField<'address'>;
    obligationId: ToField<'address'>;
    liquidityAmount: ToField<'u64'>;
}
export type ForgiveEventReified = Reified<ForgiveEvent, ForgiveEventFields>;
export type ForgiveEventJSONField = {
    lendingMarketId: string;
    coinType: string;
    reserveId: string;
    obligationId: string;
    liquidityAmount: string;
};
export type ForgiveEventJSON = {
    $typeName: typeof ForgiveEvent.$typeName;
    $typeArgs: [];
} & ForgiveEventJSONField;
export declare class ForgiveEvent implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::ForgiveEvent`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof ForgiveEvent.$typeName;
    readonly $fullTypeName: `${string}::lending_market::ForgiveEvent`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof ForgiveEvent.$isPhantom;
    readonly lendingMarketId: ToField<'address'>;
    readonly coinType: ToField<TypeName>;
    readonly reserveId: ToField<'address'>;
    readonly obligationId: ToField<'address'>;
    readonly liquidityAmount: ToField<'u64'>;
    private constructor();
    static reified(): ForgiveEventReified;
    static get r(): ForgiveEventReified;
    static phantom(): PhantomReified<ToTypeStr<ForgiveEvent>>;
    static get p(): PhantomReified<ToTypeStr<ForgiveEvent>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof ForgiveEvent.instantiateBcs>;
    static fromFields(fields: Record<string, any>): ForgiveEvent;
    static fromFieldsWithTypes(item: FieldsWithTypes): ForgiveEvent;
    static fromBcs(data: Uint8Array): ForgiveEvent;
    toJSONField(): ForgiveEventJSONField;
    toJSON(): ForgiveEventJSON;
    static fromJSONField(field: any): ForgiveEvent;
    static fromJSON(json: Record<string, any>): ForgiveEvent;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): ForgiveEvent;
    static fetch(client: ClientWithCoreApi, id: string): Promise<ForgiveEvent>;
}
export declare function isLiquidateEvent(type: string): boolean;
export interface LiquidateEventFields {
    lendingMarketId: ToField<'address'>;
    repayReserveId: ToField<'address'>;
    withdrawReserveId: ToField<'address'>;
    obligationId: ToField<'address'>;
    repayCoinType: ToField<TypeName>;
    withdrawCoinType: ToField<TypeName>;
    repayAmount: ToField<'u64'>;
    withdrawAmount: ToField<'u64'>;
    protocolFeeAmount: ToField<'u64'>;
    liquidatorBonusAmount: ToField<'u64'>;
}
export type LiquidateEventReified = Reified<LiquidateEvent, LiquidateEventFields>;
export type LiquidateEventJSONField = {
    lendingMarketId: string;
    repayReserveId: string;
    withdrawReserveId: string;
    obligationId: string;
    repayCoinType: string;
    withdrawCoinType: string;
    repayAmount: string;
    withdrawAmount: string;
    protocolFeeAmount: string;
    liquidatorBonusAmount: string;
};
export type LiquidateEventJSON = {
    $typeName: typeof LiquidateEvent.$typeName;
    $typeArgs: [];
} & LiquidateEventJSONField;
export declare class LiquidateEvent implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::LiquidateEvent`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof LiquidateEvent.$typeName;
    readonly $fullTypeName: `${string}::lending_market::LiquidateEvent`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof LiquidateEvent.$isPhantom;
    readonly lendingMarketId: ToField<'address'>;
    readonly repayReserveId: ToField<'address'>;
    readonly withdrawReserveId: ToField<'address'>;
    readonly obligationId: ToField<'address'>;
    readonly repayCoinType: ToField<TypeName>;
    readonly withdrawCoinType: ToField<TypeName>;
    readonly repayAmount: ToField<'u64'>;
    readonly withdrawAmount: ToField<'u64'>;
    readonly protocolFeeAmount: ToField<'u64'>;
    readonly liquidatorBonusAmount: ToField<'u64'>;
    private constructor();
    static reified(): LiquidateEventReified;
    static get r(): LiquidateEventReified;
    static phantom(): PhantomReified<ToTypeStr<LiquidateEvent>>;
    static get p(): PhantomReified<ToTypeStr<LiquidateEvent>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof LiquidateEvent.instantiateBcs>;
    static fromFields(fields: Record<string, any>): LiquidateEvent;
    static fromFieldsWithTypes(item: FieldsWithTypes): LiquidateEvent;
    static fromBcs(data: Uint8Array): LiquidateEvent;
    toJSONField(): LiquidateEventJSONField;
    toJSON(): LiquidateEventJSON;
    static fromJSONField(field: any): LiquidateEvent;
    static fromJSON(json: Record<string, any>): LiquidateEvent;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): LiquidateEvent;
    static fetch(client: ClientWithCoreApi, id: string): Promise<LiquidateEvent>;
}
export declare function isClaimRewardEvent(type: string): boolean;
export interface ClaimRewardEventFields {
    lendingMarketId: ToField<'address'>;
    reserveId: ToField<'address'>;
    obligationId: ToField<'address'>;
    isDepositReward: ToField<'bool'>;
    poolRewardId: ToField<'address'>;
    coinType: ToField<TypeName>;
    liquidityAmount: ToField<'u64'>;
}
export type ClaimRewardEventReified = Reified<ClaimRewardEvent, ClaimRewardEventFields>;
export type ClaimRewardEventJSONField = {
    lendingMarketId: string;
    reserveId: string;
    obligationId: string;
    isDepositReward: boolean;
    poolRewardId: string;
    coinType: string;
    liquidityAmount: string;
};
export type ClaimRewardEventJSON = {
    $typeName: typeof ClaimRewardEvent.$typeName;
    $typeArgs: [];
} & ClaimRewardEventJSONField;
export declare class ClaimRewardEvent implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::ClaimRewardEvent`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof ClaimRewardEvent.$typeName;
    readonly $fullTypeName: `${string}::lending_market::ClaimRewardEvent`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof ClaimRewardEvent.$isPhantom;
    readonly lendingMarketId: ToField<'address'>;
    readonly reserveId: ToField<'address'>;
    readonly obligationId: ToField<'address'>;
    readonly isDepositReward: ToField<'bool'>;
    readonly poolRewardId: ToField<'address'>;
    readonly coinType: ToField<TypeName>;
    readonly liquidityAmount: ToField<'u64'>;
    private constructor();
    static reified(): ClaimRewardEventReified;
    static get r(): ClaimRewardEventReified;
    static phantom(): PhantomReified<ToTypeStr<ClaimRewardEvent>>;
    static get p(): PhantomReified<ToTypeStr<ClaimRewardEvent>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof ClaimRewardEvent.instantiateBcs>;
    static fromFields(fields: Record<string, any>): ClaimRewardEvent;
    static fromFieldsWithTypes(item: FieldsWithTypes): ClaimRewardEvent;
    static fromBcs(data: Uint8Array): ClaimRewardEvent;
    toJSONField(): ClaimRewardEventJSONField;
    toJSON(): ClaimRewardEventJSON;
    static fromJSONField(field: any): ClaimRewardEvent;
    static fromJSON(json: Record<string, any>): ClaimRewardEvent;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): ClaimRewardEvent;
    static fetch(client: ClientWithCoreApi, id: string): Promise<ClaimRewardEvent>;
}
export declare function isMarketPauseEvent(type: string): boolean;
export interface MarketPauseEventFields {
    lendingMarketId: ToField<'address'>;
    paused: ToField<'bool'>;
}
export type MarketPauseEventReified = Reified<MarketPauseEvent, MarketPauseEventFields>;
export type MarketPauseEventJSONField = {
    lendingMarketId: string;
    paused: boolean;
};
export type MarketPauseEventJSON = {
    $typeName: typeof MarketPauseEvent.$typeName;
    $typeArgs: [];
} & MarketPauseEventJSONField;
export declare class MarketPauseEvent implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::MarketPauseEvent`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof MarketPauseEvent.$typeName;
    readonly $fullTypeName: `${string}::lending_market::MarketPauseEvent`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof MarketPauseEvent.$isPhantom;
    readonly lendingMarketId: ToField<'address'>;
    readonly paused: ToField<'bool'>;
    private constructor();
    static reified(): MarketPauseEventReified;
    static get r(): MarketPauseEventReified;
    static phantom(): PhantomReified<ToTypeStr<MarketPauseEvent>>;
    static get p(): PhantomReified<ToTypeStr<MarketPauseEvent>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof MarketPauseEvent.instantiateBcs>;
    static fromFields(fields: Record<string, any>): MarketPauseEvent;
    static fromFieldsWithTypes(item: FieldsWithTypes): MarketPauseEvent;
    static fromBcs(data: Uint8Array): MarketPauseEvent;
    toJSONField(): MarketPauseEventJSONField;
    toJSON(): MarketPauseEventJSON;
    static fromJSONField(field: any): MarketPauseEvent;
    static fromJSON(json: Record<string, any>): MarketPauseEvent;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): MarketPauseEvent;
    static fetch(client: ClientWithCoreApi, id: string): Promise<MarketPauseEvent>;
}
export declare function isReservePauseEvent(type: string): boolean;
export interface ReservePauseEventFields {
    lendingMarketId: ToField<'address'>;
    reserveId: ToField<'address'>;
    paused: ToField<'bool'>;
}
export type ReservePauseEventReified = Reified<ReservePauseEvent, ReservePauseEventFields>;
export type ReservePauseEventJSONField = {
    lendingMarketId: string;
    reserveId: string;
    paused: boolean;
};
export type ReservePauseEventJSON = {
    $typeName: typeof ReservePauseEvent.$typeName;
    $typeArgs: [];
} & ReservePauseEventJSONField;
export declare class ReservePauseEvent implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::ReservePauseEvent`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof ReservePauseEvent.$typeName;
    readonly $fullTypeName: `${string}::lending_market::ReservePauseEvent`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof ReservePauseEvent.$isPhantom;
    readonly lendingMarketId: ToField<'address'>;
    readonly reserveId: ToField<'address'>;
    readonly paused: ToField<'bool'>;
    private constructor();
    static reified(): ReservePauseEventReified;
    static get r(): ReservePauseEventReified;
    static phantom(): PhantomReified<ToTypeStr<ReservePauseEvent>>;
    static get p(): PhantomReified<ToTypeStr<ReservePauseEvent>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof ReservePauseEvent.instantiateBcs>;
    static fromFields(fields: Record<string, any>): ReservePauseEvent;
    static fromFieldsWithTypes(item: FieldsWithTypes): ReservePauseEvent;
    static fromBcs(data: Uint8Array): ReservePauseEvent;
    toJSONField(): ReservePauseEventJSONField;
    toJSON(): ReservePauseEventJSON;
    static fromJSONField(field: any): ReservePauseEvent;
    static fromJSON(json: Record<string, any>): ReservePauseEvent;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): ReservePauseEvent;
    static fetch(client: ClientWithCoreApi, id: string): Promise<ReservePauseEvent>;
}
export declare function isPauseCapRotatedEvent(type: string): boolean;
export interface PauseCapRotatedEventFields {
    lendingMarketId: ToField<'address'>;
    newCapId: ToField<'address'>;
    generation: ToField<'u64'>;
}
export type PauseCapRotatedEventReified = Reified<PauseCapRotatedEvent, PauseCapRotatedEventFields>;
export type PauseCapRotatedEventJSONField = {
    lendingMarketId: string;
    newCapId: string;
    generation: string;
};
export type PauseCapRotatedEventJSON = {
    $typeName: typeof PauseCapRotatedEvent.$typeName;
    $typeArgs: [];
} & PauseCapRotatedEventJSONField;
export declare class PauseCapRotatedEvent implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::lending_market::PauseCapRotatedEvent`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof PauseCapRotatedEvent.$typeName;
    readonly $fullTypeName: `${string}::lending_market::PauseCapRotatedEvent`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof PauseCapRotatedEvent.$isPhantom;
    readonly lendingMarketId: ToField<'address'>;
    readonly newCapId: ToField<'address'>;
    readonly generation: ToField<'u64'>;
    private constructor();
    static reified(): PauseCapRotatedEventReified;
    static get r(): PauseCapRotatedEventReified;
    static phantom(): PhantomReified<ToTypeStr<PauseCapRotatedEvent>>;
    static get p(): PhantomReified<ToTypeStr<PauseCapRotatedEvent>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof PauseCapRotatedEvent.instantiateBcs>;
    static fromFields(fields: Record<string, any>): PauseCapRotatedEvent;
    static fromFieldsWithTypes(item: FieldsWithTypes): PauseCapRotatedEvent;
    static fromBcs(data: Uint8Array): PauseCapRotatedEvent;
    toJSONField(): PauseCapRotatedEventJSONField;
    toJSON(): PauseCapRotatedEventJSON;
    static fromJSONField(field: any): PauseCapRotatedEvent;
    static fromJSON(json: Record<string, any>): PauseCapRotatedEvent;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): PauseCapRotatedEvent;
    static fetch(client: ClientWithCoreApi, id: string): Promise<PauseCapRotatedEvent>;
}