@suilend/sdk 3.0.8 → 4.0.0

package/_generated/suilend/obligation/structs.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import * as reified from "../../_framework/reified.js";
 import { TypeName } from "../../_dependencies/source/0x1/type-name/structs.js";
 import { ID, UID } from "../../_dependencies/source/0x2/object/structs.js";
@@ -23,10 +14,21 @@ export function isBorrow(type) {
     return type === `${PKG_V1}::obligation::Borrow`;
 }
 export class Borrow {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::obligation::Borrow`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = Borrow.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = Borrow.$isPhantom;
+    coinType;
+    reserveArrayIndex;
+    borrowedAmount;
+    cumulativeBorrowRate;
+    marketValue;
+    userRewardManagerIndex;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = Borrow.$typeName;
-        this.$isPhantom = Borrow.$isPhantom;
         this.$fullTypeName = composeSuiType(Borrow.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.coinType = fields.coinType;
@@ -49,7 +51,7 @@ export class Borrow {
             bcs: Borrow.bcs,
             fromJSONField: (field) => Borrow.fromJSONField(field),
             fromJSON: (json) => Borrow.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return Borrow.fetch(client, id); }),
+            fetch: async (client, id) => Borrow.fetch(client, id),
             new: (fields) => {
                 return new Borrow([], fields);
             },
@@ -112,7 +114,11 @@ export class Borrow {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return Borrow.reified().new({
@@ -130,29 +136,35 @@ export class Borrow {
         }
         return Borrow.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isBorrow(object.type)) {
-                throw new Error(`object at id ${id} is not a Borrow object`);
-            }
-            return Borrow.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isBorrow(object.type)) {
+            throw new Error(`object at id ${id} is not a Borrow object`);
+        }
+        return Borrow.fromBcs(object.content);
     }
 }
-Borrow.$typeName = `${PKG_V1}::obligation::Borrow`;
-Borrow.$numTypeParams = 0;
-Borrow.$isPhantom = [];
 /* ============================== BorrowRecord =============================== */
 export function isBorrowRecord(type) {
     type = compressSuiType(type);
     return type === `${PKG_V1}::obligation::BorrowRecord`;
 }
 export class BorrowRecord {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::obligation::BorrowRecord`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = BorrowRecord.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = BorrowRecord.$isPhantom;
+    coinType;
+    reserveArrayIndex;
+    borrowedAmount;
+    cumulativeBorrowRate;
+    marketValue;
+    userRewardManagerIndex;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = BorrowRecord.$typeName;
-        this.$isPhantom = BorrowRecord.$isPhantom;
         this.$fullTypeName = composeSuiType(BorrowRecord.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.coinType = fields.coinType;
@@ -175,7 +187,7 @@ export class BorrowRecord {
             bcs: BorrowRecord.bcs,
             fromJSONField: (field) => BorrowRecord.fromJSONField(field),
             fromJSON: (json) => BorrowRecord.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return BorrowRecord.fetch(client, id); }),
+            fetch: async (client, id) => BorrowRecord.fetch(client, id),
             new: (fields) => {
                 return new BorrowRecord([], fields);
             },
@@ -238,7 +250,11 @@ export class BorrowRecord {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return BorrowRecord.reified().new({
@@ -256,29 +272,35 @@ export class BorrowRecord {
         }
         return BorrowRecord.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isBorrowRecord(object.type)) {
-                throw new Error(`object at id ${id} is not a BorrowRecord object`);
-            }
-            return BorrowRecord.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isBorrowRecord(object.type)) {
+            throw new Error(`object at id ${id} is not a BorrowRecord object`);
+        }
+        return BorrowRecord.fromBcs(object.content);
     }
 }
