@dashevo/wasm-dpp2 4.2.0-beta.3 → 4.2.0-beta.5

package/dist/raw/wasm_dpp2.js

@@ -2519,6 +2519,24 @@ export class ConsensusError {
         }
         return ConsensusError.__wrap(ret[0]);
     }
+    /**
+     * The distinctFrom error this is, or `undefined` when it is not code
+     * 10419.
+     * @returns {DocumentDistinctFromErrorCode | undefined}
+     */
+    get documentDistinctFromErrorCode() {
+        const ret = wasm.consensuserror_document_distinct_from_error_code(this.__wbg_ptr);
+        return ret === 0 ? undefined : ret;
+    }
+    /**
+     * The encrypted-property error this is, or `undefined` when it is not
+     * code 10420.
+     * @returns {DocumentEncryptionErrorCode | undefined}
+     */
+    get documentEncryptionErrorCode() {
+        const ret = wasm.consensuserror_document_encryption_error_code(this.__wbg_ptr);
+        return ret === 0 ? undefined : ret;
+    }
     /**
      * The immutable-property error this is, or `undefined` when it is not
      * code 40128.
@@ -2528,9 +2546,26 @@ export class ConsensusError {
         const ret = wasm.consensuserror_document_immutability_error_code(this.__wbg_ptr);
         return ret === 0 ? undefined : ret;
     }
+    /**
+     * The maxBytes error this is, or `undefined` when it is not code 10421.
+     * @returns {DocumentMaxBytesErrorCode | undefined}
+     */
+    get documentMaxBytesErrorCode() {
+        const ret = wasm.consensuserror_document_max_bytes_error_code(this.__wbg_ptr);
+        return ret === 0 ? undefined : ret;
+    }
+    /**
+     * The propertyConstraints error this is, or `undefined` when it is not
+     * code 10422.
+     * @returns {DocumentPropertyConstraintErrorCode | undefined}
+     */
+    get documentPropertyConstraintErrorCode() {
+        const ret = wasm.consensuserror_document_property_constraint_error_code(this.__wbg_ptr);
+        return ret === 0 ? undefined : ret;
+    }
     /**
      * The reference-validation error this is, or `undefined` when it is
-     * not one of codes 40120-40125.
+     * not one of codes 40120-40125, 40131, 40135 and 40136.
      * @returns {DocumentReferenceErrorCode | undefined}
      */
     get documentReferenceErrorCode() {
@@ -3443,7 +3478,7 @@ export class ContractUserModeration {
         wasm.__wbg_contractusermoderation_free(ptr, 0);
     }
     /**
-     * The action's name: ban, unban, suspend, unsuspend or deleteDocument
+     * The action's name: ban, unban, suspend, unsuspend, warn, clearWarnings, deleteDocument or restoreDocument
      * @returns {string}
      */
     get action() {
@@ -3477,6 +3512,20 @@ export class ContractUserModeration {
         const ret = wasm.contractusermoderation_data_contract_id(this.__wbg_ptr);
         return Identifier.__wrap(ret);
     }
+    /**
+     * For a restoreDocument, the document it brings back, as it was serialized when it was
+     * deleted
+     * @returns {Uint8Array | undefined}
+     */
+    get document() {
+        const ret = wasm.contractusermoderation_document(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
     /**
      * For a deleteDocument, the document it deletes
      * @returns {Identifier | undefined}
@@ -3486,7 +3535,7 @@ export class ContractUserModeration {
         return ret === 0 ? undefined : Identifier.__wrap(ret);
     }
     /**
-     * For a deleteDocument, the document type of the document it deletes
+     * For a deleteDocument or a restoreDocument, the document type of its document
      * @returns {string | undefined}
      */
     get documentTypeName() {
@@ -3579,8 +3628,8 @@ export class ContractUserModeration {
         return BigInt.asUintN(64, ret);
     }
     /**
-     * The identity the action targets, undefined for a deleteDocument: it names a document,
-     * and whose it is is only known once the document is read
+     * The identity the action targets, undefined for a deleteDocument and a restoreDocument:
+     * they name a document, and whose it is is only known once the document is read
      * @returns {Identifier | undefined}
      */
     get identityId() {
@@ -3595,7 +3644,7 @@ export class ContractUserModeration {
         return Identifier.__wrap(ret);
     }
     /**
-     * For a ban, a suspend and a deleteDocument, why
+     * For a ban, a suspend, a warn and a deleteDocument, why
      * @returns {ContractModerationReason | undefined}
      */
     get reason() {
@@ -4018,6 +4067,57 @@ export class DataContract {
         DataContractFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * The `distinctFrom` declarations of one document type, in schema
+     * property order: each `{ path, distinctFrom }` names an identifier
+     * property and what its value must differ from, `"$ownerId"` or the
+     * dotted path of another identifier property of the same type.
+     *
+     * Empty when the document type declares none (the normal case). Throws
+     * when the contract has no document type by that name, so "no such
+     * type" and "nothing declared" stay distinguishable.
+     *
+     * The keyword is only parsed from protocol version 14 onward. A
+     * contract deserialized against an earlier platform version reports an
+     * empty list, which is exactly what consensus enforced at that version,
+     * while `toJSON()` still shows the raw keyword either way.
+     * @param {string} documentTypeName
+     * @returns {Array<DocumentPropertyDistinctFrom>}
+     */
+    documentTypeDistinctFrom(documentTypeName) {
+        const ptr0 = passStringToWasm0(documentTypeName, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.datacontract_documentTypeDistinctFrom(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * All `encryptedFor` declarations of one document type, in schema
+     * property order: which byte array properties are encrypted, for whom,
+     * under which key ids and under which scheme.
+     *
+     * Returns an empty array when the document type declares none. Throws
+     * when the contract has no document type by that name, so "no such
+     * type" and "nothing encrypted" stay distinguishable.
+     *
+     * The keyword is only parsed from protocol version 14 onward. A
+     * contract deserialized against an earlier platform version reports
+     * none, which is exactly what consensus enforced at that version, while
+     * `toJSON()` still shows the raw keyword either way.
+     * @param {string} documentTypeName
+     * @returns {Array<DocumentPropertyEncryption>}
+     */
+    documentTypeEncryptedProperties(documentTypeName) {
+        const ptr0 = passStringToWasm0(documentTypeName, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.datacontract_documentTypeEncryptedProperties(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * The `immutable` / `immutableAllowSetting` declarations of one
      * document type: `{ immutable: string[], immutableAllowSetting:
@@ -4045,8 +4145,9 @@ export class DataContract {
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * All `refersTo` declarations of one document type, in schema property
-     * order.
+     * All `refersTo` declarations of one document type: its `ownerRefersTo`
+     * or `creatorRefersTo` first, at the path `$ownerId` or `$creatorId`,
+     * then the properties' own in schema property order.
      *
      * Returns an empty array when the document type declares none. Throws
      * when the contract has no document type by that name — an empty array
@@ -4070,6 +4171,61 @@ export class DataContract {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Every typed array property of one document type (`type: "array"`
+     * with an `items` element schema), in schema property order: `{ path,
+     * items, minItems?, maxItems?, uniqueItems }`.
+     *
+     * Returns an empty array when the document type declares none. Throws
+     * when the contract has no document type by that name, so "no such
+     * type" and "no typed arrays" stay distinguishable.
+     *
+     * Typed arrays are only parsed from protocol version 14 onward. A
+     * contract deserialized against an earlier platform version cannot
+     * carry one: the parsers of those versions refuse an array that is not
+     * a byte array.
+     * @param {string} documentTypeName
+     * @returns {Array<DocumentTypedArrayProperty>}
+     */
+    documentTypeTypedArrays(documentTypeName) {
+        const ptr0 = passStringToWasm0(documentTypeName, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.datacontract_documentTypeTypedArrays(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Every document type that declares at least one `distinctFrom`, keyed
+     * by document type name.
+     *
+     * Document types with no declarations are omitted, so an empty `Map`
+     * means "this contract declares no distinctFrom at all".
+     * @returns {Map<string, Array<DocumentPropertyDistinctFrom>>}
+     */
+    get documentDistinctFrom() {
+        const ret = wasm.datacontract_document_distinct_from(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Every document type that declares at least one encrypted property,
+     * keyed by document type name.
+     *
+     * Document types with no declarations are omitted, so an empty `Map`
+     * means "this contract declares no encrypted property at all".
+     * @returns {Map<string, Array<DocumentPropertyEncryption>>}
+     */
+    get documentEncryptedProperties() {
+        const ret = wasm.datacontract_document_encrypted_properties(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Every document type that freezes at least one property, keyed by
      * document type name.
@@ -4100,6 +4256,21 @@ export class DataContract {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Every document type that declares at least one typed array property,
+     * keyed by document type name.
+     *
+     * Document types with none are omitted, so an empty `Map` means "this
+     * contract declares no typed arrays at all".
+     * @returns {Map<string, Array<DocumentTypedArrayProperty>>}
+     */
+    get documentTypedArrays() {
+        const ret = wasm.datacontract_document_typed_arrays(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * @param {string} base64
      * @param {boolean} full_validation
@@ -6288,18 +6459,27 @@ export class Document {
         return Document.__wrap(ret[0]);
     }
     /**
+     * Derives the id of a document that is about to be created, the way
+     * consensus recomputes it for the create transition.
+     *
+     * From protocol version 14 the id commits to the identity contract
+     * nonce of the create transition, so `identityContractNonce` is
+     * required at that version (and ignored before it). The platform
+     * version defaults to the latest.
      * @param {string} documentTypeName
      * @param {IdentifierLike} ownerId
      * @param {IdentifierLike} dataContractId
      * @param {Uint8Array | null} [entropy]
+     * @param {bigint | null} [identityContractNonce]
+     * @param {PlatformVersionLike | null} [platformVersion]
      * @returns {Uint8Array}
      */
-    static generateId(documentTypeName, ownerId, dataContractId, entropy) {
+    static generateId(documentTypeName, ownerId, dataContractId, entropy, identityContractNonce, platformVersion) {
         const ptr0 = passStringToWasm0(documentTypeName, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         var ptr1 = isLikeNone(entropy) ? 0 : passArray8ToWasm0(entropy, wasm.__wbindgen_malloc);
         var len1 = WASM_VECTOR_LEN;
-        const ret = wasm.document_generateId(ptr0, len0, ownerId, dataContractId, ptr1, len1);
+        const ret = wasm.document_generateId(ptr0, len0, ownerId, dataContractId, ptr1, len1, !isLikeNone(identityContractNonce), isLikeNone(identityContractNonce) ? BigInt(0) : identityContractNonce, isLikeNone(platformVersion) ? 0 : addToExternrefTable0(platformVersion));
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
@@ -6338,6 +6518,27 @@ export class Document {
         const ret = wasm.document_revision(this.__wbg_ptr);
         return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
     }
+    /**
+     * Gives the document the id its create transition will carry, derived
+     * from its entropy and the identity contract nonce that transition is
+     * going to use.
+     *
+     * `new DocumentCreateTransition(...)` does this on its own; call it
+     * yourself to know the id before the transition exists (a document that
+     * another document in the same batch references). The transition must
+     * then be built with the same nonce.
+     *
+     * Throws when the document carries no entropy (one read back from
+     * Platform), since only a new document can be created.
+     * @param {bigint} identityContractNonce
+     * @param {PlatformVersionLike | null} [platformVersion]
+     */
+    setIdForCreation(identityContractNonce, platformVersion) {
+        const ret = wasm.document_setIdForCreation(this.__wbg_ptr, identityContractNonce, isLikeNone(platformVersion) ? 0 : addToExternrefTable0(platformVersion));
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @param {bigint | null} [createdAt]
      */
@@ -7196,6 +7397,60 @@ export class DocumentDeleteTransition {
 }
 if (Symbol.dispose) DocumentDeleteTransition.prototype[Symbol.dispose] = DocumentDeleteTransition.prototype.free;
 
+/**
+ * Consensus error codes emitted by the `distinctFrom` check on document
+ * creates and replaces (protocol version 14+).
+ *
+ * Branch on an error's `code` against this instead of matching its message:
+ *
+ * ```js
+ * try {
+ *   await sdk.documents.create({ document, identityKey, signer });
+ * } catch (e) {
+ *   if (e.code === DocumentDistinctFromErrorCode.DocumentPropertyNotDistinct) {
+ *     // an identifier property equals the value it must differ from
+ *   }
+ * }
+ * ```
+ * @enum {10419}
+ */
+export const DocumentDistinctFromErrorCode = Object.freeze({
+    /**
+     * A `distinctFrom` identifier property of the written document equals
+     * the value it must differ from: the document's `$ownerId`, or the named
+     * property of the same document.
+     */
+    DocumentPropertyNotDistinct: 10419, "10419": "DocumentPropertyNotDistinct",
+});
+
+/**
+ * Consensus error codes emitted by `encryptedFor` validation, which runs
+ * from protocol version 14 onward on every document create and replace.
+ *
+ * Branch on an error's `code` against these instead of matching its
+ * message:
+ *
+ * ```js
+ * try {
+ *   await sdk.documents.create({ document, identityKey, signer });
+ * } catch (e) {
+ *   if (e.code === DocumentEncryptionErrorCode.InvalidEncryptedPropertyShape) {
+ *     // the bytes are not the shape the declared scheme produces
+ *   }
+ * }
+ * ```
+ * @enum {10420}
+ */
+export const DocumentEncryptionErrorCode = Object.freeze({
+    /**
+     * A property the document type declares `encryptedFor` was supplied
+     * with bytes that are not a ciphertext of the declared scheme: shorter
+     * than the IV plus one block, or not a multiple of the block length.
+     * The shape is all consensus checks about a ciphertext.
+     */
+    InvalidEncryptedPropertyShape: 10420, "10420": "InvalidEncryptedPropertyShape",
+});
+
 /**
  * Consensus error codes emitted by the immutable-property check on document
  * replaces (`immutable` / `immutableAllowSetting`, protocol version 14+).
@@ -7222,6 +7477,62 @@ export const DocumentImmutabilityErrorCode = Object.freeze({
     DocumentImmutablePropertyChanged: 40128, "40128": "DocumentImmutablePropertyChanged",
 });
 
+/**
+ * Consensus error codes emitted by the `maxBytes` check, which runs from
+ * protocol version 14 onward wherever a document is validated, on every
+ * create and replace included.
+ *
+ * Branch on an error's `code` against these instead of matching its
+ * message:
+ *
+ * ```js
+ * try {
+ *   await sdk.documents.create({ document, identityKey, signer });
+ * } catch (e) {
+ *   if (e.code === DocumentMaxBytesErrorCode.MaxBytesExceeded) {
+ *     // a string is longer in UTF-8 bytes than its property's maxBytes
+ *   }
+ * }
+ * ```
+ * @enum {10421}
+ */
+export const DocumentMaxBytesErrorCode = Object.freeze({
+    /**
+     * A string, or an element of a typed array of strings, is longer in
+     * UTF-8 bytes than the `maxBytes` its property declares. `maxLength`
+     * counts characters, which are up to four bytes each.
+     */
+    MaxBytesExceeded: 10421, "10421": "MaxBytesExceeded",
+});
+
+/**
+ * Consensus error codes emitted by the `propertyConstraints` check, which
+ * runs from protocol version 14 onward wherever a document is validated, on
+ * every create and replace included.
+ *
+ * Branch on an error's `code` against this instead of matching its message:
+ *
+ * ```js
+ * try {
+ *   await sdk.documents.create({ document, identityKey, signer });
+ * } catch (e) {
+ *   if (e.code === DocumentPropertyConstraintErrorCode.DocumentPropertyConstraintViolated) {
+ *     // the document breaks one of its type's rules; the message names it
+ *   }
+ * }
+ * ```
+ * @enum {10422}
+ */
+export const DocumentPropertyConstraintErrorCode = Object.freeze({
+    /**
+     * The written document breaks a rule of its document type's
+     * `propertyConstraints`: the rule does not hold, or evaluating it
+     * overflowed, divided by zero, raised to a negative power or read a value
+     * that is not an integer.
+     */
+    DocumentPropertyConstraintViolated: 10422, "10422": "DocumentPropertyConstraintViolated",
+});
+
 export class DocumentPurchaseTransition {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -7370,12 +7681,14 @@ if (Symbol.dispose) DocumentPurchaseTransition.prototype[Symbol.dispose] = Docum
  *   }
  * }
  * ```
- * @enum {40120 | 40121 | 40122 | 40123 | 40124 | 40125 | 40131}
+ * @enum {40120 | 40121 | 40122 | 40123 | 40124 | 40125 | 40131 | 40135 | 40136 | 40137 | 40138}
  */
 export const DocumentReferenceErrorCode = Object.freeze({
     /**
      * The referenced identity, contract, token or document (permanent or
-     * deletable) does not exist.
+     * deletable) does not exist, or a `listElement` value is not an element
+     * of the list it must be in (or was set while the property finding the
+     * list's document was not).
      */
     ReferencedEntityNotFound: 40120, "40120": "ReferencedEntityNotFound",
     /**
@@ -7411,6 +7724,38 @@ export const DocumentReferenceErrorCode = Object.freeze({
      * declaring `canBeDeleted: false`.
      */
     ReferencedDocumentTypeNotDeletable: 40131, "40131": "ReferencedDocumentTypeNotDeletable",
+    /**
+     * The referenced contract exists but does not meet what the reference's
+     * `contractRequirements` require of it: elected moderation, its election
+     * open, a minimum age or a minimum time since its last update at the block
+     * time of the write, an owner relation to the writer of the referring
+     * document, or a config flag (read-only, keeping history, the owner
+     * protection of its elected moderation declaration).
+     */
+    ReferencedContractRequirementNotMet: 40135, "40135": "ReferencedContractRequirementNotMet",
+    /**
+     * The referenced identity public key exists and is enabled but does not
+     * meet what the reference's `keyRequirements` require of it: its
+     * purpose, or a binding to a document type of the declaring contract.
+     */
+    ReferencedIdentityKeyRequirementNotMet: 40136, "40136": "ReferencedIdentityKeyRequirementNotMet",
+    /**
+     * A `refersTo` lookup into a document type of another contract cannot
+     * resolve there, reported at contract registration: the named index is
+     * missing or not unique, the keys do not cover it exactly, or a source
+     * holds a different kind of value than its index property. (A lookup into
+     * the declaring contract is refused by the contract parse instead.)
+     */
+    ReferencedDocumentLookupInvalid: 40137, "40137": "ReferencedDocumentLookupInvalid",
+    /**
+     * A `refersTo: listElement` whose list lives in a document type of
+     * another contract cannot be served by it, reported at contract
+     * registration: that type's documents can be deleted, the list is not a
+     * stored typed array of identifiers of it, or a replace could change the
+     * list. (A list in the declaring contract is refused by the contract parse
+     * instead.)
+     */
+    ReferencedDocumentListInvalid: 40138, "40138": "ReferencedDocumentListInvalid",
 });
 
 export class DocumentReplaceTransition {
@@ -20390,7 +20735,7 @@ export class TokenDistributionRecipient {
      * @returns {TokenDistributionRecipient}
      */
     static ContractOwner() {
-        const ret = wasm.tokendistributionrecipient_ContractOwner();
+        const ret = wasm.authorizedactiontakers_NoOne();
         return TokenDistributionRecipient.__wrap(ret);
     }
     /**
@@ -23352,8 +23697,10 @@ if (Symbol.dispose) VerifiedBalanceTransfer.prototype[Symbol.dispose] = Verified
 
 /**
  * `VerifiedContractDocumentRemoval` proof-result wrapper: the record a moderator's document
- * deletion left under the contract. The document itself is gone; the record says whose it
- * was, who removed it, why and when.
+ * deletion left under the contract, as a deletion or a restore leaves it. After a deletion
+ * the document is gone and the record says whose it was, who removed it, why, when and what
+ * it was (its hash); after a restore the document is live again and the record also says who
+ * brought it back and when.
  */
 export class VerifiedContractDocumentRemoval {
     __destroy_into_raw() {
@@ -23419,6 +23766,24 @@ export class VerifiedContractDocumentRemoval {
         const ret = wasm.__wbg_get_verifiedcontractdocumentremoval_removedAt(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
+    /**
+     * The time of the block that restored it, in milliseconds, undefined while the removal
+     * stands
+     * @returns {bigint | undefined}
+     */
+    get restoredAt() {
+        const ret = wasm.__wbg_get_verifiedcontractdocumentremoval_restoredAt(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * The contract owner or moderator that restored the document, undefined while the
+     * removal stands
+     * @returns {Identifier | undefined}
+     */
+    get restoredBy() {
+        const ret = wasm.__wbg_get_verifiedcontractdocumentremoval_restoredBy(this.__wbg_ptr);
+        return ret === 0 ? undefined : Identifier.__wrap(ret);
+    }
     /**
      * @param {Identifier} arg0
      */
@@ -23468,6 +23833,44 @@ export class VerifiedContractDocumentRemoval {
     set removedAt(arg0) {
         wasm.__wbg_set_verifiedcontractdocumentremoval_removedAt(this.__wbg_ptr, arg0);
     }
+    /**
+     * The time of the block that restored it, in milliseconds, undefined while the removal
+     * stands
+     * @param {bigint | null} [arg0]
+     */
+    set restoredAt(arg0) {
+        wasm.__wbg_set_verifiedcontractdocumentremoval_restoredAt(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? BigInt(0) : arg0);
+    }
+    /**
+     * The contract owner or moderator that restored the document, undefined while the
+     * removal stands
+     * @param {Identifier | null} [arg0]
+     */
+    set restoredBy(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, Identifier);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_verifiedcontractdocumentremoval_restoredBy(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * A double SHA-256 of the document as it was serialized under its type when it was
+     * removed: what a restore must bring back byte for byte, as 64 hex characters
+     * @returns {string}
+     */
+    get documentHash() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.verifiedcontractdocumentremoval_document_hash(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Why the moderator removed the document: the text may be empty
      * @returns {ContractModerationReason}
@@ -23703,9 +24106,9 @@ if (Symbol.dispose) VerifiedContractFeeClaim.prototype[Symbol.dispose] = Verifie
 
 /**
  * `VerifiedContractModerationListStatuses` proof-result wrapper: the target identity's status
- * on the lists a moderation transition touched (both for a ban, the edited one otherwise).
- * A list the proof does not cover is unknown: `banned` is undefined unless `lists` includes
- * `banlist`.
+ * on the lists a moderation transition touched (every barring list for a ban, the edited one
+ * otherwise). A list the proof does not cover is unknown: `banned` is undefined unless
+ * `lists` includes `banlist`, and `warnings` unless it includes `warnings`.
  */
 export class VerifiedContractModerationListStatuses {
     __destroy_into_raw() {
@@ -23741,7 +24144,7 @@ export class VerifiedContractModerationListStatuses {
         return Identifier.__wrap(ret);
     }
     /**
-     * The lists the proof covers: `banlist`, `suspensions`, or both
+     * The lists the proof covers: `banlist` and `suspensions` for a ban, else the one edited
      * @returns {string[]}
      */
     get lists() {
@@ -23772,7 +24175,7 @@ export class VerifiedContractModerationListStatuses {
     set contractId(arg0) {
         _assertClass(arg0, Identifier);
         var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_verifiedcontractdocumentremoval_documentId(this.__wbg_ptr, ptr0);
+        wasm.__wbg_set_verifiedcontractdocumentremoval_documentOwnerId(this.__wbg_ptr, ptr0);
     }
     /**
      * @param {Identifier} arg0
@@ -23780,10 +24183,10 @@ export class VerifiedContractModerationListStatuses {
     set identityId(arg0) {
         _assertClass(arg0, Identifier);
         var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_verifiedcontractdocumentremoval_documentOwnerId(this.__wbg_ptr, ptr0);
+        wasm.__wbg_set_verifiedcontractdocumentremoval_moderatorId(this.__wbg_ptr, ptr0);
     }
     /**
-     * The lists the proof covers: `banlist`, `suspensions`, or both
+     * The lists the proof covers: `banlist` and `suspensions` for a ban, else the one edited
      * @param {string[]} arg0
      */
     set lists(arg0) {
@@ -23797,7 +24200,7 @@ export class VerifiedContractModerationListStatuses {
      * @param {bigint | null} [arg0]
      */
     set suspendedUntil(arg0) {
-        wasm.__wbg_set_verifiedcontractmoderationliststatuses_suspendedUntil(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? BigInt(0) : arg0);
+        wasm.__wbg_set_verifiedcontractdocumentremoval_restoredAt(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? BigInt(0) : arg0);
     }
     /**
      * When the identity is banned: why
@@ -23865,6 +24268,14 @@ export class VerifiedContractModerationListStatuses {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * When `lists` includes `warnings`: the identity's warnings, oldest first
+     * @returns {ContractWarning[] | undefined}
+     */
+    get warnings() {
+        const ret = wasm.verifiedcontractmoderationliststatuses_warnings(this.__wbg_ptr);
+        return ret;
+    }
 }
 if (Symbol.dispose) VerifiedContractModerationListStatuses.prototype[Symbol.dispose] = VerifiedContractModerationListStatuses.prototype.free;
 
@@ -24457,7 +24868,7 @@ export class VerifiedIdentityWithShieldedNullifiers {
     set identity(arg0) {
         _assertClass(arg0, Identity);
         var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_verifiedidentitywithshieldednullifiers_identity(this.__wbg_ptr, ptr0);
+        wasm.__wbg_set_verifiedidentityfullwithaddressinfos_identity(this.__wbg_ptr, ptr0);
     }
     /**
      * @param {any} value
@@ -25418,7 +25829,7 @@ export class VerifiedTokenBalance {
     set tokenId(arg0) {
         _assertClass(arg0, Identifier);
         var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_verifiedtokenbalance_tokenId(this.__wbg_ptr, ptr0);
+        wasm.__wbg_set_verifiedcontractfeeclaim_contractId(this.__wbg_ptr, ptr0);
     }
     /**
      * @returns {any}