@suilend/sdk 12.7.0 → 13.0.0-next.g803bba0

package/_generated/suilend/lending-market/structs.js

@@ -1,616 +1,1790 @@
-import * as reified from "../../_framework/reified.js";
-import { TypeName } from "../../_dependencies/source/0x1/type-name/structs.js";
-import { ObjectTable } from "../../_dependencies/source/0x2/object-table/structs.js";
-import { ID, UID } from "../../_dependencies/source/0x2/object/structs.js";
-import { assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, fieldToJSON, phantom, } from "../../_framework/reified.js";
-import { composeSuiType, compressSuiType, } from "../../_framework/util.js";
-import { Decimal } from "../decimal/structs.js";
-import { PKG_V1, PKG_V10 } from "../index.js";
-import { Obligation } from "../obligation/structs.js";
-import { RateLimiter } from "../rate-limiter/structs.js";
-import { Reserve } from "../reserve/structs.js";
-import { bcs } from "@mysten/sui/bcs";
-import { fromHex, toHex } from "@mysten/sui/utils";
-/* ============================== MintEvent =============================== */
-export function isMintEvent(type) {
+import { bcs } from '@mysten/sui/bcs';
+import { fromHex, toHex } from '@mysten/sui/utils';
+import { TypeName } from '../../_dependencies/std/type-name/structs.js';
+import { ObjectTable } from '../../_dependencies/sui/object-table/structs.js';
+import { ID, UID } from '../../_dependencies/sui/object/structs.js';
+import { getTypeOrigin } from '../../_envs/index.js';
+import { assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, fieldToJSON, phantom, vector, } from '../../_framework/reified.js';
+import { composeSuiType, compressSuiType, parseTypeName, } from '../../_framework/util.js';
+import { Decimal } from '../decimal/structs.js';
+import { Obligation } from '../obligation/structs.js';
+import { RateLimiter } from '../rate-limiter/structs.js';
+import { Reserve } from '../reserve/structs.js';
+/* ============================== LENDING_MARKET =============================== */
+export function isLENDING_MARKET(type) {
+    type = compressSuiType(type);
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::LENDING_MARKET')}::lending_market::LENDING_MARKET`;
+}
+export class LENDING_MARKET {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::LENDING_MARKET')}::lending_market::LENDING_MARKET`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = LENDING_MARKET.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = LENDING_MARKET.$isPhantom;
+    dummyField;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(LENDING_MARKET.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.dummyField = fields.dummyField;
+    }
+    static reified() {
+        const reifiedBcs = LENDING_MARKET.bcs;
+        return {
+            get typeName() {
+                return LENDING_MARKET.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(LENDING_MARKET.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: LENDING_MARKET.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => LENDING_MARKET.fromFields(fields),
+            fromFieldsWithTypes: (item) => LENDING_MARKET.fromFieldsWithTypes(item),
+            fromBcs: (data) => LENDING_MARKET.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => LENDING_MARKET.fromJSONField(field),
+            fromJSON: (json) => LENDING_MARKET.fromJSON(json),
+            fromCoreObject: (obj) => LENDING_MARKET.fromCoreObject(obj),
+            fetch: async (client, id) => LENDING_MARKET.fetch(client, id),
+            new: (fields) => {
+                return new LENDING_MARKET([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return LENDING_MARKET.reified();
+    }
+    static phantom() {
+        return phantom(LENDING_MARKET.reified());
+    }
+    static get p() {
+        return LENDING_MARKET.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('LENDING_MARKET', {
+            dummy_field: bcs.bool(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!LENDING_MARKET.cachedBcs) {
+            LENDING_MARKET.cachedBcs = LENDING_MARKET.instantiateBcs();
+        }
+        return LENDING_MARKET.cachedBcs;
+    }
+    static fromFields(fields) {
+        return LENDING_MARKET.reified().new({
+            dummyField: decodeFromFields('bool', fields.dummy_field),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isLENDING_MARKET(item.type)) {
+            throw new Error('not a LENDING_MARKET type');
+        }
+        return LENDING_MARKET.reified().new({
+            dummyField: decodeFromFieldsWithTypes('bool', item.fields.dummy_field),
+        });
+    }
+    static fromBcs(data) {
+        return LENDING_MARKET.fromFields(LENDING_MARKET.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            dummyField: this.dummyField,
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return LENDING_MARKET.reified().new({
+            dummyField: decodeFromJSONField('bool', field.dummyField),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== LENDING_MARKET.$typeName) {
+            throw new Error(`not a LENDING_MARKET json object: expected '${LENDING_MARKET.$typeName}' but got '${json.$typeName}'`);
+        }
+        return LENDING_MARKET.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isLENDING_MARKET(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a LENDING_MARKET object`);
+        }
+        return LENDING_MARKET.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isLENDING_MARKET(object.type)) {
+            throw new Error(`object at id ${id} is not a LENDING_MARKET object`);
+        }
+        return LENDING_MARKET.fromBcs(object.content);
+    }
+}
+/* ============================== LendingMarket =============================== */
+export function isLendingMarket(type) {
+    type = compressSuiType(type);
+    return type.startsWith(`${getTypeOrigin('suilend', 'lending_market::LendingMarket')}::lending_market::LendingMarket`
+        + '<');
+}
+export class LendingMarket {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::LendingMarket')}::lending_market::LendingMarket`;
+    }
+    static $numTypeParams = 1;
+    static $isPhantom = [true];
+    $typeName = LendingMarket.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = LendingMarket.$isPhantom;
+    id;
+    version;
+    reserves;
+    obligations;
+    rateLimiter;
+    feeReceiver;
+    /** unused */
+    badDebtUsd;
+    /** unused */
+    badDebtLimitUsd;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(LendingMarket.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.id = fields.id;
+        this.version = fields.version;
+        this.reserves = fields.reserves;
+        this.obligations = fields.obligations;
+        this.rateLimiter = fields.rateLimiter;
+        this.feeReceiver = fields.feeReceiver;
+        this.badDebtUsd = fields.badDebtUsd;
+        this.badDebtLimitUsd = fields.badDebtLimitUsd;
+    }
+    static reified(P) {
+        const reifiedBcs = LendingMarket.bcs;
+        return {
+            get typeName() {
+                return LendingMarket.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(LendingMarket.$typeName, ...[extractType(P)]);
+            },
+            get typeArgs() {
+                return [extractType(P)];
+            },
+            isPhantom: LendingMarket.$isPhantom,
+            reifiedTypeArgs: [P],
+            fromFields: (fields) => LendingMarket.fromFields(P, fields),
+            fromFieldsWithTypes: (item) => LendingMarket.fromFieldsWithTypes(P, item),
+            fromBcs: (data) => LendingMarket.fromFields(P, reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => LendingMarket.fromJSONField(P, field),
+            fromJSON: (json) => LendingMarket.fromJSON(P, json),
+            fromCoreObject: (obj) => LendingMarket.fromCoreObject(P, obj),
+            fetch: async (client, id) => LendingMarket.fetch(client, P, id),
+            new: (fields) => {
+                return new LendingMarket([extractType(P)], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return LendingMarket.reified;
+    }
+    static phantom(P) {
+        return phantom(LendingMarket.reified(P));
+    }
+    static get p() {
+        return LendingMarket.phantom;
+    }
+    static instantiateBcs() {
+        return bcs.struct('LendingMarket', {
+            id: UID.bcs,
+            version: bcs.u64(),
+            reserves: bcs.vector(Reserve.bcs),
+            obligations: ObjectTable.bcs,
+            rate_limiter: RateLimiter.bcs,
+            fee_receiver: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            bad_debt_usd: Decimal.bcs,
+            bad_debt_limit_usd: Decimal.bcs,
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!LendingMarket.cachedBcs) {
+            LendingMarket.cachedBcs = LendingMarket.instantiateBcs();
+        }
+        return LendingMarket.cachedBcs;
+    }
+    static fromFields(typeArg, fields) {
+        return LendingMarket.reified(typeArg).new({
+            id: decodeFromFields(UID.reified(), fields.id),
+            version: decodeFromFields('u64', fields.version),
+            reserves: decodeFromFields(vector(Reserve.reified(typeArg)), fields.reserves),
+            obligations: decodeFromFields(ObjectTable.reified(phantom(ID.reified()), phantom(Obligation.reified(typeArg))), fields.obligations),
+            rateLimiter: decodeFromFields(RateLimiter.reified(), fields.rate_limiter),
+            feeReceiver: decodeFromFields('address', fields.fee_receiver),
+            badDebtUsd: decodeFromFields(Decimal.reified(), fields.bad_debt_usd),
+            badDebtLimitUsd: decodeFromFields(Decimal.reified(), fields.bad_debt_limit_usd),
+        });
+    }
+    static fromFieldsWithTypes(typeArg, item) {
+        if (!isLendingMarket(item.type)) {
+            throw new Error('not a LendingMarket type');
+        }
+        assertFieldsWithTypesArgsMatch(item, [typeArg]);
+        return LendingMarket.reified(typeArg).new({
+            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
+            version: decodeFromFieldsWithTypes('u64', item.fields.version),
+            reserves: decodeFromFieldsWithTypes(vector(Reserve.reified(typeArg)), item.fields.reserves),
+            obligations: decodeFromFieldsWithTypes(ObjectTable.reified(phantom(ID.reified()), phantom(Obligation.reified(typeArg))), item.fields.obligations),
+            rateLimiter: decodeFromFieldsWithTypes(RateLimiter.reified(), item.fields.rate_limiter),
+            feeReceiver: decodeFromFieldsWithTypes('address', item.fields.fee_receiver),
+            badDebtUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.bad_debt_usd),
+            badDebtLimitUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.bad_debt_limit_usd),
+        });
+    }
+    static fromBcs(typeArg, data) {
+        return LendingMarket.fromFields(typeArg, LendingMarket.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            id: this.id,
+            version: this.version.toString(),
+            reserves: fieldToJSON(`vector<${Reserve.$typeName}<${this.$typeArgs[0]}>>`, this.reserves),
+            obligations: this.obligations.toJSONField(),
+            rateLimiter: this.rateLimiter.toJSONField(),
+            feeReceiver: this.feeReceiver,
+            badDebtUsd: this.badDebtUsd.toJSONField(),
+            badDebtLimitUsd: this.badDebtLimitUsd.toJSONField(),
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(typeArg, field) {
+        return LendingMarket.reified(typeArg).new({
+            id: decodeFromJSONField(UID.reified(), field.id),
+            version: decodeFromJSONField('u64', field.version),
+            reserves: decodeFromJSONField(vector(Reserve.reified(typeArg)), field.reserves),
+            obligations: decodeFromJSONField(ObjectTable.reified(phantom(ID.reified()), phantom(Obligation.reified(typeArg))), field.obligations),
+            rateLimiter: decodeFromJSONField(RateLimiter.reified(), field.rateLimiter),
+            feeReceiver: decodeFromJSONField('address', field.feeReceiver),
+            badDebtUsd: decodeFromJSONField(Decimal.reified(), field.badDebtUsd),
+            badDebtLimitUsd: decodeFromJSONField(Decimal.reified(), field.badDebtLimitUsd),
+        });
+    }
+    static fromJSON(typeArg, json) {
+        if (json.$typeName !== LendingMarket.$typeName) {
+            throw new Error(`not a LendingMarket json object: expected '${LendingMarket.$typeName}' but got '${json.$typeName}'`);
+        }
+        assertReifiedTypeArgsMatch(composeSuiType(LendingMarket.$typeName, ...[extractType(typeArg)]), json.$typeArgs, [typeArg]);
+        return LendingMarket.fromJSONField(typeArg, json);
+    }
+    static fromCoreObject(typeArg, obj) {
+        if (!isLendingMarket(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a LendingMarket object`);
+        }
+        const gotTypeArgs = parseTypeName(obj.type).typeArgs;
+        if (gotTypeArgs.length !== 1) {
+            throw new Error(`type argument mismatch: expected 1 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 1; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType([typeArg][i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return LendingMarket.fromBcs(typeArg, obj.content);
+    }
+    static async fetch(client, typeArg, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isLendingMarket(object.type)) {
+            throw new Error(`object at id ${id} is not a LendingMarket object`);
+        }
+        const gotTypeArgs = parseTypeName(object.type).typeArgs;
+        if (gotTypeArgs.length !== 1) {
+            throw new Error(`type argument mismatch: expected 1 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 1; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType([typeArg][i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return LendingMarket.fromBcs(typeArg, object.content);
+    }
+}
+/* ============================== LendingMarketOwnerCap =============================== */
+export function isLendingMarketOwnerCap(type) {
+    type = compressSuiType(type);
+    return type.startsWith(`${getTypeOrigin('suilend', 'lending_market::LendingMarketOwnerCap')}::lending_market::LendingMarketOwnerCap` + '<');
+}
+export class LendingMarketOwnerCap {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::LendingMarketOwnerCap')}::lending_market::LendingMarketOwnerCap`;
+    }
+    static $numTypeParams = 1;
+    static $isPhantom = [true];
+    $typeName = LendingMarketOwnerCap.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = LendingMarketOwnerCap.$isPhantom;
+    id;
+    lendingMarketId;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(LendingMarketOwnerCap.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.id = fields.id;
+        this.lendingMarketId = fields.lendingMarketId;
+    }
+    static reified(P) {
+        const reifiedBcs = LendingMarketOwnerCap.bcs;
+        return {
+            get typeName() {
+                return LendingMarketOwnerCap.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(LendingMarketOwnerCap.$typeName, ...[extractType(P)]);
+            },
+            get typeArgs() {
+                return [extractType(P)];
+            },
+            isPhantom: LendingMarketOwnerCap.$isPhantom,
+            reifiedTypeArgs: [P],
+            fromFields: (fields) => LendingMarketOwnerCap.fromFields(P, fields),
+            fromFieldsWithTypes: (item) => LendingMarketOwnerCap.fromFieldsWithTypes(P, item),
+            fromBcs: (data) => LendingMarketOwnerCap.fromFields(P, reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => LendingMarketOwnerCap.fromJSONField(P, field),
+            fromJSON: (json) => LendingMarketOwnerCap.fromJSON(P, json),
+            fromCoreObject: (obj) => LendingMarketOwnerCap.fromCoreObject(P, obj),
+            fetch: async (client, id) => LendingMarketOwnerCap.fetch(client, P, id),
+            new: (fields) => {
+                return new LendingMarketOwnerCap([extractType(P)], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return LendingMarketOwnerCap.reified;
+    }
+    static phantom(P) {
+        return phantom(LendingMarketOwnerCap.reified(P));
+    }
+    static get p() {
+        return LendingMarketOwnerCap.phantom;
+    }
+    static instantiateBcs() {
+        return bcs.struct('LendingMarketOwnerCap', {
+            id: UID.bcs,
+            lending_market_id: ID.bcs,
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!LendingMarketOwnerCap.cachedBcs) {
+            LendingMarketOwnerCap.cachedBcs = LendingMarketOwnerCap.instantiateBcs();
+        }
+        return LendingMarketOwnerCap.cachedBcs;
+    }
+    static fromFields(typeArg, fields) {
+        return LendingMarketOwnerCap.reified(typeArg).new({
+            id: decodeFromFields(UID.reified(), fields.id),
+            lendingMarketId: decodeFromFields(ID.reified(), fields.lending_market_id),
+        });
+    }
+    static fromFieldsWithTypes(typeArg, item) {
+        if (!isLendingMarketOwnerCap(item.type)) {
+            throw new Error('not a LendingMarketOwnerCap type');
+        }
+        assertFieldsWithTypesArgsMatch(item, [typeArg]);
+        return LendingMarketOwnerCap.reified(typeArg).new({
+            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
+            lendingMarketId: decodeFromFieldsWithTypes(ID.reified(), item.fields.lending_market_id),
+        });
+    }
+    static fromBcs(typeArg, data) {
+        return LendingMarketOwnerCap.fromFields(typeArg, LendingMarketOwnerCap.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            id: this.id,
+            lendingMarketId: this.lendingMarketId,
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(typeArg, field) {
+        return LendingMarketOwnerCap.reified(typeArg).new({
+            id: decodeFromJSONField(UID.reified(), field.id),
+            lendingMarketId: decodeFromJSONField(ID.reified(), field.lendingMarketId),
+        });
+    }
+    static fromJSON(typeArg, json) {
+        if (json.$typeName !== LendingMarketOwnerCap.$typeName) {
+            throw new Error(`not a LendingMarketOwnerCap json object: expected '${LendingMarketOwnerCap.$typeName}' but got '${json.$typeName}'`);
+        }
+        assertReifiedTypeArgsMatch(composeSuiType(LendingMarketOwnerCap.$typeName, ...[extractType(typeArg)]), json.$typeArgs, [typeArg]);
+        return LendingMarketOwnerCap.fromJSONField(typeArg, json);
+    }
+    static fromCoreObject(typeArg, obj) {
+        if (!isLendingMarketOwnerCap(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a LendingMarketOwnerCap object`);
+        }
+        const gotTypeArgs = parseTypeName(obj.type).typeArgs;
+        if (gotTypeArgs.length !== 1) {
+            throw new Error(`type argument mismatch: expected 1 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 1; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType([typeArg][i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return LendingMarketOwnerCap.fromBcs(typeArg, obj.content);
+    }
+    static async fetch(client, typeArg, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isLendingMarketOwnerCap(object.type)) {
+            throw new Error(`object at id ${id} is not a LendingMarketOwnerCap object`);
+        }
+        const gotTypeArgs = parseTypeName(object.type).typeArgs;
+        if (gotTypeArgs.length !== 1) {
+            throw new Error(`type argument mismatch: expected 1 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 1; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType([typeArg][i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return LendingMarketOwnerCap.fromBcs(typeArg, object.content);
+    }
+}
+/* ============================== ObligationOwnerCap =============================== */
+export function isObligationOwnerCap(type) {
+    type = compressSuiType(type);
+    return type.startsWith(`${getTypeOrigin('suilend', 'lending_market::ObligationOwnerCap')}::lending_market::ObligationOwnerCap` + '<');
+}
+export class ObligationOwnerCap {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::ObligationOwnerCap')}::lending_market::ObligationOwnerCap`;
+    }
+    static $numTypeParams = 1;
+    static $isPhantom = [true];
+    $typeName = ObligationOwnerCap.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = ObligationOwnerCap.$isPhantom;
+    id;
+    obligationId;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(ObligationOwnerCap.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.id = fields.id;
+        this.obligationId = fields.obligationId;
+    }
+    static reified(P) {
+        const reifiedBcs = ObligationOwnerCap.bcs;
+        return {
+            get typeName() {
+                return ObligationOwnerCap.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(ObligationOwnerCap.$typeName, ...[extractType(P)]);
+            },
+            get typeArgs() {
+                return [extractType(P)];
+            },
+            isPhantom: ObligationOwnerCap.$isPhantom,
+            reifiedTypeArgs: [P],
+            fromFields: (fields) => ObligationOwnerCap.fromFields(P, fields),
+            fromFieldsWithTypes: (item) => ObligationOwnerCap.fromFieldsWithTypes(P, item),
+            fromBcs: (data) => ObligationOwnerCap.fromFields(P, reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => ObligationOwnerCap.fromJSONField(P, field),
+            fromJSON: (json) => ObligationOwnerCap.fromJSON(P, json),
+            fromCoreObject: (obj) => ObligationOwnerCap.fromCoreObject(P, obj),
+            fetch: async (client, id) => ObligationOwnerCap.fetch(client, P, id),
+            new: (fields) => {
+                return new ObligationOwnerCap([extractType(P)], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return ObligationOwnerCap.reified;
+    }
+    static phantom(P) {
+        return phantom(ObligationOwnerCap.reified(P));
+    }
+    static get p() {
+        return ObligationOwnerCap.phantom;
+    }
+    static instantiateBcs() {
+        return bcs.struct('ObligationOwnerCap', {
+            id: UID.bcs,
+            obligation_id: ID.bcs,
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!ObligationOwnerCap.cachedBcs) {
+            ObligationOwnerCap.cachedBcs = ObligationOwnerCap.instantiateBcs();
+        }
+        return ObligationOwnerCap.cachedBcs;
+    }
+    static fromFields(typeArg, fields) {
+        return ObligationOwnerCap.reified(typeArg).new({
+            id: decodeFromFields(UID.reified(), fields.id),
+            obligationId: decodeFromFields(ID.reified(), fields.obligation_id),
+        });
+    }
+    static fromFieldsWithTypes(typeArg, item) {
+        if (!isObligationOwnerCap(item.type)) {
+            throw new Error('not a ObligationOwnerCap type');
+        }
+        assertFieldsWithTypesArgsMatch(item, [typeArg]);
+        return ObligationOwnerCap.reified(typeArg).new({
+            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
+            obligationId: decodeFromFieldsWithTypes(ID.reified(), item.fields.obligation_id),
+        });
+    }
+    static fromBcs(typeArg, data) {
+        return ObligationOwnerCap.fromFields(typeArg, ObligationOwnerCap.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            id: this.id,
+            obligationId: this.obligationId,
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(typeArg, field) {
+        return ObligationOwnerCap.reified(typeArg).new({
+            id: decodeFromJSONField(UID.reified(), field.id),
+            obligationId: decodeFromJSONField(ID.reified(), field.obligationId),
+        });
+    }
+    static fromJSON(typeArg, json) {
+        if (json.$typeName !== ObligationOwnerCap.$typeName) {
+            throw new Error(`not a ObligationOwnerCap json object: expected '${ObligationOwnerCap.$typeName}' but got '${json.$typeName}'`);
+        }
+        assertReifiedTypeArgsMatch(composeSuiType(ObligationOwnerCap.$typeName, ...[extractType(typeArg)]), json.$typeArgs, [typeArg]);
+        return ObligationOwnerCap.fromJSONField(typeArg, json);
+    }
+    static fromCoreObject(typeArg, obj) {
+        if (!isObligationOwnerCap(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a ObligationOwnerCap object`);
+        }
+        const gotTypeArgs = parseTypeName(obj.type).typeArgs;
+        if (gotTypeArgs.length !== 1) {
+            throw new Error(`type argument mismatch: expected 1 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 1; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType([typeArg][i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return ObligationOwnerCap.fromBcs(typeArg, obj.content);
+    }
+    static async fetch(client, typeArg, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isObligationOwnerCap(object.type)) {
+            throw new Error(`object at id ${id} is not a ObligationOwnerCap object`);
+        }
+        const gotTypeArgs = parseTypeName(object.type).typeArgs;
+        if (gotTypeArgs.length !== 1) {
+            throw new Error(`type argument mismatch: expected 1 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 1; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType([typeArg][i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return ObligationOwnerCap.fromBcs(typeArg, object.content);
+    }
+}
+/* ============================== EmergencyPauseCap =============================== */
+export function isEmergencyPauseCap(type) {
+    type = compressSuiType(type);
+    return type.startsWith(`${getTypeOrigin('suilend', 'lending_market::EmergencyPauseCap')}::lending_market::EmergencyPauseCap` + '<');
+}
+/**
+ * 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 class EmergencyPauseCap {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::EmergencyPauseCap')}::lending_market::EmergencyPauseCap`;
+    }
+    static $numTypeParams = 1;
+    static $isPhantom = [true];
+    $typeName = EmergencyPauseCap.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = EmergencyPauseCap.$isPhantom;
+    id;
+    lendingMarketId;
+    generation;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(EmergencyPauseCap.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.id = fields.id;
+        this.lendingMarketId = fields.lendingMarketId;
+        this.generation = fields.generation;
+    }
+    static reified(P) {
+        const reifiedBcs = EmergencyPauseCap.bcs;
+        return {
+            get typeName() {
+                return EmergencyPauseCap.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(EmergencyPauseCap.$typeName, ...[extractType(P)]);
+            },
+            get typeArgs() {
+                return [extractType(P)];
+            },
+            isPhantom: EmergencyPauseCap.$isPhantom,
+            reifiedTypeArgs: [P],
+            fromFields: (fields) => EmergencyPauseCap.fromFields(P, fields),
+            fromFieldsWithTypes: (item) => EmergencyPauseCap.fromFieldsWithTypes(P, item),
+            fromBcs: (data) => EmergencyPauseCap.fromFields(P, reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => EmergencyPauseCap.fromJSONField(P, field),
+            fromJSON: (json) => EmergencyPauseCap.fromJSON(P, json),
+            fromCoreObject: (obj) => EmergencyPauseCap.fromCoreObject(P, obj),
+            fetch: async (client, id) => EmergencyPauseCap.fetch(client, P, id),
+            new: (fields) => {
+                return new EmergencyPauseCap([extractType(P)], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return EmergencyPauseCap.reified;
+    }
+    static phantom(P) {
+        return phantom(EmergencyPauseCap.reified(P));
+    }
+    static get p() {
+        return EmergencyPauseCap.phantom;
+    }
+    static instantiateBcs() {
+        return bcs.struct('EmergencyPauseCap', {
+            id: UID.bcs,
+            lending_market_id: ID.bcs,
+            generation: bcs.u64(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!EmergencyPauseCap.cachedBcs) {
+            EmergencyPauseCap.cachedBcs = EmergencyPauseCap.instantiateBcs();
+        }
+        return EmergencyPauseCap.cachedBcs;
+    }
+    static fromFields(typeArg, fields) {
+        return EmergencyPauseCap.reified(typeArg).new({
+            id: decodeFromFields(UID.reified(), fields.id),
+            lendingMarketId: decodeFromFields(ID.reified(), fields.lending_market_id),
+            generation: decodeFromFields('u64', fields.generation),
+        });
+    }
+    static fromFieldsWithTypes(typeArg, item) {
+        if (!isEmergencyPauseCap(item.type)) {
+            throw new Error('not a EmergencyPauseCap type');
+        }
+        assertFieldsWithTypesArgsMatch(item, [typeArg]);
+        return EmergencyPauseCap.reified(typeArg).new({
+            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
+            lendingMarketId: decodeFromFieldsWithTypes(ID.reified(), item.fields.lending_market_id),
+            generation: decodeFromFieldsWithTypes('u64', item.fields.generation),
+        });
+    }
+    static fromBcs(typeArg, data) {
+        return EmergencyPauseCap.fromFields(typeArg, EmergencyPauseCap.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            id: this.id,
+            lendingMarketId: this.lendingMarketId,
+            generation: this.generation.toString(),
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(typeArg, field) {
+        return EmergencyPauseCap.reified(typeArg).new({
+            id: decodeFromJSONField(UID.reified(), field.id),
+            lendingMarketId: decodeFromJSONField(ID.reified(), field.lendingMarketId),
+            generation: decodeFromJSONField('u64', field.generation),
+        });
+    }
+    static fromJSON(typeArg, json) {
+        if (json.$typeName !== EmergencyPauseCap.$typeName) {
+            throw new Error(`not a EmergencyPauseCap json object: expected '${EmergencyPauseCap.$typeName}' but got '${json.$typeName}'`);
+        }
+        assertReifiedTypeArgsMatch(composeSuiType(EmergencyPauseCap.$typeName, ...[extractType(typeArg)]), json.$typeArgs, [typeArg]);
+        return EmergencyPauseCap.fromJSONField(typeArg, json);
+    }
+    static fromCoreObject(typeArg, obj) {
+        if (!isEmergencyPauseCap(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a EmergencyPauseCap object`);
+        }
+        const gotTypeArgs = parseTypeName(obj.type).typeArgs;
+        if (gotTypeArgs.length !== 1) {
+            throw new Error(`type argument mismatch: expected 1 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 1; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType([typeArg][i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return EmergencyPauseCap.fromBcs(typeArg, obj.content);
+    }
+    static async fetch(client, typeArg, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isEmergencyPauseCap(object.type)) {
+            throw new Error(`object at id ${id} is not a EmergencyPauseCap object`);
+        }
+        const gotTypeArgs = parseTypeName(object.type).typeArgs;
+        if (gotTypeArgs.length !== 1) {
+            throw new Error(`type argument mismatch: expected 1 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 1; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType([typeArg][i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return EmergencyPauseCap.fromBcs(typeArg, object.content);
+    }
+}
+/* ============================== FeeReceiversKey =============================== */
+export function isFeeReceiversKey(type) {
+    type = compressSuiType(type);
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::FeeReceiversKey')}::lending_market::FeeReceiversKey`;
+}
+export class FeeReceiversKey {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::FeeReceiversKey')}::lending_market::FeeReceiversKey`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = FeeReceiversKey.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = FeeReceiversKey.$isPhantom;
+    dummyField;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(FeeReceiversKey.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.dummyField = fields.dummyField;
+    }
+    static reified() {
+        const reifiedBcs = FeeReceiversKey.bcs;
+        return {
+            get typeName() {
+                return FeeReceiversKey.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(FeeReceiversKey.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: FeeReceiversKey.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => FeeReceiversKey.fromFields(fields),
+            fromFieldsWithTypes: (item) => FeeReceiversKey.fromFieldsWithTypes(item),
+            fromBcs: (data) => FeeReceiversKey.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => FeeReceiversKey.fromJSONField(field),
+            fromJSON: (json) => FeeReceiversKey.fromJSON(json),
+            fromCoreObject: (obj) => FeeReceiversKey.fromCoreObject(obj),
+            fetch: async (client, id) => FeeReceiversKey.fetch(client, id),
+            new: (fields) => {
+                return new FeeReceiversKey([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return FeeReceiversKey.reified();
+    }
+    static phantom() {
+        return phantom(FeeReceiversKey.reified());
+    }
+    static get p() {
+        return FeeReceiversKey.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('FeeReceiversKey', {
+            dummy_field: bcs.bool(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!FeeReceiversKey.cachedBcs) {
+            FeeReceiversKey.cachedBcs = FeeReceiversKey.instantiateBcs();
+        }
+        return FeeReceiversKey.cachedBcs;
+    }
+    static fromFields(fields) {
+        return FeeReceiversKey.reified().new({
+            dummyField: decodeFromFields('bool', fields.dummy_field),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isFeeReceiversKey(item.type)) {
+            throw new Error('not a FeeReceiversKey type');
+        }
+        return FeeReceiversKey.reified().new({
+            dummyField: decodeFromFieldsWithTypes('bool', item.fields.dummy_field),
+        });
+    }
+    static fromBcs(data) {
+        return FeeReceiversKey.fromFields(FeeReceiversKey.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            dummyField: this.dummyField,
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return FeeReceiversKey.reified().new({
+            dummyField: decodeFromJSONField('bool', field.dummyField),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== FeeReceiversKey.$typeName) {
+            throw new Error(`not a FeeReceiversKey json object: expected '${FeeReceiversKey.$typeName}' but got '${json.$typeName}'`);
+        }
+        return FeeReceiversKey.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isFeeReceiversKey(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a FeeReceiversKey object`);
+        }
+        return FeeReceiversKey.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isFeeReceiversKey(object.type)) {
+            throw new Error(`object at id ${id} is not a FeeReceiversKey object`);
+        }
+        return FeeReceiversKey.fromBcs(object.content);
+    }
+}
+/* ============================== PauseKey =============================== */
+export function isPauseKey(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::lending_market::MintEvent`;
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::PauseKey')}::lending_market::PauseKey`;
 }
-export class MintEvent {
+export class PauseKey {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::lending_market::MintEvent`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::PauseKey')}::lending_market::PauseKey`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
-    $typeName = MintEvent.$typeName;
+    $typeName = PauseKey.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = MintEvent.$isPhantom;
-    lendingMarketId;
-    coinType;
-    reserveId;
-    liquidityAmount;
-    ctokenAmount;
+    $isPhantom = PauseKey.$isPhantom;
+    dummyField;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(MintEvent.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(PauseKey.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.lendingMarketId = fields.lendingMarketId;
-        this.coinType = fields.coinType;
-        this.reserveId = fields.reserveId;
-        this.liquidityAmount = fields.liquidityAmount;
-        this.ctokenAmount = fields.ctokenAmount;
+        this.dummyField = fields.dummyField;
     }
     static reified() {
+        const reifiedBcs = PauseKey.bcs;
         return {
-            typeName: MintEvent.$typeName,
-            fullTypeName: composeSuiType(MintEvent.$typeName, ...[]),
+            get typeName() {
+                return PauseKey.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(PauseKey.$typeName, ...[]);
+            },
             typeArgs: [],
-            isPhantom: MintEvent.$isPhantom,
+            isPhantom: PauseKey.$isPhantom,
             reifiedTypeArgs: [],
-            fromFields: (fields) => MintEvent.fromFields(fields),
-            fromFieldsWithTypes: (item) => MintEvent.fromFieldsWithTypes(item),
-            fromBcs: (data) => MintEvent.fromBcs(data),
-            bcs: MintEvent.bcs,
-            fromJSONField: (field) => MintEvent.fromJSONField(field),
-            fromJSON: (json) => MintEvent.fromJSON(json),
-            fetch: async (client, id) => MintEvent.fetch(client, id),
+            fromFields: (fields) => PauseKey.fromFields(fields),
+            fromFieldsWithTypes: (item) => PauseKey.fromFieldsWithTypes(item),
+            fromBcs: (data) => PauseKey.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => PauseKey.fromJSONField(field),
+            fromJSON: (json) => PauseKey.fromJSON(json),
+            fromCoreObject: (obj) => PauseKey.fromCoreObject(obj),
+            fetch: async (client, id) => PauseKey.fetch(client, id),
             new: (fields) => {
-                return new MintEvent([], fields);
+                return new PauseKey([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return MintEvent.reified();
+        return PauseKey.reified();
     }
     static phantom() {
-        return phantom(MintEvent.reified());
+        return phantom(PauseKey.reified());
     }
     static get p() {
-        return MintEvent.phantom();
+        return PauseKey.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('PauseKey', {
+            dummy_field: bcs.bool(),
+        });
     }
+    static cachedBcs = null;
     static get bcs() {
-        return bcs.struct("MintEvent", {
-            lending_market_id: bcs
-                .bytes(32)
-                .transform({
-                input: (val) => fromHex(val),
-                output: (val) => toHex(val),
-            }),
-            coin_type: TypeName.bcs,
-            reserve_id: bcs
-                .bytes(32)
-                .transform({
+        if (!PauseKey.cachedBcs) {
+            PauseKey.cachedBcs = PauseKey.instantiateBcs();
+        }
+        return PauseKey.cachedBcs;
+    }
+    static fromFields(fields) {
+        return PauseKey.reified().new({
+            dummyField: decodeFromFields('bool', fields.dummy_field),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isPauseKey(item.type)) {
+            throw new Error('not a PauseKey type');
+        }
+        return PauseKey.reified().new({
+            dummyField: decodeFromFieldsWithTypes('bool', item.fields.dummy_field),
+        });
+    }
+    static fromBcs(data) {
+        return PauseKey.fromFields(PauseKey.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            dummyField: this.dummyField,
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return PauseKey.reified().new({
+            dummyField: decodeFromJSONField('bool', field.dummyField),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== PauseKey.$typeName) {
+            throw new Error(`not a PauseKey json object: expected '${PauseKey.$typeName}' but got '${json.$typeName}'`);
+        }
+        return PauseKey.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isPauseKey(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a PauseKey object`);
+        }
+        return PauseKey.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isPauseKey(object.type)) {
+            throw new Error(`object at id ${id} is not a PauseKey object`);
+        }
+        return PauseKey.fromBcs(object.content);
+    }
+}
+/* ============================== PauseCapGenerationKey =============================== */
+export function isPauseCapGenerationKey(type) {
+    type = compressSuiType(type);
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::PauseCapGenerationKey')}::lending_market::PauseCapGenerationKey`;
+}
+export class PauseCapGenerationKey {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::PauseCapGenerationKey')}::lending_market::PauseCapGenerationKey`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = PauseCapGenerationKey.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = PauseCapGenerationKey.$isPhantom;
+    dummyField;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(PauseCapGenerationKey.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.dummyField = fields.dummyField;
+    }
+    static reified() {
+        const reifiedBcs = PauseCapGenerationKey.bcs;
+        return {
+            get typeName() {
+                return PauseCapGenerationKey.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(PauseCapGenerationKey.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: PauseCapGenerationKey.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => PauseCapGenerationKey.fromFields(fields),
+            fromFieldsWithTypes: (item) => PauseCapGenerationKey.fromFieldsWithTypes(item),
+            fromBcs: (data) => PauseCapGenerationKey.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => PauseCapGenerationKey.fromJSONField(field),
+            fromJSON: (json) => PauseCapGenerationKey.fromJSON(json),
+            fromCoreObject: (obj) => PauseCapGenerationKey.fromCoreObject(obj),
+            fetch: async (client, id) => PauseCapGenerationKey.fetch(client, id),
+            new: (fields) => {
+                return new PauseCapGenerationKey([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return PauseCapGenerationKey.reified();
+    }
+    static phantom() {
+        return phantom(PauseCapGenerationKey.reified());
+    }
+    static get p() {
+        return PauseCapGenerationKey.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('PauseCapGenerationKey', {
+            dummy_field: bcs.bool(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!PauseCapGenerationKey.cachedBcs) {
+            PauseCapGenerationKey.cachedBcs = PauseCapGenerationKey.instantiateBcs();
+        }
+        return PauseCapGenerationKey.cachedBcs;
+    }
+    static fromFields(fields) {
+        return PauseCapGenerationKey.reified().new({
+            dummyField: decodeFromFields('bool', fields.dummy_field),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isPauseCapGenerationKey(item.type)) {
+            throw new Error('not a PauseCapGenerationKey type');
+        }
+        return PauseCapGenerationKey.reified().new({
+            dummyField: decodeFromFieldsWithTypes('bool', item.fields.dummy_field),
+        });
+    }
+    static fromBcs(data) {
+        return PauseCapGenerationKey.fromFields(PauseCapGenerationKey.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            dummyField: this.dummyField,
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return PauseCapGenerationKey.reified().new({
+            dummyField: decodeFromJSONField('bool', field.dummyField),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== PauseCapGenerationKey.$typeName) {
+            throw new Error(`not a PauseCapGenerationKey json object: expected '${PauseCapGenerationKey.$typeName}' but got '${json.$typeName}'`);
+        }
+        return PauseCapGenerationKey.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isPauseCapGenerationKey(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a PauseCapGenerationKey object`);
+        }
+        return PauseCapGenerationKey.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isPauseCapGenerationKey(object.type)) {
+            throw new Error(`object at id ${id} is not a PauseCapGenerationKey object`);
+        }
+        return PauseCapGenerationKey.fromBcs(object.content);
+    }
+}
+/* ============================== FeeReceivers =============================== */
+export function isFeeReceivers(type) {
+    type = compressSuiType(type);
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::FeeReceivers')}::lending_market::FeeReceivers`;
+}
+export class FeeReceivers {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::FeeReceivers')}::lending_market::FeeReceivers`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = FeeReceivers.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = FeeReceivers.$isPhantom;
+    receivers;
+    weights;
+    totalWeight;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(FeeReceivers.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.receivers = fields.receivers;
+        this.weights = fields.weights;
+        this.totalWeight = fields.totalWeight;
+    }
+    static reified() {
+        const reifiedBcs = FeeReceivers.bcs;
+        return {
+            get typeName() {
+                return FeeReceivers.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(FeeReceivers.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: FeeReceivers.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => FeeReceivers.fromFields(fields),
+            fromFieldsWithTypes: (item) => FeeReceivers.fromFieldsWithTypes(item),
+            fromBcs: (data) => FeeReceivers.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => FeeReceivers.fromJSONField(field),
+            fromJSON: (json) => FeeReceivers.fromJSON(json),
+            fromCoreObject: (obj) => FeeReceivers.fromCoreObject(obj),
+            fetch: async (client, id) => FeeReceivers.fetch(client, id),
+            new: (fields) => {
+                return new FeeReceivers([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return FeeReceivers.reified();
+    }
+    static phantom() {
+        return phantom(FeeReceivers.reified());
+    }
+    static get p() {
+        return FeeReceivers.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('FeeReceivers', {
+            receivers: bcs.vector(bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
-            }),
-            liquidity_amount: bcs.u64(),
-            ctoken_amount: bcs.u64(),
+            })),
+            weights: bcs.vector(bcs.u64()),
+            total_weight: bcs.u64(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!FeeReceivers.cachedBcs) {
+            FeeReceivers.cachedBcs = FeeReceivers.instantiateBcs();
+        }
+        return FeeReceivers.cachedBcs;
+    }
     static fromFields(fields) {
-        return MintEvent.reified().new({
-            lendingMarketId: decodeFromFields("address", fields.lending_market_id),
-            coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
-            reserveId: decodeFromFields("address", fields.reserve_id),
-            liquidityAmount: decodeFromFields("u64", fields.liquidity_amount),
-            ctokenAmount: decodeFromFields("u64", fields.ctoken_amount),
+        return FeeReceivers.reified().new({
+            receivers: decodeFromFields(vector('address'), fields.receivers),
+            weights: decodeFromFields(vector('u64'), fields.weights),
+            totalWeight: decodeFromFields('u64', fields.total_weight),
         });
     }
     static fromFieldsWithTypes(item) {
-        if (!isMintEvent(item.type)) {
-            throw new Error("not a MintEvent type");
+        if (!isFeeReceivers(item.type)) {
+            throw new Error('not a FeeReceivers type');
         }
-        return MintEvent.reified().new({
-            lendingMarketId: decodeFromFieldsWithTypes("address", item.fields.lending_market_id),
-            coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
-            reserveId: decodeFromFieldsWithTypes("address", item.fields.reserve_id),
-            liquidityAmount: decodeFromFieldsWithTypes("u64", item.fields.liquidity_amount),
-            ctokenAmount: decodeFromFieldsWithTypes("u64", item.fields.ctoken_amount),
+        return FeeReceivers.reified().new({
+            receivers: decodeFromFieldsWithTypes(vector('address'), item.fields.receivers),
+            weights: decodeFromFieldsWithTypes(vector('u64'), item.fields.weights),
+            totalWeight: decodeFromFieldsWithTypes('u64', item.fields.total_weight),
         });
     }
     static fromBcs(data) {
-        return MintEvent.fromFields(MintEvent.bcs.parse(data));
+        return FeeReceivers.fromFields(FeeReceivers.bcs.parse(data));
     }
     toJSONField() {
         return {
-            lendingMarketId: this.lendingMarketId,
-            coinType: this.coinType.toJSONField(),
-            reserveId: this.reserveId,
-            liquidityAmount: this.liquidityAmount.toString(),
-            ctokenAmount: this.ctokenAmount.toString(),
+            receivers: fieldToJSON(`vector<address>`, this.receivers),
+            weights: fieldToJSON(`vector<u64>`, this.weights),
+            totalWeight: this.totalWeight.toString(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
-        return MintEvent.reified().new({
-            lendingMarketId: decodeFromJSONField("address", field.lendingMarketId),
-            coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
-            reserveId: decodeFromJSONField("address", field.reserveId),
-            liquidityAmount: decodeFromJSONField("u64", field.liquidityAmount),
-            ctokenAmount: decodeFromJSONField("u64", field.ctokenAmount),
+        return FeeReceivers.reified().new({
+            receivers: decodeFromJSONField(vector('address'), field.receivers),
+            weights: decodeFromJSONField(vector('u64'), field.weights),
+            totalWeight: decodeFromJSONField('u64', field.totalWeight),
         });
     }
     static fromJSON(json) {
-        if (json.$typeName !== MintEvent.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+        if (json.$typeName !== FeeReceivers.$typeName) {
+            throw new Error(`not a FeeReceivers json object: expected '${FeeReceivers.$typeName}' but got '${json.$typeName}'`);
         }
-        return MintEvent.fromJSONField(json);
+        return FeeReceivers.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isFeeReceivers(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a FeeReceivers object`);
+        }
+        return FeeReceivers.fromBcs(obj.content);
     }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isMintEvent(object.type)) {
-            throw new Error(`object at id ${id} is not a MintEvent object`);
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isFeeReceivers(object.type)) {
+            throw new Error(`object at id ${id} is not a FeeReceivers object`);
         }
-        return MintEvent.fromBcs(object.content);
+        return FeeReceivers.fromBcs(object.content);
     }
 }
-/* ============================== RedeemEvent =============================== */
-export function isRedeemEvent(type) {
+/* ============================== RateLimiterExemption =============================== */
+export function isRateLimiterExemption(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::lending_market::RedeemEvent`;
+    return type.startsWith(`${getTypeOrigin('suilend', 'lending_market::RateLimiterExemption')}::lending_market::RateLimiterExemption` + '<');
 }
-export class RedeemEvent {
+export class RateLimiterExemption {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::lending_market::RedeemEvent`;
-    static $numTypeParams = 0;
-    static $isPhantom = [];
-    $typeName = RedeemEvent.$typeName;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::RateLimiterExemption')}::lending_market::RateLimiterExemption`;
+    }
+    static $numTypeParams = 2;
+    static $isPhantom = [true, true];
+    $typeName = RateLimiterExemption.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = RedeemEvent.$isPhantom;
-    lendingMarketId;
-    coinType;
-    reserveId;
-    ctokenAmount;
-    liquidityAmount;
+    $isPhantom = RateLimiterExemption.$isPhantom;
+    amount;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(RedeemEvent.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(RateLimiterExemption.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.lendingMarketId = fields.lendingMarketId;
-        this.coinType = fields.coinType;
-        this.reserveId = fields.reserveId;
-        this.ctokenAmount = fields.ctokenAmount;
-        this.liquidityAmount = fields.liquidityAmount;
+        this.amount = fields.amount;
     }
-    static reified() {
+    static reified(P, T) {
+        const reifiedBcs = RateLimiterExemption.bcs;
         return {
-            typeName: RedeemEvent.$typeName,
-            fullTypeName: composeSuiType(RedeemEvent.$typeName, ...[]),
-            typeArgs: [],
-            isPhantom: RedeemEvent.$isPhantom,
-            reifiedTypeArgs: [],
-            fromFields: (fields) => RedeemEvent.fromFields(fields),
-            fromFieldsWithTypes: (item) => RedeemEvent.fromFieldsWithTypes(item),
-            fromBcs: (data) => RedeemEvent.fromBcs(data),
-            bcs: RedeemEvent.bcs,
-            fromJSONField: (field) => RedeemEvent.fromJSONField(field),
-            fromJSON: (json) => RedeemEvent.fromJSON(json),
-            fetch: async (client, id) => RedeemEvent.fetch(client, id),
+            get typeName() {
+                return RateLimiterExemption.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(RateLimiterExemption.$typeName, ...[extractType(P), extractType(T)]);
+            },
+            get typeArgs() {
+                return [extractType(P), extractType(T)];
+            },
+            isPhantom: RateLimiterExemption.$isPhantom,
+            reifiedTypeArgs: [P, T],
+            fromFields: (fields) => RateLimiterExemption.fromFields([P, T], fields),
+            fromFieldsWithTypes: (item) => RateLimiterExemption.fromFieldsWithTypes([P, T], item),
+            fromBcs: (data) => RateLimiterExemption.fromFields([P, T], reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => RateLimiterExemption.fromJSONField([P, T], field),
+            fromJSON: (json) => RateLimiterExemption.fromJSON([P, T], json),
+            fromCoreObject: (obj) => RateLimiterExemption.fromCoreObject([P, T], obj),
+            fetch: async (client, id) => RateLimiterExemption.fetch(client, [P, T], id),
             new: (fields) => {
-                return new RedeemEvent([], fields);
+                return new RateLimiterExemption([extractType(P), extractType(T)], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return RedeemEvent.reified();
+        return RateLimiterExemption.reified;
     }
-    static phantom() {
-        return phantom(RedeemEvent.reified());
+    static phantom(P, T) {
+        return phantom(RateLimiterExemption.reified(P, T));
     }
     static get p() {
-        return RedeemEvent.phantom();
+        return RateLimiterExemption.phantom;
     }
-    static get bcs() {
-        return bcs.struct("RedeemEvent", {
-            lending_market_id: bcs
-                .bytes(32)
-                .transform({
-                input: (val) => fromHex(val),
-                output: (val) => toHex(val),
-            }),
-            coin_type: TypeName.bcs,
-            reserve_id: bcs
-                .bytes(32)
-                .transform({
-                input: (val) => fromHex(val),
-                output: (val) => toHex(val),
-            }),
-            ctoken_amount: bcs.u64(),
-            liquidity_amount: bcs.u64(),
+    static instantiateBcs() {
+        return bcs.struct('RateLimiterExemption', {
+            amount: bcs.u64(),
         });
     }
-    static fromFields(fields) {
-        return RedeemEvent.reified().new({
-            lendingMarketId: decodeFromFields("address", fields.lending_market_id),
-            coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
-            reserveId: decodeFromFields("address", fields.reserve_id),
-            ctokenAmount: decodeFromFields("u64", fields.ctoken_amount),
-            liquidityAmount: decodeFromFields("u64", fields.liquidity_amount),
+    static cachedBcs = null;
+    static get bcs() {
+        if (!RateLimiterExemption.cachedBcs) {
+            RateLimiterExemption.cachedBcs = RateLimiterExemption.instantiateBcs();
+        }
+        return RateLimiterExemption.cachedBcs;
+    }
+    static fromFields(typeArgs, fields) {
+        return RateLimiterExemption.reified(typeArgs[0], typeArgs[1]).new({
+            amount: decodeFromFields('u64', fields.amount),
         });
     }
-    static fromFieldsWithTypes(item) {
-        if (!isRedeemEvent(item.type)) {
-            throw new Error("not a RedeemEvent type");
+    static fromFieldsWithTypes(typeArgs, item) {
+        if (!isRateLimiterExemption(item.type)) {
+            throw new Error('not a RateLimiterExemption type');
         }
-        return RedeemEvent.reified().new({
-            lendingMarketId: decodeFromFieldsWithTypes("address", item.fields.lending_market_id),
-            coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
-            reserveId: decodeFromFieldsWithTypes("address", item.fields.reserve_id),
-            ctokenAmount: decodeFromFieldsWithTypes("u64", item.fields.ctoken_amount),
-            liquidityAmount: decodeFromFieldsWithTypes("u64", item.fields.liquidity_amount),
+        assertFieldsWithTypesArgsMatch(item, typeArgs);
+        return RateLimiterExemption.reified(typeArgs[0], typeArgs[1]).new({
+            amount: decodeFromFieldsWithTypes('u64', item.fields.amount),
         });
     }
-    static fromBcs(data) {
-        return RedeemEvent.fromFields(RedeemEvent.bcs.parse(data));
+    static fromBcs(typeArgs, data) {
+        return RateLimiterExemption.fromFields(typeArgs, RateLimiterExemption.bcs.parse(data));
     }
     toJSONField() {
         return {
-            lendingMarketId: this.lendingMarketId,
-            coinType: this.coinType.toJSONField(),
-            reserveId: this.reserveId,
-            ctokenAmount: this.ctokenAmount.toString(),
-            liquidityAmount: this.liquidityAmount.toString(),
+            amount: this.amount.toString(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
-    static fromJSONField(field) {
-        return RedeemEvent.reified().new({
-            lendingMarketId: decodeFromJSONField("address", field.lendingMarketId),
-            coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
-            reserveId: decodeFromJSONField("address", field.reserveId),
-            ctokenAmount: decodeFromJSONField("u64", field.ctokenAmount),
-            liquidityAmount: decodeFromJSONField("u64", field.liquidityAmount),
+    static fromJSONField(typeArgs, field) {
+        return RateLimiterExemption.reified(typeArgs[0], typeArgs[1]).new({
+            amount: decodeFromJSONField('u64', field.amount),
         });
     }
-    static fromJSON(json) {
-        if (json.$typeName !== RedeemEvent.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+    static fromJSON(typeArgs, json) {
+        if (json.$typeName !== RateLimiterExemption.$typeName) {
+            throw new Error(`not a RateLimiterExemption json object: expected '${RateLimiterExemption.$typeName}' but got '${json.$typeName}'`);
         }
-        return RedeemEvent.fromJSONField(json);
+        assertReifiedTypeArgsMatch(composeSuiType(RateLimiterExemption.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs);
+        return RateLimiterExemption.fromJSONField(typeArgs, json);
     }
-    static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isRedeemEvent(object.type)) {
-            throw new Error(`object at id ${id} is not a RedeemEvent object`);
+    static fromCoreObject(typeArgs, obj) {
+        if (!isRateLimiterExemption(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a RateLimiterExemption object`);
         }
-        return RedeemEvent.fromBcs(object.content);
+        const gotTypeArgs = parseTypeName(obj.type).typeArgs;
+        if (gotTypeArgs.length !== 2) {
+            throw new Error(`type argument mismatch: expected 2 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 2; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType(typeArgs[i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return RateLimiterExemption.fromBcs(typeArgs, obj.content);
+    }
+    static async fetch(client, typeArgs, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isRateLimiterExemption(object.type)) {
+            throw new Error(`object at id ${id} is not a RateLimiterExemption object`);
+        }
+        const gotTypeArgs = parseTypeName(object.type).typeArgs;
+        if (gotTypeArgs.length !== 2) {
+            throw new Error(`type argument mismatch: expected 2 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 2; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType(typeArgs[i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return RateLimiterExemption.fromBcs(typeArgs, object.content);
     }
 }
-/* ============================== BorrowEvent =============================== */
-export function isBorrowEvent(type) {
+/* ============================== MintEvent =============================== */
+export function isMintEvent(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::lending_market::BorrowEvent`;
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::MintEvent')}::lending_market::MintEvent`;
 }
-export class BorrowEvent {
+export class MintEvent {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::lending_market::BorrowEvent`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::MintEvent')}::lending_market::MintEvent`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
-    $typeName = BorrowEvent.$typeName;
+    $typeName = MintEvent.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = BorrowEvent.$isPhantom;
+    $isPhantom = MintEvent.$isPhantom;
     lendingMarketId;
     coinType;
     reserveId;
-    obligationId;
     liquidityAmount;
-    originationFeeAmount;
+    ctokenAmount;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(BorrowEvent.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(MintEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
         this.coinType = fields.coinType;
         this.reserveId = fields.reserveId;
-        this.obligationId = fields.obligationId;
         this.liquidityAmount = fields.liquidityAmount;
-        this.originationFeeAmount = fields.originationFeeAmount;
+        this.ctokenAmount = fields.ctokenAmount;
     }
     static reified() {
+        const reifiedBcs = MintEvent.bcs;
         return {
-            typeName: BorrowEvent.$typeName,
-            fullTypeName: composeSuiType(BorrowEvent.$typeName, ...[]),
+            get typeName() {
+                return MintEvent.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(MintEvent.$typeName, ...[]);
+            },
             typeArgs: [],
-            isPhantom: BorrowEvent.$isPhantom,
+            isPhantom: MintEvent.$isPhantom,
             reifiedTypeArgs: [],
-            fromFields: (fields) => BorrowEvent.fromFields(fields),
-            fromFieldsWithTypes: (item) => BorrowEvent.fromFieldsWithTypes(item),
-            fromBcs: (data) => BorrowEvent.fromBcs(data),
-            bcs: BorrowEvent.bcs,
-            fromJSONField: (field) => BorrowEvent.fromJSONField(field),
-            fromJSON: (json) => BorrowEvent.fromJSON(json),
-            fetch: async (client, id) => BorrowEvent.fetch(client, id),
+            fromFields: (fields) => MintEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => MintEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => MintEvent.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => MintEvent.fromJSONField(field),
+            fromJSON: (json) => MintEvent.fromJSON(json),
+            fromCoreObject: (obj) => MintEvent.fromCoreObject(obj),
+            fetch: async (client, id) => MintEvent.fetch(client, id),
             new: (fields) => {
-                return new BorrowEvent([], fields);
+                return new MintEvent([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return BorrowEvent.reified();
+        return MintEvent.reified();
     }
     static phantom() {
-        return phantom(BorrowEvent.reified());
+        return phantom(MintEvent.reified());
     }
     static get p() {
-        return BorrowEvent.phantom();
+        return MintEvent.phantom();
     }
-    static get bcs() {
-        return bcs.struct("BorrowEvent", {
-            lending_market_id: bcs
-                .bytes(32)
-                .transform({
+    static instantiateBcs() {
+        return bcs.struct('MintEvent', {
+            lending_market_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
             coin_type: TypeName.bcs,
-            reserve_id: bcs
-                .bytes(32)
-                .transform({
-                input: (val) => fromHex(val),
-                output: (val) => toHex(val),
-            }),
-            obligation_id: bcs
-                .bytes(32)
-                .transform({
+            reserve_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
             liquidity_amount: bcs.u64(),
-            origination_fee_amount: bcs.u64(),
+            ctoken_amount: bcs.u64(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!MintEvent.cachedBcs) {
+            MintEvent.cachedBcs = MintEvent.instantiateBcs();
+        }
+        return MintEvent.cachedBcs;
+    }
     static fromFields(fields) {
-        return BorrowEvent.reified().new({
-            lendingMarketId: decodeFromFields("address", fields.lending_market_id),
+        return MintEvent.reified().new({
+            lendingMarketId: decodeFromFields('address', fields.lending_market_id),
             coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
-            reserveId: decodeFromFields("address", fields.reserve_id),
-            obligationId: decodeFromFields("address", fields.obligation_id),
-            liquidityAmount: decodeFromFields("u64", fields.liquidity_amount),
-            originationFeeAmount: decodeFromFields("u64", fields.origination_fee_amount),
+            reserveId: decodeFromFields('address', fields.reserve_id),
+            liquidityAmount: decodeFromFields('u64', fields.liquidity_amount),
+            ctokenAmount: decodeFromFields('u64', fields.ctoken_amount),
         });
     }
     static fromFieldsWithTypes(item) {
-        if (!isBorrowEvent(item.type)) {
-            throw new Error("not a BorrowEvent type");
+        if (!isMintEvent(item.type)) {
+            throw new Error('not a MintEvent type');
         }
-        return BorrowEvent.reified().new({
-            lendingMarketId: decodeFromFieldsWithTypes("address", item.fields.lending_market_id),
+        return MintEvent.reified().new({
+            lendingMarketId: decodeFromFieldsWithTypes('address', item.fields.lending_market_id),
             coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
-            reserveId: decodeFromFieldsWithTypes("address", item.fields.reserve_id),
-            obligationId: decodeFromFieldsWithTypes("address", item.fields.obligation_id),
-            liquidityAmount: decodeFromFieldsWithTypes("u64", item.fields.liquidity_amount),
-            originationFeeAmount: decodeFromFieldsWithTypes("u64", item.fields.origination_fee_amount),
+            reserveId: decodeFromFieldsWithTypes('address', item.fields.reserve_id),
+            liquidityAmount: decodeFromFieldsWithTypes('u64', item.fields.liquidity_amount),
+            ctokenAmount: decodeFromFieldsWithTypes('u64', item.fields.ctoken_amount),
         });
     }
     static fromBcs(data) {
-        return BorrowEvent.fromFields(BorrowEvent.bcs.parse(data));
+        return MintEvent.fromFields(MintEvent.bcs.parse(data));
     }
     toJSONField() {
         return {
             lendingMarketId: this.lendingMarketId,
-            coinType: this.coinType.toJSONField(),
+            coinType: this.coinType,
             reserveId: this.reserveId,
-            obligationId: this.obligationId,
             liquidityAmount: this.liquidityAmount.toString(),
-            originationFeeAmount: this.originationFeeAmount.toString(),
+            ctokenAmount: this.ctokenAmount.toString(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
-        return BorrowEvent.reified().new({
-            lendingMarketId: decodeFromJSONField("address", field.lendingMarketId),
+        return MintEvent.reified().new({
+            lendingMarketId: decodeFromJSONField('address', field.lendingMarketId),
             coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
-            reserveId: decodeFromJSONField("address", field.reserveId),
-            obligationId: decodeFromJSONField("address", field.obligationId),
-            liquidityAmount: decodeFromJSONField("u64", field.liquidityAmount),
-            originationFeeAmount: decodeFromJSONField("u64", field.originationFeeAmount),
+            reserveId: decodeFromJSONField('address', field.reserveId),
+            liquidityAmount: decodeFromJSONField('u64', field.liquidityAmount),
+            ctokenAmount: decodeFromJSONField('u64', field.ctokenAmount),
         });
     }
     static fromJSON(json) {
-        if (json.$typeName !== BorrowEvent.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+        if (json.$typeName !== MintEvent.$typeName) {
+            throw new Error(`not a MintEvent json object: expected '${MintEvent.$typeName}' but got '${json.$typeName}'`);
         }
-        return BorrowEvent.fromJSONField(json);
+        return MintEvent.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isMintEvent(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a MintEvent object`);
+        }
+        return MintEvent.fromBcs(obj.content);
     }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isBorrowEvent(object.type)) {
-            throw new Error(`object at id ${id} is not a BorrowEvent object`);
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isMintEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a MintEvent object`);
         }
-        return BorrowEvent.fromBcs(object.content);
+        return MintEvent.fromBcs(object.content);
     }
 }
-/* ============================== ClaimRewardEvent =============================== */
-export function isClaimRewardEvent(type) {
+/* ============================== RedeemEvent =============================== */
+export function isRedeemEvent(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::lending_market::ClaimRewardEvent`;
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::RedeemEvent')}::lending_market::RedeemEvent`;
 }
-export class ClaimRewardEvent {
+export class RedeemEvent {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::lending_market::ClaimRewardEvent`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::RedeemEvent')}::lending_market::RedeemEvent`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
-    $typeName = ClaimRewardEvent.$typeName;
+    $typeName = RedeemEvent.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = ClaimRewardEvent.$isPhantom;
+    $isPhantom = RedeemEvent.$isPhantom;
     lendingMarketId;
-    reserveId;
-    obligationId;
-    isDepositReward;
-    poolRewardId;
     coinType;
+    reserveId;
+    ctokenAmount;
     liquidityAmount;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(ClaimRewardEvent.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(RedeemEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
-        this.reserveId = fields.reserveId;
-        this.obligationId = fields.obligationId;
-        this.isDepositReward = fields.isDepositReward;
-        this.poolRewardId = fields.poolRewardId;
         this.coinType = fields.coinType;
+        this.reserveId = fields.reserveId;
+        this.ctokenAmount = fields.ctokenAmount;
         this.liquidityAmount = fields.liquidityAmount;
     }
     static reified() {
+        const reifiedBcs = RedeemEvent.bcs;
         return {
-            typeName: ClaimRewardEvent.$typeName,
-            fullTypeName: composeSuiType(ClaimRewardEvent.$typeName, ...[]),
+            get typeName() {
+                return RedeemEvent.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(RedeemEvent.$typeName, ...[]);
+            },
             typeArgs: [],
-            isPhantom: ClaimRewardEvent.$isPhantom,
+            isPhantom: RedeemEvent.$isPhantom,
             reifiedTypeArgs: [],
-            fromFields: (fields) => ClaimRewardEvent.fromFields(fields),
-            fromFieldsWithTypes: (item) => ClaimRewardEvent.fromFieldsWithTypes(item),
-            fromBcs: (data) => ClaimRewardEvent.fromBcs(data),
-            bcs: ClaimRewardEvent.bcs,
-            fromJSONField: (field) => ClaimRewardEvent.fromJSONField(field),
-            fromJSON: (json) => ClaimRewardEvent.fromJSON(json),
-            fetch: async (client, id) => ClaimRewardEvent.fetch(client, id),
+            fromFields: (fields) => RedeemEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => RedeemEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => RedeemEvent.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => RedeemEvent.fromJSONField(field),
+            fromJSON: (json) => RedeemEvent.fromJSON(json),
+            fromCoreObject: (obj) => RedeemEvent.fromCoreObject(obj),
+            fetch: async (client, id) => RedeemEvent.fetch(client, id),
             new: (fields) => {
-                return new ClaimRewardEvent([], fields);
+                return new RedeemEvent([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return ClaimRewardEvent.reified();
+        return RedeemEvent.reified();
     }
     static phantom() {
-        return phantom(ClaimRewardEvent.reified());
+        return phantom(RedeemEvent.reified());
     }
     static get p() {
-        return ClaimRewardEvent.phantom();
+        return RedeemEvent.phantom();
     }
-    static get bcs() {
-        return bcs.struct("ClaimRewardEvent", {
-            lending_market_id: bcs
-                .bytes(32)
-                .transform({
-                input: (val) => fromHex(val),
-                output: (val) => toHex(val),
-            }),
-            reserve_id: bcs
-                .bytes(32)
-                .transform({
-                input: (val) => fromHex(val),
-                output: (val) => toHex(val),
-            }),
-            obligation_id: bcs
-                .bytes(32)
-                .transform({
+    static instantiateBcs() {
+        return bcs.struct('RedeemEvent', {
+            lending_market_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
-            is_deposit_reward: bcs.bool(),
-            pool_reward_id: bcs
-                .bytes(32)
-                .transform({
+            coin_type: TypeName.bcs,
+            reserve_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
-            coin_type: TypeName.bcs,
+            ctoken_amount: bcs.u64(),
             liquidity_amount: bcs.u64(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!RedeemEvent.cachedBcs) {
+            RedeemEvent.cachedBcs = RedeemEvent.instantiateBcs();
+        }
+        return RedeemEvent.cachedBcs;
+    }
     static fromFields(fields) {
-        return ClaimRewardEvent.reified().new({
-            lendingMarketId: decodeFromFields("address", fields.lending_market_id),
-            reserveId: decodeFromFields("address", fields.reserve_id),
-            obligationId: decodeFromFields("address", fields.obligation_id),
-            isDepositReward: decodeFromFields("bool", fields.is_deposit_reward),
-            poolRewardId: decodeFromFields("address", fields.pool_reward_id),
+        return RedeemEvent.reified().new({
+            lendingMarketId: decodeFromFields('address', fields.lending_market_id),
             coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
-            liquidityAmount: decodeFromFields("u64", fields.liquidity_amount),
+            reserveId: decodeFromFields('address', fields.reserve_id),
+            ctokenAmount: decodeFromFields('u64', fields.ctoken_amount),
+            liquidityAmount: decodeFromFields('u64', fields.liquidity_amount),
         });
     }
     static fromFieldsWithTypes(item) {
-        if (!isClaimRewardEvent(item.type)) {
-            throw new Error("not a ClaimRewardEvent type");
+        if (!isRedeemEvent(item.type)) {
+            throw new Error('not a RedeemEvent type');
         }
-        return ClaimRewardEvent.reified().new({
-            lendingMarketId: decodeFromFieldsWithTypes("address", item.fields.lending_market_id),
-            reserveId: decodeFromFieldsWithTypes("address", item.fields.reserve_id),
-            obligationId: decodeFromFieldsWithTypes("address", item.fields.obligation_id),
-            isDepositReward: decodeFromFieldsWithTypes("bool", item.fields.is_deposit_reward),
-            poolRewardId: decodeFromFieldsWithTypes("address", item.fields.pool_reward_id),
+        return RedeemEvent.reified().new({
+            lendingMarketId: decodeFromFieldsWithTypes('address', item.fields.lending_market_id),
             coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
-            liquidityAmount: decodeFromFieldsWithTypes("u64", item.fields.liquidity_amount),
+            reserveId: decodeFromFieldsWithTypes('address', item.fields.reserve_id),
+            ctokenAmount: decodeFromFieldsWithTypes('u64', item.fields.ctoken_amount),
+            liquidityAmount: decodeFromFieldsWithTypes('u64', item.fields.liquidity_amount),
         });
     }
     static fromBcs(data) {
-        return ClaimRewardEvent.fromFields(ClaimRewardEvent.bcs.parse(data));
+        return RedeemEvent.fromFields(RedeemEvent.bcs.parse(data));
     }
     toJSONField() {
         return {
             lendingMarketId: this.lendingMarketId,
+            coinType: this.coinType,
             reserveId: this.reserveId,
-            obligationId: this.obligationId,
-            isDepositReward: this.isDepositReward,
-            poolRewardId: this.poolRewardId,
-            coinType: this.coinType.toJSONField(),
+            ctokenAmount: this.ctokenAmount.toString(),
             liquidityAmount: this.liquidityAmount.toString(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
-        return ClaimRewardEvent.reified().new({
-            lendingMarketId: decodeFromJSONField("address", field.lendingMarketId),
-            reserveId: decodeFromJSONField("address", field.reserveId),
-            obligationId: decodeFromJSONField("address", field.obligationId),
-            isDepositReward: decodeFromJSONField("bool", field.isDepositReward),
-            poolRewardId: decodeFromJSONField("address", field.poolRewardId),
+        return RedeemEvent.reified().new({
+            lendingMarketId: decodeFromJSONField('address', field.lendingMarketId),
             coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
-            liquidityAmount: decodeFromJSONField("u64", field.liquidityAmount),
+            reserveId: decodeFromJSONField('address', field.reserveId),
+            ctokenAmount: decodeFromJSONField('u64', field.ctokenAmount),
+            liquidityAmount: decodeFromJSONField('u64', field.liquidityAmount),
         });
     }
     static fromJSON(json) {
-        if (json.$typeName !== ClaimRewardEvent.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+        if (json.$typeName !== RedeemEvent.$typeName) {
+            throw new Error(`not a RedeemEvent json object: expected '${RedeemEvent.$typeName}' but got '${json.$typeName}'`);
         }
-        return ClaimRewardEvent.fromJSONField(json);
+        return RedeemEvent.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isRedeemEvent(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a RedeemEvent object`);
+        }
+        return RedeemEvent.fromBcs(obj.content);
     }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isClaimRewardEvent(object.type)) {
-            throw new Error(`object at id ${id} is not a ClaimRewardEvent object`);
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isRedeemEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a RedeemEvent object`);
         }
-        return ClaimRewardEvent.fromBcs(object.content);
+        return RedeemEvent.fromBcs(object.content);
     }
 }
 /* ============================== DepositEvent =============================== */
 export function isDepositEvent(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::lending_market::DepositEvent`;
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::DepositEvent')}::lending_market::DepositEvent`;
 }
 export class DepositEvent {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::lending_market::DepositEvent`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::DepositEvent')}::lending_market::DepositEvent`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
     $typeName = DepositEvent.$typeName;
@@ -632,23 +1806,29 @@ export class DepositEvent {
         this.ctokenAmount = fields.ctokenAmount;
     }
     static reified() {
+        const reifiedBcs = DepositEvent.bcs;
         return {
-            typeName: DepositEvent.$typeName,
-            fullTypeName: composeSuiType(DepositEvent.$typeName, ...[]),
+            get typeName() {
+                return DepositEvent.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(DepositEvent.$typeName, ...[]);
+            },
             typeArgs: [],
             isPhantom: DepositEvent.$isPhantom,
             reifiedTypeArgs: [],
             fromFields: (fields) => DepositEvent.fromFields(fields),
             fromFieldsWithTypes: (item) => DepositEvent.fromFieldsWithTypes(item),
-            fromBcs: (data) => DepositEvent.fromBcs(data),
-            bcs: DepositEvent.bcs,
+            fromBcs: (data) => DepositEvent.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
             fromJSONField: (field) => DepositEvent.fromJSONField(field),
             fromJSON: (json) => DepositEvent.fromJSON(json),
+            fromCoreObject: (obj) => DepositEvent.fromCoreObject(obj),
             fetch: async (client, id) => DepositEvent.fetch(client, id),
             new: (fields) => {
                 return new DepositEvent([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
@@ -660,49 +1840,50 @@ export class DepositEvent {
     static get p() {
         return DepositEvent.phantom();
     }
-    static get bcs() {
-        return bcs.struct("DepositEvent", {
-            lending_market_id: bcs
-                .bytes(32)
-                .transform({
+    static instantiateBcs() {
+        return bcs.struct('DepositEvent', {
+            lending_market_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
             coin_type: TypeName.bcs,
-            reserve_id: bcs
-                .bytes(32)
-                .transform({
+            reserve_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
-            obligation_id: bcs
-                .bytes(32)
-                .transform({
+            obligation_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
             ctoken_amount: bcs.u64(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!DepositEvent.cachedBcs) {
+            DepositEvent.cachedBcs = DepositEvent.instantiateBcs();
+        }
+        return DepositEvent.cachedBcs;
+    }
     static fromFields(fields) {
         return DepositEvent.reified().new({
-            lendingMarketId: decodeFromFields("address", fields.lending_market_id),
+            lendingMarketId: decodeFromFields('address', fields.lending_market_id),
             coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
-            reserveId: decodeFromFields("address", fields.reserve_id),
-            obligationId: decodeFromFields("address", fields.obligation_id),
-            ctokenAmount: decodeFromFields("u64", fields.ctoken_amount),
+            reserveId: decodeFromFields('address', fields.reserve_id),
+            obligationId: decodeFromFields('address', fields.obligation_id),
+            ctokenAmount: decodeFromFields('u64', fields.ctoken_amount),
         });
     }
     static fromFieldsWithTypes(item) {
         if (!isDepositEvent(item.type)) {
-            throw new Error("not a DepositEvent type");
+            throw new Error('not a DepositEvent type');
         }
         return DepositEvent.reified().new({
-            lendingMarketId: decodeFromFieldsWithTypes("address", item.fields.lending_market_id),
+            lendingMarketId: decodeFromFieldsWithTypes('address', item.fields.lending_market_id),
             coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
-            reserveId: decodeFromFieldsWithTypes("address", item.fields.reserve_id),
-            obligationId: decodeFromFieldsWithTypes("address", item.fields.obligation_id),
-            ctokenAmount: decodeFromFieldsWithTypes("u64", item.fields.ctoken_amount),
+            reserveId: decodeFromFieldsWithTypes('address', item.fields.reserve_id),
+            obligationId: decodeFromFieldsWithTypes('address', item.fields.obligation_id),
+            ctokenAmount: decodeFromFieldsWithTypes('u64', item.fields.ctoken_amount),
         });
     }
     static fromBcs(data) {
@@ -711,783 +1892,701 @@ export class DepositEvent {
     toJSONField() {
         return {
             lendingMarketId: this.lendingMarketId,
-            coinType: this.coinType.toJSONField(),
+            coinType: this.coinType,
             reserveId: this.reserveId,
             obligationId: this.obligationId,
             ctokenAmount: this.ctokenAmount.toString(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
         return DepositEvent.reified().new({
-            lendingMarketId: decodeFromJSONField("address", field.lendingMarketId),
+            lendingMarketId: decodeFromJSONField('address', field.lendingMarketId),
             coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
-            reserveId: decodeFromJSONField("address", field.reserveId),
-            obligationId: decodeFromJSONField("address", field.obligationId),
-            ctokenAmount: decodeFromJSONField("u64", field.ctokenAmount),
+            reserveId: decodeFromJSONField('address', field.reserveId),
+            obligationId: decodeFromJSONField('address', field.obligationId),
+            ctokenAmount: decodeFromJSONField('u64', field.ctokenAmount),
         });
     }
     static fromJSON(json) {
         if (json.$typeName !== DepositEvent.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+            throw new Error(`not a DepositEvent json object: expected '${DepositEvent.$typeName}' but got '${json.$typeName}'`);
         }
         return DepositEvent.fromJSONField(json);
     }
+    static fromCoreObject(obj) {
+        if (!isDepositEvent(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a DepositEvent object`);
+        }
+        return DepositEvent.fromBcs(obj.content);
+    }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
         if (!isDepositEvent(object.type)) {
             throw new Error(`object at id ${id} is not a DepositEvent object`);
         }
         return DepositEvent.fromBcs(object.content);
     }
 }
-/* ============================== FeeReceivers =============================== */
-export function isFeeReceivers(type) {
-    type = compressSuiType(type);
-    return type === `${PKG_V10}::lending_market::FeeReceivers`;
-}
-export class FeeReceivers {
-    __StructClass = true;
-    static $typeName = `${PKG_V10}::lending_market::FeeReceivers`;
-    static $numTypeParams = 0;
-    static $isPhantom = [];
-    $typeName = FeeReceivers.$typeName;
-    $fullTypeName;
-    $typeArgs;
-    $isPhantom = FeeReceivers.$isPhantom;
-    receivers;
-    weights;
-    totalWeight;
-    constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(FeeReceivers.$typeName, ...typeArgs);
-        this.$typeArgs = typeArgs;
-        this.receivers = fields.receivers;
-        this.weights = fields.weights;
-        this.totalWeight = fields.totalWeight;
-    }
-    static reified() {
-        return {
-            typeName: FeeReceivers.$typeName,
-            fullTypeName: composeSuiType(FeeReceivers.$typeName, ...[]),
-            typeArgs: [],
-            isPhantom: FeeReceivers.$isPhantom,
-            reifiedTypeArgs: [],
-            fromFields: (fields) => FeeReceivers.fromFields(fields),
-            fromFieldsWithTypes: (item) => FeeReceivers.fromFieldsWithTypes(item),
-            fromBcs: (data) => FeeReceivers.fromBcs(data),
-            bcs: FeeReceivers.bcs,
-            fromJSONField: (field) => FeeReceivers.fromJSONField(field),
-            fromJSON: (json) => FeeReceivers.fromJSON(json),
-            fetch: async (client, id) => FeeReceivers.fetch(client, id),
-            new: (fields) => {
-                return new FeeReceivers([], fields);
-            },
-            kind: "StructClassReified",
-        };
-    }
-    static get r() {
-        return FeeReceivers.reified();
-    }
-    static phantom() {
-        return phantom(FeeReceivers.reified());
-    }
-    static get p() {
-        return FeeReceivers.phantom();
-    }
-    static get bcs() {
-        return bcs.struct("FeeReceivers", {
-            receivers: bcs.vector(bcs
-                .bytes(32)
-                .transform({
-                input: (val) => fromHex(val),
-                output: (val) => toHex(val),
-            })),
-            weights: bcs.vector(bcs.u64()),
-            total_weight: bcs.u64(),
-        });
-    }
-    static fromFields(fields) {
-        return FeeReceivers.reified().new({
-            receivers: decodeFromFields(reified.vector("address"), fields.receivers),
-            weights: decodeFromFields(reified.vector("u64"), fields.weights),
-            totalWeight: decodeFromFields("u64", fields.total_weight),
-        });
-    }
-    static fromFieldsWithTypes(item) {
-        if (!isFeeReceivers(item.type)) {
-            throw new Error("not a FeeReceivers type");
-        }
-        return FeeReceivers.reified().new({
-            receivers: decodeFromFieldsWithTypes(reified.vector("address"), item.fields.receivers),
-            weights: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.weights),
-            totalWeight: decodeFromFieldsWithTypes("u64", item.fields.total_weight),
-        });
-    }
-    static fromBcs(data) {
-        return FeeReceivers.fromFields(FeeReceivers.bcs.parse(data));
-    }
-    toJSONField() {
-        return {
-            receivers: fieldToJSON(`vector<address>`, this.receivers),
-            weights: fieldToJSON(`vector<u64>`, this.weights),
-            totalWeight: this.totalWeight.toString(),
-        };
-    }
-    toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
-    }
-    static fromJSONField(field) {
-        return FeeReceivers.reified().new({
-            receivers: decodeFromJSONField(reified.vector("address"), field.receivers),
-            weights: decodeFromJSONField(reified.vector("u64"), field.weights),
-            totalWeight: decodeFromJSONField("u64", field.totalWeight),
-        });
-    }
-    static fromJSON(json) {
-        if (json.$typeName !== FeeReceivers.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
-        }
-        return FeeReceivers.fromJSONField(json);
-    }
-    static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isFeeReceivers(object.type)) {
-            throw new Error(`object at id ${id} is not a FeeReceivers object`);
-        }
-        return FeeReceivers.fromBcs(object.content);
-    }
-}
-/* ============================== FeeReceiversKey =============================== */
-export function isFeeReceiversKey(type) {
+/* ============================== WithdrawEvent =============================== */
+export function isWithdrawEvent(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V10}::lending_market::FeeReceiversKey`;
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::WithdrawEvent')}::lending_market::WithdrawEvent`;
 }
-export class FeeReceiversKey {
+export class WithdrawEvent {
     __StructClass = true;
-    static $typeName = `${PKG_V10}::lending_market::FeeReceiversKey`;
-    static $numTypeParams = 0;
-    static $isPhantom = [];
-    $typeName = FeeReceiversKey.$typeName;
-    $fullTypeName;
-    $typeArgs;
-    $isPhantom = FeeReceiversKey.$isPhantom;
-    dummyField;
-    constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(FeeReceiversKey.$typeName, ...typeArgs);
-        this.$typeArgs = typeArgs;
-        this.dummyField = fields.dummyField;
-    }
-    static reified() {
-        return {
-            typeName: FeeReceiversKey.$typeName,
-            fullTypeName: composeSuiType(FeeReceiversKey.$typeName, ...[]),
-            typeArgs: [],
-            isPhantom: FeeReceiversKey.$isPhantom,
-            reifiedTypeArgs: [],
-            fromFields: (fields) => FeeReceiversKey.fromFields(fields),
-            fromFieldsWithTypes: (item) => FeeReceiversKey.fromFieldsWithTypes(item),
-            fromBcs: (data) => FeeReceiversKey.fromBcs(data),
-            bcs: FeeReceiversKey.bcs,
-            fromJSONField: (field) => FeeReceiversKey.fromJSONField(field),
-            fromJSON: (json) => FeeReceiversKey.fromJSON(json),
-            fetch: async (client, id) => FeeReceiversKey.fetch(client, id),
-            new: (fields) => {
-                return new FeeReceiversKey([], fields);
-            },
-            kind: "StructClassReified",
-        };
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::WithdrawEvent')}::lending_market::WithdrawEvent`;
     }
-    static get r() {
-        return FeeReceiversKey.reified();
-    }
-    static phantom() {
-        return phantom(FeeReceiversKey.reified());
-    }
-    static get p() {
-        return FeeReceiversKey.phantom();
-    }
-    static get bcs() {
-        return bcs.struct("FeeReceiversKey", {
-            dummy_field: bcs.bool(),
-        });
-    }
-    static fromFields(fields) {
-        return FeeReceiversKey.reified().new({
-            dummyField: decodeFromFields("bool", fields.dummy_field),
-        });
-    }
-    static fromFieldsWithTypes(item) {
-        if (!isFeeReceiversKey(item.type)) {
-            throw new Error("not a FeeReceiversKey type");
-        }
-        return FeeReceiversKey.reified().new({
-            dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field),
-        });
-    }
-    static fromBcs(data) {
-        return FeeReceiversKey.fromFields(FeeReceiversKey.bcs.parse(data));
-    }
-    toJSONField() {
-        return {
-            dummyField: this.dummyField,
-        };
-    }
-    toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
-    }
-    static fromJSONField(field) {
-        return FeeReceiversKey.reified().new({
-            dummyField: decodeFromJSONField("bool", field.dummyField),
-        });
-    }
-    static fromJSON(json) {
-        if (json.$typeName !== FeeReceiversKey.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
-        }
-        return FeeReceiversKey.fromJSONField(json);
-    }
-    static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isFeeReceiversKey(object.type)) {
-            throw new Error(`object at id ${id} is not a FeeReceiversKey object`);
-        }
-        return FeeReceiversKey.fromBcs(object.content);
-    }
-}
-/* ============================== ForgiveEvent =============================== */
-export function isForgiveEvent(type) {
-    type = compressSuiType(type);
-    return type === `${PKG_V1}::lending_market::ForgiveEvent`;
-}
-export class ForgiveEvent {
-    __StructClass = true;
-    static $typeName = `${PKG_V1}::lending_market::ForgiveEvent`;
     static $numTypeParams = 0;
     static $isPhantom = [];
-    $typeName = ForgiveEvent.$typeName;
+    $typeName = WithdrawEvent.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = ForgiveEvent.$isPhantom;
+    $isPhantom = WithdrawEvent.$isPhantom;
     lendingMarketId;
     coinType;
     reserveId;
     obligationId;
-    liquidityAmount;
+    ctokenAmount;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(ForgiveEvent.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(WithdrawEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
         this.coinType = fields.coinType;
         this.reserveId = fields.reserveId;
         this.obligationId = fields.obligationId;
-        this.liquidityAmount = fields.liquidityAmount;
+        this.ctokenAmount = fields.ctokenAmount;
     }
     static reified() {
+        const reifiedBcs = WithdrawEvent.bcs;
         return {
-            typeName: ForgiveEvent.$typeName,
-            fullTypeName: composeSuiType(ForgiveEvent.$typeName, ...[]),
+            get typeName() {
+                return WithdrawEvent.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(WithdrawEvent.$typeName, ...[]);
+            },
             typeArgs: [],
-            isPhantom: ForgiveEvent.$isPhantom,
+            isPhantom: WithdrawEvent.$isPhantom,
             reifiedTypeArgs: [],
-            fromFields: (fields) => ForgiveEvent.fromFields(fields),
-            fromFieldsWithTypes: (item) => ForgiveEvent.fromFieldsWithTypes(item),
-            fromBcs: (data) => ForgiveEvent.fromBcs(data),
-            bcs: ForgiveEvent.bcs,
-            fromJSONField: (field) => ForgiveEvent.fromJSONField(field),
-            fromJSON: (json) => ForgiveEvent.fromJSON(json),
-            fetch: async (client, id) => ForgiveEvent.fetch(client, id),
+            fromFields: (fields) => WithdrawEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => WithdrawEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => WithdrawEvent.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => WithdrawEvent.fromJSONField(field),
+            fromJSON: (json) => WithdrawEvent.fromJSON(json),
+            fromCoreObject: (obj) => WithdrawEvent.fromCoreObject(obj),
+            fetch: async (client, id) => WithdrawEvent.fetch(client, id),
             new: (fields) => {
-                return new ForgiveEvent([], fields);
+                return new WithdrawEvent([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return ForgiveEvent.reified();
+        return WithdrawEvent.reified();
     }
     static phantom() {
-        return phantom(ForgiveEvent.reified());
+        return phantom(WithdrawEvent.reified());
     }
     static get p() {
-        return ForgiveEvent.phantom();
+        return WithdrawEvent.phantom();
     }
-    static get bcs() {
-        return bcs.struct("ForgiveEvent", {
-            lending_market_id: bcs
-                .bytes(32)
-                .transform({
+    static instantiateBcs() {
+        return bcs.struct('WithdrawEvent', {
+            lending_market_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
             coin_type: TypeName.bcs,
-            reserve_id: bcs
-                .bytes(32)
-                .transform({
+            reserve_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
-            obligation_id: bcs
-                .bytes(32)
-                .transform({
+            obligation_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
-            liquidity_amount: bcs.u64(),
+            ctoken_amount: bcs.u64(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!WithdrawEvent.cachedBcs) {
+            WithdrawEvent.cachedBcs = WithdrawEvent.instantiateBcs();
+        }
+        return WithdrawEvent.cachedBcs;
+    }
     static fromFields(fields) {
-        return ForgiveEvent.reified().new({
-            lendingMarketId: decodeFromFields("address", fields.lending_market_id),
+        return WithdrawEvent.reified().new({
+            lendingMarketId: decodeFromFields('address', fields.lending_market_id),
             coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
-            reserveId: decodeFromFields("address", fields.reserve_id),
-            obligationId: decodeFromFields("address", fields.obligation_id),
-            liquidityAmount: decodeFromFields("u64", fields.liquidity_amount),
+            reserveId: decodeFromFields('address', fields.reserve_id),
+            obligationId: decodeFromFields('address', fields.obligation_id),
+            ctokenAmount: decodeFromFields('u64', fields.ctoken_amount),
         });
     }
     static fromFieldsWithTypes(item) {
-        if (!isForgiveEvent(item.type)) {
-            throw new Error("not a ForgiveEvent type");
+        if (!isWithdrawEvent(item.type)) {
+            throw new Error('not a WithdrawEvent type');
         }
-        return ForgiveEvent.reified().new({
-            lendingMarketId: decodeFromFieldsWithTypes("address", item.fields.lending_market_id),
+        return WithdrawEvent.reified().new({
+            lendingMarketId: decodeFromFieldsWithTypes('address', item.fields.lending_market_id),
             coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
-            reserveId: decodeFromFieldsWithTypes("address", item.fields.reserve_id),
-            obligationId: decodeFromFieldsWithTypes("address", item.fields.obligation_id),
-            liquidityAmount: decodeFromFieldsWithTypes("u64", item.fields.liquidity_amount),
+            reserveId: decodeFromFieldsWithTypes('address', item.fields.reserve_id),
+            obligationId: decodeFromFieldsWithTypes('address', item.fields.obligation_id),
+            ctokenAmount: decodeFromFieldsWithTypes('u64', item.fields.ctoken_amount),
         });
     }
     static fromBcs(data) {
-        return ForgiveEvent.fromFields(ForgiveEvent.bcs.parse(data));
+        return WithdrawEvent.fromFields(WithdrawEvent.bcs.parse(data));
     }
     toJSONField() {
         return {
             lendingMarketId: this.lendingMarketId,
-            coinType: this.coinType.toJSONField(),
+            coinType: this.coinType,
             reserveId: this.reserveId,
             obligationId: this.obligationId,
-            liquidityAmount: this.liquidityAmount.toString(),
+            ctokenAmount: this.ctokenAmount.toString(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
-        return ForgiveEvent.reified().new({
-            lendingMarketId: decodeFromJSONField("address", field.lendingMarketId),
+        return WithdrawEvent.reified().new({
+            lendingMarketId: decodeFromJSONField('address', field.lendingMarketId),
             coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
-            reserveId: decodeFromJSONField("address", field.reserveId),
-            obligationId: decodeFromJSONField("address", field.obligationId),
-            liquidityAmount: decodeFromJSONField("u64", field.liquidityAmount),
+            reserveId: decodeFromJSONField('address', field.reserveId),
+            obligationId: decodeFromJSONField('address', field.obligationId),
+            ctokenAmount: decodeFromJSONField('u64', field.ctokenAmount),
         });
     }
     static fromJSON(json) {
-        if (json.$typeName !== ForgiveEvent.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+        if (json.$typeName !== WithdrawEvent.$typeName) {
+            throw new Error(`not a WithdrawEvent json object: expected '${WithdrawEvent.$typeName}' but got '${json.$typeName}'`);
         }
-        return ForgiveEvent.fromJSONField(json);
+        return WithdrawEvent.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isWithdrawEvent(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a WithdrawEvent object`);
+        }
+        return WithdrawEvent.fromBcs(obj.content);
     }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isForgiveEvent(object.type)) {
-            throw new Error(`object at id ${id} is not a ForgiveEvent object`);
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isWithdrawEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a WithdrawEvent object`);
         }
-        return ForgiveEvent.fromBcs(object.content);
+        return WithdrawEvent.fromBcs(object.content);
     }
 }
-/* ============================== LENDING_MARKET =============================== */
-export function isLENDING_MARKET(type) {
+/* ============================== BorrowEvent =============================== */
+export function isBorrowEvent(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::lending_market::LENDING_MARKET`;
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::BorrowEvent')}::lending_market::BorrowEvent`;
 }
-export class LENDING_MARKET {
+export class BorrowEvent {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::lending_market::LENDING_MARKET`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::BorrowEvent')}::lending_market::BorrowEvent`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
-    $typeName = LENDING_MARKET.$typeName;
+    $typeName = BorrowEvent.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = LENDING_MARKET.$isPhantom;
-    dummyField;
+    $isPhantom = BorrowEvent.$isPhantom;
+    lendingMarketId;
+    coinType;
+    reserveId;
+    obligationId;
+    liquidityAmount;
+    originationFeeAmount;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(LENDING_MARKET.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(BorrowEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.dummyField = fields.dummyField;
+        this.lendingMarketId = fields.lendingMarketId;
+        this.coinType = fields.coinType;
+        this.reserveId = fields.reserveId;
+        this.obligationId = fields.obligationId;
+        this.liquidityAmount = fields.liquidityAmount;
+        this.originationFeeAmount = fields.originationFeeAmount;
     }
     static reified() {
+        const reifiedBcs = BorrowEvent.bcs;
         return {
-            typeName: LENDING_MARKET.$typeName,
-            fullTypeName: composeSuiType(LENDING_MARKET.$typeName, ...[]),
+            get typeName() {
+                return BorrowEvent.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(BorrowEvent.$typeName, ...[]);
+            },
             typeArgs: [],
-            isPhantom: LENDING_MARKET.$isPhantom,
+            isPhantom: BorrowEvent.$isPhantom,
             reifiedTypeArgs: [],
-            fromFields: (fields) => LENDING_MARKET.fromFields(fields),
-            fromFieldsWithTypes: (item) => LENDING_MARKET.fromFieldsWithTypes(item),
-            fromBcs: (data) => LENDING_MARKET.fromBcs(data),
-            bcs: LENDING_MARKET.bcs,
-            fromJSONField: (field) => LENDING_MARKET.fromJSONField(field),
-            fromJSON: (json) => LENDING_MARKET.fromJSON(json),
-            fetch: async (client, id) => LENDING_MARKET.fetch(client, id),
+            fromFields: (fields) => BorrowEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => BorrowEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => BorrowEvent.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => BorrowEvent.fromJSONField(field),
+            fromJSON: (json) => BorrowEvent.fromJSON(json),
+            fromCoreObject: (obj) => BorrowEvent.fromCoreObject(obj),
+            fetch: async (client, id) => BorrowEvent.fetch(client, id),
             new: (fields) => {
-                return new LENDING_MARKET([], fields);
+                return new BorrowEvent([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return LENDING_MARKET.reified();
+        return BorrowEvent.reified();
     }
     static phantom() {
-        return phantom(LENDING_MARKET.reified());
+        return phantom(BorrowEvent.reified());
     }
     static get p() {
-        return LENDING_MARKET.phantom();
+        return BorrowEvent.phantom();
     }
-    static get bcs() {
-        return bcs.struct("LENDING_MARKET", {
-            dummy_field: bcs.bool(),
+    static instantiateBcs() {
+        return bcs.struct('BorrowEvent', {
+            lending_market_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            coin_type: TypeName.bcs,
+            reserve_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            obligation_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            liquidity_amount: bcs.u64(),
+            origination_fee_amount: bcs.u64(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!BorrowEvent.cachedBcs) {
+            BorrowEvent.cachedBcs = BorrowEvent.instantiateBcs();
+        }
+        return BorrowEvent.cachedBcs;
+    }
     static fromFields(fields) {
-        return LENDING_MARKET.reified().new({
-            dummyField: decodeFromFields("bool", fields.dummy_field),
+        return BorrowEvent.reified().new({
+            lendingMarketId: decodeFromFields('address', fields.lending_market_id),
+            coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
+            reserveId: decodeFromFields('address', fields.reserve_id),
+            obligationId: decodeFromFields('address', fields.obligation_id),
+            liquidityAmount: decodeFromFields('u64', fields.liquidity_amount),
+            originationFeeAmount: decodeFromFields('u64', fields.origination_fee_amount),
         });
     }
     static fromFieldsWithTypes(item) {
-        if (!isLENDING_MARKET(item.type)) {
-            throw new Error("not a LENDING_MARKET type");
+        if (!isBorrowEvent(item.type)) {
+            throw new Error('not a BorrowEvent type');
         }
-        return LENDING_MARKET.reified().new({
-            dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field),
+        return BorrowEvent.reified().new({
+            lendingMarketId: decodeFromFieldsWithTypes('address', item.fields.lending_market_id),
+            coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
+            reserveId: decodeFromFieldsWithTypes('address', item.fields.reserve_id),
+            obligationId: decodeFromFieldsWithTypes('address', item.fields.obligation_id),
+            liquidityAmount: decodeFromFieldsWithTypes('u64', item.fields.liquidity_amount),
+            originationFeeAmount: decodeFromFieldsWithTypes('u64', item.fields.origination_fee_amount),
         });
     }
     static fromBcs(data) {
-        return LENDING_MARKET.fromFields(LENDING_MARKET.bcs.parse(data));
+        return BorrowEvent.fromFields(BorrowEvent.bcs.parse(data));
     }
     toJSONField() {
         return {
-            dummyField: this.dummyField,
+            lendingMarketId: this.lendingMarketId,
+            coinType: this.coinType,
+            reserveId: this.reserveId,
+            obligationId: this.obligationId,
+            liquidityAmount: this.liquidityAmount.toString(),
+            originationFeeAmount: this.originationFeeAmount.toString(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
-        return LENDING_MARKET.reified().new({
-            dummyField: decodeFromJSONField("bool", field.dummyField),
+        return BorrowEvent.reified().new({
+            lendingMarketId: decodeFromJSONField('address', field.lendingMarketId),
+            coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
+            reserveId: decodeFromJSONField('address', field.reserveId),
+            obligationId: decodeFromJSONField('address', field.obligationId),
+            liquidityAmount: decodeFromJSONField('u64', field.liquidityAmount),
+            originationFeeAmount: decodeFromJSONField('u64', field.originationFeeAmount),
         });
     }
     static fromJSON(json) {
-        if (json.$typeName !== LENDING_MARKET.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+        if (json.$typeName !== BorrowEvent.$typeName) {
+            throw new Error(`not a BorrowEvent json object: expected '${BorrowEvent.$typeName}' but got '${json.$typeName}'`);
         }
-        return LENDING_MARKET.fromJSONField(json);
+        return BorrowEvent.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isBorrowEvent(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a BorrowEvent object`);
+        }
+        return BorrowEvent.fromBcs(obj.content);
     }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isLENDING_MARKET(object.type)) {
-            throw new Error(`object at id ${id} is not a LENDING_MARKET object`);
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isBorrowEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a BorrowEvent object`);
         }
-        return LENDING_MARKET.fromBcs(object.content);
+        return BorrowEvent.fromBcs(object.content);
     }
 }
-/* ============================== LendingMarket =============================== */
-export function isLendingMarket(type) {
+/* ============================== RepayEvent =============================== */
+export function isRepayEvent(type) {
     type = compressSuiType(type);
-    return type.startsWith(`${PKG_V1}::lending_market::LendingMarket` + "<");
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::RepayEvent')}::lending_market::RepayEvent`;
 }
-export class LendingMarket {
+export class RepayEvent {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::lending_market::LendingMarket`;
-    static $numTypeParams = 1;
-    static $isPhantom = [true];
-    $typeName = LendingMarket.$typeName;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::RepayEvent')}::lending_market::RepayEvent`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = RepayEvent.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = LendingMarket.$isPhantom;
-    id;
-    version;
-    reserves;
-    obligations;
-    rateLimiter;
-    feeReceiver;
-    badDebtUsd;
-    badDebtLimitUsd;
+    $isPhantom = RepayEvent.$isPhantom;
+    lendingMarketId;
+    coinType;
+    reserveId;
+    obligationId;
+    liquidityAmount;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(LendingMarket.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(RepayEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.id = fields.id;
-        this.version = fields.version;
-        this.reserves = fields.reserves;
-        this.obligations = fields.obligations;
-        this.rateLimiter = fields.rateLimiter;
-        this.feeReceiver = fields.feeReceiver;
-        this.badDebtUsd = fields.badDebtUsd;
-        this.badDebtLimitUsd = fields.badDebtLimitUsd;
+        this.lendingMarketId = fields.lendingMarketId;
+        this.coinType = fields.coinType;
+        this.reserveId = fields.reserveId;
+        this.obligationId = fields.obligationId;
+        this.liquidityAmount = fields.liquidityAmount;
     }
-    static reified(P) {
+    static reified() {
+        const reifiedBcs = RepayEvent.bcs;
         return {
-            typeName: LendingMarket.$typeName,
-            fullTypeName: composeSuiType(LendingMarket.$typeName, ...[extractType(P)]),
-            typeArgs: [extractType(P)],
-            isPhantom: LendingMarket.$isPhantom,
-            reifiedTypeArgs: [P],
-            fromFields: (fields) => LendingMarket.fromFields(P, fields),
-            fromFieldsWithTypes: (item) => LendingMarket.fromFieldsWithTypes(P, item),
-            fromBcs: (data) => LendingMarket.fromBcs(P, data),
-            bcs: LendingMarket.bcs,
-            fromJSONField: (field) => LendingMarket.fromJSONField(P, field),
-            fromJSON: (json) => LendingMarket.fromJSON(P, json),
-            fetch: async (client, id) => LendingMarket.fetch(client, P, id),
+            get typeName() {
+                return RepayEvent.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(RepayEvent.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: RepayEvent.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => RepayEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => RepayEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => RepayEvent.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => RepayEvent.fromJSONField(field),
+            fromJSON: (json) => RepayEvent.fromJSON(json),
+            fromCoreObject: (obj) => RepayEvent.fromCoreObject(obj),
+            fetch: async (client, id) => RepayEvent.fetch(client, id),
             new: (fields) => {
-                return new LendingMarket([extractType(P)], fields);
+                return new RepayEvent([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return LendingMarket.reified;
+        return RepayEvent.reified();
     }
-    static phantom(P) {
-        return phantom(LendingMarket.reified(P));
+    static phantom() {
+        return phantom(RepayEvent.reified());
     }
     static get p() {
-        return LendingMarket.phantom;
+        return RepayEvent.phantom();
     }
-    static get bcs() {
-        return bcs.struct("LendingMarket", {
-            id: UID.bcs,
-            version: bcs.u64(),
-            reserves: bcs.vector(Reserve.bcs),
-            obligations: ObjectTable.bcs,
-            rate_limiter: RateLimiter.bcs,
-            fee_receiver: bcs
-                .bytes(32)
-                .transform({
+    static instantiateBcs() {
+        return bcs.struct('RepayEvent', {
+            lending_market_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
-            bad_debt_usd: Decimal.bcs,
-            bad_debt_limit_usd: Decimal.bcs,
+            coin_type: TypeName.bcs,
+            reserve_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            obligation_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            liquidity_amount: bcs.u64(),
         });
     }
-    static fromFields(typeArg, fields) {
-        return LendingMarket.reified(typeArg).new({
-            id: decodeFromFields(UID.reified(), fields.id),
-            version: decodeFromFields("u64", fields.version),
-            reserves: decodeFromFields(reified.vector(Reserve.reified(typeArg)), fields.reserves),
-            obligations: decodeFromFields(ObjectTable.reified(reified.phantom(ID.reified()), reified.phantom(Obligation.reified(typeArg))), fields.obligations),
-            rateLimiter: decodeFromFields(RateLimiter.reified(), fields.rate_limiter),
-            feeReceiver: decodeFromFields("address", fields.fee_receiver),
-            badDebtUsd: decodeFromFields(Decimal.reified(), fields.bad_debt_usd),
-            badDebtLimitUsd: decodeFromFields(Decimal.reified(), fields.bad_debt_limit_usd),
+    static cachedBcs = null;
+    static get bcs() {
+        if (!RepayEvent.cachedBcs) {
+            RepayEvent.cachedBcs = RepayEvent.instantiateBcs();
+        }
+        return RepayEvent.cachedBcs;
+    }
+    static fromFields(fields) {
+        return RepayEvent.reified().new({
+            lendingMarketId: decodeFromFields('address', fields.lending_market_id),
+            coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
+            reserveId: decodeFromFields('address', fields.reserve_id),
+            obligationId: decodeFromFields('address', fields.obligation_id),
+            liquidityAmount: decodeFromFields('u64', fields.liquidity_amount),
         });
     }
-    static fromFieldsWithTypes(typeArg, item) {
-        if (!isLendingMarket(item.type)) {
-            throw new Error("not a LendingMarket type");
+    static fromFieldsWithTypes(item) {
+        if (!isRepayEvent(item.type)) {
+            throw new Error('not a RepayEvent type');
         }
-        assertFieldsWithTypesArgsMatch(item, [typeArg]);
-        return LendingMarket.reified(typeArg).new({
-            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
-            version: decodeFromFieldsWithTypes("u64", item.fields.version),
-            reserves: decodeFromFieldsWithTypes(reified.vector(Reserve.reified(typeArg)), item.fields.reserves),
-            obligations: decodeFromFieldsWithTypes(ObjectTable.reified(reified.phantom(ID.reified()), reified.phantom(Obligation.reified(typeArg))), item.fields.obligations),
-            rateLimiter: decodeFromFieldsWithTypes(RateLimiter.reified(), item.fields.rate_limiter),
-            feeReceiver: decodeFromFieldsWithTypes("address", item.fields.fee_receiver),
-            badDebtUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.bad_debt_usd),
-            badDebtLimitUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.bad_debt_limit_usd),
+        return RepayEvent.reified().new({
+            lendingMarketId: decodeFromFieldsWithTypes('address', item.fields.lending_market_id),
+            coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
+            reserveId: decodeFromFieldsWithTypes('address', item.fields.reserve_id),
+            obligationId: decodeFromFieldsWithTypes('address', item.fields.obligation_id),
+            liquidityAmount: decodeFromFieldsWithTypes('u64', item.fields.liquidity_amount),
         });
     }
-    static fromBcs(typeArg, data) {
-        return LendingMarket.fromFields(typeArg, LendingMarket.bcs.parse(data));
+    static fromBcs(data) {
+        return RepayEvent.fromFields(RepayEvent.bcs.parse(data));
     }
     toJSONField() {
         return {
-            id: this.id,
-            version: this.version.toString(),
-            reserves: fieldToJSON(`vector<${Reserve.$typeName}<${this.$typeArgs[0]}>>`, this.reserves),
-            obligations: this.obligations.toJSONField(),
-            rateLimiter: this.rateLimiter.toJSONField(),
-            feeReceiver: this.feeReceiver,
-            badDebtUsd: this.badDebtUsd.toJSONField(),
-            badDebtLimitUsd: this.badDebtLimitUsd.toJSONField(),
+            lendingMarketId: this.lendingMarketId,
+            coinType: this.coinType,
+            reserveId: this.reserveId,
+            obligationId: this.obligationId,
+            liquidityAmount: this.liquidityAmount.toString(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
-    static fromJSONField(typeArg, field) {
-        return LendingMarket.reified(typeArg).new({
-            id: decodeFromJSONField(UID.reified(), field.id),
-            version: decodeFromJSONField("u64", field.version),
-            reserves: decodeFromJSONField(reified.vector(Reserve.reified(typeArg)), field.reserves),
-            obligations: decodeFromJSONField(ObjectTable.reified(reified.phantom(ID.reified()), reified.phantom(Obligation.reified(typeArg))), field.obligations),
-            rateLimiter: decodeFromJSONField(RateLimiter.reified(), field.rateLimiter),
-            feeReceiver: decodeFromJSONField("address", field.feeReceiver),
-            badDebtUsd: decodeFromJSONField(Decimal.reified(), field.badDebtUsd),
-            badDebtLimitUsd: decodeFromJSONField(Decimal.reified(), field.badDebtLimitUsd),
+    static fromJSONField(field) {
+        return RepayEvent.reified().new({
+            lendingMarketId: decodeFromJSONField('address', field.lendingMarketId),
+            coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
+            reserveId: decodeFromJSONField('address', field.reserveId),
+            obligationId: decodeFromJSONField('address', field.obligationId),
+            liquidityAmount: decodeFromJSONField('u64', field.liquidityAmount),
         });
     }
-    static fromJSON(typeArg, json) {
-        if (json.$typeName !== LendingMarket.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+    static fromJSON(json) {
+        if (json.$typeName !== RepayEvent.$typeName) {
+            throw new Error(`not a RepayEvent json object: expected '${RepayEvent.$typeName}' but got '${json.$typeName}'`);
         }
-        assertReifiedTypeArgsMatch(composeSuiType(LendingMarket.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg]);
-        return LendingMarket.fromJSONField(typeArg, json);
+        return RepayEvent.fromJSONField(json);
     }
-    static async fetch(client, typeArg, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isLendingMarket(object.type)) {
-            throw new Error(`object at id ${id} is not a LendingMarket object`);
+    static fromCoreObject(obj) {
+        if (!isRepayEvent(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a RepayEvent object`);
         }
-        return LendingMarket.fromBcs(typeArg, object.content);
+        return RepayEvent.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isRepayEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a RepayEvent object`);
+        }
+        return RepayEvent.fromBcs(object.content);
     }
 }
-/* ============================== LendingMarketOwnerCap =============================== */
-export function isLendingMarketOwnerCap(type) {
+/* ============================== ForgiveEvent =============================== */
+export function isForgiveEvent(type) {
     type = compressSuiType(type);
-    return type.startsWith(`${PKG_V1}::lending_market::LendingMarketOwnerCap` + "<");
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::ForgiveEvent')}::lending_market::ForgiveEvent`;
 }
-export class LendingMarketOwnerCap {
+export class ForgiveEvent {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::lending_market::LendingMarketOwnerCap`;
-    static $numTypeParams = 1;
-    static $isPhantom = [true];
-    $typeName = LendingMarketOwnerCap.$typeName;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::ForgiveEvent')}::lending_market::ForgiveEvent`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = ForgiveEvent.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = LendingMarketOwnerCap.$isPhantom;
-    id;
+    $isPhantom = ForgiveEvent.$isPhantom;
     lendingMarketId;
+    coinType;
+    reserveId;
+    obligationId;
+    liquidityAmount;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(LendingMarketOwnerCap.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(ForgiveEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.id = fields.id;
         this.lendingMarketId = fields.lendingMarketId;
+        this.coinType = fields.coinType;
+        this.reserveId = fields.reserveId;
+        this.obligationId = fields.obligationId;
+        this.liquidityAmount = fields.liquidityAmount;
     }
-    static reified(P) {
+    static reified() {
+        const reifiedBcs = ForgiveEvent.bcs;
         return {
-            typeName: LendingMarketOwnerCap.$typeName,
-            fullTypeName: composeSuiType(LendingMarketOwnerCap.$typeName, ...[extractType(P)]),
-            typeArgs: [extractType(P)],
-            isPhantom: LendingMarketOwnerCap.$isPhantom,
-            reifiedTypeArgs: [P],
-            fromFields: (fields) => LendingMarketOwnerCap.fromFields(P, fields),
-            fromFieldsWithTypes: (item) => LendingMarketOwnerCap.fromFieldsWithTypes(P, item),
-            fromBcs: (data) => LendingMarketOwnerCap.fromBcs(P, data),
-            bcs: LendingMarketOwnerCap.bcs,
-            fromJSONField: (field) => LendingMarketOwnerCap.fromJSONField(P, field),
-            fromJSON: (json) => LendingMarketOwnerCap.fromJSON(P, json),
-            fetch: async (client, id) => LendingMarketOwnerCap.fetch(client, P, id),
+            get typeName() {
+                return ForgiveEvent.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(ForgiveEvent.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: ForgiveEvent.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => ForgiveEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => ForgiveEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => ForgiveEvent.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => ForgiveEvent.fromJSONField(field),
+            fromJSON: (json) => ForgiveEvent.fromJSON(json),
+            fromCoreObject: (obj) => ForgiveEvent.fromCoreObject(obj),
+            fetch: async (client, id) => ForgiveEvent.fetch(client, id),
             new: (fields) => {
-                return new LendingMarketOwnerCap([extractType(P)], fields);
+                return new ForgiveEvent([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return LendingMarketOwnerCap.reified;
+        return ForgiveEvent.reified();
     }
-    static phantom(P) {
-        return phantom(LendingMarketOwnerCap.reified(P));
+    static phantom() {
+        return phantom(ForgiveEvent.reified());
     }
     static get p() {
-        return LendingMarketOwnerCap.phantom;
+        return ForgiveEvent.phantom();
     }
-    static get bcs() {
-        return bcs.struct("LendingMarketOwnerCap", {
-            id: UID.bcs,
-            lending_market_id: ID.bcs,
+    static instantiateBcs() {
+        return bcs.struct('ForgiveEvent', {
+            lending_market_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            coin_type: TypeName.bcs,
+            reserve_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            obligation_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            liquidity_amount: bcs.u64(),
         });
     }
-    static fromFields(typeArg, fields) {
-        return LendingMarketOwnerCap.reified(typeArg).new({
-            id: decodeFromFields(UID.reified(), fields.id),
-            lendingMarketId: decodeFromFields(ID.reified(), fields.lending_market_id),
+    static cachedBcs = null;
+    static get bcs() {
+        if (!ForgiveEvent.cachedBcs) {
+            ForgiveEvent.cachedBcs = ForgiveEvent.instantiateBcs();
+        }
+        return ForgiveEvent.cachedBcs;
+    }
+    static fromFields(fields) {
+        return ForgiveEvent.reified().new({
+            lendingMarketId: decodeFromFields('address', fields.lending_market_id),
+            coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
+            reserveId: decodeFromFields('address', fields.reserve_id),
+            obligationId: decodeFromFields('address', fields.obligation_id),
+            liquidityAmount: decodeFromFields('u64', fields.liquidity_amount),
         });
     }
-    static fromFieldsWithTypes(typeArg, item) {
-        if (!isLendingMarketOwnerCap(item.type)) {
-            throw new Error("not a LendingMarketOwnerCap type");
+    static fromFieldsWithTypes(item) {
+        if (!isForgiveEvent(item.type)) {
+            throw new Error('not a ForgiveEvent type');
         }
-        assertFieldsWithTypesArgsMatch(item, [typeArg]);
-        return LendingMarketOwnerCap.reified(typeArg).new({
-            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
-            lendingMarketId: decodeFromFieldsWithTypes(ID.reified(), item.fields.lending_market_id),
+        return ForgiveEvent.reified().new({
+            lendingMarketId: decodeFromFieldsWithTypes('address', item.fields.lending_market_id),
+            coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
+            reserveId: decodeFromFieldsWithTypes('address', item.fields.reserve_id),
+            obligationId: decodeFromFieldsWithTypes('address', item.fields.obligation_id),
+            liquidityAmount: decodeFromFieldsWithTypes('u64', item.fields.liquidity_amount),
         });
     }
-    static fromBcs(typeArg, data) {
-        return LendingMarketOwnerCap.fromFields(typeArg, LendingMarketOwnerCap.bcs.parse(data));
+    static fromBcs(data) {
+        return ForgiveEvent.fromFields(ForgiveEvent.bcs.parse(data));
     }
     toJSONField() {
         return {
-            id: this.id,
             lendingMarketId: this.lendingMarketId,
+            coinType: this.coinType,
+            reserveId: this.reserveId,
+            obligationId: this.obligationId,
+            liquidityAmount: this.liquidityAmount.toString(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
-    static fromJSONField(typeArg, field) {
-        return LendingMarketOwnerCap.reified(typeArg).new({
-            id: decodeFromJSONField(UID.reified(), field.id),
-            lendingMarketId: decodeFromJSONField(ID.reified(), field.lendingMarketId),
+    static fromJSONField(field) {
+        return ForgiveEvent.reified().new({
+            lendingMarketId: decodeFromJSONField('address', field.lendingMarketId),
+            coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
+            reserveId: decodeFromJSONField('address', field.reserveId),
+            obligationId: decodeFromJSONField('address', field.obligationId),
+            liquidityAmount: decodeFromJSONField('u64', field.liquidityAmount),
         });
     }
-    static fromJSON(typeArg, json) {
-        if (json.$typeName !== LendingMarketOwnerCap.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+    static fromJSON(json) {
+        if (json.$typeName !== ForgiveEvent.$typeName) {
+            throw new Error(`not a ForgiveEvent json object: expected '${ForgiveEvent.$typeName}' but got '${json.$typeName}'`);
         }
-        assertReifiedTypeArgsMatch(composeSuiType(LendingMarketOwnerCap.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg]);
-        return LendingMarketOwnerCap.fromJSONField(typeArg, json);
+        return ForgiveEvent.fromJSONField(json);
     }
-    static async fetch(client, typeArg, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isLendingMarketOwnerCap(object.type)) {
-            throw new Error(`object at id ${id} is not a LendingMarketOwnerCap object`);
+    static fromCoreObject(obj) {
+        if (!isForgiveEvent(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a ForgiveEvent object`);
         }
-        return LendingMarketOwnerCap.fromBcs(typeArg, object.content);
+        return ForgiveEvent.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isForgiveEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a ForgiveEvent object`);
+        }
+        return ForgiveEvent.fromBcs(object.content);
     }
 }
 /* ============================== LiquidateEvent =============================== */
 export function isLiquidateEvent(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::lending_market::LiquidateEvent`;
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::LiquidateEvent')}::lending_market::LiquidateEvent`;
 }
 export class LiquidateEvent {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::lending_market::LiquidateEvent`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::LiquidateEvent')}::lending_market::LiquidateEvent`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
     $typeName = LiquidateEvent.$typeName;
@@ -1519,23 +2618,29 @@ export class LiquidateEvent {
         this.liquidatorBonusAmount = fields.liquidatorBonusAmount;
     }
     static reified() {
+        const reifiedBcs = LiquidateEvent.bcs;
         return {
-            typeName: LiquidateEvent.$typeName,
-            fullTypeName: composeSuiType(LiquidateEvent.$typeName, ...[]),
+            get typeName() {
+                return LiquidateEvent.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(LiquidateEvent.$typeName, ...[]);
+            },
             typeArgs: [],
             isPhantom: LiquidateEvent.$isPhantom,
             reifiedTypeArgs: [],
             fromFields: (fields) => LiquidateEvent.fromFields(fields),
             fromFieldsWithTypes: (item) => LiquidateEvent.fromFieldsWithTypes(item),
-            fromBcs: (data) => LiquidateEvent.fromBcs(data),
-            bcs: LiquidateEvent.bcs,
+            fromBcs: (data) => LiquidateEvent.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
             fromJSONField: (field) => LiquidateEvent.fromJSONField(field),
             fromJSON: (json) => LiquidateEvent.fromJSON(json),
+            fromCoreObject: (obj) => LiquidateEvent.fromCoreObject(obj),
             fetch: async (client, id) => LiquidateEvent.fetch(client, id),
             new: (fields) => {
                 return new LiquidateEvent([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
@@ -1547,29 +2652,21 @@ export class LiquidateEvent {
     static get p() {
         return LiquidateEvent.phantom();
     }
-    static get bcs() {
-        return bcs.struct("LiquidateEvent", {
-            lending_market_id: bcs
-                .bytes(32)
-                .transform({
+    static instantiateBcs() {
+        return bcs.struct('LiquidateEvent', {
+            lending_market_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
-            repay_reserve_id: bcs
-                .bytes(32)
-                .transform({
+            repay_reserve_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
-            withdraw_reserve_id: bcs
-                .bytes(32)
-                .transform({
+            withdraw_reserve_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
-            obligation_id: bcs
-                .bytes(32)
-                .transform({
+            obligation_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
@@ -1581,35 +2678,42 @@ export class LiquidateEvent {
             liquidator_bonus_amount: bcs.u64(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!LiquidateEvent.cachedBcs) {
+            LiquidateEvent.cachedBcs = LiquidateEvent.instantiateBcs();
+        }
+        return LiquidateEvent.cachedBcs;
+    }
     static fromFields(fields) {
         return LiquidateEvent.reified().new({
-            lendingMarketId: decodeFromFields("address", fields.lending_market_id),
-            repayReserveId: decodeFromFields("address", fields.repay_reserve_id),
-            withdrawReserveId: decodeFromFields("address", fields.withdraw_reserve_id),
-            obligationId: decodeFromFields("address", fields.obligation_id),
+            lendingMarketId: decodeFromFields('address', fields.lending_market_id),
+            repayReserveId: decodeFromFields('address', fields.repay_reserve_id),
+            withdrawReserveId: decodeFromFields('address', fields.withdraw_reserve_id),
+            obligationId: decodeFromFields('address', fields.obligation_id),
             repayCoinType: decodeFromFields(TypeName.reified(), fields.repay_coin_type),
             withdrawCoinType: decodeFromFields(TypeName.reified(), fields.withdraw_coin_type),
-            repayAmount: decodeFromFields("u64", fields.repay_amount),
-            withdrawAmount: decodeFromFields("u64", fields.withdraw_amount),
-            protocolFeeAmount: decodeFromFields("u64", fields.protocol_fee_amount),
-            liquidatorBonusAmount: decodeFromFields("u64", fields.liquidator_bonus_amount),
+            repayAmount: decodeFromFields('u64', fields.repay_amount),
+            withdrawAmount: decodeFromFields('u64', fields.withdraw_amount),
+            protocolFeeAmount: decodeFromFields('u64', fields.protocol_fee_amount),
+            liquidatorBonusAmount: decodeFromFields('u64', fields.liquidator_bonus_amount),
         });
     }
     static fromFieldsWithTypes(item) {
         if (!isLiquidateEvent(item.type)) {
-            throw new Error("not a LiquidateEvent type");
+            throw new Error('not a LiquidateEvent type');
         }
         return LiquidateEvent.reified().new({
-            lendingMarketId: decodeFromFieldsWithTypes("address", item.fields.lending_market_id),
-            repayReserveId: decodeFromFieldsWithTypes("address", item.fields.repay_reserve_id),
-            withdrawReserveId: decodeFromFieldsWithTypes("address", item.fields.withdraw_reserve_id),
-            obligationId: decodeFromFieldsWithTypes("address", item.fields.obligation_id),
+            lendingMarketId: decodeFromFieldsWithTypes('address', item.fields.lending_market_id),
+            repayReserveId: decodeFromFieldsWithTypes('address', item.fields.repay_reserve_id),
+            withdrawReserveId: decodeFromFieldsWithTypes('address', item.fields.withdraw_reserve_id),
+            obligationId: decodeFromFieldsWithTypes('address', item.fields.obligation_id),
             repayCoinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.repay_coin_type),
             withdrawCoinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.withdraw_coin_type),
-            repayAmount: decodeFromFieldsWithTypes("u64", item.fields.repay_amount),
-            withdrawAmount: decodeFromFieldsWithTypes("u64", item.fields.withdraw_amount),
-            protocolFeeAmount: decodeFromFieldsWithTypes("u64", item.fields.protocol_fee_amount),
-            liquidatorBonusAmount: decodeFromFieldsWithTypes("u64", item.fields.liquidator_bonus_amount),
+            repayAmount: decodeFromFieldsWithTypes('u64', item.fields.repay_amount),
+            withdrawAmount: decodeFromFieldsWithTypes('u64', item.fields.withdraw_amount),
+            protocolFeeAmount: decodeFromFieldsWithTypes('u64', item.fields.protocol_fee_amount),
+            liquidatorBonusAmount: decodeFromFieldsWithTypes('u64', item.fields.liquidator_bonus_amount),
         });
     }
     static fromBcs(data) {
@@ -1621,8 +2725,8 @@ export class LiquidateEvent {
             repayReserveId: this.repayReserveId,
             withdrawReserveId: this.withdrawReserveId,
             obligationId: this.obligationId,
-            repayCoinType: this.repayCoinType.toJSONField(),
-            withdrawCoinType: this.withdrawCoinType.toJSONField(),
+            repayCoinType: this.repayCoinType,
+            withdrawCoinType: this.withdrawCoinType,
             repayAmount: this.repayAmount.toString(),
             withdrawAmount: this.withdrawAmount.toString(),
             protocolFeeAmount: this.protocolFeeAmount.toString(),
@@ -1630,538 +2734,634 @@ export class LiquidateEvent {
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
         return LiquidateEvent.reified().new({
-            lendingMarketId: decodeFromJSONField("address", field.lendingMarketId),
-            repayReserveId: decodeFromJSONField("address", field.repayReserveId),
-            withdrawReserveId: decodeFromJSONField("address", field.withdrawReserveId),
-            obligationId: decodeFromJSONField("address", field.obligationId),
+            lendingMarketId: decodeFromJSONField('address', field.lendingMarketId),
+            repayReserveId: decodeFromJSONField('address', field.repayReserveId),
+            withdrawReserveId: decodeFromJSONField('address', field.withdrawReserveId),
+            obligationId: decodeFromJSONField('address', field.obligationId),
             repayCoinType: decodeFromJSONField(TypeName.reified(), field.repayCoinType),
             withdrawCoinType: decodeFromJSONField(TypeName.reified(), field.withdrawCoinType),
-            repayAmount: decodeFromJSONField("u64", field.repayAmount),
-            withdrawAmount: decodeFromJSONField("u64", field.withdrawAmount),
-            protocolFeeAmount: decodeFromJSONField("u64", field.protocolFeeAmount),
-            liquidatorBonusAmount: decodeFromJSONField("u64", field.liquidatorBonusAmount),
+            repayAmount: decodeFromJSONField('u64', field.repayAmount),
+            withdrawAmount: decodeFromJSONField('u64', field.withdrawAmount),
+            protocolFeeAmount: decodeFromJSONField('u64', field.protocolFeeAmount),
+            liquidatorBonusAmount: decodeFromJSONField('u64', field.liquidatorBonusAmount),
         });
     }
     static fromJSON(json) {
         if (json.$typeName !== LiquidateEvent.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+            throw new Error(`not a LiquidateEvent json object: expected '${LiquidateEvent.$typeName}' but got '${json.$typeName}'`);
         }
         return LiquidateEvent.fromJSONField(json);
     }
+    static fromCoreObject(obj) {
+        if (!isLiquidateEvent(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a LiquidateEvent object`);
+        }
+        return LiquidateEvent.fromBcs(obj.content);
+    }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
         if (!isLiquidateEvent(object.type)) {
             throw new Error(`object at id ${id} is not a LiquidateEvent object`);
         }
         return LiquidateEvent.fromBcs(object.content);
     }
 }
-/* ============================== ObligationOwnerCap =============================== */
-export function isObligationOwnerCap(type) {
+/* ============================== ClaimRewardEvent =============================== */
+export function isClaimRewardEvent(type) {
     type = compressSuiType(type);
-    return type.startsWith(`${PKG_V1}::lending_market::ObligationOwnerCap` + "<");
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::ClaimRewardEvent')}::lending_market::ClaimRewardEvent`;
 }
-export class ObligationOwnerCap {
+export class ClaimRewardEvent {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::lending_market::ObligationOwnerCap`;
-    static $numTypeParams = 1;
-    static $isPhantom = [true];
-    $typeName = ObligationOwnerCap.$typeName;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::ClaimRewardEvent')}::lending_market::ClaimRewardEvent`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = ClaimRewardEvent.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = ObligationOwnerCap.$isPhantom;
-    id;
+    $isPhantom = ClaimRewardEvent.$isPhantom;
+    lendingMarketId;
+    reserveId;
     obligationId;
+    isDepositReward;
+    poolRewardId;
+    coinType;
+    liquidityAmount;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(ObligationOwnerCap.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(ClaimRewardEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.id = fields.id;
+        this.lendingMarketId = fields.lendingMarketId;
+        this.reserveId = fields.reserveId;
         this.obligationId = fields.obligationId;
+        this.isDepositReward = fields.isDepositReward;
+        this.poolRewardId = fields.poolRewardId;
+        this.coinType = fields.coinType;
+        this.liquidityAmount = fields.liquidityAmount;
     }
-    static reified(P) {
+    static reified() {
+        const reifiedBcs = ClaimRewardEvent.bcs;
         return {
-            typeName: ObligationOwnerCap.$typeName,
-            fullTypeName: composeSuiType(ObligationOwnerCap.$typeName, ...[extractType(P)]),
-            typeArgs: [extractType(P)],
-            isPhantom: ObligationOwnerCap.$isPhantom,
-            reifiedTypeArgs: [P],
-            fromFields: (fields) => ObligationOwnerCap.fromFields(P, fields),
-            fromFieldsWithTypes: (item) => ObligationOwnerCap.fromFieldsWithTypes(P, item),
-            fromBcs: (data) => ObligationOwnerCap.fromBcs(P, data),
-            bcs: ObligationOwnerCap.bcs,
-            fromJSONField: (field) => ObligationOwnerCap.fromJSONField(P, field),
-            fromJSON: (json) => ObligationOwnerCap.fromJSON(P, json),
-            fetch: async (client, id) => ObligationOwnerCap.fetch(client, P, id),
+            get typeName() {
+                return ClaimRewardEvent.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(ClaimRewardEvent.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: ClaimRewardEvent.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => ClaimRewardEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => ClaimRewardEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => ClaimRewardEvent.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => ClaimRewardEvent.fromJSONField(field),
+            fromJSON: (json) => ClaimRewardEvent.fromJSON(json),
+            fromCoreObject: (obj) => ClaimRewardEvent.fromCoreObject(obj),
+            fetch: async (client, id) => ClaimRewardEvent.fetch(client, id),
             new: (fields) => {
-                return new ObligationOwnerCap([extractType(P)], fields);
+                return new ClaimRewardEvent([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return ObligationOwnerCap.reified;
+        return ClaimRewardEvent.reified();
     }
-    static phantom(P) {
-        return phantom(ObligationOwnerCap.reified(P));
+    static phantom() {
+        return phantom(ClaimRewardEvent.reified());
     }
     static get p() {
-        return ObligationOwnerCap.phantom;
+        return ClaimRewardEvent.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('ClaimRewardEvent', {
+            lending_market_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            reserve_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            obligation_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            is_deposit_reward: bcs.bool(),
+            pool_reward_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            coin_type: TypeName.bcs,
+            liquidity_amount: bcs.u64(),
+        });
     }
+    static cachedBcs = null;
     static get bcs() {
-        return bcs.struct("ObligationOwnerCap", {
-            id: UID.bcs,
-            obligation_id: ID.bcs,
-        });
+        if (!ClaimRewardEvent.cachedBcs) {
+            ClaimRewardEvent.cachedBcs = ClaimRewardEvent.instantiateBcs();
+        }
+        return ClaimRewardEvent.cachedBcs;
     }
-    static fromFields(typeArg, fields) {
-        return ObligationOwnerCap.reified(typeArg).new({
-            id: decodeFromFields(UID.reified(), fields.id),
-            obligationId: decodeFromFields(ID.reified(), fields.obligation_id),
+    static fromFields(fields) {
+        return ClaimRewardEvent.reified().new({
+            lendingMarketId: decodeFromFields('address', fields.lending_market_id),
+            reserveId: decodeFromFields('address', fields.reserve_id),
+            obligationId: decodeFromFields('address', fields.obligation_id),
+            isDepositReward: decodeFromFields('bool', fields.is_deposit_reward),
+            poolRewardId: decodeFromFields('address', fields.pool_reward_id),
+            coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
+            liquidityAmount: decodeFromFields('u64', fields.liquidity_amount),
         });
     }
-    static fromFieldsWithTypes(typeArg, item) {
-        if (!isObligationOwnerCap(item.type)) {
-            throw new Error("not a ObligationOwnerCap type");
+    static fromFieldsWithTypes(item) {
+        if (!isClaimRewardEvent(item.type)) {
+            throw new Error('not a ClaimRewardEvent type');
         }
-        assertFieldsWithTypesArgsMatch(item, [typeArg]);
-        return ObligationOwnerCap.reified(typeArg).new({
-            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
-            obligationId: decodeFromFieldsWithTypes(ID.reified(), item.fields.obligation_id),
+        return ClaimRewardEvent.reified().new({
+            lendingMarketId: decodeFromFieldsWithTypes('address', item.fields.lending_market_id),
+            reserveId: decodeFromFieldsWithTypes('address', item.fields.reserve_id),
+            obligationId: decodeFromFieldsWithTypes('address', item.fields.obligation_id),
+            isDepositReward: decodeFromFieldsWithTypes('bool', item.fields.is_deposit_reward),
+            poolRewardId: decodeFromFieldsWithTypes('address', item.fields.pool_reward_id),
+            coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
+            liquidityAmount: decodeFromFieldsWithTypes('u64', item.fields.liquidity_amount),
         });
     }
-    static fromBcs(typeArg, data) {
-        return ObligationOwnerCap.fromFields(typeArg, ObligationOwnerCap.bcs.parse(data));
+    static fromBcs(data) {
+        return ClaimRewardEvent.fromFields(ClaimRewardEvent.bcs.parse(data));
     }
     toJSONField() {
         return {
-            id: this.id,
+            lendingMarketId: this.lendingMarketId,
+            reserveId: this.reserveId,
             obligationId: this.obligationId,
+            isDepositReward: this.isDepositReward,
+            poolRewardId: this.poolRewardId,
+            coinType: this.coinType,
+            liquidityAmount: this.liquidityAmount.toString(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
-    static fromJSONField(typeArg, field) {
-        return ObligationOwnerCap.reified(typeArg).new({
-            id: decodeFromJSONField(UID.reified(), field.id),
-            obligationId: decodeFromJSONField(ID.reified(), field.obligationId),
+    static fromJSONField(field) {
+        return ClaimRewardEvent.reified().new({
+            lendingMarketId: decodeFromJSONField('address', field.lendingMarketId),
+            reserveId: decodeFromJSONField('address', field.reserveId),
+            obligationId: decodeFromJSONField('address', field.obligationId),
+            isDepositReward: decodeFromJSONField('bool', field.isDepositReward),
+            poolRewardId: decodeFromJSONField('address', field.poolRewardId),
+            coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
+            liquidityAmount: decodeFromJSONField('u64', field.liquidityAmount),
         });
     }
-    static fromJSON(typeArg, json) {
-        if (json.$typeName !== ObligationOwnerCap.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+    static fromJSON(json) {
+        if (json.$typeName !== ClaimRewardEvent.$typeName) {
+            throw new Error(`not a ClaimRewardEvent json object: expected '${ClaimRewardEvent.$typeName}' but got '${json.$typeName}'`);
         }
-        assertReifiedTypeArgsMatch(composeSuiType(ObligationOwnerCap.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg]);
-        return ObligationOwnerCap.fromJSONField(typeArg, json);
+        return ClaimRewardEvent.fromJSONField(json);
     }
-    static async fetch(client, typeArg, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isObligationOwnerCap(object.type)) {
-            throw new Error(`object at id ${id} is not a ObligationOwnerCap object`);
+    static fromCoreObject(obj) {
+        if (!isClaimRewardEvent(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a ClaimRewardEvent object`);
         }
-        return ObligationOwnerCap.fromBcs(typeArg, object.content);
+        return ClaimRewardEvent.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isClaimRewardEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a ClaimRewardEvent object`);
+        }
+        return ClaimRewardEvent.fromBcs(object.content);
     }
 }
-/* ============================== RateLimiterExemption =============================== */
-export function isRateLimiterExemption(type) {
+/* ============================== MarketPauseEvent =============================== */
+export function isMarketPauseEvent(type) {
     type = compressSuiType(type);
-    return type.startsWith(`${PKG_V1}::lending_market::RateLimiterExemption` + "<");
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::MarketPauseEvent')}::lending_market::MarketPauseEvent`;
 }
-export class RateLimiterExemption {
+export class MarketPauseEvent {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::lending_market::RateLimiterExemption`;
-    static $numTypeParams = 2;
-    static $isPhantom = [true, true];
-    $typeName = RateLimiterExemption.$typeName;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::MarketPauseEvent')}::lending_market::MarketPauseEvent`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = MarketPauseEvent.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = RateLimiterExemption.$isPhantom;
-    amount;
+    $isPhantom = MarketPauseEvent.$isPhantom;
+    lendingMarketId;
+    paused;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(RateLimiterExemption.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(MarketPauseEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.amount = fields.amount;
+        this.lendingMarketId = fields.lendingMarketId;
+        this.paused = fields.paused;
     }
-    static reified(P, T) {
+    static reified() {
+        const reifiedBcs = MarketPauseEvent.bcs;
         return {
-            typeName: RateLimiterExemption.$typeName,
-            fullTypeName: composeSuiType(RateLimiterExemption.$typeName, ...[extractType(P), extractType(T)]),
-            typeArgs: [extractType(P), extractType(T)],
-            isPhantom: RateLimiterExemption.$isPhantom,
-            reifiedTypeArgs: [P, T],
-            fromFields: (fields) => RateLimiterExemption.fromFields([P, T], fields),
-            fromFieldsWithTypes: (item) => RateLimiterExemption.fromFieldsWithTypes([P, T], item),
-            fromBcs: (data) => RateLimiterExemption.fromBcs([P, T], data),
-            bcs: RateLimiterExemption.bcs,
-            fromJSONField: (field) => RateLimiterExemption.fromJSONField([P, T], field),
-            fromJSON: (json) => RateLimiterExemption.fromJSON([P, T], json),
-            fetch: async (client, id) => RateLimiterExemption.fetch(client, [P, T], id),
+            get typeName() {
+                return MarketPauseEvent.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(MarketPauseEvent.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: MarketPauseEvent.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => MarketPauseEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => MarketPauseEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => MarketPauseEvent.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => MarketPauseEvent.fromJSONField(field),
+            fromJSON: (json) => MarketPauseEvent.fromJSON(json),
+            fromCoreObject: (obj) => MarketPauseEvent.fromCoreObject(obj),
+            fetch: async (client, id) => MarketPauseEvent.fetch(client, id),
             new: (fields) => {
-                return new RateLimiterExemption([extractType(P), extractType(T)], fields);
+                return new MarketPauseEvent([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return RateLimiterExemption.reified;
+        return MarketPauseEvent.reified();
     }
-    static phantom(P, T) {
-        return phantom(RateLimiterExemption.reified(P, T));
+    static phantom() {
+        return phantom(MarketPauseEvent.reified());
     }
     static get p() {
-        return RateLimiterExemption.phantom;
+        return MarketPauseEvent.phantom();
     }
-    static get bcs() {
-        return bcs.struct("RateLimiterExemption", {
-            amount: bcs.u64(),
+    static instantiateBcs() {
+        return bcs.struct('MarketPauseEvent', {
+            lending_market_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            paused: bcs.bool(),
         });
     }
-    static fromFields(typeArgs, fields) {
-        return RateLimiterExemption.reified(typeArgs[0], typeArgs[1]).new({
-            amount: decodeFromFields("u64", fields.amount),
+    static cachedBcs = null;
+    static get bcs() {
+        if (!MarketPauseEvent.cachedBcs) {
+            MarketPauseEvent.cachedBcs = MarketPauseEvent.instantiateBcs();
+        }
+        return MarketPauseEvent.cachedBcs;
+    }
+    static fromFields(fields) {
+        return MarketPauseEvent.reified().new({
+            lendingMarketId: decodeFromFields('address', fields.lending_market_id),
+            paused: decodeFromFields('bool', fields.paused),
         });
     }
-    static fromFieldsWithTypes(typeArgs, item) {
-        if (!isRateLimiterExemption(item.type)) {
-            throw new Error("not a RateLimiterExemption type");
+    static fromFieldsWithTypes(item) {
+        if (!isMarketPauseEvent(item.type)) {
+            throw new Error('not a MarketPauseEvent type');
         }
-        assertFieldsWithTypesArgsMatch(item, typeArgs);
-        return RateLimiterExemption.reified(typeArgs[0], typeArgs[1]).new({
-            amount: decodeFromFieldsWithTypes("u64", item.fields.amount),
+        return MarketPauseEvent.reified().new({
+            lendingMarketId: decodeFromFieldsWithTypes('address', item.fields.lending_market_id),
+            paused: decodeFromFieldsWithTypes('bool', item.fields.paused),
         });
     }
-    static fromBcs(typeArgs, data) {
-        return RateLimiterExemption.fromFields(typeArgs, RateLimiterExemption.bcs.parse(data));
+    static fromBcs(data) {
+        return MarketPauseEvent.fromFields(MarketPauseEvent.bcs.parse(data));
     }
     toJSONField() {
         return {
-            amount: this.amount.toString(),
+            lendingMarketId: this.lendingMarketId,
+            paused: this.paused,
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
-    static fromJSONField(typeArgs, field) {
-        return RateLimiterExemption.reified(typeArgs[0], typeArgs[1]).new({
-            amount: decodeFromJSONField("u64", field.amount),
+    static fromJSONField(field) {
+        return MarketPauseEvent.reified().new({
+            lendingMarketId: decodeFromJSONField('address', field.lendingMarketId),
+            paused: decodeFromJSONField('bool', field.paused),
         });
     }
-    static fromJSON(typeArgs, json) {
-        if (json.$typeName !== RateLimiterExemption.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+    static fromJSON(json) {
+        if (json.$typeName !== MarketPauseEvent.$typeName) {
+            throw new Error(`not a MarketPauseEvent json object: expected '${MarketPauseEvent.$typeName}' but got '${json.$typeName}'`);
         }
-        assertReifiedTypeArgsMatch(composeSuiType(RateLimiterExemption.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs);
-        return RateLimiterExemption.fromJSONField(typeArgs, json);
+        return MarketPauseEvent.fromJSONField(json);
     }
-    static async fetch(client, typeArgs, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isRateLimiterExemption(object.type)) {
-            throw new Error(`object at id ${id} is not a RateLimiterExemption object`);
+    static fromCoreObject(obj) {
+        if (!isMarketPauseEvent(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a MarketPauseEvent object`);
         }
-        return RateLimiterExemption.fromBcs(typeArgs, object.content);
+        return MarketPauseEvent.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isMarketPauseEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a MarketPauseEvent object`);
+        }
+        return MarketPauseEvent.fromBcs(object.content);
     }
 }
-/* ============================== RepayEvent =============================== */
-export function isRepayEvent(type) {
+/* ============================== ReservePauseEvent =============================== */
+export function isReservePauseEvent(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::lending_market::RepayEvent`;
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::ReservePauseEvent')}::lending_market::ReservePauseEvent`;
 }
-export class RepayEvent {
+export class ReservePauseEvent {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::lending_market::RepayEvent`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::ReservePauseEvent')}::lending_market::ReservePauseEvent`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
-    $typeName = RepayEvent.$typeName;
+    $typeName = ReservePauseEvent.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = RepayEvent.$isPhantom;
+    $isPhantom = ReservePauseEvent.$isPhantom;
     lendingMarketId;
-    coinType;
     reserveId;
-    obligationId;
-    liquidityAmount;
+    paused;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(RepayEvent.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(ReservePauseEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
-        this.coinType = fields.coinType;
         this.reserveId = fields.reserveId;
-        this.obligationId = fields.obligationId;
-        this.liquidityAmount = fields.liquidityAmount;
+        this.paused = fields.paused;
     }
     static reified() {
+        const reifiedBcs = ReservePauseEvent.bcs;
         return {
-            typeName: RepayEvent.$typeName,
-            fullTypeName: composeSuiType(RepayEvent.$typeName, ...[]),
+            get typeName() {
+                return ReservePauseEvent.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(ReservePauseEvent.$typeName, ...[]);
+            },
             typeArgs: [],
-            isPhantom: RepayEvent.$isPhantom,
+            isPhantom: ReservePauseEvent.$isPhantom,
             reifiedTypeArgs: [],
-            fromFields: (fields) => RepayEvent.fromFields(fields),
-            fromFieldsWithTypes: (item) => RepayEvent.fromFieldsWithTypes(item),
-            fromBcs: (data) => RepayEvent.fromBcs(data),
-            bcs: RepayEvent.bcs,
-            fromJSONField: (field) => RepayEvent.fromJSONField(field),
-            fromJSON: (json) => RepayEvent.fromJSON(json),
-            fetch: async (client, id) => RepayEvent.fetch(client, id),
+            fromFields: (fields) => ReservePauseEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => ReservePauseEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => ReservePauseEvent.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => ReservePauseEvent.fromJSONField(field),
+            fromJSON: (json) => ReservePauseEvent.fromJSON(json),
+            fromCoreObject: (obj) => ReservePauseEvent.fromCoreObject(obj),
+            fetch: async (client, id) => ReservePauseEvent.fetch(client, id),
             new: (fields) => {
-                return new RepayEvent([], fields);
+                return new ReservePauseEvent([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return RepayEvent.reified();
+        return ReservePauseEvent.reified();
     }
     static phantom() {
-        return phantom(RepayEvent.reified());
+        return phantom(ReservePauseEvent.reified());
     }
     static get p() {
-        return RepayEvent.phantom();
+        return ReservePauseEvent.phantom();
     }
-    static get bcs() {
-        return bcs.struct("RepayEvent", {
-            lending_market_id: bcs
-                .bytes(32)
-                .transform({
-                input: (val) => fromHex(val),
-                output: (val) => toHex(val),
-            }),
-            coin_type: TypeName.bcs,
-            reserve_id: bcs
-                .bytes(32)
-                .transform({
+    static instantiateBcs() {
+        return bcs.struct('ReservePauseEvent', {
+            lending_market_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
-            obligation_id: bcs
-                .bytes(32)
-                .transform({
+            reserve_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
-            liquidity_amount: bcs.u64(),
+            paused: bcs.bool(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!ReservePauseEvent.cachedBcs) {
+            ReservePauseEvent.cachedBcs = ReservePauseEvent.instantiateBcs();
+        }
+        return ReservePauseEvent.cachedBcs;
+    }
     static fromFields(fields) {
-        return RepayEvent.reified().new({
-            lendingMarketId: decodeFromFields("address", fields.lending_market_id),
-            coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
-            reserveId: decodeFromFields("address", fields.reserve_id),
-            obligationId: decodeFromFields("address", fields.obligation_id),
-            liquidityAmount: decodeFromFields("u64", fields.liquidity_amount),
+        return ReservePauseEvent.reified().new({
+            lendingMarketId: decodeFromFields('address', fields.lending_market_id),
+            reserveId: decodeFromFields('address', fields.reserve_id),
+            paused: decodeFromFields('bool', fields.paused),
         });
     }
     static fromFieldsWithTypes(item) {
-        if (!isRepayEvent(item.type)) {
-            throw new Error("not a RepayEvent type");
+        if (!isReservePauseEvent(item.type)) {
+            throw new Error('not a ReservePauseEvent type');
         }
-        return RepayEvent.reified().new({
-            lendingMarketId: decodeFromFieldsWithTypes("address", item.fields.lending_market_id),
-            coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
-            reserveId: decodeFromFieldsWithTypes("address", item.fields.reserve_id),
-            obligationId: decodeFromFieldsWithTypes("address", item.fields.obligation_id),
-            liquidityAmount: decodeFromFieldsWithTypes("u64", item.fields.liquidity_amount),
+        return ReservePauseEvent.reified().new({
+            lendingMarketId: decodeFromFieldsWithTypes('address', item.fields.lending_market_id),
+            reserveId: decodeFromFieldsWithTypes('address', item.fields.reserve_id),
+            paused: decodeFromFieldsWithTypes('bool', item.fields.paused),
         });
     }
     static fromBcs(data) {
-        return RepayEvent.fromFields(RepayEvent.bcs.parse(data));
+        return ReservePauseEvent.fromFields(ReservePauseEvent.bcs.parse(data));
     }
     toJSONField() {
         return {
             lendingMarketId: this.lendingMarketId,
-            coinType: this.coinType.toJSONField(),
             reserveId: this.reserveId,
-            obligationId: this.obligationId,
-            liquidityAmount: this.liquidityAmount.toString(),
+            paused: this.paused,
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
-        return RepayEvent.reified().new({
-            lendingMarketId: decodeFromJSONField("address", field.lendingMarketId),
-            coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
-            reserveId: decodeFromJSONField("address", field.reserveId),
-            obligationId: decodeFromJSONField("address", field.obligationId),
-            liquidityAmount: decodeFromJSONField("u64", field.liquidityAmount),
+        return ReservePauseEvent.reified().new({
+            lendingMarketId: decodeFromJSONField('address', field.lendingMarketId),
+            reserveId: decodeFromJSONField('address', field.reserveId),
+            paused: decodeFromJSONField('bool', field.paused),
         });
     }
     static fromJSON(json) {
-        if (json.$typeName !== RepayEvent.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+        if (json.$typeName !== ReservePauseEvent.$typeName) {
+            throw new Error(`not a ReservePauseEvent json object: expected '${ReservePauseEvent.$typeName}' but got '${json.$typeName}'`);
         }
-        return RepayEvent.fromJSONField(json);
+        return ReservePauseEvent.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isReservePauseEvent(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a ReservePauseEvent object`);
+        }
+        return ReservePauseEvent.fromBcs(obj.content);
     }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isRepayEvent(object.type)) {
-            throw new Error(`object at id ${id} is not a RepayEvent object`);
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isReservePauseEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a ReservePauseEvent object`);
         }
-        return RepayEvent.fromBcs(object.content);
+        return ReservePauseEvent.fromBcs(object.content);
     }
 }
-/* ============================== WithdrawEvent =============================== */
-export function isWithdrawEvent(type) {
+/* ============================== PauseCapRotatedEvent =============================== */
+export function isPauseCapRotatedEvent(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::lending_market::WithdrawEvent`;
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::PauseCapRotatedEvent')}::lending_market::PauseCapRotatedEvent`;
 }
-export class WithdrawEvent {
+export class PauseCapRotatedEvent {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::lending_market::WithdrawEvent`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::PauseCapRotatedEvent')}::lending_market::PauseCapRotatedEvent`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
-    $typeName = WithdrawEvent.$typeName;
+    $typeName = PauseCapRotatedEvent.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = WithdrawEvent.$isPhantom;
+    $isPhantom = PauseCapRotatedEvent.$isPhantom;
     lendingMarketId;
-    coinType;
-    reserveId;
-    obligationId;
-    ctokenAmount;
+    newCapId;
+    generation;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(WithdrawEvent.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(PauseCapRotatedEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
-        this.coinType = fields.coinType;
-        this.reserveId = fields.reserveId;
-        this.obligationId = fields.obligationId;
-        this.ctokenAmount = fields.ctokenAmount;
+        this.newCapId = fields.newCapId;
+        this.generation = fields.generation;
     }
     static reified() {
+        const reifiedBcs = PauseCapRotatedEvent.bcs;
         return {
-            typeName: WithdrawEvent.$typeName,
-            fullTypeName: composeSuiType(WithdrawEvent.$typeName, ...[]),
+            get typeName() {
+                return PauseCapRotatedEvent.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(PauseCapRotatedEvent.$typeName, ...[]);
+            },
             typeArgs: [],
-            isPhantom: WithdrawEvent.$isPhantom,
+            isPhantom: PauseCapRotatedEvent.$isPhantom,
             reifiedTypeArgs: [],
-            fromFields: (fields) => WithdrawEvent.fromFields(fields),
-            fromFieldsWithTypes: (item) => WithdrawEvent.fromFieldsWithTypes(item),
-            fromBcs: (data) => WithdrawEvent.fromBcs(data),
-            bcs: WithdrawEvent.bcs,
-            fromJSONField: (field) => WithdrawEvent.fromJSONField(field),
-            fromJSON: (json) => WithdrawEvent.fromJSON(json),
-            fetch: async (client, id) => WithdrawEvent.fetch(client, id),
+            fromFields: (fields) => PauseCapRotatedEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => PauseCapRotatedEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => PauseCapRotatedEvent.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => PauseCapRotatedEvent.fromJSONField(field),
+            fromJSON: (json) => PauseCapRotatedEvent.fromJSON(json),
+            fromCoreObject: (obj) => PauseCapRotatedEvent.fromCoreObject(obj),
+            fetch: async (client, id) => PauseCapRotatedEvent.fetch(client, id),
             new: (fields) => {
-                return new WithdrawEvent([], fields);
+                return new PauseCapRotatedEvent([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return WithdrawEvent.reified();
+        return PauseCapRotatedEvent.reified();
     }
     static phantom() {
-        return phantom(WithdrawEvent.reified());
+        return phantom(PauseCapRotatedEvent.reified());
     }
     static get p() {
-        return WithdrawEvent.phantom();
+        return PauseCapRotatedEvent.phantom();
     }
-    static get bcs() {
-        return bcs.struct("WithdrawEvent", {
-            lending_market_id: bcs
-                .bytes(32)
-                .transform({
-                input: (val) => fromHex(val),
-                output: (val) => toHex(val),
-            }),
-            coin_type: TypeName.bcs,
-            reserve_id: bcs
-                .bytes(32)
-                .transform({
+    static instantiateBcs() {
+        return bcs.struct('PauseCapRotatedEvent', {
+            lending_market_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
-            obligation_id: bcs
-                .bytes(32)
-                .transform({
+            new_cap_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
-            ctoken_amount: bcs.u64(),
+            generation: bcs.u64(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!PauseCapRotatedEvent.cachedBcs) {
+            PauseCapRotatedEvent.cachedBcs = PauseCapRotatedEvent.instantiateBcs();
+        }
+        return PauseCapRotatedEvent.cachedBcs;
+    }
     static fromFields(fields) {
-        return WithdrawEvent.reified().new({
-            lendingMarketId: decodeFromFields("address", fields.lending_market_id),
-            coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
-            reserveId: decodeFromFields("address", fields.reserve_id),
-            obligationId: decodeFromFields("address", fields.obligation_id),
-            ctokenAmount: decodeFromFields("u64", fields.ctoken_amount),
+        return PauseCapRotatedEvent.reified().new({
+            lendingMarketId: decodeFromFields('address', fields.lending_market_id),
+            newCapId: decodeFromFields('address', fields.new_cap_id),
+            generation: decodeFromFields('u64', fields.generation),
         });
     }
     static fromFieldsWithTypes(item) {
-        if (!isWithdrawEvent(item.type)) {
-            throw new Error("not a WithdrawEvent type");
+        if (!isPauseCapRotatedEvent(item.type)) {
+            throw new Error('not a PauseCapRotatedEvent type');
         }
-        return WithdrawEvent.reified().new({
-            lendingMarketId: decodeFromFieldsWithTypes("address", item.fields.lending_market_id),
-            coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
-            reserveId: decodeFromFieldsWithTypes("address", item.fields.reserve_id),
-            obligationId: decodeFromFieldsWithTypes("address", item.fields.obligation_id),
-            ctokenAmount: decodeFromFieldsWithTypes("u64", item.fields.ctoken_amount),
+        return PauseCapRotatedEvent.reified().new({
+            lendingMarketId: decodeFromFieldsWithTypes('address', item.fields.lending_market_id),
+            newCapId: decodeFromFieldsWithTypes('address', item.fields.new_cap_id),
+            generation: decodeFromFieldsWithTypes('u64', item.fields.generation),
         });
     }
     static fromBcs(data) {
-        return WithdrawEvent.fromFields(WithdrawEvent.bcs.parse(data));
+        return PauseCapRotatedEvent.fromFields(PauseCapRotatedEvent.bcs.parse(data));
     }
     toJSONField() {
         return {
             lendingMarketId: this.lendingMarketId,
-            coinType: this.coinType.toJSONField(),
-            reserveId: this.reserveId,
-            obligationId: this.obligationId,
-            ctokenAmount: this.ctokenAmount.toString(),
+            newCapId: this.newCapId,
+            generation: this.generation.toString(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
-        return WithdrawEvent.reified().new({
-            lendingMarketId: decodeFromJSONField("address", field.lendingMarketId),
-            coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
-            reserveId: decodeFromJSONField("address", field.reserveId),
-            obligationId: decodeFromJSONField("address", field.obligationId),
-            ctokenAmount: decodeFromJSONField("u64", field.ctokenAmount),
+        return PauseCapRotatedEvent.reified().new({
+            lendingMarketId: decodeFromJSONField('address', field.lendingMarketId),
+            newCapId: decodeFromJSONField('address', field.newCapId),
+            generation: decodeFromJSONField('u64', field.generation),
         });
     }
     static fromJSON(json) {
-        if (json.$typeName !== WithdrawEvent.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+        if (json.$typeName !== PauseCapRotatedEvent.$typeName) {
+            throw new Error(`not a PauseCapRotatedEvent json object: expected '${PauseCapRotatedEvent.$typeName}' but got '${json.$typeName}'`);
         }
-        return WithdrawEvent.fromJSONField(json);
+        return PauseCapRotatedEvent.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isPauseCapRotatedEvent(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a PauseCapRotatedEvent object`);
+        }
+        return PauseCapRotatedEvent.fromBcs(obj.content);
     }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isWithdrawEvent(object.type)) {
-            throw new Error(`object at id ${id} is not a WithdrawEvent object`);
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isPauseCapRotatedEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a PauseCapRotatedEvent object`);
         }
-        return WithdrawEvent.fromBcs(object.content);
+        return PauseCapRotatedEvent.fromBcs(object.content);
     }
 }