-BorrowRecord.$typeName = `${PKG_V1}::obligation::BorrowRecord`;
-BorrowRecord.$numTypeParams = 0;
-BorrowRecord.$isPhantom = [];
 /* ============================== Deposit =============================== */
 export function isDeposit(type) {
     type = compressSuiType(type);
     return type === `${PKG_V1}::obligation::Deposit`;
 }
 export class Deposit {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::obligation::Deposit`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = Deposit.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = Deposit.$isPhantom;
+    coinType;
+    reserveArrayIndex;
+    depositedCtokenAmount;
+    marketValue;
+    userRewardManagerIndex;
+    attributedBorrowValue;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = Deposit.$typeName;
-        this.$isPhantom = Deposit.$isPhantom;
         this.$fullTypeName = composeSuiType(Deposit.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.coinType = fields.coinType;
@@ -301,7 +323,7 @@ export class Deposit {
             bcs: Deposit.bcs,
             fromJSONField: (field) => Deposit.fromJSONField(field),
             fromJSON: (json) => Deposit.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return Deposit.fetch(client, id); }),
+            fetch: async (client, id) => Deposit.fetch(client, id),
             new: (fields) => {
                 return new Deposit([], fields);
             },
@@ -364,7 +386,11 @@ export class Deposit {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return Deposit.reified().new({
@@ -382,29 +408,35 @@ export class Deposit {
         }
         return Deposit.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isDeposit(object.type)) {
-                throw new Error(`object at id ${id} is not a Deposit object`);
-            }
-            return Deposit.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isDeposit(object.type)) {
+            throw new Error(`object at id ${id} is not a Deposit object`);
+        }
+        return Deposit.fromBcs(object.content);
     }
 }
-Deposit.$typeName = `${PKG_V1}::obligation::Deposit`;
-Deposit.$numTypeParams = 0;
-Deposit.$isPhantom = [];
 /* ============================== DepositRecord =============================== */
 export function isDepositRecord(type) {
     type = compressSuiType(type);
     return type === `${PKG_V1}::obligation::DepositRecord`;
 }
 export class DepositRecord {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::obligation::DepositRecord`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = DepositRecord.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = DepositRecord.$isPhantom;
+    coinType;
+    reserveArrayIndex;
+    depositedCtokenAmount;
+    marketValue;
+    userRewardManagerIndex;
+    attributedBorrowValue;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = DepositRecord.$typeName;
-        this.$isPhantom = DepositRecord.$isPhantom;
         this.$fullTypeName = composeSuiType(DepositRecord.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.coinType = fields.coinType;
@@ -427,7 +459,7 @@ export class DepositRecord {
             bcs: DepositRecord.bcs,
             fromJSONField: (field) => DepositRecord.fromJSONField(field),
             fromJSON: (json) => DepositRecord.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return DepositRecord.fetch(client, id); }),
+            fetch: async (client, id) => DepositRecord.fetch(client, id),
             new: (fields) => {
                 return new DepositRecord([], fields);
             },
@@ -490,7 +522,11 @@ export class DepositRecord {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return DepositRecord.reified().new({
@@ -508,29 +544,30 @@ export class DepositRecord {
         }
         return DepositRecord.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isDepositRecord(object.type)) {
-                throw new Error(`object at id ${id} is not a DepositRecord object`);
-            }
-            return DepositRecord.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isDepositRecord(object.type)) {
+            throw new Error(`object at id ${id} is not a DepositRecord object`);
+        }
+        return DepositRecord.fromBcs(object.content);
     }
 }
-DepositRecord.$typeName = `${PKG_V1}::obligation::DepositRecord`;
-DepositRecord.$numTypeParams = 0;
-DepositRecord.$isPhantom = [];
 /* ============================== ExistStaleOracles =============================== */
 export function isExistStaleOracles(type) {
     type = compressSuiType(type);
     return type === `${PKG_V11}::obligation::ExistStaleOracles`;
 }
 export class ExistStaleOracles {
+    __StructClass = true;
+    static $typeName = `${PKG_V11}::obligation::ExistStaleOracles`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = ExistStaleOracles.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = ExistStaleOracles.$isPhantom;
+    dummyField;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = ExistStaleOracles.$typeName;
-        this.$isPhantom = ExistStaleOracles.$isPhantom;
         this.$fullTypeName = composeSuiType(ExistStaleOracles.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.dummyField = fields.dummyField;
@@ -548,7 +585,7 @@ export class ExistStaleOracles {
             bcs: ExistStaleOracles.bcs,
             fromJSONField: (field) => ExistStaleOracles.fromJSONField(field),
             fromJSON: (json) => ExistStaleOracles.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return ExistStaleOracles.fetch(client, id); }),
+            fetch: async (client, id) => ExistStaleOracles.fetch(client, id),
             new: (fields) => {
                 return new ExistStaleOracles([], fields);
             },
@@ -591,7 +628,11 @@ export class ExistStaleOracles {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return ExistStaleOracles.reified().new({
@@ -604,29 +645,44 @@ export class ExistStaleOracles {
         }
         return ExistStaleOracles.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isExistStaleOracles(object.type)) {
-                throw new Error(`object at id ${id} is not a ExistStaleOracles object`);
-            }
-            return ExistStaleOracles.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isExistStaleOracles(object.type)) {
+            throw new Error(`object at id ${id} is not a ExistStaleOracles object`);
+        }
+        return ExistStaleOracles.fromBcs(object.content);
     }
 }
