import type { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
import { TypeName } from '../../_dependencies/std/type-name/structs';
import { ID, UID } from '../../_dependencies/sui/object/structs';
import { PhantomReified, PhantomToTypeStr, PhantomTypeArgument, Reified, StructClass, ToField, ToJSON, ToPhantomTypeArgument, ToTypeStr } from '../../_framework/reified';
import { FieldsWithTypes } from '../../_framework/util';
import { Vector } from '../../_framework/vector';
import { Decimal } from '../decimal/structs';
import { UserRewardManager } from '../liquidity-mining/structs';
export declare function isObligation(type: string): boolean;
export interface ObligationFields<P extends PhantomTypeArgument> {
    id: ToField<UID>;
    lendingMarketId: ToField<ID>;
    /**
     * all deposits in the obligation. there is at most one deposit per coin type
     * There should never be a deposit object with a zeroed amount
     */
    deposits: ToField<Vector<Deposit>>;
    /**
     * all borrows in the obligation. there is at most one deposit per coin type
     * There should never be a borrow object with a zeroed amount
     */
    borrows: ToField<Vector<Borrow>>;
    /** value of all deposits in USD */
    depositedValueUsd: ToField<Decimal>;
    /**
     * sum(deposit value * open ltv) for all deposits.
     * if weighted_borrowed_value_usd > allowed_borrow_value_usd,
     * the obligation is not healthy
     */
    allowedBorrowValueUsd: ToField<Decimal>;
    /**
     * sum(deposit value * close ltv) for all deposits
     * if weighted_borrowed_value_usd > unhealthy_borrow_value_usd,
     * the obligation is unhealthy and can be liquidated
     */
    unhealthyBorrowValueUsd: ToField<Decimal>;
    superUnhealthyBorrowValueUsd: ToField<Decimal>;
    /** value of all borrows in USD */
    unweightedBorrowedValueUsd: ToField<Decimal>;
    /** weighted value of all borrows in USD. used when checking if an obligation is liquidatable */
    weightedBorrowedValueUsd: ToField<Decimal>;
    /**
     * weighted value of all borrows in USD, but using the upper bound of the market value
     * used to limit borrows and withdraws
     */
    weightedBorrowedValueUpperBoundUsd: ToField<Decimal>;
    borrowingIsolatedAsset: ToField<'bool'>;
    userRewardManagers: ToField<Vector<UserRewardManager>>;
    /** unused */
    badDebtUsd: ToField<Decimal>;
    /** unused */
    closable: ToField<'bool'>;
}
export type ObligationReified<P extends PhantomTypeArgument> = Reified<Obligation<P>, ObligationFields<P>>;
export type ObligationJSONField<P extends PhantomTypeArgument> = {
    id: string;
    lendingMarketId: string;
    deposits: ToJSON<Deposit>[];
    borrows: ToJSON<Borrow>[];
    depositedValueUsd: ToJSON<Decimal>;
    allowedBorrowValueUsd: ToJSON<Decimal>;
    unhealthyBorrowValueUsd: ToJSON<Decimal>;
    superUnhealthyBorrowValueUsd: ToJSON<Decimal>;
    unweightedBorrowedValueUsd: ToJSON<Decimal>;
    weightedBorrowedValueUsd: ToJSON<Decimal>;
    weightedBorrowedValueUpperBoundUsd: ToJSON<Decimal>;
    borrowingIsolatedAsset: boolean;
    userRewardManagers: ToJSON<UserRewardManager>[];
    badDebtUsd: ToJSON<Decimal>;
    closable: boolean;
};
export type ObligationJSON<P extends PhantomTypeArgument> = {
    $typeName: typeof Obligation.$typeName;
    $typeArgs: [PhantomToTypeStr<P>];
} & ObligationJSONField<P>;
export declare class Obligation<P extends PhantomTypeArgument> implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::obligation::Obligation`;
    static readonly $numTypeParams = 1;
    static readonly $isPhantom: readonly [true];
    readonly $typeName: typeof Obligation.$typeName;
    readonly $fullTypeName: `${string}::obligation::Obligation<${PhantomToTypeStr<P>}>`;
    readonly $typeArgs: [PhantomToTypeStr<P>];
    readonly $isPhantom: typeof Obligation.$isPhantom;
    readonly id: ToField<UID>;
    readonly lendingMarketId: ToField<ID>;
    /**
     * all deposits in the obligation. there is at most one deposit per coin type
     * There should never be a deposit object with a zeroed amount
     */
    readonly deposits: ToField<Vector<Deposit>>;
    /**
     * all borrows in the obligation. there is at most one deposit per coin type
     * There should never be a borrow object with a zeroed amount
     */
    readonly borrows: ToField<Vector<Borrow>>;
    /** value of all deposits in USD */
    readonly depositedValueUsd: ToField<Decimal>;
    /**
     * sum(deposit value * open ltv) for all deposits.
     * if weighted_borrowed_value_usd > allowed_borrow_value_usd,
     * the obligation is not healthy
     */
    readonly allowedBorrowValueUsd: ToField<Decimal>;
    /**
     * sum(deposit value * close ltv) for all deposits
     * if weighted_borrowed_value_usd > unhealthy_borrow_value_usd,
     * the obligation is unhealthy and can be liquidated
     */
    readonly unhealthyBorrowValueUsd: ToField<Decimal>;
    readonly superUnhealthyBorrowValueUsd: ToField<Decimal>;
    /** value of all borrows in USD */
    readonly unweightedBorrowedValueUsd: ToField<Decimal>;
    /** weighted value of all borrows in USD. used when checking if an obligation is liquidatable */
    readonly weightedBorrowedValueUsd: ToField<Decimal>;
    /**
     * weighted value of all borrows in USD, but using the upper bound of the market value
     * used to limit borrows and withdraws
     */
    readonly weightedBorrowedValueUpperBoundUsd: ToField<Decimal>;
    readonly borrowingIsolatedAsset: ToField<'bool'>;
    readonly userRewardManagers: ToField<Vector<UserRewardManager>>;
    /** unused */
    readonly badDebtUsd: ToField<Decimal>;
    /** unused */
    readonly closable: ToField<'bool'>;
    private constructor();
    static reified<P extends PhantomReified<PhantomTypeArgument>>(P: P): ObligationReified<ToPhantomTypeArgument<P>>;
    static get r(): typeof Obligation.reified;
    static phantom<P extends PhantomReified<PhantomTypeArgument>>(P: P): PhantomReified<ToTypeStr<Obligation<ToPhantomTypeArgument<P>>>>;
    static get p(): typeof Obligation.phantom;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof Obligation.instantiateBcs>;
    static fromFields<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, fields: Record<string, any>): Obligation<ToPhantomTypeArgument<P>>;
    static fromFieldsWithTypes<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, item: FieldsWithTypes): Obligation<ToPhantomTypeArgument<P>>;
    static fromBcs<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, data: Uint8Array): Obligation<ToPhantomTypeArgument<P>>;
    toJSONField(): ObligationJSONField<P>;
    toJSON(): ObligationJSON<P>;
    static fromJSONField<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, field: any): Obligation<ToPhantomTypeArgument<P>>;
    static fromJSON<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, json: Record<string, any>): Obligation<ToPhantomTypeArgument<P>>;
    static fromCoreObject<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, obj: SuiClientTypes.Object<{
        content: true;
    }>): Obligation<ToPhantomTypeArgument<P>>;
    static fetch<P extends PhantomReified<PhantomTypeArgument>>(client: ClientWithCoreApi, typeArg: P, id: string): Promise<Obligation<ToPhantomTypeArgument<P>>>;
}
export declare function isDeposit(type: string): boolean;
export interface DepositFields {
    coinType: ToField<TypeName>;
    reserveArrayIndex: ToField<'u64'>;
    depositedCtokenAmount: ToField<'u64'>;
    marketValue: ToField<Decimal>;
    userRewardManagerIndex: ToField<'u64'>;
    /** unused */
    attributedBorrowValue: ToField<Decimal>;
}
export type DepositReified = Reified<Deposit, DepositFields>;
export type DepositJSONField = {
    coinType: string;
    reserveArrayIndex: string;
    depositedCtokenAmount: string;
    marketValue: ToJSON<Decimal>;
    userRewardManagerIndex: string;
    attributedBorrowValue: ToJSON<Decimal>;
};
export type DepositJSON = {
    $typeName: typeof Deposit.$typeName;
    $typeArgs: [];
} & DepositJSONField;
export declare class Deposit implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::obligation::Deposit`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof Deposit.$typeName;
    readonly $fullTypeName: `${string}::obligation::Deposit`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof Deposit.$isPhantom;
    readonly coinType: ToField<TypeName>;
    readonly reserveArrayIndex: ToField<'u64'>;
    readonly depositedCtokenAmount: ToField<'u64'>;
    readonly marketValue: ToField<Decimal>;
    readonly userRewardManagerIndex: ToField<'u64'>;
    /** unused */
    readonly attributedBorrowValue: ToField<Decimal>;
    private constructor();
    static reified(): DepositReified;
    static get r(): DepositReified;
    static phantom(): PhantomReified<ToTypeStr<Deposit>>;
    static get p(): PhantomReified<ToTypeStr<Deposit>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof Deposit.instantiateBcs>;
    static fromFields(fields: Record<string, any>): Deposit;
    static fromFieldsWithTypes(item: FieldsWithTypes): Deposit;
    static fromBcs(data: Uint8Array): Deposit;
    toJSONField(): DepositJSONField;
    toJSON(): DepositJSON;
    static fromJSONField(field: any): Deposit;
    static fromJSON(json: Record<string, any>): Deposit;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): Deposit;
    static fetch(client: ClientWithCoreApi, id: string): Promise<Deposit>;
}
export declare function isBorrow(type: string): boolean;
export interface BorrowFields {
    coinType: ToField<TypeName>;
    reserveArrayIndex: ToField<'u64'>;
    borrowedAmount: ToField<Decimal>;
    cumulativeBorrowRate: ToField<Decimal>;
    marketValue: ToField<Decimal>;
    userRewardManagerIndex: ToField<'u64'>;
}
export type BorrowReified = Reified<Borrow, BorrowFields>;
export type BorrowJSONField = {
    coinType: string;
    reserveArrayIndex: string;
    borrowedAmount: ToJSON<Decimal>;
    cumulativeBorrowRate: ToJSON<Decimal>;
    marketValue: ToJSON<Decimal>;
    userRewardManagerIndex: string;
};
export type BorrowJSON = {
    $typeName: typeof Borrow.$typeName;
    $typeArgs: [];
} & BorrowJSONField;
export declare class Borrow implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::obligation::Borrow`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof Borrow.$typeName;
    readonly $fullTypeName: `${string}::obligation::Borrow`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof Borrow.$isPhantom;
    readonly coinType: ToField<TypeName>;
    readonly reserveArrayIndex: ToField<'u64'>;
    readonly borrowedAmount: ToField<Decimal>;
    readonly cumulativeBorrowRate: ToField<Decimal>;
    readonly marketValue: ToField<Decimal>;
    readonly userRewardManagerIndex: ToField<'u64'>;
    private constructor();
    static reified(): BorrowReified;
    static get r(): BorrowReified;
    static phantom(): PhantomReified<ToTypeStr<Borrow>>;
    static get p(): PhantomReified<ToTypeStr<Borrow>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof Borrow.instantiateBcs>;
    static fromFields(fields: Record<string, any>): Borrow;
    static fromFieldsWithTypes(item: FieldsWithTypes): Borrow;
    static fromBcs(data: Uint8Array): Borrow;
    toJSONField(): BorrowJSONField;
    toJSON(): BorrowJSON;
    static fromJSONField(field: any): Borrow;
    static fromJSON(json: Record<string, any>): Borrow;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): Borrow;
    static fetch(client: ClientWithCoreApi, id: string): Promise<Borrow>;
}
export declare function isExistStaleOracles(type: string): boolean;
export interface ExistStaleOraclesFields {
    dummyField: ToField<'bool'>;
}
export type ExistStaleOraclesReified = Reified<ExistStaleOracles, ExistStaleOraclesFields>;
export type ExistStaleOraclesJSONField = {
    dummyField: boolean;
};
export type ExistStaleOraclesJSON = {
    $typeName: typeof ExistStaleOracles.$typeName;
    $typeArgs: [];
} & ExistStaleOraclesJSONField;
export declare class ExistStaleOracles implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::obligation::ExistStaleOracles`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof ExistStaleOracles.$typeName;
    readonly $fullTypeName: `${string}::obligation::ExistStaleOracles`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof ExistStaleOracles.$isPhantom;
    readonly dummyField: ToField<'bool'>;
    private constructor();
    static reified(): ExistStaleOraclesReified;
    static get r(): ExistStaleOraclesReified;
    static phantom(): PhantomReified<ToTypeStr<ExistStaleOracles>>;
    static get p(): PhantomReified<ToTypeStr<ExistStaleOracles>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof ExistStaleOracles.instantiateBcs>;
    static fromFields(fields: Record<string, any>): ExistStaleOracles;
    static fromFieldsWithTypes(item: FieldsWithTypes): ExistStaleOracles;
    static fromBcs(data: Uint8Array): ExistStaleOracles;
    toJSONField(): ExistStaleOraclesJSONField;
    toJSON(): ExistStaleOraclesJSON;
    static fromJSONField(field: any): ExistStaleOracles;
    static fromJSON(json: Record<string, any>): ExistStaleOracles;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): ExistStaleOracles;
    static fetch(client: ClientWithCoreApi, id: string): Promise<ExistStaleOracles>;
}
export declare function isObligationDataEvent(type: string): boolean;
export interface ObligationDataEventFields {
    lendingMarketId: ToField<'address'>;
    obligationId: ToField<'address'>;
    deposits: ToField<Vector<DepositRecord>>;
    borrows: ToField<Vector<BorrowRecord>>;
    depositedValueUsd: ToField<Decimal>;
    allowedBorrowValueUsd: ToField<Decimal>;
    unhealthyBorrowValueUsd: ToField<Decimal>;
    superUnhealthyBorrowValueUsd: ToField<Decimal>;
    unweightedBorrowedValueUsd: ToField<Decimal>;
    weightedBorrowedValueUsd: ToField<Decimal>;
    weightedBorrowedValueUpperBoundUsd: ToField<Decimal>;
    borrowingIsolatedAsset: ToField<'bool'>;
    badDebtUsd: ToField<Decimal>;
    closable: ToField<'bool'>;
}
export type ObligationDataEventReified = Reified<ObligationDataEvent, ObligationDataEventFields>;
export type ObligationDataEventJSONField = {
    lendingMarketId: string;
    obligationId: string;
    deposits: ToJSON<DepositRecord>[];
    borrows: ToJSON<BorrowRecord>[];
    depositedValueUsd: ToJSON<Decimal>;
    allowedBorrowValueUsd: ToJSON<Decimal>;
    unhealthyBorrowValueUsd: ToJSON<Decimal>;
    superUnhealthyBorrowValueUsd: ToJSON<Decimal>;
    unweightedBorrowedValueUsd: ToJSON<Decimal>;
    weightedBorrowedValueUsd: ToJSON<Decimal>;
    weightedBorrowedValueUpperBoundUsd: ToJSON<Decimal>;
    borrowingIsolatedAsset: boolean;
    badDebtUsd: ToJSON<Decimal>;
    closable: boolean;
};
export type ObligationDataEventJSON = {
    $typeName: typeof ObligationDataEvent.$typeName;
    $typeArgs: [];
} & ObligationDataEventJSONField;
export declare class ObligationDataEvent implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::obligation::ObligationDataEvent`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof ObligationDataEvent.$typeName;
    readonly $fullTypeName: `${string}::obligation::ObligationDataEvent`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof ObligationDataEvent.$isPhantom;
    readonly lendingMarketId: ToField<'address'>;
    readonly obligationId: ToField<'address'>;
    readonly deposits: ToField<Vector<DepositRecord>>;
    readonly borrows: ToField<Vector<BorrowRecord>>;
    readonly depositedValueUsd: ToField<Decimal>;
    readonly allowedBorrowValueUsd: ToField<Decimal>;
    readonly unhealthyBorrowValueUsd: ToField<Decimal>;
    readonly superUnhealthyBorrowValueUsd: ToField<Decimal>;
    readonly unweightedBorrowedValueUsd: ToField<Decimal>;
    readonly weightedBorrowedValueUsd: ToField<Decimal>;
    readonly weightedBorrowedValueUpperBoundUsd: ToField<Decimal>;
    readonly borrowingIsolatedAsset: ToField<'bool'>;
    readonly badDebtUsd: ToField<Decimal>;
    readonly closable: ToField<'bool'>;
    private constructor();
    static reified(): ObligationDataEventReified;
    static get r(): ObligationDataEventReified;
    static phantom(): PhantomReified<ToTypeStr<ObligationDataEvent>>;
    static get p(): PhantomReified<ToTypeStr<ObligationDataEvent>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof ObligationDataEvent.instantiateBcs>;
    static fromFields(fields: Record<string, any>): ObligationDataEvent;
    static fromFieldsWithTypes(item: FieldsWithTypes): ObligationDataEvent;
    static fromBcs(data: Uint8Array): ObligationDataEvent;
    toJSONField(): ObligationDataEventJSONField;
    toJSON(): ObligationDataEventJSON;
    static fromJSONField(field: any): ObligationDataEvent;
    static fromJSON(json: Record<string, any>): ObligationDataEvent;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): ObligationDataEvent;
    static fetch(client: ClientWithCoreApi, id: string): Promise<ObligationDataEvent>;
}
export declare function isDepositRecord(type: string): boolean;
export interface DepositRecordFields {
    coinType: ToField<TypeName>;
    reserveArrayIndex: ToField<'u64'>;
    depositedCtokenAmount: ToField<'u64'>;
    marketValue: ToField<Decimal>;
    userRewardManagerIndex: ToField<'u64'>;
    /** unused */
    attributedBorrowValue: ToField<Decimal>;
}
export type DepositRecordReified = Reified<DepositRecord, DepositRecordFields>;
export type DepositRecordJSONField = {
    coinType: string;
    reserveArrayIndex: string;
    depositedCtokenAmount: string;
    marketValue: ToJSON<Decimal>;
    userRewardManagerIndex: string;
    attributedBorrowValue: ToJSON<Decimal>;
};
export type DepositRecordJSON = {
    $typeName: typeof DepositRecord.$typeName;
    $typeArgs: [];
} & DepositRecordJSONField;
export declare class DepositRecord implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::obligation::DepositRecord`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof DepositRecord.$typeName;
    readonly $fullTypeName: `${string}::obligation::DepositRecord`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof DepositRecord.$isPhantom;
    readonly coinType: ToField<TypeName>;
    readonly reserveArrayIndex: ToField<'u64'>;
    readonly depositedCtokenAmount: ToField<'u64'>;
    readonly marketValue: ToField<Decimal>;
    readonly userRewardManagerIndex: ToField<'u64'>;
    /** unused */
    readonly attributedBorrowValue: ToField<Decimal>;
    private constructor();
    static reified(): DepositRecordReified;
    static get r(): DepositRecordReified;
    static phantom(): PhantomReified<ToTypeStr<DepositRecord>>;
    static get p(): PhantomReified<ToTypeStr<DepositRecord>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof DepositRecord.instantiateBcs>;
    static fromFields(fields: Record<string, any>): DepositRecord;
    static fromFieldsWithTypes(item: FieldsWithTypes): DepositRecord;
    static fromBcs(data: Uint8Array): DepositRecord;
    toJSONField(): DepositRecordJSONField;
    toJSON(): DepositRecordJSON;
    static fromJSONField(field: any): DepositRecord;
    static fromJSON(json: Record<string, any>): DepositRecord;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): DepositRecord;
    static fetch(client: ClientWithCoreApi, id: string): Promise<DepositRecord>;
}
export declare function isBorrowRecord(type: string): boolean;
export interface BorrowRecordFields {
    coinType: ToField<TypeName>;
    reserveArrayIndex: ToField<'u64'>;
    borrowedAmount: ToField<Decimal>;
    cumulativeBorrowRate: ToField<Decimal>;
    marketValue: ToField<Decimal>;
    userRewardManagerIndex: ToField<'u64'>;
}
export type BorrowRecordReified = Reified<BorrowRecord, BorrowRecordFields>;
export type BorrowRecordJSONField = {
    coinType: string;
    reserveArrayIndex: string;
    borrowedAmount: ToJSON<Decimal>;
    cumulativeBorrowRate: ToJSON<Decimal>;
    marketValue: ToJSON<Decimal>;
    userRewardManagerIndex: string;
};
export type BorrowRecordJSON = {
    $typeName: typeof BorrowRecord.$typeName;
    $typeArgs: [];
} & BorrowRecordJSONField;
export declare class BorrowRecord implements StructClass {
    __StructClass: true;
    static get $typeName(): `${string}::obligation::BorrowRecord`;
    static readonly $numTypeParams = 0;
    static readonly $isPhantom: readonly [];
    readonly $typeName: typeof BorrowRecord.$typeName;
    readonly $fullTypeName: `${string}::obligation::BorrowRecord`;
    readonly $typeArgs: [];
    readonly $isPhantom: typeof BorrowRecord.$isPhantom;
    readonly coinType: ToField<TypeName>;
    readonly reserveArrayIndex: ToField<'u64'>;
    readonly borrowedAmount: ToField<Decimal>;
    readonly cumulativeBorrowRate: ToField<Decimal>;
    readonly marketValue: ToField<Decimal>;
    readonly userRewardManagerIndex: ToField<'u64'>;
    private constructor();
    static reified(): BorrowRecordReified;
    static get r(): BorrowRecordReified;
    static phantom(): PhantomReified<ToTypeStr<BorrowRecord>>;
    static get p(): PhantomReified<ToTypeStr<BorrowRecord>>;
    private static instantiateBcs;
    private static cachedBcs;
    static get bcs(): ReturnType<typeof BorrowRecord.instantiateBcs>;
    static fromFields(fields: Record<string, any>): BorrowRecord;
    static fromFieldsWithTypes(item: FieldsWithTypes): BorrowRecord;
    static fromBcs(data: Uint8Array): BorrowRecord;
    toJSONField(): BorrowRecordJSONField;
    toJSON(): BorrowRecordJSON;
    static fromJSONField(field: any): BorrowRecord;
    static fromJSON(json: Record<string, any>): BorrowRecord;
    static fromCoreObject(obj: SuiClientTypes.Object<{
        content: true;
    }>): BorrowRecord;
    static fetch(client: ClientWithCoreApi, id: string): Promise<BorrowRecord>;
}