@suilend/sdk 15.0.0 → 16.0.0

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

@@ -650,9 +650,9 @@ export function isEmergencyPauseCap(type) {
 /**
  * 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.
+ * compile-time incapable of minting an `ObligationOwnerCap`, changing price feeds, or
+ * touching reserve config beyond lowering a protocol liquidation fee. Revocation is
+ * minting the next generation via `new_pause_cap`, no package upgrade needed.
  */
 export class EmergencyPauseCap {
     __StructClass = true;
@@ -1054,6 +1054,372 @@ export class PauseKey {
         return PauseKey.fromBcs(object.content);
     }
 }
+/* ============================== OperationHoldKey =============================== */
+export function isOperationHoldKey(type) {
+    type = compressSuiType(type);
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::OperationHoldKey')}::lending_market::OperationHoldKey`;
+}
+export class OperationHoldKey {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::OperationHoldKey')}::lending_market::OperationHoldKey`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = OperationHoldKey.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = OperationHoldKey.$isPhantom;
+    operation;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(OperationHoldKey.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.operation = fields.operation;
+    }
+    static reified() {
+        const reifiedBcs = OperationHoldKey.bcs;
+        return {
+            get typeName() {
+                return OperationHoldKey.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(OperationHoldKey.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: OperationHoldKey.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => OperationHoldKey.fromFields(fields),
+            fromFieldsWithTypes: (item) => OperationHoldKey.fromFieldsWithTypes(item),
+            fromBcs: (data) => OperationHoldKey.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => OperationHoldKey.fromJSONField(field),
+            fromJSON: (json) => OperationHoldKey.fromJSON(json),
+            fromCoreObject: (obj) => OperationHoldKey.fromCoreObject(obj),
+            fetch: async (client, id) => OperationHoldKey.fetch(client, id),
+            new: (fields) => {
+                return new OperationHoldKey([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return OperationHoldKey.reified();
+    }
+    static phantom() {
+        return phantom(OperationHoldKey.reified());
+    }
+    static get p() {
+        return OperationHoldKey.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('OperationHoldKey', {
+            operation: bcs.u8(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!OperationHoldKey.cachedBcs) {
+            OperationHoldKey.cachedBcs = OperationHoldKey.instantiateBcs();
+        }
+        return OperationHoldKey.cachedBcs;
+    }
+    static fromFields(fields) {
+        return OperationHoldKey.reified().new({
+            operation: decodeFromFields('u8', fields.operation),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isOperationHoldKey(item.type)) {
+            throw new Error('not a OperationHoldKey type');
+        }
+        return OperationHoldKey.reified().new({
+            operation: decodeFromFieldsWithTypes('u8', item.fields.operation),
+        });
+    }
+    static fromBcs(data) {
+        return OperationHoldKey.fromFields(OperationHoldKey.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            operation: this.operation,
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return OperationHoldKey.reified().new({
+            operation: decodeFromJSONField('u8', field.operation),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== OperationHoldKey.$typeName) {
+            throw new Error(`not a OperationHoldKey json object: expected '${OperationHoldKey.$typeName}' but got '${json.$typeName}'`);
+        }
+        return OperationHoldKey.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isOperationHoldKey(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a OperationHoldKey object`);
+        }
+        return OperationHoldKey.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isOperationHoldKey(object.type)) {
+            throw new Error(`object at id ${id} is not a OperationHoldKey object`);
+        }
+        return OperationHoldKey.fromBcs(object.content);
+    }
+}
+/* ============================== OperationHoldGenerationKey =============================== */
+export function isOperationHoldGenerationKey(type) {
+    type = compressSuiType(type);
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::OperationHoldGenerationKey')}::lending_market::OperationHoldGenerationKey`;
+}
+export class OperationHoldGenerationKey {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::OperationHoldGenerationKey')}::lending_market::OperationHoldGenerationKey`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = OperationHoldGenerationKey.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = OperationHoldGenerationKey.$isPhantom;
+    operation;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(OperationHoldGenerationKey.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.operation = fields.operation;
+    }
+    static reified() {
+        const reifiedBcs = OperationHoldGenerationKey.bcs;
+        return {
+            get typeName() {
+                return OperationHoldGenerationKey.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(OperationHoldGenerationKey.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: OperationHoldGenerationKey.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => OperationHoldGenerationKey.fromFields(fields),
+            fromFieldsWithTypes: (item) => OperationHoldGenerationKey.fromFieldsWithTypes(item),
+            fromBcs: (data) => OperationHoldGenerationKey.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => OperationHoldGenerationKey.fromJSONField(field),
+            fromJSON: (json) => OperationHoldGenerationKey.fromJSON(json),
+            fromCoreObject: (obj) => OperationHoldGenerationKey.fromCoreObject(obj),
+            fetch: async (client, id) => OperationHoldGenerationKey.fetch(client, id),
+            new: (fields) => {
+                return new OperationHoldGenerationKey([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return OperationHoldGenerationKey.reified();
+    }
+    static phantom() {
+        return phantom(OperationHoldGenerationKey.reified());
+    }
+    static get p() {
+        return OperationHoldGenerationKey.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('OperationHoldGenerationKey', {
+            operation: bcs.u8(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!OperationHoldGenerationKey.cachedBcs) {
+            OperationHoldGenerationKey.cachedBcs = OperationHoldGenerationKey.instantiateBcs();
+        }
+        return OperationHoldGenerationKey.cachedBcs;
+    }
+    static fromFields(fields) {
+        return OperationHoldGenerationKey.reified().new({
+            operation: decodeFromFields('u8', fields.operation),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isOperationHoldGenerationKey(item.type)) {
+            throw new Error('not a OperationHoldGenerationKey type');
+        }
+        return OperationHoldGenerationKey.reified().new({
+            operation: decodeFromFieldsWithTypes('u8', item.fields.operation),
+        });
+    }
+    static fromBcs(data) {
+        return OperationHoldGenerationKey.fromFields(OperationHoldGenerationKey.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            operation: this.operation,
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return OperationHoldGenerationKey.reified().new({
+            operation: decodeFromJSONField('u8', field.operation),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== OperationHoldGenerationKey.$typeName) {
+            throw new Error(`not a OperationHoldGenerationKey json object: expected '${OperationHoldGenerationKey.$typeName}' but got '${json.$typeName}'`);
+        }
+        return OperationHoldGenerationKey.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isOperationHoldGenerationKey(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a OperationHoldGenerationKey object`);
+        }
+        return OperationHoldGenerationKey.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isOperationHoldGenerationKey(object.type)) {
+            throw new Error(`object at id ${id} is not a OperationHoldGenerationKey object`);
+        }
+        return OperationHoldGenerationKey.fromBcs(object.content);
+    }
+}
+/* ============================== WithdrawHoldExemptKey =============================== */
+export function isWithdrawHoldExemptKey(type) {
+    type = compressSuiType(type);
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::WithdrawHoldExemptKey')}::lending_market::WithdrawHoldExemptKey`;
+}
+export class WithdrawHoldExemptKey {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::WithdrawHoldExemptKey')}::lending_market::WithdrawHoldExemptKey`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = WithdrawHoldExemptKey.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = WithdrawHoldExemptKey.$isPhantom;
+    obligationId;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(WithdrawHoldExemptKey.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.obligationId = fields.obligationId;
+    }
+    static reified() {
+        const reifiedBcs = WithdrawHoldExemptKey.bcs;
+        return {
+            get typeName() {
+                return WithdrawHoldExemptKey.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(WithdrawHoldExemptKey.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: WithdrawHoldExemptKey.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => WithdrawHoldExemptKey.fromFields(fields),
+            fromFieldsWithTypes: (item) => WithdrawHoldExemptKey.fromFieldsWithTypes(item),
+            fromBcs: (data) => WithdrawHoldExemptKey.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => WithdrawHoldExemptKey.fromJSONField(field),
+            fromJSON: (json) => WithdrawHoldExemptKey.fromJSON(json),
+            fromCoreObject: (obj) => WithdrawHoldExemptKey.fromCoreObject(obj),
+            fetch: async (client, id) => WithdrawHoldExemptKey.fetch(client, id),
+            new: (fields) => {
+                return new WithdrawHoldExemptKey([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return WithdrawHoldExemptKey.reified();
+    }
+    static phantom() {
+        return phantom(WithdrawHoldExemptKey.reified());
+    }
+    static get p() {
+        return WithdrawHoldExemptKey.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('WithdrawHoldExemptKey', {
+            obligation_id: ID.bcs,
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!WithdrawHoldExemptKey.cachedBcs) {
+            WithdrawHoldExemptKey.cachedBcs = WithdrawHoldExemptKey.instantiateBcs();
+        }
+        return WithdrawHoldExemptKey.cachedBcs;
+    }
+    static fromFields(fields) {
+        return WithdrawHoldExemptKey.reified().new({
+            obligationId: decodeFromFields(ID.reified(), fields.obligation_id),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isWithdrawHoldExemptKey(item.type)) {
+            throw new Error('not a WithdrawHoldExemptKey type');
+        }
+        return WithdrawHoldExemptKey.reified().new({
+            obligationId: decodeFromFieldsWithTypes(ID.reified(), item.fields.obligation_id),
+        });
+    }
+    static fromBcs(data) {
+        return WithdrawHoldExemptKey.fromFields(WithdrawHoldExemptKey.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            obligationId: this.obligationId,
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return WithdrawHoldExemptKey.reified().new({
+            obligationId: decodeFromJSONField(ID.reified(), field.obligationId),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== WithdrawHoldExemptKey.$typeName) {
+            throw new Error(`not a WithdrawHoldExemptKey json object: expected '${WithdrawHoldExemptKey.$typeName}' but got '${json.$typeName}'`);
+        }
+        return WithdrawHoldExemptKey.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isWithdrawHoldExemptKey(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a WithdrawHoldExemptKey object`);
+        }
+        return WithdrawHoldExemptKey.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isWithdrawHoldExemptKey(object.type)) {
+            throw new Error(`object at id ${id} is not a WithdrawHoldExemptKey object`);
+        }
+        return WithdrawHoldExemptKey.fromBcs(object.content);
+    }
+}
 /* ============================== PauseCapGenerationKey =============================== */
 export function isPauseCapGenerationKey(type) {
     type = compressSuiType(type);
@@ -1462,6 +1828,128 @@ export class RateLimiterExemption {
         return RateLimiterExemption.fromBcs(typeArgs, object.content);
     }
 }
+/* ============================== AdminWitness =============================== */
+export function isAdminWitness(type) {
+    type = compressSuiType(type);
+    return type
+        === `${getTypeOrigin('suilend', 'lending_market::AdminWitness')}::lending_market::AdminWitness`;
+}
+export class AdminWitness {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'lending_market::AdminWitness')}::lending_market::AdminWitness`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = AdminWitness.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = AdminWitness.$isPhantom;
+    dummyField;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(AdminWitness.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.dummyField = fields.dummyField;
+    }
+    static reified() {
+        const reifiedBcs = AdminWitness.bcs;
+        return {
+            get typeName() {
+                return AdminWitness.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(AdminWitness.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: AdminWitness.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => AdminWitness.fromFields(fields),
+            fromFieldsWithTypes: (item) => AdminWitness.fromFieldsWithTypes(item),
+            fromBcs: (data) => AdminWitness.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => AdminWitness.fromJSONField(field),
+            fromJSON: (json) => AdminWitness.fromJSON(json),
+            fromCoreObject: (obj) => AdminWitness.fromCoreObject(obj),
+            fetch: async (client, id) => AdminWitness.fetch(client, id),
+            new: (fields) => {
+                return new AdminWitness([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return AdminWitness.reified();
+    }
+    static phantom() {
+        return phantom(AdminWitness.reified());
+    }
+    static get p() {
+        return AdminWitness.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('AdminWitness', {
+            dummy_field: bcs.bool(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!AdminWitness.cachedBcs) {
+            AdminWitness.cachedBcs = AdminWitness.instantiateBcs();
+        }
+        return AdminWitness.cachedBcs;
+    }
+    static fromFields(fields) {
+        return AdminWitness.reified().new({
+            dummyField: decodeFromFields('bool', fields.dummy_field),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isAdminWitness(item.type)) {
+            throw new Error('not a AdminWitness type');
+        }
+        return AdminWitness.reified().new({
+            dummyField: decodeFromFieldsWithTypes('bool', item.fields.dummy_field),
+        });
+    }
+    static fromBcs(data) {
+        return AdminWitness.fromFields(AdminWitness.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            dummyField: this.dummyField,
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return AdminWitness.reified().new({
+            dummyField: decodeFromJSONField('bool', field.dummyField),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== AdminWitness.$typeName) {
+            throw new Error(`not a AdminWitness json object: expected '${AdminWitness.$typeName}' but got '${json.$typeName}'`);
+        }
+        return AdminWitness.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isAdminWitness(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a AdminWitness object`);
+        }
+        return AdminWitness.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isAdminWitness(object.type)) {
+            throw new Error(`object at id ${id} is not a AdminWitness object`);
+        }
+        return AdminWitness.fromBcs(object.content);
+    }
+}
 /* ============================== MintEvent =============================== */
 export function isMintEvent(type) {
     type = compressSuiType(type);