-ExistStaleOracles.$typeName = `${PKG_V11}::obligation::ExistStaleOracles`;
-ExistStaleOracles.$numTypeParams = 0;
-ExistStaleOracles.$isPhantom = [];
 /* ============================== Obligation =============================== */
 export function isObligation(type) {
     type = compressSuiType(type);
     return type.startsWith(`${PKG_V1}::obligation::Obligation` + "<");
 }
 export class Obligation {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::obligation::Obligation`;
+    static $numTypeParams = 1;
+    static $isPhantom = [true];
+    $typeName = Obligation.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = Obligation.$isPhantom;
+    id;
+    lendingMarketId;
+    deposits;
+    borrows;
+    depositedValueUsd;
+    allowedBorrowValueUsd;
+    unhealthyBorrowValueUsd;
+    superUnhealthyBorrowValueUsd;
+    unweightedBorrowedValueUsd;
+    weightedBorrowedValueUsd;
+    weightedBorrowedValueUpperBoundUsd;
+    borrowingIsolatedAsset;
+    userRewardManagers;
+    badDebtUsd;
+    closable;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = Obligation.$typeName;
-        this.$isPhantom = Obligation.$isPhantom;
         this.$fullTypeName = composeSuiType(Obligation.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.id = fields.id;
@@ -659,7 +715,7 @@ export class Obligation {
             bcs: Obligation.bcs,
             fromJSONField: (field) => Obligation.fromJSONField(P, field),
             fromJSON: (json) => Obligation.fromJSON(P, json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return Obligation.fetch(client, P, id); }),
+            fetch: async (client, id) => Obligation.fetch(client, P, id),
             new: (fields) => {
                 return new Obligation([extractType(P)], fields);
             },
@@ -759,7 +815,11 @@ export class Obligation {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(typeArg, field) {
         return Obligation.reified(typeArg).new({
@@ -787,29 +847,43 @@ export class Obligation {
         assertReifiedTypeArgsMatch(composeSuiType(Obligation.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg]);
         return Obligation.fromJSONField(typeArg, json);
     }
-    static fetch(client, typeArg, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isObligation(object.type)) {
-                throw new Error(`object at id ${id} is not a Obligation object`);
-            }
-            return Obligation.fromBcs(typeArg, object.content);
-        });
+    static async fetch(client, typeArg, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isObligation(object.type)) {
+            throw new Error(`object at id ${id} is not a Obligation object`);
+        }
+        return Obligation.fromBcs(typeArg, object.content);
     }
 }
-Obligation.$typeName = `${PKG_V1}::obligation::Obligation`;
-Obligation.$numTypeParams = 1;
-Obligation.$isPhantom = [true];
 /* ============================== ObligationDataEvent =============================== */
 export function isObligationDataEvent(type) {
     type = compressSuiType(type);
     return type === `${PKG_V1}::obligation::ObligationDataEvent`;
 }
 export class ObligationDataEvent {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::obligation::ObligationDataEvent`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = ObligationDataEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = ObligationDataEvent.$isPhantom;
+    lendingMarketId;
+    obligationId;
+    deposits;
+    borrows;
+    depositedValueUsd;
+    allowedBorrowValueUsd;
+    unhealthyBorrowValueUsd;
+    superUnhealthyBorrowValueUsd;
+    unweightedBorrowedValueUsd;
+    weightedBorrowedValueUsd;
+    weightedBorrowedValueUpperBoundUsd;
+    borrowingIsolatedAsset;
+    badDebtUsd;
+    closable;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = ObligationDataEvent.$typeName;
-        this.$isPhantom = ObligationDataEvent.$isPhantom;
         this.$fullTypeName = composeSuiType(ObligationDataEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
@@ -841,7 +915,7 @@ export class ObligationDataEvent {
             bcs: ObligationDataEvent.bcs,
             fromJSONField: (field) => ObligationDataEvent.fromJSONField(field),
             fromJSON: (json) => ObligationDataEvent.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return ObligationDataEvent.fetch(client, id); }),
+            fetch: async (client, id) => ObligationDataEvent.fetch(client, id),
             new: (fields) => {
                 return new ObligationDataEvent([], fields);
             },
@@ -946,7 +1020,11 @@ export class ObligationDataEvent {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return ObligationDataEvent.reified().new({
@@ -972,16 +1050,11 @@ export class ObligationDataEvent {
         }
         return ObligationDataEvent.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isObligationDataEvent(object.type)) {
-                throw new Error(`object at id ${id} is not a ObligationDataEvent object`);
-            }
-            return ObligationDataEvent.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isObligationDataEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a ObligationDataEvent object`);
+        }
+        return ObligationDataEvent.fromBcs(object.content);
     }
 }
-ObligationDataEvent.$typeName = `${PKG_V1}::obligation::ObligationDataEvent`;
-ObligationDataEvent.$numTypeParams = 0;
-ObligationDataEvent.$isPhantom = [];

package/_generated/suilend/rate-limiter/structs.d.ts

@@ -29,17 +29,17 @@ export declare class RateLimiter implements StructClass {
     static get r(): import("../../_framework/reified").StructClassReified<RateLimiter, RateLimiterFields>;
     static phantom(): PhantomReified<ToTypeStr<RateLimiter>>;
     static get p(): PhantomReified<"0x1f54a9a2d71799553197e9ea24557797c6398d6a65f2d4d3818c9304b75d5e21::rate_limiter::RateLimiter" | "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::rate_limiter::RateLimiter">;
-    static get bcs(): import("@mysten/sui/bcs").BcsStruct<{
-        config: import("@mysten/sui/bcs").BcsStruct<{
-            window_duration: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
-            max_outflow: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    static get bcs(): import("@mysten/bcs").BcsStruct<{
+        config: import("@mysten/bcs").BcsStruct<{
+            window_duration: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+            max_outflow: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
         }, string>;
-        prev_qty: import("@mysten/sui/bcs").BcsStruct<{
-            value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u256">;
+        prev_qty: import("@mysten/bcs").BcsStruct<{
+            value: import("@mysten/bcs").BcsType<string, string | number | bigint, "u256">;
         }, string>;
-        window_start: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
-        cur_qty: import("@mysten/sui/bcs").BcsStruct<{
-            value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u256">;
+        window_start: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+        cur_qty: import("@mysten/bcs").BcsStruct<{
+            value: import("@mysten/bcs").BcsType<string, string | number | bigint, "u256">;
         }, string>;
     }, string>;
     static fromFields(fields: Record<string, any>): RateLimiter;
@@ -99,9 +99,9 @@ export declare class RateLimiterConfig implements StructClass {
     static get r(): import("../../_framework/reified").StructClassReified<RateLimiterConfig, RateLimiterConfigFields>;
     static phantom(): PhantomReified<ToTypeStr<RateLimiterConfig>>;
     static get p(): PhantomReified<"0x1f54a9a2d71799553197e9ea24557797c6398d6a65f2d4d3818c9304b75d5e21::rate_limiter::RateLimiterConfig" | "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::rate_limiter::RateLimiterConfig">;
-    static get bcs(): import("@mysten/sui/bcs").BcsStruct<{
-        window_duration: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
-        max_outflow: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    static get bcs(): import("@mysten/bcs").BcsStruct<{
+        window_duration: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+        max_outflow: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
     }, string>;
     static fromFields(fields: Record<string, any>): RateLimiterConfig;
     static fromFieldsWithTypes(item: FieldsWithTypes): RateLimiterConfig;