@enbox/dwn-sdk-js 0.0.4 → 0.0.5

package/dist/esm/generated/precompiled-validators.js

@@ -168,7 +168,7 @@ validate20.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": f
 export const AuthorizationDelegatedGrant = validate24;
 const schema37 = { "$id": "https://identity.foundation/dwn/json-schemas/authorization-delegated-grant.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object", "additionalProperties": false, "properties": { "signature": { "$ref": "https://identity.foundation/dwn/json-schemas/general-jws.json" }, "authorDelegatedGrant": { "$ref": "https://identity.foundation/dwn/json-schemas/records-write-data-encoded.json" } } };
 const schema38 = { "$id": "https://identity.foundation/dwn/json-schemas/records-write-data-encoded.json", "$ref": "https://identity.foundation/dwn/json-schemas/records-write-unidentified.json", "unevaluatedProperties": false, "type": "object", "required": ["recordId", "authorization", "encodedData"], "properties": { "encodedData": { "type": "string" } } };
-const schema39 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/records-write-unidentified.json", "type": "object", "required": ["descriptor"], "properties": { "recordId": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600, "pattern": "^[a-zA-Z0-9]+(/[a-zA-Z0-9]+)*$" }, "attestation": { "$ref": "https://identity.foundation/dwn/json-schemas/general-jws.json" }, "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization-owner.json" }, "encryption": { "type": "object", "properties": { "algorithm": { "type": "string", "enum": ["A256CTR"] }, "initializationVector": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url" }, "keyEncryption": { "type": "array", "minItems": 1, "items": { "type": "object", "properties": { "rootKeyId": { "type": "string" }, "derivationScheme": { "type": "string", "enum": ["dataFormats", "protocolContext", "protocolPath", "schemas"] }, "derivedPublicKey": { "$ref": "https://identity.foundation/dwn/json-schemas/public-jwk.json" }, "algorithm": { "type": "string", "enum": ["ECIES-ES256K"] }, "encryptedKey": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url" }, "initializationVector": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url" }, "ephemeralPublicKey": { "$ref": "https://identity.foundation/dwn/json-schemas/public-jwk.json" }, "messageAuthenticationCode": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url" } }, "additionalProperties": false, "required": ["rootKeyId", "derivationScheme", "algorithm", "encryptedKey", "initializationVector", "ephemeralPublicKey", "messageAuthenticationCode"] } } }, "additionalProperties": false, "required": ["algorithm", "initializationVector", "keyEncryption"] }, "descriptor": { "type": "object", "properties": { "interface": { "enum": ["Records"], "type": "string" }, "method": { "enum": ["Write"], "type": "string" }, "recipient": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/did" }, "protocol": { "type": "string" }, "protocolPath": { "type": "string", "pattern": "^[a-zA-Z]+(/[a-zA-Z]+)*$" }, "schema": { "type": "string" }, "tags": { "type": "object", "minProperties": 1, "maxProperties": 10, "additionalProperties": { "oneOf": [{ "type": "string" }, { "type": "number" }, { "type": "boolean" }, { "type": "array", "minItems": 1, "maxItems": 10, "items": { "type": "string" } }, { "type": "array", "minItems": 1, "maxItems": 10, "items": { "type": "number" } }] } }, "parentId": { "type": "string" }, "dataCid": { "type": "string" }, "dataSize": { "type": "number" }, "dateCreated": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "messageTimestamp": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "published": { "type": "boolean" }, "datePublished": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "dataFormat": { "type": "string" }, "permissionGrantId": { "type": "string" } }, "additionalProperties": false, "required": ["interface", "method", "dataCid", "dataSize", "dateCreated", "messageTimestamp", "dataFormat"], "dependencies": { "parentId": ["protocol"] }, "allOf": [{ "$comment": "rule defining `published` and `datePublished` relationship", "anyOf": [{ "properties": { "published": { "type": "boolean", "enum": [true] } }, "required": ["published", "datePublished"] }, { "properties": { "published": { "type": "boolean", "enum": [false] } }, "not": { "required": ["datePublished"] } }, { "allOf": [{ "not": { "required": ["published"] } }, { "not": { "required": ["datePublished"] } }] }] }] } }, "$comment": "rule defining `protocol` and `contextId` relationship", "anyOf": [{ "properties": { "descriptor": { "type": "object", "required": ["protocol", "protocolPath"] } }, "required": ["contextId"] }, { "allOf": [{ "not": { "required": ["contextId"] } }, { "properties": { "descriptor": { "type": "object", "not": { "required": ["protocol"] } } } }, { "properties": { "descriptor": { "type": "object", "not": { "required": ["protocolPath"] } } } }] }] };
+const schema39 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/records-write-unidentified.json", "type": "object", "required": ["descriptor"], "properties": { "recordId": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600, "pattern": "^[a-zA-Z0-9]+(/[a-zA-Z0-9]+)*$" }, "attestation": { "$ref": "https://identity.foundation/dwn/json-schemas/general-jws.json" }, "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization-owner.json" }, "encryption": { "type": "object", "properties": { "protected": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url" }, "iv": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url" }, "tag": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url" }, "recipients": { "type": "array", "minItems": 1, "items": { "type": "object", "properties": { "header": { "type": "object", "properties": { "kid": { "type": "string" }, "epk": { "$ref": "https://identity.foundation/dwn/json-schemas/public-jwk.json" }, "derivationScheme": { "type": "string", "enum": ["dataFormats", "protocolContext", "protocolPath", "schemas"] }, "derivedPublicKey": { "$ref": "https://identity.foundation/dwn/json-schemas/public-jwk.json" } }, "additionalProperties": false, "required": ["kid", "epk", "derivationScheme"] }, "encrypted_key": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url" } }, "additionalProperties": false, "required": ["header", "encrypted_key"] } } }, "additionalProperties": false, "required": ["protected", "iv", "tag", "recipients"] }, "descriptor": { "type": "object", "properties": { "interface": { "enum": ["Records"], "type": "string" }, "method": { "enum": ["Write"], "type": "string" }, "recipient": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/did" }, "protocol": { "type": "string" }, "protocolPath": { "type": "string", "pattern": "^[a-zA-Z]+(/[a-zA-Z]+)*$" }, "schema": { "type": "string" }, "tags": { "type": "object", "minProperties": 1, "maxProperties": 10, "additionalProperties": { "oneOf": [{ "type": "string" }, { "type": "number" }, { "type": "boolean" }, { "type": "array", "minItems": 1, "maxItems": 10, "items": { "type": "string" } }, { "type": "array", "minItems": 1, "maxItems": 10, "items": { "type": "number" } }] } }, "parentId": { "type": "string" }, "dataCid": { "type": "string" }, "dataSize": { "type": "number" }, "dateCreated": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "messageTimestamp": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "published": { "type": "boolean" }, "datePublished": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "dataFormat": { "type": "string" }, "permissionGrantId": { "type": "string" } }, "additionalProperties": false, "required": ["interface", "method", "dataCid", "dataSize", "dateCreated", "messageTimestamp", "dataFormat"], "dependencies": { "parentId": ["protocol"] }, "allOf": [{ "$comment": "rule defining `published` and `datePublished` relationship", "anyOf": [{ "properties": { "published": { "type": "boolean", "enum": [true] } }, "required": ["published", "datePublished"] }, { "properties": { "published": { "type": "boolean", "enum": [false] } }, "not": { "required": ["datePublished"] } }, { "allOf": [{ "not": { "required": ["published"] } }, { "not": { "required": ["datePublished"] } }] }] }] } }, "$comment": "rule defining `protocol` and `contextId` relationship", "anyOf": [{ "properties": { "descriptor": { "type": "object", "required": ["protocol", "protocolPath"] } }, "required": ["contextId"] }, { "allOf": [{ "not": { "required": ["contextId"] } }, { "properties": { "descriptor": { "type": "object", "not": { "required": ["protocol"] } } } }, { "properties": { "descriptor": { "type": "object", "not": { "required": ["protocolPath"] } } } }] }] };
 const schema47 = { "type": "string", "pattern": "^did:([a-z0-9]+):((?:(?:[a-zA-Z0-9._-]|(?:%[0-9a-fA-F]{2}))*:)*((?:[a-zA-Z0-9._-]|(?:%[0-9a-fA-F]{2}))+))((;[a-zA-Z0-9_.:%-]+=[a-zA-Z0-9_.:%-]*)*)(/[^#?]*)?([?][^#]*)?(#.*)?$" };
 const schema48 = { "type": "string", "pattern": "^\\d{4}-[0-1]\\d-[0-3]\\dT(?:[0-2]\\d:[0-5]\\d:[0-5]\\d|23:59:60)\\.\\d{6}Z$" };
 const func1 = (_a = func1Mod.default) !== null && _a !== void 0 ? _a : func1Mod;
@@ -1757,30 +1757,35 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                     if (errors === _errs26) {
                                         if (data7 && typeof data7 == "object" && !Array.isArray(data7)) {
                                             let missing6;
-                                            if ((((data7.algorithm === undefined) && (missing6 = "algorithm")) || ((data7.initializationVector === undefined) && (missing6 = "initializationVector"))) || ((data7.keyEncryption === undefined) && (missing6 = "keyEncryption"))) {
+                                            if (((((data7.protected === undefined) && (missing6 = "protected")) || ((data7.iv === undefined) && (missing6 = "iv"))) || ((data7.tag === undefined) && (missing6 = "tag"))) || ((data7.recipients === undefined) && (missing6 = "recipients"))) {
                                                 validate27.errors = [{ instancePath: instancePath + "/encryption", schemaPath: "#/properties/encryption/required", keyword: "required", params: { missingProperty: missing6 }, message: "must have required property '" + missing6 + "'" }];
                                                 return false;
                                             }
                                             else {
                                                 const _errs28 = errors;
                                                 for (const key0 in data7) {
-                                                    if (!(((key0 === "algorithm") || (key0 === "initializationVector")) || (key0 === "keyEncryption"))) {
+                                                    if (!((((key0 === "protected") || (key0 === "iv")) || (key0 === "tag")) || (key0 === "recipients"))) {
                                                         validate27.errors = [{ instancePath: instancePath + "/encryption", schemaPath: "#/properties/encryption/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
                                                         return false;
                                                         break;
                                                     }
                                                 }
                                                 if (_errs28 === errors) {
-                                                    if (data7.algorithm !== undefined) {
-                                                        let data8 = data7.algorithm;
+                                                    if (data7.protected !== undefined) {
+                                                        let data8 = data7.protected;
                                                         const _errs29 = errors;
-                                                        if (typeof data8 !== "string") {
-                                                            validate27.errors = [{ instancePath: instancePath + "/encryption/algorithm", schemaPath: "#/properties/encryption/properties/algorithm/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
-                                                            return false;
-                                                        }
-                                                        if (!(data8 === "A256CTR")) {
-                                                            validate27.errors = [{ instancePath: instancePath + "/encryption/algorithm", schemaPath: "#/properties/encryption/properties/algorithm/enum", keyword: "enum", params: { allowedValues: schema39.properties.encryption.properties.algorithm.enum }, message: "must be equal to one of the allowed values" }];
-                                                            return false;
+                                                        const _errs30 = errors;
+                                                        if (errors === _errs30) {
+                                                            if (typeof data8 === "string") {
+                                                                if (!pattern4.test(data8)) {
+                                                                    validate27.errors = [{ instancePath: instancePath + "/encryption/protected", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: "must match pattern \"" + "^[A-Za-z0-9_-]+$" + "\"" }];
+                                                                    return false;
+                                                                }
+                                                            }
+                                                            else {
+                                                                validate27.errors = [{ instancePath: instancePath + "/encryption/protected", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                return false;
+                                                            }
                                                         }
                                                         var valid9 = _errs29 === errors;
                                                     }
@@ -1788,226 +1793,218 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                         var valid9 = true;
                                                     }
                                                     if (valid9) {
-                                                        if (data7.initializationVector !== undefined) {
-                                                            let data9 = data7.initializationVector;
-                                                            const _errs31 = errors;
+                                                        if (data7.iv !== undefined) {
+                                                            let data9 = data7.iv;
                                                             const _errs32 = errors;
-                                                            if (errors === _errs32) {
+                                                            const _errs33 = errors;
+                                                            if (errors === _errs33) {
                                                                 if (typeof data9 === "string") {
                                                                     if (!pattern4.test(data9)) {
-                                                                        validate27.errors = [{ instancePath: instancePath + "/encryption/initializationVector", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: "must match pattern \"" + "^[A-Za-z0-9_-]+$" + "\"" }];
+                                                                        validate27.errors = [{ instancePath: instancePath + "/encryption/iv", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: "must match pattern \"" + "^[A-Za-z0-9_-]+$" + "\"" }];
                                                                         return false;
                                                                     }
                                                                 }
                                                                 else {
-                                                                    validate27.errors = [{ instancePath: instancePath + "/encryption/initializationVector", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                    validate27.errors = [{ instancePath: instancePath + "/encryption/iv", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                                                                     return false;
                                                                 }
                                                             }
-                                                            var valid9 = _errs31 === errors;
+                                                            var valid9 = _errs32 === errors;
                                                         }
                                                         else {
                                                             var valid9 = true;
                                                         }
                                                         if (valid9) {
-                                                            if (data7.keyEncryption !== undefined) {
-                                                                let data10 = data7.keyEncryption;
-                                                                const _errs34 = errors;
-                                                                if (errors === _errs34) {
-                                                                    if (Array.isArray(data10)) {
-                                                                        if (data10.length < 1) {
-                                                                            validate27.errors = [{ instancePath: instancePath + "/encryption/keyEncryption", schemaPath: "#/properties/encryption/properties/keyEncryption/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" }];
+                                                            if (data7.tag !== undefined) {
+                                                                let data10 = data7.tag;
+                                                                const _errs35 = errors;
+                                                                const _errs36 = errors;
+                                                                if (errors === _errs36) {
+                                                                    if (typeof data10 === "string") {
+                                                                        if (!pattern4.test(data10)) {
+                                                                            validate27.errors = [{ instancePath: instancePath + "/encryption/tag", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: "must match pattern \"" + "^[A-Za-z0-9_-]+$" + "\"" }];
                                                                             return false;
                                                                         }
-                                                                        else {
-                                                                            var valid11 = true;
-                                                                            const len0 = data10.length;
-                                                                            for (let i0 = 0; i0 < len0; i0++) {
-                                                                                let data11 = data10[i0];
-                                                                                const _errs36 = errors;
-                                                                                if (errors === _errs36) {
-                                                                                    if (data11 && typeof data11 == "object" && !Array.isArray(data11)) {
-                                                                                        let missing7;
-                                                                                        if ((((((((data11.rootKeyId === undefined) && (missing7 = "rootKeyId")) || ((data11.derivationScheme === undefined) && (missing7 = "derivationScheme"))) || ((data11.algorithm === undefined) && (missing7 = "algorithm"))) || ((data11.encryptedKey === undefined) && (missing7 = "encryptedKey"))) || ((data11.initializationVector === undefined) && (missing7 = "initializationVector"))) || ((data11.ephemeralPublicKey === undefined) && (missing7 = "ephemeralPublicKey"))) || ((data11.messageAuthenticationCode === undefined) && (missing7 = "messageAuthenticationCode"))) {
-                                                                                            validate27.errors = [{ instancePath: instancePath + "/encryption/keyEncryption/" + i0, schemaPath: "#/properties/encryption/properties/keyEncryption/items/required", keyword: "required", params: { missingProperty: missing7 }, message: "must have required property '" + missing7 + "'" }];
-                                                                                            return false;
-                                                                                        }
-                                                                                        else {
-                                                                                            const _errs38 = errors;
-                                                                                            for (const key1 in data11) {
-                                                                                                if (!((((((((key1 === "rootKeyId") || (key1 === "derivationScheme")) || (key1 === "derivedPublicKey")) || (key1 === "algorithm")) || (key1 === "encryptedKey")) || (key1 === "initializationVector")) || (key1 === "ephemeralPublicKey")) || (key1 === "messageAuthenticationCode"))) {
-                                                                                                    validate27.errors = [{ instancePath: instancePath + "/encryption/keyEncryption/" + i0, schemaPath: "#/properties/encryption/properties/keyEncryption/items/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
-                                                                                                    return false;
-                                                                                                    break;
-                                                                                                }
+                                                                    }
+                                                                    else {
+                                                                        validate27.errors = [{ instancePath: instancePath + "/encryption/tag", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                        return false;
+                                                                    }
+                                                                }
+                                                                var valid9 = _errs35 === errors;
+                                                            }
+                                                            else {
+                                                                var valid9 = true;
+                                                            }
+                                                            if (valid9) {
+                                                                if (data7.recipients !== undefined) {
+                                                                    let data11 = data7.recipients;
+                                                                    const _errs38 = errors;
+                                                                    if (errors === _errs38) {
+                                                                        if (Array.isArray(data11)) {
+                                                                            if (data11.length < 1) {
+                                                                                validate27.errors = [{ instancePath: instancePath + "/encryption/recipients", schemaPath: "#/properties/encryption/properties/recipients/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" }];
+                                                                                return false;
+                                                                            }
+                                                                            else {
+                                                                                var valid13 = true;
+                                                                                const len0 = data11.length;
+                                                                                for (let i0 = 0; i0 < len0; i0++) {
+                                                                                    let data12 = data11[i0];
+                                                                                    const _errs40 = errors;
+                                                                                    if (errors === _errs40) {
+                                                                                        if (data12 && typeof data12 == "object" && !Array.isArray(data12)) {
+                                                                                            let missing7;
+                                                                                            if (((data12.header === undefined) && (missing7 = "header")) || ((data12.encrypted_key === undefined) && (missing7 = "encrypted_key"))) {
+                                                                                                validate27.errors = [{ instancePath: instancePath + "/encryption/recipients/" + i0, schemaPath: "#/properties/encryption/properties/recipients/items/required", keyword: "required", params: { missingProperty: missing7 }, message: "must have required property '" + missing7 + "'" }];
+                                                                                                return false;
                                                                                             }
-                                                                                            if (_errs38 === errors) {
-                                                                                                if (data11.rootKeyId !== undefined) {
-                                                                                                    const _errs39 = errors;
-                                                                                                    if (typeof data11.rootKeyId !== "string") {
-                                                                                                        validate27.errors = [{ instancePath: instancePath + "/encryption/keyEncryption/" + i0 + "/rootKeyId", schemaPath: "#/properties/encryption/properties/keyEncryption/items/properties/rootKeyId/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                            else {
+                                                                                                const _errs42 = errors;
+                                                                                                for (const key1 in data12) {
+                                                                                                    if (!((key1 === "header") || (key1 === "encrypted_key"))) {
+                                                                                                        validate27.errors = [{ instancePath: instancePath + "/encryption/recipients/" + i0, schemaPath: "#/properties/encryption/properties/recipients/items/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
                                                                                                         return false;
+                                                                                                        break;
                                                                                                     }
-                                                                                                    var valid12 = _errs39 === errors;
                                                                                                 }
-                                                                                                else {
-                                                                                                    var valid12 = true;
-                                                                                                }
-                                                                                                if (valid12) {
-                                                                                                    if (data11.derivationScheme !== undefined) {
-                                                                                                        let data13 = data11.derivationScheme;
-                                                                                                        const _errs41 = errors;
-                                                                                                        if (typeof data13 !== "string") {
-                                                                                                            validate27.errors = [{ instancePath: instancePath + "/encryption/keyEncryption/" + i0 + "/derivationScheme", schemaPath: "#/properties/encryption/properties/keyEncryption/items/properties/derivationScheme/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
-                                                                                                            return false;
-                                                                                                        }
-                                                                                                        if (!((((data13 === "dataFormats") || (data13 === "protocolContext")) || (data13 === "protocolPath")) || (data13 === "schemas"))) {
-                                                                                                            validate27.errors = [{ instancePath: instancePath + "/encryption/keyEncryption/" + i0 + "/derivationScheme", schemaPath: "#/properties/encryption/properties/keyEncryption/items/properties/derivationScheme/enum", keyword: "enum", params: { allowedValues: schema39.properties.encryption.properties.keyEncryption.items.properties.derivationScheme.enum }, message: "must be equal to one of the allowed values" }];
-                                                                                                            return false;
-                                                                                                        }
-                                                                                                        var valid12 = _errs41 === errors;
-                                                                                                    }
-                                                                                                    else {
-                                                                                                        var valid12 = true;
-                                                                                                    }
-                                                                                                    if (valid12) {
-                                                                                                        if (data11.derivedPublicKey !== undefined) {
-                                                                                                            const _errs43 = errors;
-                                                                                                            if (!(validate32(data11.derivedPublicKey, { instancePath: instancePath + "/encryption/keyEncryption/" + i0 + "/derivedPublicKey", parentData: data11, parentDataProperty: "derivedPublicKey", rootData, dynamicAnchors }))) {
-                                                                                                                vErrors = vErrors === null ? validate32.errors : vErrors.concat(validate32.errors);
-                                                                                                                errors = vErrors.length;
-                                                                                                            }
-                                                                                                            var valid12 = _errs43 === errors;
-                                                                                                        }
-                                                                                                        else {
-                                                                                                            var valid12 = true;
-                                                                                                        }
-                                                                                                        if (valid12) {
-                                                                                                            if (data11.algorithm !== undefined) {
-                                                                                                                let data15 = data11.algorithm;
-                                                                                                                const _errs44 = errors;
-                                                                                                                if (typeof data15 !== "string") {
-                                                                                                                    validate27.errors = [{ instancePath: instancePath + "/encryption/keyEncryption/" + i0 + "/algorithm", schemaPath: "#/properties/encryption/properties/keyEncryption/items/properties/algorithm/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
-                                                                                                                    return false;
-                                                                                                                }
-                                                                                                                if (!(data15 === "ECIES-ES256K")) {
-                                                                                                                    validate27.errors = [{ instancePath: instancePath + "/encryption/keyEncryption/" + i0 + "/algorithm", schemaPath: "#/properties/encryption/properties/keyEncryption/items/properties/algorithm/enum", keyword: "enum", params: { allowedValues: schema39.properties.encryption.properties.keyEncryption.items.properties.algorithm.enum }, message: "must be equal to one of the allowed values" }];
+                                                                                                if (_errs42 === errors) {
+                                                                                                    if (data12.header !== undefined) {
+                                                                                                        let data13 = data12.header;
+                                                                                                        const _errs43 = errors;
+                                                                                                        if (errors === _errs43) {
+                                                                                                            if (data13 && typeof data13 == "object" && !Array.isArray(data13)) {
+                                                                                                                let missing8;
+                                                                                                                if ((((data13.kid === undefined) && (missing8 = "kid")) || ((data13.epk === undefined) && (missing8 = "epk"))) || ((data13.derivationScheme === undefined) && (missing8 = "derivationScheme"))) {
+                                                                                                                    validate27.errors = [{ instancePath: instancePath + "/encryption/recipients/" + i0 + "/header", schemaPath: "#/properties/encryption/properties/recipients/items/properties/header/required", keyword: "required", params: { missingProperty: missing8 }, message: "must have required property '" + missing8 + "'" }];
                                                                                                                     return false;
                                                                                                                 }
-                                                                                                                var valid12 = _errs44 === errors;
-                                                                                                            }
-                                                                                                            else {
-                                                                                                                var valid12 = true;
-                                                                                                            }
-                                                                                                            if (valid12) {
-                                                                                                                if (data11.encryptedKey !== undefined) {
-                                                                                                                    let data16 = data11.encryptedKey;
-                                                                                                                    const _errs46 = errors;
-                                                                                                                    const _errs47 = errors;
-                                                                                                                    if (errors === _errs47) {
-                                                                                                                        if (typeof data16 === "string") {
-                                                                                                                            if (!pattern4.test(data16)) {
-                                                                                                                                validate27.errors = [{ instancePath: instancePath + "/encryption/keyEncryption/" + i0 + "/encryptedKey", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: "must match pattern \"" + "^[A-Za-z0-9_-]+$" + "\"" }];
+                                                                                                                else {
+                                                                                                                    const _errs45 = errors;
+                                                                                                                    for (const key2 in data13) {
+                                                                                                                        if (!((((key2 === "kid") || (key2 === "epk")) || (key2 === "derivationScheme")) || (key2 === "derivedPublicKey"))) {
+                                                                                                                            validate27.errors = [{ instancePath: instancePath + "/encryption/recipients/" + i0 + "/header", schemaPath: "#/properties/encryption/properties/recipients/items/properties/header/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" }];
+                                                                                                                            return false;
+                                                                                                                            break;
+                                                                                                                        }
+                                                                                                                    }
+                                                                                                                    if (_errs45 === errors) {
+                                                                                                                        if (data13.kid !== undefined) {
+                                                                                                                            const _errs46 = errors;
+                                                                                                                            if (typeof data13.kid !== "string") {
+                                                                                                                                validate27.errors = [{ instancePath: instancePath + "/encryption/recipients/" + i0 + "/header/kid", schemaPath: "#/properties/encryption/properties/recipients/items/properties/header/properties/kid/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                                                                                                                                 return false;
                                                                                                                             }
+                                                                                                                            var valid15 = _errs46 === errors;
                                                                                                                         }
                                                                                                                         else {
-                                                                                                                            validate27.errors = [{ instancePath: instancePath + "/encryption/keyEncryption/" + i0 + "/encryptedKey", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
-                                                                                                                            return false;
+                                                                                                                            var valid15 = true;
                                                                                                                         }
-                                                                                                                    }
-                                                                                                                    var valid12 = _errs46 === errors;
-                                                                                                                }
-                                                                                                                else {
-                                                                                                                    var valid12 = true;
-                                                                                                                }
-                                                                                                                if (valid12) {
-                                                                                                                    if (data11.initializationVector !== undefined) {
-                                                                                                                        let data17 = data11.initializationVector;
-                                                                                                                        const _errs49 = errors;
-                                                                                                                        const _errs50 = errors;
-                                                                                                                        if (errors === _errs50) {
-                                                                                                                            if (typeof data17 === "string") {
-                                                                                                                                if (!pattern4.test(data17)) {
-                                                                                                                                    validate27.errors = [{ instancePath: instancePath + "/encryption/keyEncryption/" + i0 + "/initializationVector", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: "must match pattern \"" + "^[A-Za-z0-9_-]+$" + "\"" }];
-                                                                                                                                    return false;
+                                                                                                                        if (valid15) {
+                                                                                                                            if (data13.epk !== undefined) {
+                                                                                                                                const _errs48 = errors;
+                                                                                                                                if (!(validate32(data13.epk, { instancePath: instancePath + "/encryption/recipients/" + i0 + "/header/epk", parentData: data13, parentDataProperty: "epk", rootData, dynamicAnchors }))) {
+                                                                                                                                    vErrors = vErrors === null ? validate32.errors : vErrors.concat(validate32.errors);
+                                                                                                                                    errors = vErrors.length;
                                                                                                                                 }
+                                                                                                                                var valid15 = _errs48 === errors;
                                                                                                                             }
                                                                                                                             else {
-                                                                                                                                validate27.errors = [{ instancePath: instancePath + "/encryption/keyEncryption/" + i0 + "/initializationVector", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
-                                                                                                                                return false;
-                                                                                                                            }
-                                                                                                                        }
-                                                                                                                        var valid12 = _errs49 === errors;
-                                                                                                                    }
-                                                                                                                    else {
-                                                                                                                        var valid12 = true;
-                                                                                                                    }
-                                                                                                                    if (valid12) {
-                                                                                                                        if (data11.ephemeralPublicKey !== undefined) {
-                                                                                                                            const _errs52 = errors;
-                                                                                                                            if (!(validate32(data11.ephemeralPublicKey, { instancePath: instancePath + "/encryption/keyEncryption/" + i0 + "/ephemeralPublicKey", parentData: data11, parentDataProperty: "ephemeralPublicKey", rootData, dynamicAnchors }))) {
-                                                                                                                                vErrors = vErrors === null ? validate32.errors : vErrors.concat(validate32.errors);
-                                                                                                                                errors = vErrors.length;
+                                                                                                                                var valid15 = true;
                                                                                                                             }
-                                                                                                                            var valid12 = _errs52 === errors;
-                                                                                                                        }
-                                                                                                                        else {
-                                                                                                                            var valid12 = true;
-                                                                                                                        }
-                                                                                                                        if (valid12) {
-                                                                                                                            if (data11.messageAuthenticationCode !== undefined) {
-                                                                                                                                let data19 = data11.messageAuthenticationCode;
-                                                                                                                                const _errs53 = errors;
-                                                                                                                                const _errs54 = errors;
-                                                                                                                                if (errors === _errs54) {
-                                                                                                                                    if (typeof data19 === "string") {
-                                                                                                                                        if (!pattern4.test(data19)) {
-                                                                                                                                            validate27.errors = [{ instancePath: instancePath + "/encryption/keyEncryption/" + i0 + "/messageAuthenticationCode", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: "must match pattern \"" + "^[A-Za-z0-9_-]+$" + "\"" }];
-                                                                                                                                            return false;
+                                                                                                                            if (valid15) {
+                                                                                                                                if (data13.derivationScheme !== undefined) {
+                                                                                                                                    let data16 = data13.derivationScheme;
+                                                                                                                                    const _errs49 = errors;
+                                                                                                                                    if (typeof data16 !== "string") {
+                                                                                                                                        validate27.errors = [{ instancePath: instancePath + "/encryption/recipients/" + i0 + "/header/derivationScheme", schemaPath: "#/properties/encryption/properties/recipients/items/properties/header/properties/derivationScheme/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                                        return false;
+                                                                                                                                    }
+                                                                                                                                    if (!((((data16 === "dataFormats") || (data16 === "protocolContext")) || (data16 === "protocolPath")) || (data16 === "schemas"))) {
+                                                                                                                                        validate27.errors = [{ instancePath: instancePath + "/encryption/recipients/" + i0 + "/header/derivationScheme", schemaPath: "#/properties/encryption/properties/recipients/items/properties/header/properties/derivationScheme/enum", keyword: "enum", params: { allowedValues: schema39.properties.encryption.properties.recipients.items.properties.header.properties.derivationScheme.enum }, message: "must be equal to one of the allowed values" }];
+                                                                                                                                        return false;
+                                                                                                                                    }
+                                                                                                                                    var valid15 = _errs49 === errors;
+                                                                                                                                }
+                                                                                                                                else {
+                                                                                                                                    var valid15 = true;
+                                                                                                                                }
+                                                                                                                                if (valid15) {
+                                                                                                                                    if (data13.derivedPublicKey !== undefined) {
+                                                                                                                                        const _errs51 = errors;
+                                                                                                                                        if (!(validate32(data13.derivedPublicKey, { instancePath: instancePath + "/encryption/recipients/" + i0 + "/header/derivedPublicKey", parentData: data13, parentDataProperty: "derivedPublicKey", rootData, dynamicAnchors }))) {
+                                                                                                                                            vErrors = vErrors === null ? validate32.errors : vErrors.concat(validate32.errors);
+                                                                                                                                            errors = vErrors.length;
                                                                                                                                         }
+                                                                                                                                        var valid15 = _errs51 === errors;
                                                                                                                                     }
                                                                                                                                     else {
-                                                                                                                                        validate27.errors = [{ instancePath: instancePath + "/encryption/keyEncryption/" + i0 + "/messageAuthenticationCode", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
-                                                                                                                                        return false;
+                                                                                                                                        var valid15 = true;
                                                                                                                                     }
                                                                                                                                 }
-                                                                                                                                var valid12 = _errs53 === errors;
-                                                                                                                            }
-                                                                                                                            else {
-                                                                                                                                var valid12 = true;
                                                                                                                             }
                                                                                                                         }
                                                                                                                     }
                                                                                                                 }
                                                                                                             }
+                                                                                                            else {
+                                                                                                                validate27.errors = [{ instancePath: instancePath + "/encryption/recipients/" + i0 + "/header", schemaPath: "#/properties/encryption/properties/recipients/items/properties/header/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                                                return false;
+                                                                                                            }
+                                                                                                        }
+                                                                                                        var valid14 = _errs43 === errors;
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        var valid14 = true;
+                                                                                                    }
+                                                                                                    if (valid14) {
+                                                                                                        if (data12.encrypted_key !== undefined) {
+                                                                                                            let data18 = data12.encrypted_key;
+                                                                                                            const _errs52 = errors;
+                                                                                                            const _errs53 = errors;
+                                                                                                            if (errors === _errs53) {
+                                                                                                                if (typeof data18 === "string") {
+                                                                                                                    if (!pattern4.test(data18)) {
+                                                                                                                        validate27.errors = [{ instancePath: instancePath + "/encryption/recipients/" + i0 + "/encrypted_key", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: "must match pattern \"" + "^[A-Za-z0-9_-]+$" + "\"" }];
+                                                                                                                        return false;
+                                                                                                                    }
+                                                                                                                }
+                                                                                                                else {
+                                                                                                                    validate27.errors = [{ instancePath: instancePath + "/encryption/recipients/" + i0 + "/encrypted_key", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                    return false;
+                                                                                                                }
+                                                                                                            }
+                                                                                                            var valid14 = _errs52 === errors;
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            var valid14 = true;
                                                                                                         }
                                                                                                     }
                                                                                                 }
                                                                                             }
                                                                                         }
+                                                                                        else {
+                                                                                            validate27.errors = [{ instancePath: instancePath + "/encryption/recipients/" + i0, schemaPath: "#/properties/encryption/properties/recipients/items/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                            return false;
+                                                                                        }
                                                                                     }
-                                                                                    else {
-                                                                                        validate27.errors = [{ instancePath: instancePath + "/encryption/keyEncryption/" + i0, schemaPath: "#/properties/encryption/properties/keyEncryption/items/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
-                                                                                        return false;
+                                                                                    var valid13 = _errs40 === errors;
+                                                                                    if (!valid13) {
+                                                                                        break;
                                                                                     }
                                                                                 }
-                                                                                var valid11 = _errs36 === errors;
-                                                                                if (!valid11) {
-                                                                                    break;
-                                                                                }
                                                                             }
                                                                         }
+                                                                        else {
+                                                                            validate27.errors = [{ instancePath: instancePath + "/encryption/recipients", schemaPath: "#/properties/encryption/properties/recipients/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                                            return false;
+                                                                        }
                                                                     }
-                                                                    else {
-                                                                        validate27.errors = [{ instancePath: instancePath + "/encryption/keyEncryption", schemaPath: "#/properties/encryption/properties/keyEncryption/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
-                                                                        return false;
-                                                                    }
+                                                                    var valid9 = _errs38 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid9 = true;
                                                                 }
-                                                                var valid9 = _errs34 === errors;
-                                                            }
-                                                            else {
-                                                                var valid9 = true;
                                                             }
                                                         }
                                                     }
@@ -2026,15 +2023,15 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                 }
                                 if (valid8) {
                                     if (data.descriptor !== undefined) {
-                                        let data20 = data.descriptor;
-                                        const _errs56 = errors;
+                                        let data19 = data.descriptor;
+                                        const _errs55 = errors;
+                                        const _errs59 = errors;
+                                        let valid18 = false;
                                         const _errs60 = errors;
-                                        let valid17 = false;
-                                        const _errs61 = errors;
-                                        if (data20 && typeof data20 == "object" && !Array.isArray(data20)) {
-                                            let missing8;
-                                            if (((data20.published === undefined) && (missing8 = "published")) || ((data20.datePublished === undefined) && (missing8 = "datePublished"))) {
-                                                const err12 = { instancePath: instancePath + "/descriptor", schemaPath: "#/properties/descriptor/allOf/0/anyOf/0/required", keyword: "required", params: { missingProperty: missing8 }, message: "must have required property '" + missing8 + "'" };
+                                        if (data19 && typeof data19 == "object" && !Array.isArray(data19)) {
+                                            let missing9;
+                                            if (((data19.published === undefined) && (missing9 = "published")) || ((data19.datePublished === undefined) && (missing9 = "datePublished"))) {
+                                                const err12 = { instancePath: instancePath + "/descriptor", schemaPath: "#/properties/descriptor/allOf/0/anyOf/0/required", keyword: "required", params: { missingProperty: missing9 }, message: "must have required property '" + missing9 + "'" };
                                                 if (vErrors === null) {
                                                     vErrors = [err12];
                                                 }
@@ -2044,9 +2041,9 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                 errors++;
                                             }
                                             else {
-                                                if (data20.published !== undefined) {
-                                                    let data21 = data20.published;
-                                                    if (typeof data21 !== "boolean") {
+                                                if (data19.published !== undefined) {
+                                                    let data20 = data19.published;
+                                                    if (typeof data20 !== "boolean") {
                                                         const err13 = { instancePath: instancePath + "/descriptor/published", schemaPath: "#/properties/descriptor/allOf/0/anyOf/0/properties/published/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
                                                         if (vErrors === null) {
                                                             vErrors = [err13];
@@ -2056,7 +2053,7 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                         }
                                                         errors++;
                                                     }
-                                                    if (!(data21 === true)) {
+                                                    if (!(data20 === true)) {
                                                         const err14 = { instancePath: instancePath + "/descriptor/published", schemaPath: "#/properties/descriptor/allOf/0/anyOf/0/properties/published/enum", keyword: "enum", params: { allowedValues: schema39.properties.descriptor.allOf[0].anyOf[0].properties.published.enum }, message: "must be equal to one of the allowed values" };
                                                         if (vErrors === null) {
                                                             vErrors = [err14];
@@ -2069,18 +2066,18 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                 }
                                             }
                                         }
-                                        var _valid1 = _errs61 === errors;
-                                        valid17 = valid17 || _valid1;
+                                        var _valid1 = _errs60 === errors;
+                                        valid18 = valid18 || _valid1;
                                         if (_valid1) {
                                             var props3 = {};
                                             props3.published = true;
                                         }
+                                        const _errs63 = errors;
                                         const _errs64 = errors;
                                         const _errs65 = errors;
-                                        const _errs66 = errors;
-                                        if (data20 && typeof data20 == "object" && !Array.isArray(data20)) {
-                                            let missing9;
-                                            if ((data20.datePublished === undefined) && (missing9 = "datePublished")) {
+                                        if (data19 && typeof data19 == "object" && !Array.isArray(data19)) {
+                                            let missing10;
+                                            if ((data19.datePublished === undefined) && (missing10 = "datePublished")) {
                                                 const err15 = {};
                                                 if (vErrors === null) {
                                                     vErrors = [err15];
@@ -2091,8 +2088,8 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                 errors++;
                                             }
                                         }
-                                        var valid19 = _errs66 === errors;
-                                        if (valid19) {
+                                        var valid20 = _errs65 === errors;
+                                        if (valid20) {
                                             const err16 = { instancePath: instancePath + "/descriptor", schemaPath: "#/properties/descriptor/allOf/0/anyOf/1/not", keyword: "not", params: {}, message: "must NOT be valid" };
                                             if (vErrors === null) {
                                                 vErrors = [err16];
@@ -2103,21 +2100,21 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                             errors++;
                                         }
                                         else {
-                                            errors = _errs65;
+                                            errors = _errs64;
                                             if (vErrors !== null) {
-                                                if (_errs65) {
-                                                    vErrors.length = _errs65;
+                                                if (_errs64) {
+                                                    vErrors.length = _errs64;
                                                 }
                                                 else {
                                                     vErrors = null;
                                                 }
                                             }
                                         }
-                                        if (errors === _errs64) {
-                                            if (data20 && typeof data20 == "object" && !Array.isArray(data20)) {
-                                                if (data20.published !== undefined) {
-                                                    let data22 = data20.published;
-                                                    if (typeof data22 !== "boolean") {
+                                        if (errors === _errs63) {
+                                            if (data19 && typeof data19 == "object" && !Array.isArray(data19)) {
+                                                if (data19.published !== undefined) {
+                                                    let data21 = data19.published;
+                                                    if (typeof data21 !== "boolean") {
                                                         const err17 = { instancePath: instancePath + "/descriptor/published", schemaPath: "#/properties/descriptor/allOf/0/anyOf/1/properties/published/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
                                                         if (vErrors === null) {
                                                             vErrors = [err17];
@@ -2127,7 +2124,7 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                         }
                                                         errors++;
                                                     }
-                                                    if (!(data22 === false)) {
+                                                    if (!(data21 === false)) {
                                                         const err18 = { instancePath: instancePath + "/descriptor/published", schemaPath: "#/properties/descriptor/allOf/0/anyOf/1/properties/published/enum", keyword: "enum", params: { allowedValues: schema39.properties.descriptor.allOf[0].anyOf[1].properties.published.enum }, message: "must be equal to one of the allowed values" };
                                                         if (vErrors === null) {
                                                             vErrors = [err18];
@@ -2140,21 +2137,21 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                 }
                                             }
                                         }
-                                        var _valid1 = _errs64 === errors;
-                                        valid17 = valid17 || _valid1;
+                                        var _valid1 = _errs63 === errors;
+                                        valid18 = valid18 || _valid1;
                                         if (_valid1) {
                                             if (props3 !== true) {
                                                 props3 = props3 || {};
                                                 props3.published = true;
                                             }
                                         }
+                                        const _errs68 = errors;
                                         const _errs69 = errors;
                                         const _errs70 = errors;
                                         const _errs71 = errors;
-                                        const _errs72 = errors;
-                                        if (data20 && typeof data20 == "object" && !Array.isArray(data20)) {
-                                            let missing10;
-                                            if ((data20.published === undefined) && (missing10 = "published")) {
+                                        if (data19 && typeof data19 == "object" && !Array.isArray(data19)) {
+                                            let missing11;
+                                            if ((data19.published === undefined) && (missing11 = "published")) {
                                                 const err19 = {};
                                                 if (vErrors === null) {
                                                     vErrors = [err19];
@@ -2165,8 +2162,8 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                 errors++;
                                             }
                                         }
-                                        var valid22 = _errs72 === errors;
-                                        if (valid22) {
+                                        var valid23 = _errs71 === errors;
+                                        if (valid23) {
                                             const err20 = { instancePath: instancePath + "/descriptor", schemaPath: "#/properties/descriptor/allOf/0/anyOf/2/allOf/0/not", keyword: "not", params: {}, message: "must NOT be valid" };
                                             if (vErrors === null) {
                                                 vErrors = [err20];
@@ -2177,24 +2174,24 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                             errors++;
                                         }
                                         else {
-                                            errors = _errs71;
+                                            errors = _errs70;
                                             if (vErrors !== null) {
-                                                if (_errs71) {
-                                                    vErrors.length = _errs71;
+                                                if (_errs70) {
+                                                    vErrors.length = _errs70;
                                                 }
                                                 else {
                                                     vErrors = null;
                                                 }
                                             }
                                         }
-                                        var valid21 = _errs70 === errors;
-                                        if (valid21) {
+                                        var valid22 = _errs69 === errors;
+                                        if (valid22) {
+                                            const _errs72 = errors;
                                             const _errs73 = errors;
                                             const _errs74 = errors;
-                                            const _errs75 = errors;
-                                            if (data20 && typeof data20 == "object" && !Array.isArray(data20)) {
-                                                let missing11;
-                                                if ((data20.datePublished === undefined) && (missing11 = "datePublished")) {
+                                            if (data19 && typeof data19 == "object" && !Array.isArray(data19)) {
+                                                let missing12;
+                                                if ((data19.datePublished === undefined) && (missing12 = "datePublished")) {
                                                     const err21 = {};
                                                     if (vErrors === null) {
                                                         vErrors = [err21];
@@ -2205,8 +2202,8 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                     errors++;
                                                 }
                                             }
-                                            var valid23 = _errs75 === errors;
-                                            if (valid23) {
+                                            var valid24 = _errs74 === errors;
+                                            if (valid24) {
                                                 const err22 = { instancePath: instancePath + "/descriptor", schemaPath: "#/properties/descriptor/allOf/0/anyOf/2/allOf/1/not", keyword: "not", params: {}, message: "must NOT be valid" };
                                                 if (vErrors === null) {
                                                     vErrors = [err22];
@@ -2217,21 +2214,21 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                 errors++;
                                             }
                                             else {
-                                                errors = _errs74;
+                                                errors = _errs73;
                                                 if (vErrors !== null) {
-                                                    if (_errs74) {
-                                                        vErrors.length = _errs74;
+                                                    if (_errs73) {
+                                                        vErrors.length = _errs73;
                                                     }
                                                     else {
                                                         vErrors = null;
                                                     }
                                                 }
                                             }
-                                            var valid21 = _errs73 === errors;
+                                            var valid22 = _errs72 === errors;
                                         }
-                                        var _valid1 = _errs69 === errors;
-                                        valid17 = valid17 || _valid1;
-                                        if (!valid17) {
+                                        var _valid1 = _errs68 === errors;
+                                        valid18 = valid18 || _valid1;
+                                        if (!valid18) {
                                             const err23 = { instancePath: instancePath + "/descriptor", schemaPath: "#/properties/descriptor/allOf/0/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
                                             if (vErrors === null) {
                                                 vErrors = [err23];
@@ -2244,83 +2241,83 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                             return false;
                                         }
                                         else {
-                                            errors = _errs60;
+                                            errors = _errs59;
                                             if (vErrors !== null) {
-                                                if (_errs60) {
-                                                    vErrors.length = _errs60;
+                                                if (_errs59) {
+                                                    vErrors.length = _errs59;
                                                 }
                                                 else {
                                                     vErrors = null;
                                                 }
                                             }
                                         }
-                                        if (errors === _errs56) {
-                                            if (data20 && typeof data20 == "object" && !Array.isArray(data20)) {
-                                                let missing12;
-                                                if ((((((((data20.interface === undefined) && (missing12 = "interface")) || ((data20.method === undefined) && (missing12 = "method"))) || ((data20.dataCid === undefined) && (missing12 = "dataCid"))) || ((data20.dataSize === undefined) && (missing12 = "dataSize"))) || ((data20.dateCreated === undefined) && (missing12 = "dateCreated"))) || ((data20.messageTimestamp === undefined) && (missing12 = "messageTimestamp"))) || ((data20.dataFormat === undefined) && (missing12 = "dataFormat"))) {
-                                                    validate27.errors = [{ instancePath: instancePath + "/descriptor", schemaPath: "#/properties/descriptor/required", keyword: "required", params: { missingProperty: missing12 }, message: "must have required property '" + missing12 + "'" }];
+                                        if (errors === _errs55) {
+                                            if (data19 && typeof data19 == "object" && !Array.isArray(data19)) {
+                                                let missing13;
+                                                if ((((((((data19.interface === undefined) && (missing13 = "interface")) || ((data19.method === undefined) && (missing13 = "method"))) || ((data19.dataCid === undefined) && (missing13 = "dataCid"))) || ((data19.dataSize === undefined) && (missing13 = "dataSize"))) || ((data19.dateCreated === undefined) && (missing13 = "dateCreated"))) || ((data19.messageTimestamp === undefined) && (missing13 = "messageTimestamp"))) || ((data19.dataFormat === undefined) && (missing13 = "dataFormat"))) {
+                                                    validate27.errors = [{ instancePath: instancePath + "/descriptor", schemaPath: "#/properties/descriptor/required", keyword: "required", params: { missingProperty: missing13 }, message: "must have required property '" + missing13 + "'" }];
                                                     return false;
                                                 }
                                                 else {
-                                                    const _errs76 = errors;
-                                                    for (const key2 in data20) {
-                                                        if (!(func2.call(schema39.properties.descriptor.properties, key2))) {
-                                                            validate27.errors = [{ instancePath: instancePath + "/descriptor", schemaPath: "#/properties/descriptor/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" }];
+                                                    const _errs75 = errors;
+                                                    for (const key3 in data19) {
+                                                        if (!(func2.call(schema39.properties.descriptor.properties, key3))) {
+                                                            validate27.errors = [{ instancePath: instancePath + "/descriptor", schemaPath: "#/properties/descriptor/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key3 }, message: "must NOT have additional properties" }];
                                                             return false;
                                                             break;
                                                         }
                                                     }
-                                                    if (_errs76 === errors) {
-                                                        let missing13;
-                                                        if (data20.parentId !== undefined && ((data20.protocol === undefined) && (missing13 = "protocol"))) {
+                                                    if (_errs75 === errors) {
+                                                        let missing14;
+                                                        if (data19.parentId !== undefined && ((data19.protocol === undefined) && (missing14 = "protocol"))) {
                                                             validate27.errors = [{ instancePath: instancePath + "/descriptor", schemaPath: "#/properties/descriptor/dependencies", keyword: "dependencies", params: { property: "parentId",
-                                                                        missingProperty: missing13,
+                                                                        missingProperty: missing14,
                                                                         depsCount: 1,
                                                                         deps: "protocol" }, message: "must have property protocol when property parentId is present" }];
                                                             return false;
                                                         }
                                                         else {
-                                                            if (data20.interface !== undefined) {
-                                                                let data23 = data20.interface;
-                                                                const _errs77 = errors;
-                                                                if (typeof data23 !== "string") {
+                                                            if (data19.interface !== undefined) {
+                                                                let data22 = data19.interface;
+                                                                const _errs76 = errors;
+                                                                if (typeof data22 !== "string") {
                                                                     validate27.errors = [{ instancePath: instancePath + "/descriptor/interface", schemaPath: "#/properties/descriptor/properties/interface/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                                                                     return false;
                                                                 }
-                                                                if (!(data23 === "Records")) {
+                                                                if (!(data22 === "Records")) {
                                                                     validate27.errors = [{ instancePath: instancePath + "/descriptor/interface", schemaPath: "#/properties/descriptor/properties/interface/enum", keyword: "enum", params: { allowedValues: schema39.properties.descriptor.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
                                                                     return false;
                                                                 }
-                                                                var valid25 = _errs77 === errors;
+                                                                var valid26 = _errs76 === errors;
                                                             }
                                                             else {
-                                                                var valid25 = true;
+                                                                var valid26 = true;
                                                             }
-                                                            if (valid25) {
-                                                                if (data20.method !== undefined) {
-                                                                    let data24 = data20.method;
-                                                                    const _errs79 = errors;
-                                                                    if (typeof data24 !== "string") {
+                                                            if (valid26) {
+                                                                if (data19.method !== undefined) {
+                                                                    let data23 = data19.method;
+                                                                    const _errs78 = errors;
+                                                                    if (typeof data23 !== "string") {
                                                                         validate27.errors = [{ instancePath: instancePath + "/descriptor/method", schemaPath: "#/properties/descriptor/properties/method/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                                                                         return false;
                                                                     }
-                                                                    if (!(data24 === "Write")) {
+                                                                    if (!(data23 === "Write")) {
                                                                         validate27.errors = [{ instancePath: instancePath + "/descriptor/method", schemaPath: "#/properties/descriptor/properties/method/enum", keyword: "enum", params: { allowedValues: schema39.properties.descriptor.properties.method.enum }, message: "must be equal to one of the allowed values" }];
                                                                         return false;
                                                                     }
-                                                                    var valid25 = _errs79 === errors;
+                                                                    var valid26 = _errs78 === errors;
                                                                 }
                                                                 else {
-                                                                    var valid25 = true;
+                                                                    var valid26 = true;
                                                                 }
-                                                                if (valid25) {
-                                                                    if (data20.recipient !== undefined) {
-                                                                        let data25 = data20.recipient;
+                                                                if (valid26) {
+                                                                    if (data19.recipient !== undefined) {
+                                                                        let data24 = data19.recipient;
+                                                                        const _errs80 = errors;
                                                                         const _errs81 = errors;
-                                                                        const _errs82 = errors;
-                                                                        if (errors === _errs82) {
-                                                                            if (typeof data25 === "string") {
-                                                                                if (!pattern12.test(data25)) {
+                                                                        if (errors === _errs81) {
+                                                                            if (typeof data24 === "string") {
+                                                                                if (!pattern12.test(data24)) {
                                                                                     validate27.errors = [{ instancePath: instancePath + "/descriptor/recipient", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/did/pattern", keyword: "pattern", params: { pattern: "^did:([a-z0-9]+):((?:(?:[a-zA-Z0-9._-]|(?:%[0-9a-fA-F]{2}))*:)*((?:[a-zA-Z0-9._-]|(?:%[0-9a-fA-F]{2}))+))((;[a-zA-Z0-9_.:%-]+=[a-zA-Z0-9_.:%-]*)*)(/[^#?]*)?([?][^#]*)?(#.*)?$" }, message: "must match pattern \"" + "^did:([a-z0-9]+):((?:(?:[a-zA-Z0-9._-]|(?:%[0-9a-fA-F]{2}))*:)*((?:[a-zA-Z0-9._-]|(?:%[0-9a-fA-F]{2}))+))((;[a-zA-Z0-9_.:%-]+=[a-zA-Z0-9_.:%-]*)*)(/[^#?]*)?([?][^#]*)?(#.*)?$" + "\"" }];
                                                                                     return false;
                                                                                 }
@@ -2330,30 +2327,30 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                 return false;
                                                                             }
                                                                         }
-                                                                        var valid25 = _errs81 === errors;
+                                                                        var valid26 = _errs80 === errors;
                                                                     }
                                                                     else {
-                                                                        var valid25 = true;
+                                                                        var valid26 = true;
                                                                     }
-                                                                    if (valid25) {
-                                                                        if (data20.protocol !== undefined) {
-                                                                            const _errs84 = errors;
-                                                                            if (typeof data20.protocol !== "string") {
+                                                                    if (valid26) {
+                                                                        if (data19.protocol !== undefined) {
+                                                                            const _errs83 = errors;
+                                                                            if (typeof data19.protocol !== "string") {
                                                                                 validate27.errors = [{ instancePath: instancePath + "/descriptor/protocol", schemaPath: "#/properties/descriptor/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                                                                                 return false;
                                                                             }
-                                                                            var valid25 = _errs84 === errors;
+                                                                            var valid26 = _errs83 === errors;
                                                                         }
                                                                         else {
-                                                                            var valid25 = true;
+                                                                            var valid26 = true;
                                                                         }
-                                                                        if (valid25) {
-                                                                            if (data20.protocolPath !== undefined) {
-                                                                                let data27 = data20.protocolPath;
-                                                                                const _errs86 = errors;
-                                                                                if (errors === _errs86) {
-                                                                                    if (typeof data27 === "string") {
-                                                                                        if (!pattern13.test(data27)) {
+                                                                        if (valid26) {
+                                                                            if (data19.protocolPath !== undefined) {
+                                                                                let data26 = data19.protocolPath;
+                                                                                const _errs85 = errors;
+                                                                                if (errors === _errs85) {
+                                                                                    if (typeof data26 === "string") {
+                                                                                        if (!pattern13.test(data26)) {
                                                                                             validate27.errors = [{ instancePath: instancePath + "/descriptor/protocolPath", schemaPath: "#/properties/descriptor/properties/protocolPath/pattern", keyword: "pattern", params: { pattern: "^[a-zA-Z]+(/[a-zA-Z]+)*$" }, message: "must match pattern \"" + "^[a-zA-Z]+(/[a-zA-Z]+)*$" + "\"" }];
                                                                                             return false;
                                                                                         }
@@ -2363,48 +2360,48 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                         return false;
                                                                                     }
                                                                                 }
-                                                                                var valid25 = _errs86 === errors;
+                                                                                var valid26 = _errs85 === errors;
                                                                             }
                                                                             else {
-                                                                                var valid25 = true;
+                                                                                var valid26 = true;
                                                                             }
-                                                                            if (valid25) {
-                                                                                if (data20.schema !== undefined) {
-                                                                                    const _errs88 = errors;
-                                                                                    if (typeof data20.schema !== "string") {
+                                                                            if (valid26) {
+                                                                                if (data19.schema !== undefined) {
+                                                                                    const _errs87 = errors;
+                                                                                    if (typeof data19.schema !== "string") {
                                                                                         validate27.errors = [{ instancePath: instancePath + "/descriptor/schema", schemaPath: "#/properties/descriptor/properties/schema/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                                                                                         return false;
                                                                                     }
-                                                                                    var valid25 = _errs88 === errors;
+                                                                                    var valid26 = _errs87 === errors;
                                                                                 }
                                                                                 else {
-                                                                                    var valid25 = true;
+                                                                                    var valid26 = true;
                                                                                 }
-                                                                                if (valid25) {
-                                                                                    if (data20.tags !== undefined) {
-                                                                                        let data29 = data20.tags;
-                                                                                        const _errs90 = errors;
-                                                                                        if (errors === _errs90) {
-                                                                                            if (data29 && typeof data29 == "object" && !Array.isArray(data29)) {
-                                                                                                if (Object.keys(data29).length > 10) {
+                                                                                if (valid26) {
+                                                                                    if (data19.tags !== undefined) {
+                                                                                        let data28 = data19.tags;
+                                                                                        const _errs89 = errors;
+                                                                                        if (errors === _errs89) {
+                                                                                            if (data28 && typeof data28 == "object" && !Array.isArray(data28)) {
+                                                                                                if (Object.keys(data28).length > 10) {
                                                                                                     validate27.errors = [{ instancePath: instancePath + "/descriptor/tags", schemaPath: "#/properties/descriptor/properties/tags/maxProperties", keyword: "maxProperties", params: { limit: 10 }, message: "must NOT have more than 10 properties" }];
                                                                                                     return false;
                                                                                                 }
                                                                                                 else {
-                                                                                                    if (Object.keys(data29).length < 1) {
+                                                                                                    if (Object.keys(data28).length < 1) {
                                                                                                         validate27.errors = [{ instancePath: instancePath + "/descriptor/tags", schemaPath: "#/properties/descriptor/properties/tags/minProperties", keyword: "minProperties", params: { limit: 1 }, message: "must NOT have fewer than 1 properties" }];
                                                                                                         return false;
                                                                                                     }
                                                                                                     else {
-                                                                                                        for (const key3 in data29) {
-                                                                                                            let data30 = data29[key3];
+                                                                                                        for (const key4 in data28) {
+                                                                                                            let data29 = data28[key4];
+                                                                                                            const _errs92 = errors;
                                                                                                             const _errs93 = errors;
-                                                                                                            const _errs94 = errors;
-                                                                                                            let valid28 = false;
+                                                                                                            let valid29 = false;
                                                                                                             let passing0 = null;
-                                                                                                            const _errs95 = errors;
-                                                                                                            if (typeof data30 !== "string") {
-                                                                                                                const err24 = { instancePath: instancePath + "/descriptor/tags/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/0/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                                                                                            const _errs94 = errors;
+                                                                                                            if (typeof data29 !== "string") {
+                                                                                                                const err24 = { instancePath: instancePath + "/descriptor/tags/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/0/type", keyword: "type", params: { type: "string" }, message: "must be string" };
                                                                                                                 if (vErrors === null) {
                                                                                                                     vErrors = [err24];
                                                                                                                 }
@@ -2413,14 +2410,14 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                 }
                                                                                                                 errors++;
                                                                                                             }
-                                                                                                            var _valid2 = _errs95 === errors;
+                                                                                                            var _valid2 = _errs94 === errors;
                                                                                                             if (_valid2) {
-                                                                                                                valid28 = true;
+                                                                                                                valid29 = true;
                                                                                                                 passing0 = 0;
                                                                                                             }
-                                                                                                            const _errs97 = errors;
-                                                                                                            if (!((typeof data30 == "number") && (isFinite(data30)))) {
-                                                                                                                const err25 = { instancePath: instancePath + "/descriptor/tags/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/1/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                                                                                            const _errs96 = errors;
+                                                                                                            if (!((typeof data29 == "number") && (isFinite(data29)))) {
+                                                                                                                const err25 = { instancePath: instancePath + "/descriptor/tags/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/1/type", keyword: "type", params: { type: "number" }, message: "must be number" };
                                                                                                                 if (vErrors === null) {
                                                                                                                     vErrors = [err25];
                                                                                                                 }
@@ -2429,19 +2426,19 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                 }
                                                                                                                 errors++;
                                                                                                             }
-                                                                                                            var _valid2 = _errs97 === errors;
-                                                                                                            if (_valid2 && valid28) {
-                                                                                                                valid28 = false;
+                                                                                                            var _valid2 = _errs96 === errors;
+                                                                                                            if (_valid2 && valid29) {
+                                                                                                                valid29 = false;
                                                                                                                 passing0 = [passing0, 1];
                                                                                                             }
                                                                                                             else {
                                                                                                                 if (_valid2) {
-                                                                                                                    valid28 = true;
+                                                                                                                    valid29 = true;
                                                                                                                     passing0 = 1;
                                                                                                                 }
-                                                                                                                const _errs99 = errors;
-                                                                                                                if (typeof data30 !== "boolean") {
-                                                                                                                    const err26 = { instancePath: instancePath + "/descriptor/tags/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/2/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
+                                                                                                                const _errs98 = errors;
+                                                                                                                if (typeof data29 !== "boolean") {
+                                                                                                                    const err26 = { instancePath: instancePath + "/descriptor/tags/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/2/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
                                                                                                                     if (vErrors === null) {
                                                                                                                         vErrors = [err26];
                                                                                                                     }
@@ -2450,21 +2447,21 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                     }
                                                                                                                     errors++;
                                                                                                                 }
-                                                                                                                var _valid2 = _errs99 === errors;
-                                                                                                                if (_valid2 && valid28) {
-                                                                                                                    valid28 = false;
+                                                                                                                var _valid2 = _errs98 === errors;
+                                                                                                                if (_valid2 && valid29) {
+                                                                                                                    valid29 = false;
                                                                                                                     passing0 = [passing0, 2];
                                                                                                                 }
                                                                                                                 else {
                                                                                                                     if (_valid2) {
-                                                                                                                        valid28 = true;
+                                                                                                                        valid29 = true;
                                                                                                                         passing0 = 2;
                                                                                                                     }
-                                                                                                                    const _errs101 = errors;
-                                                                                                                    if (errors === _errs101) {
-                                                                                                                        if (Array.isArray(data30)) {
-                                                                                                                            if (data30.length > 10) {
-                                                                                                                                const err27 = { instancePath: instancePath + "/descriptor/tags/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/3/maxItems", keyword: "maxItems", params: { limit: 10 }, message: "must NOT have more than 10 items" };
+                                                                                                                    const _errs100 = errors;
+                                                                                                                    if (errors === _errs100) {
+                                                                                                                        if (Array.isArray(data29)) {
+                                                                                                                            if (data29.length > 10) {
+                                                                                                                                const err27 = { instancePath: instancePath + "/descriptor/tags/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/3/maxItems", keyword: "maxItems", params: { limit: 10 }, message: "must NOT have more than 10 items" };
                                                                                                                                 if (vErrors === null) {
                                                                                                                                     vErrors = [err27];
                                                                                                                                 }
@@ -2474,8 +2471,8 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                                 errors++;
                                                                                                                             }
                                                                                                                             else {
-                                                                                                                                if (data30.length < 1) {
-                                                                                                                                    const err28 = { instancePath: instancePath + "/descriptor/tags/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/3/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
+                                                                                                                                if (data29.length < 1) {
+                                                                                                                                    const err28 = { instancePath: instancePath + "/descriptor/tags/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/3/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
                                                                                                                                     if (vErrors === null) {
                                                                                                                                         vErrors = [err28];
                                                                                                                                     }
@@ -2485,12 +2482,12 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                                     errors++;
                                                                                                                                 }
                                                                                                                                 else {
-                                                                                                                                    var valid29 = true;
-                                                                                                                                    const len1 = data30.length;
+                                                                                                                                    var valid30 = true;
+                                                                                                                                    const len1 = data29.length;
                                                                                                                                     for (let i1 = 0; i1 < len1; i1++) {
-                                                                                                                                        const _errs103 = errors;
-                                                                                                                                        if (typeof data30[i1] !== "string") {
-                                                                                                                                            const err29 = { instancePath: instancePath + "/descriptor/tags/" + key3.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i1, schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/3/items/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                                                                                                                        const _errs102 = errors;
+                                                                                                                                        if (typeof data29[i1] !== "string") {
+                                                                                                                                            const err29 = { instancePath: instancePath + "/descriptor/tags/" + key4.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i1, schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/3/items/type", keyword: "type", params: { type: "string" }, message: "must be string" };
                                                                                                                                             if (vErrors === null) {
                                                                                                                                                 vErrors = [err29];
                                                                                                                                             }
@@ -2499,8 +2496,8 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                                             }
                                                                                                                                             errors++;
                                                                                                                                         }
-                                                                                                                                        var valid29 = _errs103 === errors;
-                                                                                                                                        if (!valid29) {
+                                                                                                                                        var valid30 = _errs102 === errors;
+                                                                                                                                        if (!valid30) {
                                                                                                                                             break;
                                                                                                                                         }
                                                                                                                                     }
@@ -2508,7 +2505,7 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                             }
                                                                                                                         }
                                                                                                                         else {
-                                                                                                                            const err30 = { instancePath: instancePath + "/descriptor/tags/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/3/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                                                                                                                            const err30 = { instancePath: instancePath + "/descriptor/tags/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/3/type", keyword: "type", params: { type: "array" }, message: "must be array" };
                                                                                                                             if (vErrors === null) {
                                                                                                                                 vErrors = [err30];
                                                                                                                             }
@@ -2518,22 +2515,22 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                             errors++;
                                                                                                                         }
                                                                                                                     }
-                                                                                                                    var _valid2 = _errs101 === errors;
-                                                                                                                    if (_valid2 && valid28) {
-                                                                                                                        valid28 = false;
+                                                                                                                    var _valid2 = _errs100 === errors;
+                                                                                                                    if (_valid2 && valid29) {
+                                                                                                                        valid29 = false;
                                                                                                                         passing0 = [passing0, 3];
                                                                                                                     }
                                                                                                                     else {
                                                                                                                         if (_valid2) {
-                                                                                                                            valid28 = true;
+                                                                                                                            valid29 = true;
                                                                                                                             passing0 = 3;
                                                                                                                             var items0 = true;
                                                                                                                         }
-                                                                                                                        const _errs105 = errors;
-                                                                                                                        if (errors === _errs105) {
-                                                                                                                            if (Array.isArray(data30)) {
-                                                                                                                                if (data30.length > 10) {
-                                                                                                                                    const err31 = { instancePath: instancePath + "/descriptor/tags/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/4/maxItems", keyword: "maxItems", params: { limit: 10 }, message: "must NOT have more than 10 items" };
+                                                                                                                        const _errs104 = errors;
+                                                                                                                        if (errors === _errs104) {
+                                                                                                                            if (Array.isArray(data29)) {
+                                                                                                                                if (data29.length > 10) {
+                                                                                                                                    const err31 = { instancePath: instancePath + "/descriptor/tags/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/4/maxItems", keyword: "maxItems", params: { limit: 10 }, message: "must NOT have more than 10 items" };
                                                                                                                                     if (vErrors === null) {
                                                                                                                                         vErrors = [err31];
                                                                                                                                     }
@@ -2543,8 +2540,8 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                                     errors++;
                                                                                                                                 }
                                                                                                                                 else {
-                                                                                                                                    if (data30.length < 1) {
-                                                                                                                                        const err32 = { instancePath: instancePath + "/descriptor/tags/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/4/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
+                                                                                                                                    if (data29.length < 1) {
+                                                                                                                                        const err32 = { instancePath: instancePath + "/descriptor/tags/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/4/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
                                                                                                                                         if (vErrors === null) {
                                                                                                                                             vErrors = [err32];
                                                                                                                                         }
@@ -2554,13 +2551,13 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                                         errors++;
                                                                                                                                     }
                                                                                                                                     else {
-                                                                                                                                        var valid30 = true;
-                                                                                                                                        const len2 = data30.length;
+                                                                                                                                        var valid31 = true;
+                                                                                                                                        const len2 = data29.length;
                                                                                                                                         for (let i2 = 0; i2 < len2; i2++) {
-                                                                                                                                            let data32 = data30[i2];
-                                                                                                                                            const _errs107 = errors;
-                                                                                                                                            if (!((typeof data32 == "number") && (isFinite(data32)))) {
-                                                                                                                                                const err33 = { instancePath: instancePath + "/descriptor/tags/" + key3.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i2, schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/4/items/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                                                                                                                            let data31 = data29[i2];
+                                                                                                                                            const _errs106 = errors;
+                                                                                                                                            if (!((typeof data31 == "number") && (isFinite(data31)))) {
+                                                                                                                                                const err33 = { instancePath: instancePath + "/descriptor/tags/" + key4.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i2, schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/4/items/type", keyword: "type", params: { type: "number" }, message: "must be number" };
                                                                                                                                                 if (vErrors === null) {
                                                                                                                                                     vErrors = [err33];
                                                                                                                                                 }
@@ -2569,8 +2566,8 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                                                 }
                                                                                                                                                 errors++;
                                                                                                                                             }
-                                                                                                                                            var valid30 = _errs107 === errors;
-                                                                                                                                            if (!valid30) {
+                                                                                                                                            var valid31 = _errs106 === errors;
+                                                                                                                                            if (!valid31) {
                                                                                                                                                 break;
                                                                                                                                             }
                                                                                                                                         }
@@ -2578,7 +2575,7 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                                 }
                                                                                                                             }
                                                                                                                             else {
-                                                                                                                                const err34 = { instancePath: instancePath + "/descriptor/tags/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/4/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                                                                                                                                const err34 = { instancePath: instancePath + "/descriptor/tags/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf/4/type", keyword: "type", params: { type: "array" }, message: "must be array" };
                                                                                                                                 if (vErrors === null) {
                                                                                                                                     vErrors = [err34];
                                                                                                                                 }
@@ -2588,14 +2585,14 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                                 errors++;
                                                                                                                             }
                                                                                                                         }
-                                                                                                                        var _valid2 = _errs105 === errors;
-                                                                                                                        if (_valid2 && valid28) {
-                                                                                                                            valid28 = false;
+                                                                                                                        var _valid2 = _errs104 === errors;
+                                                                                                                        if (_valid2 && valid29) {
+                                                                                                                            valid29 = false;
                                                                                                                             passing0 = [passing0, 4];
                                                                                                                         }
                                                                                                                         else {
                                                                                                                             if (_valid2) {
-                                                                                                                                valid28 = true;
+                                                                                                                                valid29 = true;
                                                                                                                                 passing0 = 4;
                                                                                                                                 if (items0 !== true) {
                                                                                                                                     items0 = true;
@@ -2605,8 +2602,8 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                     }
                                                                                                                 }
                                                                                                             }
-                                                                                                            if (!valid28) {
-                                                                                                                const err35 = { instancePath: instancePath + "/descriptor/tags/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf", keyword: "oneOf", params: { passingSchemas: passing0 }, message: "must match exactly one schema in oneOf" };
+                                                                                                            if (!valid29) {
+                                                                                                                const err35 = { instancePath: instancePath + "/descriptor/tags/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/descriptor/properties/tags/additionalProperties/oneOf", keyword: "oneOf", params: { passingSchemas: passing0 }, message: "must match exactly one schema in oneOf" };
                                                                                                                 if (vErrors === null) {
                                                                                                                     vErrors = [err35];
                                                                                                                 }
@@ -2618,18 +2615,18 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                 return false;
                                                                                                             }
                                                                                                             else {
-                                                                                                                errors = _errs94;
+                                                                                                                errors = _errs93;
                                                                                                                 if (vErrors !== null) {
-                                                                                                                    if (_errs94) {
-                                                                                                                        vErrors.length = _errs94;
+                                                                                                                    if (_errs93) {
+                                                                                                                        vErrors.length = _errs93;
                                                                                                                     }
                                                                                                                     else {
                                                                                                                         vErrors = null;
                                                                                                                     }
                                                                                                                 }
                                                                                                             }
-                                                                                                            var valid27 = _errs93 === errors;
-                                                                                                            if (!valid27) {
+                                                                                                            var valid28 = _errs92 === errors;
+                                                                                                            if (!valid28) {
                                                                                                                 break;
                                                                                                             }
                                                                                                         }
@@ -2641,56 +2638,56 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                 return false;
                                                                                             }
                                                                                         }
-                                                                                        var valid25 = _errs90 === errors;
+                                                                                        var valid26 = _errs89 === errors;
                                                                                     }
                                                                                     else {
-                                                                                        var valid25 = true;
+                                                                                        var valid26 = true;
                                                                                     }
-                                                                                    if (valid25) {
-                                                                                        if (data20.parentId !== undefined) {
-                                                                                            const _errs109 = errors;
-                                                                                            if (typeof data20.parentId !== "string") {
+                                                                                    if (valid26) {
+                                                                                        if (data19.parentId !== undefined) {
+                                                                                            const _errs108 = errors;
+                                                                                            if (typeof data19.parentId !== "string") {
                                                                                                 validate27.errors = [{ instancePath: instancePath + "/descriptor/parentId", schemaPath: "#/properties/descriptor/properties/parentId/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                                                                                                 return false;
                                                                                             }
-                                                                                            var valid25 = _errs109 === errors;
+                                                                                            var valid26 = _errs108 === errors;
                                                                                         }
                                                                                         else {
-                                                                                            var valid25 = true;
+                                                                                            var valid26 = true;
                                                                                         }
-                                                                                        if (valid25) {
-                                                                                            if (data20.dataCid !== undefined) {
-                                                                                                const _errs111 = errors;
-                                                                                                if (typeof data20.dataCid !== "string") {
+                                                                                        if (valid26) {
+                                                                                            if (data19.dataCid !== undefined) {
+                                                                                                const _errs110 = errors;
+                                                                                                if (typeof data19.dataCid !== "string") {
                                                                                                     validate27.errors = [{ instancePath: instancePath + "/descriptor/dataCid", schemaPath: "#/properties/descriptor/properties/dataCid/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                                                                                                     return false;
                                                                                                 }
-                                                                                                var valid25 = _errs111 === errors;
+                                                                                                var valid26 = _errs110 === errors;
                                                                                             }
                                                                                             else {
-                                                                                                var valid25 = true;
+                                                                                                var valid26 = true;
                                                                                             }
-                                                                                            if (valid25) {
-                                                                                                if (data20.dataSize !== undefined) {
-                                                                                                    let data35 = data20.dataSize;
-                                                                                                    const _errs113 = errors;
-                                                                                                    if (!((typeof data35 == "number") && (isFinite(data35)))) {
+                                                                                            if (valid26) {
+                                                                                                if (data19.dataSize !== undefined) {
+                                                                                                    let data34 = data19.dataSize;
+                                                                                                    const _errs112 = errors;
+                                                                                                    if (!((typeof data34 == "number") && (isFinite(data34)))) {
                                                                                                         validate27.errors = [{ instancePath: instancePath + "/descriptor/dataSize", schemaPath: "#/properties/descriptor/properties/dataSize/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
                                                                                                         return false;
                                                                                                     }
-                                                                                                    var valid25 = _errs113 === errors;
+                                                                                                    var valid26 = _errs112 === errors;
                                                                                                 }
                                                                                                 else {
-                                                                                                    var valid25 = true;
+                                                                                                    var valid26 = true;
                                                                                                 }
-                                                                                                if (valid25) {
-                                                                                                    if (data20.dateCreated !== undefined) {
-                                                                                                        let data36 = data20.dateCreated;
+                                                                                                if (valid26) {
+                                                                                                    if (data19.dateCreated !== undefined) {
+                                                                                                        let data35 = data19.dateCreated;
+                                                                                                        const _errs114 = errors;
                                                                                                         const _errs115 = errors;
-                                                                                                        const _errs116 = errors;
-                                                                                                        if (errors === _errs116) {
-                                                                                                            if (typeof data36 === "string") {
-                                                                                                                if (!pattern14.test(data36)) {
+                                                                                                        if (errors === _errs115) {
+                                                                                                            if (typeof data35 === "string") {
+                                                                                                                if (!pattern14.test(data35)) {
                                                                                                                     validate27.errors = [{ instancePath: instancePath + "/descriptor/dateCreated", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time/pattern", keyword: "pattern", params: { pattern: "^\\d{4}-[0-1]\\d-[0-3]\\dT(?:[0-2]\\d:[0-5]\\d:[0-5]\\d|23:59:60)\\.\\d{6}Z$" }, message: "must match pattern \"" + "^\\d{4}-[0-1]\\d-[0-3]\\dT(?:[0-2]\\d:[0-5]\\d:[0-5]\\d|23:59:60)\\.\\d{6}Z$" + "\"" }];
                                                                                                                     return false;
                                                                                                                 }
@@ -2700,19 +2697,19 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                 return false;
                                                                                                             }
                                                                                                         }
-                                                                                                        var valid25 = _errs115 === errors;
+                                                                                                        var valid26 = _errs114 === errors;
                                                                                                     }
                                                                                                     else {
-                                                                                                        var valid25 = true;
+                                                                                                        var valid26 = true;
                                                                                                     }
-                                                                                                    if (valid25) {
-                                                                                                        if (data20.messageTimestamp !== undefined) {
-                                                                                                            let data37 = data20.messageTimestamp;
+                                                                                                    if (valid26) {
+                                                                                                        if (data19.messageTimestamp !== undefined) {
+                                                                                                            let data36 = data19.messageTimestamp;
+                                                                                                            const _errs117 = errors;
                                                                                                             const _errs118 = errors;
-                                                                                                            const _errs119 = errors;
-                                                                                                            if (errors === _errs119) {
-                                                                                                                if (typeof data37 === "string") {
-                                                                                                                    if (!pattern14.test(data37)) {
+                                                                                                            if (errors === _errs118) {
+                                                                                                                if (typeof data36 === "string") {
+                                                                                                                    if (!pattern14.test(data36)) {
                                                                                                                         validate27.errors = [{ instancePath: instancePath + "/descriptor/messageTimestamp", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time/pattern", keyword: "pattern", params: { pattern: "^\\d{4}-[0-1]\\d-[0-3]\\dT(?:[0-2]\\d:[0-5]\\d:[0-5]\\d|23:59:60)\\.\\d{6}Z$" }, message: "must match pattern \"" + "^\\d{4}-[0-1]\\d-[0-3]\\dT(?:[0-2]\\d:[0-5]\\d:[0-5]\\d|23:59:60)\\.\\d{6}Z$" + "\"" }];
                                                                                                                         return false;
                                                                                                                     }
@@ -2722,31 +2719,31 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                     return false;
                                                                                                                 }
                                                                                                             }
-                                                                                                            var valid25 = _errs118 === errors;
+                                                                                                            var valid26 = _errs117 === errors;
                                                                                                         }
                                                                                                         else {
-                                                                                                            var valid25 = true;
+                                                                                                            var valid26 = true;
                                                                                                         }
-                                                                                                        if (valid25) {
-                                                                                                            if (data20.published !== undefined) {
-                                                                                                                const _errs121 = errors;
-                                                                                                                if (typeof data20.published !== "boolean") {
+                                                                                                        if (valid26) {
+                                                                                                            if (data19.published !== undefined) {
+                                                                                                                const _errs120 = errors;
+                                                                                                                if (typeof data19.published !== "boolean") {
                                                                                                                     validate27.errors = [{ instancePath: instancePath + "/descriptor/published", schemaPath: "#/properties/descriptor/properties/published/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
                                                                                                                     return false;
                                                                                                                 }
-                                                                                                                var valid25 = _errs121 === errors;
+                                                                                                                var valid26 = _errs120 === errors;
                                                                                                             }
                                                                                                             else {
-                                                                                                                var valid25 = true;
+                                                                                                                var valid26 = true;
                                                                                                             }
-                                                                                                            if (valid25) {
-                                                                                                                if (data20.datePublished !== undefined) {
-                                                                                                                    let data39 = data20.datePublished;
+                                                                                                            if (valid26) {
+                                                                                                                if (data19.datePublished !== undefined) {
+                                                                                                                    let data38 = data19.datePublished;
+                                                                                                                    const _errs122 = errors;
                                                                                                                     const _errs123 = errors;
-                                                                                                                    const _errs124 = errors;
-                                                                                                                    if (errors === _errs124) {
-                                                                                                                        if (typeof data39 === "string") {
-                                                                                                                            if (!pattern14.test(data39)) {
+                                                                                                                    if (errors === _errs123) {
+                                                                                                                        if (typeof data38 === "string") {
+                                                                                                                            if (!pattern14.test(data38)) {
                                                                                                                                 validate27.errors = [{ instancePath: instancePath + "/descriptor/datePublished", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time/pattern", keyword: "pattern", params: { pattern: "^\\d{4}-[0-1]\\d-[0-3]\\dT(?:[0-2]\\d:[0-5]\\d:[0-5]\\d|23:59:60)\\.\\d{6}Z$" }, message: "must match pattern \"" + "^\\d{4}-[0-1]\\d-[0-3]\\dT(?:[0-2]\\d:[0-5]\\d:[0-5]\\d|23:59:60)\\.\\d{6}Z$" + "\"" }];
                                                                                                                                 return false;
                                                                                                                             }
@@ -2756,34 +2753,34 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                             return false;
                                                                                                                         }
                                                                                                                     }
-                                                                                                                    var valid25 = _errs123 === errors;
+                                                                                                                    var valid26 = _errs122 === errors;
                                                                                                                 }
                                                                                                                 else {
-                                                                                                                    var valid25 = true;
+                                                                                                                    var valid26 = true;
                                                                                                                 }
-                                                                                                                if (valid25) {
-                                                                                                                    if (data20.dataFormat !== undefined) {
-                                                                                                                        const _errs126 = errors;
-                                                                                                                        if (typeof data20.dataFormat !== "string") {
+                                                                                                                if (valid26) {
+                                                                                                                    if (data19.dataFormat !== undefined) {
+                                                                                                                        const _errs125 = errors;
+                                                                                                                        if (typeof data19.dataFormat !== "string") {
                                                                                                                             validate27.errors = [{ instancePath: instancePath + "/descriptor/dataFormat", schemaPath: "#/properties/descriptor/properties/dataFormat/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                                                                                                                             return false;
                                                                                                                         }
-                                                                                                                        var valid25 = _errs126 === errors;
+                                                                                                                        var valid26 = _errs125 === errors;
                                                                                                                     }
                                                                                                                     else {
-                                                                                                                        var valid25 = true;
+                                                                                                                        var valid26 = true;
                                                                                                                     }
-                                                                                                                    if (valid25) {
-                                                                                                                        if (data20.permissionGrantId !== undefined) {
-                                                                                                                            const _errs128 = errors;
-                                                                                                                            if (typeof data20.permissionGrantId !== "string") {
+                                                                                                                    if (valid26) {
+                                                                                                                        if (data19.permissionGrantId !== undefined) {
+                                                                                                                            const _errs127 = errors;
+                                                                                                                            if (typeof data19.permissionGrantId !== "string") {
                                                                                                                                 validate27.errors = [{ instancePath: instancePath + "/descriptor/permissionGrantId", schemaPath: "#/properties/descriptor/properties/permissionGrantId/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                                                                                                                                 return false;
                                                                                                                             }
-                                                                                                                            var valid25 = _errs128 === errors;
+                                                                                                                            var valid26 = _errs127 === errors;
                                                                                                                         }
                                                                                                                         else {
-                                                                                                                            var valid25 = true;
+                                                                                                                            var valid26 = true;
                                                                                                                         }
                                                                                                                     }
                                                                                                                 }
@@ -2809,7 +2806,7 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                                                 return false;
                                             }
                                         }
-                                        var valid8 = _errs56 === errors;
+                                        var valid8 = _errs55 === errors;
                                     }
                                     else {
                                         var valid8 = true;
@@ -5381,7 +5378,7 @@ function validate45(data, { instancePath = "", parentData, parentDataProperty, r
 } validate45.errors = vErrors; return errors === 0; }
 validate45.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const RecordsSubscribe = validate48;
-const schema73 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/records-subscribe.json", "type": "object", "additionalProperties": false, "required": ["descriptor"], "properties": { "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization-delegated-grant.json" }, "descriptor": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "messageTimestamp", "filter"], "properties": { "interface": { "enum": ["Records"], "type": "string" }, "method": { "enum": ["Subscribe"], "type": "string" }, "messageTimestamp": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "filter": { "$ref": "https://identity.foundation/dwn/json-schemas/records-filter.json" } } } } };
+const schema73 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/records-subscribe.json", "type": "object", "additionalProperties": false, "required": ["descriptor"], "properties": { "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization-delegated-grant.json" }, "descriptor": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "messageTimestamp", "filter"], "properties": { "interface": { "enum": ["Records"], "type": "string" }, "method": { "enum": ["Subscribe"], "type": "string" }, "messageTimestamp": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "filter": { "$ref": "https://identity.foundation/dwn/json-schemas/records-filter.json" }, "pagination": { "type": "object", "additionalProperties": false, "properties": { "limit": { "type": "number", "minimum": 1 }, "cursor": { "$ref": "https://identity.foundation/dwn/json-schemas/pagination-cursor.json" } } }, "dateSort": { "enum": ["createdAscending", "createdDescending", "publishedAscending", "publishedDescending", "updatedAscending", "updatedDescending"], "type": "string" } } } } };
 function validate48(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/records-subscribe.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate48.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -5428,7 +5425,7 @@ function validate48(data, { instancePath = "", parentData, parentDataProperty, r
                                 else {
                                     const _errs5 = errors;
                                     for (const key1 in data1) {
-                                        if (!((((key1 === "interface") || (key1 === "method")) || (key1 === "messageTimestamp")) || (key1 === "filter"))) {
+                                        if (!((((((key1 === "interface") || (key1 === "method")) || (key1 === "messageTimestamp")) || (key1 === "filter")) || (key1 === "pagination")) || (key1 === "dateSort"))) {
                                             validate48.errors = [{ instancePath: instancePath + "/descriptor", schemaPath: "#/properties/descriptor/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
                                             return false;
                                             break;
@@ -5502,6 +5499,139 @@ function validate48(data, { instancePath = "", parentData, parentDataProperty, r
                                                     else {
                                                         var valid1 = true;
                                                     }
+                                                    if (valid1) {
+                                                        if (data1.pagination !== undefined) {
+                                                            let data6 = data1.pagination;
+                                                            const _errs14 = errors;
+                                                            if (errors === _errs14) {
+                                                                if (data6 && typeof data6 == "object" && !Array.isArray(data6)) {
+                                                                    const _errs16 = errors;
+                                                                    for (const key2 in data6) {
+                                                                        if (!((key2 === "limit") || (key2 === "cursor"))) {
+                                                                            validate48.errors = [{ instancePath: instancePath + "/descriptor/pagination", schemaPath: "#/properties/descriptor/properties/pagination/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" }];
+                                                                            return false;
+                                                                            break;
+                                                                        }
+                                                                    }
+                                                                    if (_errs16 === errors) {
+                                                                        if (data6.limit !== undefined) {
+                                                                            let data7 = data6.limit;
+                                                                            const _errs17 = errors;
+                                                                            if (errors === _errs17) {
+                                                                                if ((typeof data7 == "number") && (isFinite(data7))) {
+                                                                                    if (data7 < 1 || isNaN(data7)) {
+                                                                                        validate48.errors = [{ instancePath: instancePath + "/descriptor/pagination/limit", schemaPath: "#/properties/descriptor/properties/pagination/properties/limit/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                }
+                                                                                else {
+                                                                                    validate48.errors = [{ instancePath: instancePath + "/descriptor/pagination/limit", schemaPath: "#/properties/descriptor/properties/pagination/properties/limit/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                                    return false;
+                                                                                }
+                                                                            }
+                                                                            var valid3 = _errs17 === errors;
+                                                                        }
+                                                                        else {
+                                                                            var valid3 = true;
+                                                                        }
+                                                                        if (valid3) {
+                                                                            if (data6.cursor !== undefined) {
+                                                                                let data8 = data6.cursor;
+                                                                                const _errs19 = errors;
+                                                                                const _errs20 = errors;
+                                                                                if (errors === _errs20) {
+                                                                                    if (data8 && typeof data8 == "object" && !Array.isArray(data8)) {
+                                                                                        if (Object.keys(data8).length < 1) {
+                                                                                            validate48.errors = [{ instancePath: instancePath + "/descriptor/pagination/cursor", schemaPath: "https://identity.foundation/dwn/json-schemas/pagination-cursor.json/minProperties", keyword: "minProperties", params: { limit: 1 }, message: "must NOT have fewer than 1 properties" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                        else {
+                                                                                            let missing2;
+                                                                                            if (((data8.messageCid === undefined) && (missing2 = "messageCid")) || ((data8.value === undefined) && (missing2 = "value"))) {
+                                                                                                validate48.errors = [{ instancePath: instancePath + "/descriptor/pagination/cursor", schemaPath: "https://identity.foundation/dwn/json-schemas/pagination-cursor.json/required", keyword: "required", params: { missingProperty: missing2 }, message: "must have required property '" + missing2 + "'" }];
+                                                                                                return false;
+                                                                                            }
+                                                                                            else {
+                                                                                                const _errs22 = errors;
+                                                                                                for (const key3 in data8) {
+                                                                                                    if (!((key3 === "messageCid") || (key3 === "value"))) {
+                                                                                                        validate48.errors = [{ instancePath: instancePath + "/descriptor/pagination/cursor", schemaPath: "https://identity.foundation/dwn/json-schemas/pagination-cursor.json/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key3 }, message: "must NOT have additional properties" }];
+                                                                                                        return false;
+                                                                                                        break;
+                                                                                                    }
+                                                                                                }
+                                                                                                if (_errs22 === errors) {
+                                                                                                    if (data8.messageCid !== undefined) {
+                                                                                                        const _errs23 = errors;
+                                                                                                        if (typeof data8.messageCid !== "string") {
+                                                                                                            validate48.errors = [{ instancePath: instancePath + "/descriptor/pagination/cursor/messageCid", schemaPath: "https://identity.foundation/dwn/json-schemas/pagination-cursor.json/properties/messageCid/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                        var valid5 = _errs23 === errors;
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        var valid5 = true;
+                                                                                                    }
+                                                                                                    if (valid5) {
+                                                                                                        if (data8.value !== undefined) {
+                                                                                                            let data10 = data8.value;
+                                                                                                            const _errs25 = errors;
+                                                                                                            if ((typeof data10 !== "string") && (!((typeof data10 == "number") && (isFinite(data10))))) {
+                                                                                                                validate48.errors = [{ instancePath: instancePath + "/descriptor/pagination/cursor/value", schemaPath: "https://identity.foundation/dwn/json-schemas/pagination-cursor.json/properties/value/type", keyword: "type", params: { type: schema72.properties.value.type }, message: "must be string,number" }];
+                                                                                                                return false;
+                                                                                                            }
+                                                                                                            var valid5 = _errs25 === errors;
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            var valid5 = true;
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                    else {
+                                                                                        validate48.errors = [{ instancePath: instancePath + "/descriptor/pagination/cursor", schemaPath: "https://identity.foundation/dwn/json-schemas/pagination-cursor.json/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                }
+                                                                                var valid3 = _errs19 === errors;
+                                                                            }
+                                                                            else {
+                                                                                var valid3 = true;
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                                else {
+                                                                    validate48.errors = [{ instancePath: instancePath + "/descriptor/pagination", schemaPath: "#/properties/descriptor/properties/pagination/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                    return false;
+                                                                }
+                                                            }
+                                                            var valid1 = _errs14 === errors;
+                                                        }
+                                                        else {
+                                                            var valid1 = true;
+                                                        }
+                                                        if (valid1) {
+                                                            if (data1.dateSort !== undefined) {
+                                                                let data11 = data1.dateSort;
+                                                                const _errs27 = errors;
+                                                                if (typeof data11 !== "string") {
+                                                                    validate48.errors = [{ instancePath: instancePath + "/descriptor/dateSort", schemaPath: "#/properties/descriptor/properties/dateSort/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                    return false;
+                                                                }
+                                                                if (!((((((data11 === "createdAscending") || (data11 === "createdDescending")) || (data11 === "publishedAscending")) || (data11 === "publishedDescending")) || (data11 === "updatedAscending")) || (data11 === "updatedDescending"))) {
+                                                                    validate48.errors = [{ instancePath: instancePath + "/descriptor/dateSort", schemaPath: "#/properties/descriptor/properties/dateSort/enum", keyword: "enum", params: { allowedValues: schema73.properties.descriptor.properties.dateSort.enum }, message: "must be equal to one of the allowed values" }];
+                                                                    return false;
+                                                                }
+                                                                var valid1 = _errs27 === errors;
+                                                            }
+                                                            else {
+                                                                var valid1 = true;
+                                                            }
+                                                        }
+                                                    }
                                                 }
                                             }
                                         }
@@ -5529,7 +5659,7 @@ function validate48(data, { instancePath = "", parentData, parentDataProperty, r
 } validate48.errors = vErrors; return errors === 0; }
 validate48.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const RecordsWrite = validate51;
-const schema75 = { "$id": "https://identity.foundation/dwn/json-schemas/records-write.json", "$ref": "https://identity.foundation/dwn/json-schemas/records-write-unidentified.json", "unevaluatedProperties": false, "type": "object", "required": ["recordId", "authorization"] };
+const schema76 = { "$id": "https://identity.foundation/dwn/json-schemas/records-write.json", "$ref": "https://identity.foundation/dwn/json-schemas/records-write-unidentified.json", "unevaluatedProperties": false, "type": "object", "required": ["recordId", "authorization"] };
 function validate51(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/records-write.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate51.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -6282,7 +6412,7 @@ else {
 validate53.evaluated = { "dynamicProps": true, "dynamicItems": false };
 export const GeneralJws = validate21;
 export const JwkVerificationMethod = validate54;
-const schema77 = { "$id": "https://identity.foundation/dwn/json-schemas/jwk-verification-method.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object", "additionalProperties": false, "required": ["id", "type", "controller", "publicKeyJwk"], "properties": { "id": { "type": "string" }, "type": { "enum": ["JsonWebKey", "JsonWebKey2020"] }, "controller": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/did" }, "publicKeyJwk": { "$ref": "https://identity.foundation/dwn/json-schemas/public-jwk.json" } } };
+const schema78 = { "$id": "https://identity.foundation/dwn/json-schemas/jwk-verification-method.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object", "additionalProperties": false, "required": ["id", "type", "controller", "publicKeyJwk"], "properties": { "id": { "type": "string" }, "type": { "enum": ["JsonWebKey", "JsonWebKey2020"] }, "controller": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/did" }, "publicKeyJwk": { "$ref": "https://identity.foundation/dwn/json-schemas/public-jwk.json" } } };
 function validate54(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/jwk-verification-method.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate54.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -6320,7 +6450,7 @@ function validate54(data, { instancePath = "", parentData, parentDataProperty, r
                         let data1 = data.type;
                         const _errs4 = errors;
                         if (!((data1 === "JsonWebKey") || (data1 === "JsonWebKey2020"))) {
-                            validate54.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/enum", keyword: "enum", params: { allowedValues: schema77.properties.type.enum }, message: "must be equal to one of the allowed values" }];
+                            validate54.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/enum", keyword: "enum", params: { allowedValues: schema78.properties.type.enum }, message: "must be equal to one of the allowed values" }];
                             return false;
                         }
                         var valid0 = _errs4 === errors;
@@ -6375,7 +6505,7 @@ function validate54(data, { instancePath = "", parentData, parentDataProperty, r
 } validate54.errors = vErrors; return errors === 0; }
 validate54.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const MessagesFilter = validate56;
-const schema79 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/messages-filter.json", "type": "object", "additionalProperties": false, "minProperties": 1, "properties": { "interface": { "enum": ["Protocols", "Records"], "type": "string" }, "method": { "enum": ["Configure", "Delete", "Write"], "type": "string" }, "protocol": { "type": "string" }, "messageTimestamp": { "type": "object", "minProperties": 1, "additionalProperties": false, "properties": { "from": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "to": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" } } } } };
+const schema80 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/messages-filter.json", "type": "object", "additionalProperties": false, "minProperties": 1, "properties": { "interface": { "enum": ["Messages", "Protocols", "Records"], "type": "string" }, "method": { "enum": ["Configure", "Delete", "Write"], "type": "string" }, "protocol": { "type": "string" }, "messageTimestamp": { "type": "object", "minProperties": 1, "additionalProperties": false, "properties": { "from": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "to": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" } } } } };
 function validate56(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/messages-filter.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate56.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -6403,8 +6533,8 @@ function validate56(data, { instancePath = "", parentData, parentDataProperty, r
                         validate56.errors = [{ instancePath: instancePath + "/interface", schemaPath: "#/properties/interface/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                         return false;
                     }
-                    if (!((data0 === "Protocols") || (data0 === "Records"))) {
-                        validate56.errors = [{ instancePath: instancePath + "/interface", schemaPath: "#/properties/interface/enum", keyword: "enum", params: { allowedValues: schema79.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
+                    if (!(((data0 === "Messages") || (data0 === "Protocols")) || (data0 === "Records"))) {
+                        validate56.errors = [{ instancePath: instancePath + "/interface", schemaPath: "#/properties/interface/enum", keyword: "enum", params: { allowedValues: schema80.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
                         return false;
                     }
                     var valid0 = _errs2 === errors;
@@ -6421,7 +6551,7 @@ function validate56(data, { instancePath = "", parentData, parentDataProperty, r
                             return false;
                         }
                         if (!(((data1 === "Configure") || (data1 === "Delete")) || (data1 === "Write"))) {
-                            validate56.errors = [{ instancePath: instancePath + "/method", schemaPath: "#/properties/method/enum", keyword: "enum", params: { allowedValues: schema79.properties.method.enum }, message: "must be equal to one of the allowed values" }];
+                            validate56.errors = [{ instancePath: instancePath + "/method", schemaPath: "#/properties/method/enum", keyword: "enum", params: { allowedValues: schema80.properties.method.enum }, message: "must be equal to one of the allowed values" }];
                             return false;
                         }
                         var valid0 = _errs4 === errors;
@@ -6531,7 +6661,7 @@ function validate56(data, { instancePath = "", parentData, parentDataProperty, r
 } validate56.errors = vErrors; return errors === 0; }
 validate56.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const MessagesRead = validate57;
-const schema82 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/messages-read.json", "type": "object", "additionalProperties": false, "required": ["authorization", "descriptor"], "properties": { "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization.json" }, "descriptor": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "messageTimestamp"], "properties": { "interface": { "enum": ["Messages"], "type": "string" }, "method": { "enum": ["Read"], "type": "string" }, "messageTimestamp": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "messageCid": { "type": "string" }, "permissionGrantId": { "type": "string" } } } } };
+const schema83 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/messages-read.json", "type": "object", "additionalProperties": false, "required": ["authorization", "descriptor"], "properties": { "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization.json" }, "descriptor": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "messageTimestamp", "messageCid"], "properties": { "interface": { "enum": ["Messages"], "type": "string" }, "method": { "enum": ["Read"], "type": "string" }, "messageTimestamp": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "messageCid": { "type": "string" }, "permissionGrantId": { "type": "string" } } } } };
 function validate57(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/messages-read.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate57.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -6571,7 +6701,7 @@ function validate57(data, { instancePath = "", parentData, parentDataProperty, r
                         if (errors === _errs3) {
                             if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
                                 let missing1;
-                                if ((((data1.interface === undefined) && (missing1 = "interface")) || ((data1.method === undefined) && (missing1 = "method"))) || ((data1.messageTimestamp === undefined) && (missing1 = "messageTimestamp"))) {
+                                if (((((data1.interface === undefined) && (missing1 = "interface")) || ((data1.method === undefined) && (missing1 = "method"))) || ((data1.messageTimestamp === undefined) && (missing1 = "messageTimestamp"))) || ((data1.messageCid === undefined) && (missing1 = "messageCid"))) {
                                     validate57.errors = [{ instancePath: instancePath + "/descriptor", schemaPath: "#/properties/descriptor/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
                                     return false;
                                 }
@@ -6593,7 +6723,7 @@ function validate57(data, { instancePath = "", parentData, parentDataProperty, r
                                                 return false;
                                             }
                                             if (!(data2 === "Messages")) {
-                                                validate57.errors = [{ instancePath: instancePath + "/descriptor/interface", schemaPath: "#/properties/descriptor/properties/interface/enum", keyword: "enum", params: { allowedValues: schema82.properties.descriptor.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
+                                                validate57.errors = [{ instancePath: instancePath + "/descriptor/interface", schemaPath: "#/properties/descriptor/properties/interface/enum", keyword: "enum", params: { allowedValues: schema83.properties.descriptor.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
                                                 return false;
                                             }
                                             var valid1 = _errs6 === errors;
@@ -6610,7 +6740,7 @@ function validate57(data, { instancePath = "", parentData, parentDataProperty, r
                                                     return false;
                                                 }
                                                 if (!(data3 === "Read")) {
-                                                    validate57.errors = [{ instancePath: instancePath + "/descriptor/method", schemaPath: "#/properties/descriptor/properties/method/enum", keyword: "enum", params: { allowedValues: schema82.properties.descriptor.properties.method.enum }, message: "must be equal to one of the allowed values" }];
+                                                    validate57.errors = [{ instancePath: instancePath + "/descriptor/method", schemaPath: "#/properties/descriptor/properties/method/enum", keyword: "enum", params: { allowedValues: schema83.properties.descriptor.properties.method.enum }, message: "must be equal to one of the allowed values" }];
                                                     return false;
                                                 }
                                                 var valid1 = _errs8 === errors;
@@ -6692,7 +6822,7 @@ function validate57(data, { instancePath = "", parentData, parentDataProperty, r
 } validate57.errors = vErrors; return errors === 0; }
 validate57.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const MessagesSubscribe = validate59;
-const schema84 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/messages-subscribe.json", "type": "object", "additionalProperties": false, "required": ["descriptor", "authorization"], "properties": { "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization.json" }, "descriptor": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "messageTimestamp", "filters"], "properties": { "interface": { "enum": ["Messages"], "type": "string" }, "method": { "enum": ["Subscribe"], "type": "string" }, "messageTimestamp": { "type": "string" }, "filters": { "type": "array", "items": { "$ref": "https://identity.foundation/dwn/json-schemas/messages-filter.json" } }, "permissionGrantId": { "type": "string" } } } } };
+const schema85 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/messages-subscribe.json", "type": "object", "additionalProperties": false, "required": ["descriptor", "authorization"], "properties": { "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization.json" }, "descriptor": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "messageTimestamp", "filters"], "properties": { "interface": { "enum": ["Messages"], "type": "string" }, "method": { "enum": ["Subscribe"], "type": "string" }, "messageTimestamp": { "type": "string" }, "filters": { "type": "array", "items": { "$ref": "https://identity.foundation/dwn/json-schemas/messages-filter.json" } }, "permissionGrantId": { "type": "string" } } } } };
 function validate59(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/messages-subscribe.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate59.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -6754,7 +6884,7 @@ function validate59(data, { instancePath = "", parentData, parentDataProperty, r
                                                 return false;
                                             }
                                             if (!(data2 === "Messages")) {
-                                                validate59.errors = [{ instancePath: instancePath + "/descriptor/interface", schemaPath: "#/properties/descriptor/properties/interface/enum", keyword: "enum", params: { allowedValues: schema84.properties.descriptor.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
+                                                validate59.errors = [{ instancePath: instancePath + "/descriptor/interface", schemaPath: "#/properties/descriptor/properties/interface/enum", keyword: "enum", params: { allowedValues: schema85.properties.descriptor.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
                                                 return false;
                                             }
                                             var valid1 = _errs6 === errors;
@@ -6771,7 +6901,7 @@ function validate59(data, { instancePath = "", parentData, parentDataProperty, r
                                                     return false;
                                                 }
                                                 if (!(data3 === "Subscribe")) {
-                                                    validate59.errors = [{ instancePath: instancePath + "/descriptor/method", schemaPath: "#/properties/descriptor/properties/method/enum", keyword: "enum", params: { allowedValues: schema84.properties.descriptor.properties.method.enum }, message: "must be equal to one of the allowed values" }];
+                                                    validate59.errors = [{ instancePath: instancePath + "/descriptor/method", schemaPath: "#/properties/descriptor/properties/method/enum", keyword: "enum", params: { allowedValues: schema85.properties.descriptor.properties.method.enum }, message: "must be equal to one of the allowed values" }];
                                                     return false;
                                                 }
                                                 var valid1 = _errs8 === errors;
@@ -6861,7 +6991,7 @@ function validate59(data, { instancePath = "", parentData, parentDataProperty, r
 } validate59.errors = vErrors; return errors === 0; }
 validate59.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const MessagesSync = validate62;
-const schema85 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/messages-sync.json", "type": "object", "additionalProperties": false, "required": ["authorization", "descriptor"], "properties": { "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization.json" }, "descriptor": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "messageTimestamp", "action"], "properties": { "interface": { "enum": ["Messages"], "type": "string" }, "method": { "enum": ["Sync"], "type": "string" }, "messageTimestamp": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "action": { "enum": ["root", "subtree", "leaves"], "type": "string" }, "protocol": { "type": "string" }, "prefix": { "type": "string", "pattern": "^[01]*$" }, "permissionGrantId": { "type": "string" } }, "allOf": [{ "if": { "properties": { "action": { "const": "subtree" } } }, "then": { "required": ["prefix"] } }, { "if": { "properties": { "action": { "const": "leaves" } } }, "then": { "required": ["prefix"] } }] } } };
+const schema86 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/messages-sync.json", "type": "object", "additionalProperties": false, "required": ["authorization", "descriptor"], "properties": { "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization.json" }, "descriptor": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "messageTimestamp", "action"], "properties": { "interface": { "enum": ["Messages"], "type": "string" }, "method": { "enum": ["Sync"], "type": "string" }, "messageTimestamp": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "action": { "enum": ["root", "subtree", "leaves"], "type": "string" }, "protocol": { "type": "string" }, "prefix": { "type": "string", "pattern": "^[01]*$" }, "permissionGrantId": { "type": "string" } }, "allOf": [{ "if": { "properties": { "action": { "const": "subtree" } } }, "then": { "required": ["prefix"] } }, { "if": { "properties": { "action": { "const": "leaves" } } }, "then": { "required": ["prefix"] } }] } } };
 const pattern37 = new RegExp("^[01]*$", "u");
 function validate62(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/messages-sync.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate62.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
@@ -7032,7 +7162,7 @@ function validate62(data, { instancePath = "", parentData, parentDataProperty, r
                                                 return false;
                                             }
                                             if (!(data4 === "Messages")) {
-                                                validate62.errors = [{ instancePath: instancePath + "/descriptor/interface", schemaPath: "#/properties/descriptor/properties/interface/enum", keyword: "enum", params: { allowedValues: schema85.properties.descriptor.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
+                                                validate62.errors = [{ instancePath: instancePath + "/descriptor/interface", schemaPath: "#/properties/descriptor/properties/interface/enum", keyword: "enum", params: { allowedValues: schema86.properties.descriptor.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
                                                 return false;
                                             }
                                             var valid6 = _errs16 === errors;
@@ -7049,7 +7179,7 @@ function validate62(data, { instancePath = "", parentData, parentDataProperty, r
                                                     return false;
                                                 }
                                                 if (!(data5 === "Sync")) {
-                                                    validate62.errors = [{ instancePath: instancePath + "/descriptor/method", schemaPath: "#/properties/descriptor/properties/method/enum", keyword: "enum", params: { allowedValues: schema85.properties.descriptor.properties.method.enum }, message: "must be equal to one of the allowed values" }];
+                                                    validate62.errors = [{ instancePath: instancePath + "/descriptor/method", schemaPath: "#/properties/descriptor/properties/method/enum", keyword: "enum", params: { allowedValues: schema86.properties.descriptor.properties.method.enum }, message: "must be equal to one of the allowed values" }];
                                                     return false;
                                                 }
                                                 var valid6 = _errs18 === errors;
@@ -7088,7 +7218,7 @@ function validate62(data, { instancePath = "", parentData, parentDataProperty, r
                                                             return false;
                                                         }
                                                         if (!(((data7 === "root") || (data7 === "subtree")) || (data7 === "leaves"))) {
-                                                            validate62.errors = [{ instancePath: instancePath + "/descriptor/action", schemaPath: "#/properties/descriptor/properties/action/enum", keyword: "enum", params: { allowedValues: schema85.properties.descriptor.properties.action.enum }, message: "must be equal to one of the allowed values" }];
+                                                            validate62.errors = [{ instancePath: instancePath + "/descriptor/action", schemaPath: "#/properties/descriptor/properties/action/enum", keyword: "enum", params: { allowedValues: schema86.properties.descriptor.properties.action.enum }, message: "must be equal to one of the allowed values" }];
                                                             return false;
                                                         }
                                                         var valid6 = _errs23 === errors;
@@ -7477,20 +7607,20 @@ function validate65(data, { instancePath = "", parentData, parentDataProperty, r
 } validate65.errors = vErrors; return errors === 0; }
 validate65.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const PermissionGrantData = validate66;
-const schema89 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/permission-grant-data.json", "type": "object", "additionalProperties": false, "required": ["dateExpires", "scope"], "properties": { "description": { "type": "string" }, "dateExpires": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "requestId": { "type": "string" }, "delegated": { "type": "boolean" }, "scope": { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/scope" }, "conditions": { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions" } } };
-const schema105 = { "type": "object", "additionalProperties": false, "properties": { "publication": { "enum": ["Required", "Prohibited"], "type": "string" } } };
-const schema92 = { "oneOf": [{ "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-subscribe-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-sync-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-configure-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-query-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope" }] };
-const schema94 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Messages" }, "method": { "const": "Read" }, "protocol": { "type": "string" } } };
-const schema95 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Messages" }, "method": { "const": "Subscribe" }, "protocol": { "type": "string" } } };
-const schema96 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Messages" }, "method": { "const": "Sync" }, "protocol": { "type": "string" } } };
-const schema97 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Protocols" }, "method": { "const": "Configure" }, "protocol": { "type": "string" } } };
-const schema98 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Protocols" }, "method": { "const": "Query" }, "protocol": { "type": "string" } } };
-const schema99 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Read" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } };
-const schema100 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Delete" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } };
-const schema101 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Write" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } };
-const schema102 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Query" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } };
-const schema103 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Subscribe" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } };
-const schema104 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Count" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } };
+const schema90 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/permission-grant-data.json", "type": "object", "additionalProperties": false, "required": ["dateExpires", "scope"], "properties": { "description": { "type": "string" }, "dateExpires": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "requestId": { "type": "string" }, "delegated": { "type": "boolean" }, "scope": { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/scope" }, "conditions": { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions" } } };
+const schema106 = { "type": "object", "additionalProperties": false, "properties": { "publication": { "enum": ["Required", "Prohibited"], "type": "string" } } };
+const schema93 = { "oneOf": [{ "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-subscribe-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-sync-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-configure-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-query-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope" }] };
+const schema95 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Messages" }, "method": { "const": "Read" }, "protocol": { "type": "string" } } };
+const schema96 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Messages" }, "method": { "const": "Subscribe" }, "protocol": { "type": "string" } } };
+const schema97 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Messages" }, "method": { "const": "Sync" }, "protocol": { "type": "string" } } };
+const schema98 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Protocols" }, "method": { "const": "Configure" }, "protocol": { "type": "string" } } };
+const schema99 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Protocols" }, "method": { "const": "Query" }, "protocol": { "type": "string" } } };
+const schema100 = { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Read" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } };
+const schema101 = { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Delete" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } };
+const schema102 = { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Write" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } };
+const schema103 = { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Query" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } };
+const schema104 = { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Subscribe" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } };
+const schema105 = { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Count" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } };
 function validate68(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate68.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -8049,7 +8179,7 @@ else {
                 if (errors === _errs42) {
                     if (data && typeof data == "object" && !Array.isArray(data)) {
                         let missing5;
-                        if (((data.interface === undefined) && (missing5 = "interface")) || ((data.method === undefined) && (missing5 = "method"))) {
+                        if ((((data.interface === undefined) && (missing5 = "interface")) || ((data.method === undefined) && (missing5 = "method"))) || ((data.protocol === undefined) && (missing5 = "protocol"))) {
                             const err30 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/required", keyword: "required", params: { missingProperty: missing5 }, message: "must have required property '" + missing5 + "'" };
                             if (vErrors === null) {
                                 vErrors = [err30];
@@ -8215,7 +8345,7 @@ else {
                     if (errors === _errs54) {
                         if (data && typeof data == "object" && !Array.isArray(data)) {
                             let missing6;
-                            if (((data.interface === undefined) && (missing6 = "interface")) || ((data.method === undefined) && (missing6 = "method"))) {
+                            if ((((data.interface === undefined) && (missing6 = "interface")) || ((data.method === undefined) && (missing6 = "method"))) || ((data.protocol === undefined) && (missing6 = "protocol"))) {
                                 const err39 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/required", keyword: "required", params: { missingProperty: missing6 }, message: "must have required property '" + missing6 + "'" };
                                 if (vErrors === null) {
                                     vErrors = [err39];
@@ -8381,7 +8511,7 @@ else {
                         if (errors === _errs66) {
                             if (data && typeof data == "object" && !Array.isArray(data)) {
                                 let missing7;
-                                if (((data.interface === undefined) && (missing7 = "interface")) || ((data.method === undefined) && (missing7 = "method"))) {
+                                if ((((data.interface === undefined) && (missing7 = "interface")) || ((data.method === undefined) && (missing7 = "method"))) || ((data.protocol === undefined) && (missing7 = "protocol"))) {
                                     const err48 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/required", keyword: "required", params: { missingProperty: missing7 }, message: "must have required property '" + missing7 + "'" };
                                     if (vErrors === null) {
                                         vErrors = [err48];
@@ -8547,7 +8677,7 @@ else {
                             if (errors === _errs78) {
                                 if (data && typeof data == "object" && !Array.isArray(data)) {
                                     let missing8;
-                                    if (((data.interface === undefined) && (missing8 = "interface")) || ((data.method === undefined) && (missing8 = "method"))) {
+                                    if ((((data.interface === undefined) && (missing8 = "interface")) || ((data.method === undefined) && (missing8 = "method"))) || ((data.protocol === undefined) && (missing8 = "protocol"))) {
                                         const err57 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/required", keyword: "required", params: { missingProperty: missing8 }, message: "must have required property '" + missing8 + "'" };
                                         if (vErrors === null) {
                                             vErrors = [err57];
@@ -8713,7 +8843,7 @@ else {
                                 if (errors === _errs90) {
                                     if (data && typeof data == "object" && !Array.isArray(data)) {
                                         let missing9;
-                                        if (((data.interface === undefined) && (missing9 = "interface")) || ((data.method === undefined) && (missing9 = "method"))) {
+                                        if ((((data.interface === undefined) && (missing9 = "interface")) || ((data.method === undefined) && (missing9 = "method"))) || ((data.protocol === undefined) && (missing9 = "protocol"))) {
                                             const err66 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/required", keyword: "required", params: { missingProperty: missing9 }, message: "must have required property '" + missing9 + "'" };
                                             if (vErrors === null) {
                                                 vErrors = [err66];
@@ -8879,7 +9009,7 @@ else {
                                     if (errors === _errs102) {
                                         if (data && typeof data == "object" && !Array.isArray(data)) {
                                             let missing10;
-                                            if (((data.interface === undefined) && (missing10 = "interface")) || ((data.method === undefined) && (missing10 = "method"))) {
+                                            if ((((data.interface === undefined) && (missing10 = "interface")) || ((data.method === undefined) && (missing10 = "method"))) || ((data.protocol === undefined) && (missing10 = "protocol"))) {
                                                 const err75 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/required", keyword: "required", params: { missingProperty: missing10 }, message: "must have required property '" + missing10 + "'" };
                                                 if (vErrors === null) {
                                                     vErrors = [err75];
@@ -9186,7 +9316,7 @@ function validate66(data, { instancePath = "", parentData, parentDataProperty, r
                                                             return false;
                                                         }
                                                         if (!((data6 === "Required") || (data6 === "Prohibited"))) {
-                                                            validate66.errors = [{ instancePath: instancePath + "/conditions/publication", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions/properties/publication/enum", keyword: "enum", params: { allowedValues: schema105.properties.publication.enum }, message: "must be equal to one of the allowed values" }];
+                                                            validate66.errors = [{ instancePath: instancePath + "/conditions/publication", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions/properties/publication/enum", keyword: "enum", params: { allowedValues: schema106.properties.publication.enum }, message: "must be equal to one of the allowed values" }];
                                                             return false;
                                                         }
                                                     }
@@ -9217,7 +9347,7 @@ function validate66(data, { instancePath = "", parentData, parentDataProperty, r
 } validate66.errors = vErrors; return errors === 0; }
 validate66.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const PermissionRequestData = validate71;
-const schema106 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/permission-request-data.json", "type": "object", "additionalProperties": false, "required": ["delegated", "scope"], "properties": { "description": { "type": "string" }, "delegated": { "type": "boolean" }, "scope": { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/scope" }, "conditions": { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions" } } };
+const schema107 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/permission-request-data.json", "type": "object", "additionalProperties": false, "required": ["delegated", "scope"], "properties": { "description": { "type": "string" }, "delegated": { "type": "boolean" }, "scope": { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/scope" }, "conditions": { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions" } } };
 function validate72(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate72.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -9776,7 +9906,7 @@ else {
                 if (errors === _errs42) {
                     if (data && typeof data == "object" && !Array.isArray(data)) {
                         let missing5;
-                        if (((data.interface === undefined) && (missing5 = "interface")) || ((data.method === undefined) && (missing5 = "method"))) {
+                        if ((((data.interface === undefined) && (missing5 = "interface")) || ((data.method === undefined) && (missing5 = "method"))) || ((data.protocol === undefined) && (missing5 = "protocol"))) {
                             const err30 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/required", keyword: "required", params: { missingProperty: missing5 }, message: "must have required property '" + missing5 + "'" };
                             if (vErrors === null) {
                                 vErrors = [err30];
@@ -9942,7 +10072,7 @@ else {
                     if (errors === _errs54) {
                         if (data && typeof data == "object" && !Array.isArray(data)) {
                             let missing6;
-                            if (((data.interface === undefined) && (missing6 = "interface")) || ((data.method === undefined) && (missing6 = "method"))) {
+                            if ((((data.interface === undefined) && (missing6 = "interface")) || ((data.method === undefined) && (missing6 = "method"))) || ((data.protocol === undefined) && (missing6 = "protocol"))) {
                                 const err39 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/required", keyword: "required", params: { missingProperty: missing6 }, message: "must have required property '" + missing6 + "'" };
                                 if (vErrors === null) {
                                     vErrors = [err39];
@@ -10108,7 +10238,7 @@ else {
                         if (errors === _errs66) {
                             if (data && typeof data == "object" && !Array.isArray(data)) {
                                 let missing7;
-                                if (((data.interface === undefined) && (missing7 = "interface")) || ((data.method === undefined) && (missing7 = "method"))) {
+                                if ((((data.interface === undefined) && (missing7 = "interface")) || ((data.method === undefined) && (missing7 = "method"))) || ((data.protocol === undefined) && (missing7 = "protocol"))) {
                                     const err48 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/required", keyword: "required", params: { missingProperty: missing7 }, message: "must have required property '" + missing7 + "'" };
                                     if (vErrors === null) {
                                         vErrors = [err48];
@@ -10274,7 +10404,7 @@ else {
                             if (errors === _errs78) {
                                 if (data && typeof data == "object" && !Array.isArray(data)) {
                                     let missing8;
-                                    if (((data.interface === undefined) && (missing8 = "interface")) || ((data.method === undefined) && (missing8 = "method"))) {
+                                    if ((((data.interface === undefined) && (missing8 = "interface")) || ((data.method === undefined) && (missing8 = "method"))) || ((data.protocol === undefined) && (missing8 = "protocol"))) {
                                         const err57 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/required", keyword: "required", params: { missingProperty: missing8 }, message: "must have required property '" + missing8 + "'" };
                                         if (vErrors === null) {
                                             vErrors = [err57];
@@ -10440,7 +10570,7 @@ else {
                                 if (errors === _errs90) {
                                     if (data && typeof data == "object" && !Array.isArray(data)) {
                                         let missing9;
-                                        if (((data.interface === undefined) && (missing9 = "interface")) || ((data.method === undefined) && (missing9 = "method"))) {
+                                        if ((((data.interface === undefined) && (missing9 = "interface")) || ((data.method === undefined) && (missing9 = "method"))) || ((data.protocol === undefined) && (missing9 = "protocol"))) {
                                             const err66 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/required", keyword: "required", params: { missingProperty: missing9 }, message: "must have required property '" + missing9 + "'" };
                                             if (vErrors === null) {
                                                 vErrors = [err66];
@@ -10606,7 +10736,7 @@ else {
                                     if (errors === _errs102) {
                                         if (data && typeof data == "object" && !Array.isArray(data)) {
                                             let missing10;
-                                            if (((data.interface === undefined) && (missing10 = "interface")) || ((data.method === undefined) && (missing10 = "method"))) {
+                                            if ((((data.interface === undefined) && (missing10 = "interface")) || ((data.method === undefined) && (missing10 = "method"))) || ((data.protocol === undefined) && (missing10 = "protocol"))) {
                                                 const err75 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/required", keyword: "required", params: { missingProperty: missing10 }, message: "must have required property '" + missing10 + "'" };
                                                 if (vErrors === null) {
                                                     vErrors = [err75];
@@ -10879,7 +11009,7 @@ function validate71(data, { instancePath = "", parentData, parentDataProperty, r
                                                     return false;
                                                 }
                                                 if (!((data4 === "Required") || (data4 === "Prohibited"))) {
-                                                    validate71.errors = [{ instancePath: instancePath + "/conditions/publication", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions/properties/publication/enum", keyword: "enum", params: { allowedValues: schema105.properties.publication.enum }, message: "must be equal to one of the allowed values" }];
+                                                    validate71.errors = [{ instancePath: instancePath + "/conditions/publication", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions/properties/publication/enum", keyword: "enum", params: { allowedValues: schema106.properties.publication.enum }, message: "must be equal to one of the allowed values" }];
                                                     return false;
                                                 }
                                             }
@@ -10908,7 +11038,7 @@ function validate71(data, { instancePath = "", parentData, parentDataProperty, r
 } validate71.errors = vErrors; return errors === 0; }
 validate71.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const PermissionRevocationData = validate74;
-const schema120 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/permission-revoke-data.json", "type": "object", "additionalProperties": false, "properties": { "description": { "type": "string" } } };
+const schema121 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/permission-revoke-data.json", "type": "object", "additionalProperties": false, "properties": { "description": { "type": "string" } } };
 function validate74(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/permission-revoke-data.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate74.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -10939,7 +11069,7 @@ function validate74(data, { instancePath = "", parentData, parentDataProperty, r
 } validate74.errors = vErrors; return errors === 0; }
 validate74.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const PermissionsDefinitions = validate67;
-const schema91 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/permissions/defs.json", "type": "object", "$defs": { "scope": { "oneOf": [{ "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-subscribe-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-sync-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-configure-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-query-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope" }] }, "conditions": { "type": "object", "additionalProperties": false, "properties": { "publication": { "enum": ["Required", "Prohibited"], "type": "string" } } } } };
+const schema92 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/permissions/defs.json", "type": "object", "$defs": { "scope": { "oneOf": [{ "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-subscribe-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-sync-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-configure-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-query-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope" }] }, "conditions": { "type": "object", "additionalProperties": false, "properties": { "publication": { "enum": ["Required", "Prohibited"], "type": "string" } } } } };
 function validate67(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/permissions/defs.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate67.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -10950,7 +11080,7 @@ function validate67(data, { instancePath = "", parentData, parentDataProperty, r
 } validate67.errors = vErrors; return errors === 0; }
 validate67.evaluated = { "dynamicProps": false, "dynamicItems": false };
 export const PermissionsScopes = validate69;
-const schema93 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json", "type": "object", "$defs": { "messages-read-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Messages" }, "method": { "const": "Read" }, "protocol": { "type": "string" } } }, "messages-subscribe-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Messages" }, "method": { "const": "Subscribe" }, "protocol": { "type": "string" } } }, "messages-sync-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Messages" }, "method": { "const": "Sync" }, "protocol": { "type": "string" } } }, "protocols-configure-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Protocols" }, "method": { "const": "Configure" }, "protocol": { "type": "string" } } }, "protocols-query-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Protocols" }, "method": { "const": "Query" }, "protocol": { "type": "string" } } }, "records-delete-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Delete" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } }, "records-read-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Read" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } }, "records-write-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Write" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } }, "records-query-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Query" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } }, "records-subscribe-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Subscribe" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } }, "records-count-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Count" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } } } };
+const schema94 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json", "type": "object", "$defs": { "messages-read-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Messages" }, "method": { "const": "Read" }, "protocol": { "type": "string" } } }, "messages-subscribe-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Messages" }, "method": { "const": "Subscribe" }, "protocol": { "type": "string" } } }, "messages-sync-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Messages" }, "method": { "const": "Sync" }, "protocol": { "type": "string" } } }, "protocols-configure-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Protocols" }, "method": { "const": "Configure" }, "protocol": { "type": "string" } } }, "protocols-query-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Protocols" }, "method": { "const": "Query" }, "protocol": { "type": "string" } } }, "records-delete-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Delete" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } }, "records-read-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Read" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } }, "records-write-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Write" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } }, "records-query-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Query" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } }, "records-subscribe-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Subscribe" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } }, "records-count-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Count" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string" } } } } };
 function validate69(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/permissions/scopes.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate69.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -10961,10 +11091,10 @@ function validate69(data, { instancePath = "", parentData, parentDataProperty, r
 } validate69.errors = vErrors; return errors === 0; }
 validate69.evaluated = { "dynamicProps": false, "dynamicItems": false };
 export const ProtocolDefinition = validate75;
-const schema121 = { "$id": "https://identity.foundation/dwn/json-schemas/protocol-definition.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object", "additionalProperties": false, "required": ["protocol", "published", "types", "structure"], "properties": { "protocol": { "type": "string" }, "published": { "type": "boolean" }, "uses": { "$comment": "Maps alias names to external protocol URIs for composition. Each alias can be used in $ref values and cross-protocol role/of references using 'alias:path' syntax.", "type": "object", "minProperties": 1, "patternProperties": { "^[a-zA-Z][a-zA-Z0-9_-]*$": { "type": "string" } }, "additionalProperties": false }, "types": { "type": "object", "patternProperties": { ".*": { "type": "object", "additionalProperties": false, "properties": { "schema": { "type": "string" }, "dataFormats": { "type": "array", "minItems": 1, "items": { "type": "string" } }, "encryptionRequired": { "type": "boolean" } } } } }, "structure": { "type": "object", "patternProperties": { ".*": { "$ref": "https://identity.foundation/dwn/json-schemas/protocol-rule-set.json" } } } } };
+const schema122 = { "$id": "https://identity.foundation/dwn/json-schemas/protocol-definition.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object", "additionalProperties": false, "required": ["protocol", "published", "types", "structure"], "properties": { "protocol": { "type": "string" }, "published": { "type": "boolean" }, "uses": { "$comment": "Maps alias names to external protocol URIs for composition. Each alias can be used in $ref values and cross-protocol role/of references using 'alias:path' syntax.", "type": "object", "minProperties": 1, "patternProperties": { "^[a-zA-Z][a-zA-Z0-9_-]*$": { "type": "string" } }, "additionalProperties": false }, "types": { "type": "object", "patternProperties": { ".*": { "type": "object", "additionalProperties": false, "properties": { "schema": { "type": "string" }, "dataFormats": { "type": "array", "minItems": 1, "items": { "type": "string" } }, "encryptionRequired": { "type": "boolean" } } } } }, "structure": { "type": "object", "patternProperties": { ".*": { "$ref": "https://identity.foundation/dwn/json-schemas/protocol-rule-set.json" } } } } };
 const pattern39 = new RegExp("^[a-zA-Z][a-zA-Z0-9_-]*$", "u");
 const pattern41 = new RegExp(".*", "u");
-const schema122 = { "$id": "https://identity.foundation/dwn/json-schemas/protocol-rule-set.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object", "additionalProperties": false, "properties": { "$encryption": { "type": "object", "additionalProperties": false, "properties": { "rootKeyId": { "type": "string" }, "publicKeyJwk": { "$ref": "https://identity.foundation/dwn/json-schemas/public-jwk.json" } }, "required": ["rootKeyId", "publicKeyJwk"] }, "$actions": { "type": "array", "minItems": 1, "items": { "type": "object", "oneOf": [{ "required": ["who", "can"], "additionalProperties": false, "properties": { "who": { "type": "string", "enum": ["anyone", "author", "recipient"] }, "of": { "type": "string" }, "can": { "type": "array", "minItems": 1, "items": { "type": "string", "enum": ["co-delete", "co-prune", "co-update", "create", "delete", "prune", "read", "update"] } } } }, { "required": ["role", "can"], "additionalProperties": false, "properties": { "role": { "$comment": "Must be the protocol path of a role record type", "type": "string" }, "can": { "type": "array", "minItems": 1, "items": { "type": "string", "enum": ["co-delete", "co-prune", "co-update", "create", "delete", "prune", "read", "update"] } } } }] } }, "$role": { "$comment": "When `true`, this turns a record into `role` that may be used within a context/sub-context", "type": "boolean" }, "$ref": { "$comment": "References a type from an external protocol declared in `uses`. Format: 'alias:typePath'. A $ref node is a pure attachment point and must not have $actions, $role, $size, $tags, or $encryption.", "type": "string", "pattern": "^[a-zA-Z][a-zA-Z0-9_-]*:.+$" }, "$size": { "type": "object", "additionalProperties": false, "properties": { "min": { "type": "number", "minimum": 0 }, "max": { "type": "number", "minimum": 0 } } }, "$tags": { "type": "object", "minProperties": 1, "properties": { "$requiredTags": { "type": "array", "items": { "type": "string" } }, "$allowUndefinedTags": { "type": "boolean" } }, "patternProperties": { "^(?!\\$requiredTags$|\\$allowUndefinedTags$).*$": { "type": "object", "additionalProperties": false, "properties": { "type": { "enum": ["string", "number", "integer", "boolean", "array"] }, "items": { "type": "object", "properties": { "type": { "enum": ["string", "number", "integer"] } }, "patternProperties": { "^(enum|minimum|maximum|exclusiveMinimum|exclusiveMaximum|minLength|maxLength)$": {} } }, "contains": { "type": "object", "properties": { "type": { "enum": ["string", "number", "integer"] } }, "patternProperties": { "^(enum|minimum|maximum|exclusiveMinimum|exclusiveMaximum|minLength|maxLength)$": {} } } }, "patternProperties": { "^(enum|minimum|maximum|exclusiveMinimum|exclusiveMaximum|minLength|maxLength|minItems|maxItems|uniqueItems|minContains|maxContains)$": {} } } } } }, "patternProperties": { "^[^$].*$": { "$ref": "https://identity.foundation/dwn/json-schemas/protocol-rule-set.json" } } };
+const schema123 = { "$id": "https://identity.foundation/dwn/json-schemas/protocol-rule-set.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object", "additionalProperties": false, "properties": { "$encryption": { "type": "object", "additionalProperties": false, "properties": { "rootKeyId": { "type": "string" }, "publicKeyJwk": { "$ref": "https://identity.foundation/dwn/json-schemas/public-jwk.json" } }, "required": ["rootKeyId", "publicKeyJwk"] }, "$actions": { "type": "array", "minItems": 1, "items": { "type": "object", "oneOf": [{ "required": ["who", "can"], "additionalProperties": false, "properties": { "who": { "type": "string", "enum": ["anyone", "author", "recipient"] }, "of": { "type": "string" }, "can": { "type": "array", "minItems": 1, "items": { "type": "string", "enum": ["co-delete", "co-prune", "co-update", "create", "delete", "prune", "read", "update"] } } } }, { "required": ["role", "can"], "additionalProperties": false, "properties": { "role": { "$comment": "Must be the protocol path of a role record type", "type": "string" }, "can": { "type": "array", "minItems": 1, "items": { "type": "string", "enum": ["co-delete", "co-prune", "co-update", "create", "delete", "prune", "read", "update"] } } } }] } }, "$role": { "$comment": "When `true`, this turns a record into `role` that may be used within a context/sub-context", "type": "boolean" }, "$ref": { "$comment": "References a type from an external protocol declared in `uses`. Format: 'alias:typePath'. A $ref node is a pure attachment point and must not have $actions, $role, $size, $tags, or $encryption.", "type": "string", "pattern": "^[a-zA-Z][a-zA-Z0-9_-]*:.+$" }, "$size": { "type": "object", "additionalProperties": false, "properties": { "min": { "type": "number", "minimum": 0 }, "max": { "type": "number", "minimum": 0 } } }, "$tags": { "type": "object", "minProperties": 1, "properties": { "$requiredTags": { "type": "array", "items": { "type": "string" } }, "$allowUndefinedTags": { "type": "boolean" } }, "patternProperties": { "^(?!\\$requiredTags$|\\$allowUndefinedTags$).*$": { "type": "object", "additionalProperties": false, "properties": { "type": { "enum": ["string", "number", "integer", "boolean", "array"] }, "items": { "type": "object", "properties": { "type": { "enum": ["string", "number", "integer"] } }, "patternProperties": { "^(enum|minimum|maximum|exclusiveMinimum|exclusiveMaximum|minLength|maxLength)$": {} } }, "contains": { "type": "object", "properties": { "type": { "enum": ["string", "number", "integer"] } }, "patternProperties": { "^(enum|minimum|maximum|exclusiveMinimum|exclusiveMaximum|minLength|maxLength)$": {} } } }, "patternProperties": { "^(enum|minimum|maximum|exclusiveMinimum|exclusiveMaximum|minLength|maxLength|minItems|maxItems|uniqueItems|minContains|maxContains)$": {} } } } } }, "patternProperties": { "^[^$].*$": { "$ref": "https://identity.foundation/dwn/json-schemas/protocol-rule-set.json" } } };
 const pattern43 = new RegExp("^[^$].*$", "u");
 const pattern44 = new RegExp("^[a-zA-Z][a-zA-Z0-9_-]*:.+$", "u");
 const pattern45 = new RegExp("^(?!\\$requiredTags$|\\$allowUndefinedTags$).*$", "u");
@@ -11109,7 +11239,7 @@ function validate76(data, { instancePath = "", parentData, parentDataProperty, r
                                                         errors++;
                                                     }
                                                     if (!(((data5 === "anyone") || (data5 === "author")) || (data5 === "recipient"))) {
-                                                        const err3 = { instancePath: instancePath + "/$actions/" + i0 + "/who", schemaPath: "#/properties/%24actions/items/oneOf/0/properties/who/enum", keyword: "enum", params: { allowedValues: schema122.properties.$actions.items.oneOf[0].properties.who.enum }, message: "must be equal to one of the allowed values" };
+                                                        const err3 = { instancePath: instancePath + "/$actions/" + i0 + "/who", schemaPath: "#/properties/%24actions/items/oneOf/0/properties/who/enum", keyword: "enum", params: { allowedValues: schema123.properties.$actions.items.oneOf[0].properties.who.enum }, message: "must be equal to one of the allowed values" };
                                                         if (vErrors === null) {
                                                             vErrors = [err3];
                                                         }
@@ -11174,7 +11304,7 @@ function validate76(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                 errors++;
                                                                             }
                                                                             if (!((((((((data8 === "co-delete") || (data8 === "co-prune")) || (data8 === "co-update")) || (data8 === "create")) || (data8 === "delete")) || (data8 === "prune")) || (data8 === "read")) || (data8 === "update"))) {
-                                                                                const err7 = { instancePath: instancePath + "/$actions/" + i0 + "/can/" + i1, schemaPath: "#/properties/%24actions/items/oneOf/0/properties/can/items/enum", keyword: "enum", params: { allowedValues: schema122.properties.$actions.items.oneOf[0].properties.can.items.enum }, message: "must be equal to one of the allowed values" };
+                                                                                const err7 = { instancePath: instancePath + "/$actions/" + i0 + "/can/" + i1, schemaPath: "#/properties/%24actions/items/oneOf/0/properties/can/items/enum", keyword: "enum", params: { allowedValues: schema123.properties.$actions.items.oneOf[0].properties.can.items.enum }, message: "must be equal to one of the allowed values" };
                                                                                 if (vErrors === null) {
                                                                                     vErrors = [err7];
                                                                                 }
@@ -11296,7 +11426,7 @@ function validate76(data, { instancePath = "", parentData, parentDataProperty, r
                                                                             errors++;
                                                                         }
                                                                         if (!((((((((data11 === "co-delete") || (data11 === "co-prune")) || (data11 === "co-update")) || (data11 === "create")) || (data11 === "delete")) || (data11 === "prune")) || (data11 === "read")) || (data11 === "update"))) {
-                                                                            const err14 = { instancePath: instancePath + "/$actions/" + i0 + "/can/" + i2, schemaPath: "#/properties/%24actions/items/oneOf/1/properties/can/items/enum", keyword: "enum", params: { allowedValues: schema122.properties.$actions.items.oneOf[1].properties.can.items.enum }, message: "must be equal to one of the allowed values" };
+                                                                            const err14 = { instancePath: instancePath + "/$actions/" + i0 + "/can/" + i2, schemaPath: "#/properties/%24actions/items/oneOf/1/properties/can/items/enum", keyword: "enum", params: { allowedValues: schema123.properties.$actions.items.oneOf[1].properties.can.items.enum }, message: "must be equal to one of the allowed values" };
                                                                             if (vErrors === null) {
                                                                                 vErrors = [err14];
                                                                             }
@@ -11563,7 +11693,7 @@ function validate76(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                 let data22 = data21.type;
                                                                                 const _errs56 = errors;
                                                                                 if (!(((((data22 === "string") || (data22 === "number")) || (data22 === "integer")) || (data22 === "boolean")) || (data22 === "array"))) {
-                                                                                    validate76.errors = [{ instancePath: instancePath + "/$tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1") + "/type", schemaPath: "#/properties/%24tags/patternProperties/%5E(%3F!%5C%24requiredTags%24%7C%5C%24allowUndefinedTags%24).*%24/properties/type/enum", keyword: "enum", params: { allowedValues: schema122.properties.$tags.patternProperties["^(?!\\$requiredTags$|\\$allowUndefinedTags$).*$"].properties.type.enum }, message: "must be equal to one of the allowed values" }];
+                                                                                    validate76.errors = [{ instancePath: instancePath + "/$tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1") + "/type", schemaPath: "#/properties/%24tags/patternProperties/%5E(%3F!%5C%24requiredTags%24%7C%5C%24allowUndefinedTags%24).*%24/properties/type/enum", keyword: "enum", params: { allowedValues: schema123.properties.$tags.patternProperties["^(?!\\$requiredTags$|\\$allowUndefinedTags$).*$"].properties.type.enum }, message: "must be equal to one of the allowed values" }];
                                                                                     return false;
                                                                                 }
                                                                                 var valid12 = _errs56 === errors;
@@ -11581,7 +11711,7 @@ function validate76(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                 let data24 = data23.type;
                                                                                                 const _errs59 = errors;
                                                                                                 if (!(((data24 === "string") || (data24 === "number")) || (data24 === "integer"))) {
-                                                                                                    validate76.errors = [{ instancePath: instancePath + "/$tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1") + "/items/type", schemaPath: "#/properties/%24tags/patternProperties/%5E(%3F!%5C%24requiredTags%24%7C%5C%24allowUndefinedTags%24).*%24/properties/items/properties/type/enum", keyword: "enum", params: { allowedValues: schema122.properties.$tags.patternProperties["^(?!\\$requiredTags$|\\$allowUndefinedTags$).*$"].properties.items.properties.type.enum }, message: "must be equal to one of the allowed values" }];
+                                                                                                    validate76.errors = [{ instancePath: instancePath + "/$tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1") + "/items/type", schemaPath: "#/properties/%24tags/patternProperties/%5E(%3F!%5C%24requiredTags%24%7C%5C%24allowUndefinedTags%24).*%24/properties/items/properties/type/enum", keyword: "enum", params: { allowedValues: schema123.properties.$tags.patternProperties["^(?!\\$requiredTags$|\\$allowUndefinedTags$).*$"].properties.items.properties.type.enum }, message: "must be equal to one of the allowed values" }];
                                                                                                     return false;
                                                                                                 }
                                                                                                 var valid13 = _errs59 === errors;
@@ -11619,7 +11749,7 @@ function validate76(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                     let data26 = data25.type;
                                                                                                     const _errs62 = errors;
                                                                                                     if (!(((data26 === "string") || (data26 === "number")) || (data26 === "integer"))) {
-                                                                                                        validate76.errors = [{ instancePath: instancePath + "/$tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1") + "/contains/type", schemaPath: "#/properties/%24tags/patternProperties/%5E(%3F!%5C%24requiredTags%24%7C%5C%24allowUndefinedTags%24).*%24/properties/contains/properties/type/enum", keyword: "enum", params: { allowedValues: schema122.properties.$tags.patternProperties["^(?!\\$requiredTags$|\\$allowUndefinedTags$).*$"].properties.contains.properties.type.enum }, message: "must be equal to one of the allowed values" }];
+                                                                                                        validate76.errors = [{ instancePath: instancePath + "/$tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1") + "/contains/type", schemaPath: "#/properties/%24tags/patternProperties/%5E(%3F!%5C%24requiredTags%24%7C%5C%24allowUndefinedTags%24).*%24/properties/contains/properties/type/enum", keyword: "enum", params: { allowedValues: schema123.properties.$tags.patternProperties["^(?!\\$requiredTags$|\\$allowUndefinedTags$).*$"].properties.contains.properties.type.enum }, message: "must be equal to one of the allowed values" }];
                                                                                                         return false;
                                                                                                     }
                                                                                                     var valid15 = _errs62 === errors;
@@ -11939,7 +12069,7 @@ function validate75(data, { instancePath = "", parentData, parentDataProperty, r
 validate75.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const ProtocolRuleSet = validate76;
 export const ProtocolsConfigure = validate79;
-const schema123 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/protocols-configure.json", "type": "object", "additionalProperties": false, "required": ["authorization", "descriptor"], "properties": { "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization-delegated-grant.json" }, "descriptor": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "messageTimestamp", "definition"], "properties": { "interface": { "enum": ["Protocols"], "type": "string" }, "method": { "enum": ["Configure"], "type": "string" }, "messageTimestamp": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "definition": { "$ref": "https://identity.foundation/dwn/json-schemas/protocol-definition.json" }, "permissionGrantId": { "type": "string" } } } } };
+const schema124 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/protocols-configure.json", "type": "object", "additionalProperties": false, "required": ["authorization", "descriptor"], "properties": { "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization-delegated-grant.json" }, "descriptor": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "messageTimestamp", "definition"], "properties": { "interface": { "enum": ["Protocols"], "type": "string" }, "method": { "enum": ["Configure"], "type": "string" }, "messageTimestamp": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "definition": { "$ref": "https://identity.foundation/dwn/json-schemas/protocol-definition.json" }, "permissionGrantId": { "type": "string" } } } } };
 function validate79(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/protocols-configure.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate79.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -12001,7 +12131,7 @@ function validate79(data, { instancePath = "", parentData, parentDataProperty, r
                                                 return false;
                                             }
                                             if (!(data2 === "Protocols")) {
-                                                validate79.errors = [{ instancePath: instancePath + "/descriptor/interface", schemaPath: "#/properties/descriptor/properties/interface/enum", keyword: "enum", params: { allowedValues: schema123.properties.descriptor.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
+                                                validate79.errors = [{ instancePath: instancePath + "/descriptor/interface", schemaPath: "#/properties/descriptor/properties/interface/enum", keyword: "enum", params: { allowedValues: schema124.properties.descriptor.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
                                                 return false;
                                             }
                                             var valid1 = _errs6 === errors;
@@ -12018,7 +12148,7 @@ function validate79(data, { instancePath = "", parentData, parentDataProperty, r
                                                     return false;
                                                 }
                                                 if (!(data3 === "Configure")) {
-                                                    validate79.errors = [{ instancePath: instancePath + "/descriptor/method", schemaPath: "#/properties/descriptor/properties/method/enum", keyword: "enum", params: { allowedValues: schema123.properties.descriptor.properties.method.enum }, message: "must be equal to one of the allowed values" }];
+                                                    validate79.errors = [{ instancePath: instancePath + "/descriptor/method", schemaPath: "#/properties/descriptor/properties/method/enum", keyword: "enum", params: { allowedValues: schema124.properties.descriptor.properties.method.enum }, message: "must be equal to one of the allowed values" }];
                                                     return false;
                                                 }
                                                 var valid1 = _errs8 === errors;
@@ -12100,7 +12230,7 @@ function validate79(data, { instancePath = "", parentData, parentDataProperty, r
 } validate79.errors = vErrors; return errors === 0; }
 validate79.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const ProtocolsQuery = validate82;
-const schema125 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/protocols-query.json", "type": "object", "additionalProperties": false, "required": ["descriptor"], "properties": { "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization.json" }, "descriptor": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "messageTimestamp"], "properties": { "interface": { "enum": ["Protocols"], "type": "string" }, "method": { "enum": ["Query"], "type": "string" }, "messageTimestamp": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "filter": { "type": "object", "minProperties": 1, "additionalProperties": false, "properties": { "protocol": { "type": "string" }, "recipient": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/did" } } }, "permissionGrantId": { "type": "string" } } } } };
+const schema126 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/protocols-query.json", "type": "object", "additionalProperties": false, "required": ["descriptor"], "properties": { "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization.json" }, "descriptor": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "messageTimestamp"], "properties": { "interface": { "enum": ["Protocols"], "type": "string" }, "method": { "enum": ["Query"], "type": "string" }, "messageTimestamp": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "filter": { "type": "object", "minProperties": 1, "additionalProperties": false, "properties": { "protocol": { "type": "string" }, "recipient": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/did" } } }, "permissionGrantId": { "type": "string" } } } } };
 function validate82(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/protocols-query.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate82.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -12162,7 +12292,7 @@ function validate82(data, { instancePath = "", parentData, parentDataProperty, r
                                                 return false;
                                             }
                                             if (!(data2 === "Protocols")) {
-                                                validate82.errors = [{ instancePath: instancePath + "/descriptor/interface", schemaPath: "#/properties/descriptor/properties/interface/enum", keyword: "enum", params: { allowedValues: schema125.properties.descriptor.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
+                                                validate82.errors = [{ instancePath: instancePath + "/descriptor/interface", schemaPath: "#/properties/descriptor/properties/interface/enum", keyword: "enum", params: { allowedValues: schema126.properties.descriptor.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
                                                 return false;
                                             }
                                             var valid1 = _errs6 === errors;
@@ -12179,7 +12309,7 @@ function validate82(data, { instancePath = "", parentData, parentDataProperty, r
                                                     return false;
                                                 }
                                                 if (!(data3 === "Query")) {
-                                                    validate82.errors = [{ instancePath: instancePath + "/descriptor/method", schemaPath: "#/properties/descriptor/properties/method/enum", keyword: "enum", params: { allowedValues: schema125.properties.descriptor.properties.method.enum }, message: "must be equal to one of the allowed values" }];
+                                                    validate82.errors = [{ instancePath: instancePath + "/descriptor/method", schemaPath: "#/properties/descriptor/properties/method/enum", keyword: "enum", params: { allowedValues: schema126.properties.descriptor.properties.method.enum }, message: "must be equal to one of the allowed values" }];
                                                     return false;
                                                 }
                                                 var valid1 = _errs8 === errors;
@@ -12316,7 +12446,7 @@ function validate82(data, { instancePath = "", parentData, parentDataProperty, r
 } validate82.errors = vErrors; return errors === 0; }
 validate82.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const RecordsRead = validate84;
-const schema128 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/records-read.json", "type": "object", "additionalProperties": false, "required": ["descriptor"], "properties": { "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization-delegated-grant.json" }, "descriptor": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "messageTimestamp", "filter"], "properties": { "interface": { "enum": ["Records"], "type": "string" }, "method": { "enum": ["Read"], "type": "string" }, "messageTimestamp": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "filter": { "$ref": "https://identity.foundation/dwn/json-schemas/records-filter.json" }, "permissionGrantId": { "type": "string" }, "dateSort": { "enum": ["createdAscending", "createdDescending", "publishedAscending", "publishedDescending", "updatedAscending", "updatedDescending"], "type": "string" } } } } };
+const schema129 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/records-read.json", "type": "object", "additionalProperties": false, "required": ["descriptor"], "properties": { "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization-delegated-grant.json" }, "descriptor": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "messageTimestamp", "filter"], "properties": { "interface": { "enum": ["Records"], "type": "string" }, "method": { "enum": ["Read"], "type": "string" }, "messageTimestamp": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "filter": { "$ref": "https://identity.foundation/dwn/json-schemas/records-filter.json" }, "permissionGrantId": { "type": "string" }, "dateSort": { "enum": ["createdAscending", "createdDescending", "publishedAscending", "publishedDescending", "updatedAscending", "updatedDescending"], "type": "string" } } } } };
 function validate84(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/records-read.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate84.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -12378,7 +12508,7 @@ function validate84(data, { instancePath = "", parentData, parentDataProperty, r
                                                 return false;
                                             }
                                             if (!(data2 === "Records")) {
-                                                validate84.errors = [{ instancePath: instancePath + "/descriptor/interface", schemaPath: "#/properties/descriptor/properties/interface/enum", keyword: "enum", params: { allowedValues: schema128.properties.descriptor.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
+                                                validate84.errors = [{ instancePath: instancePath + "/descriptor/interface", schemaPath: "#/properties/descriptor/properties/interface/enum", keyword: "enum", params: { allowedValues: schema129.properties.descriptor.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
                                                 return false;
                                             }
                                             var valid1 = _errs6 === errors;
@@ -12395,7 +12525,7 @@ function validate84(data, { instancePath = "", parentData, parentDataProperty, r
                                                     return false;
                                                 }
                                                 if (!(data3 === "Read")) {
-                                                    validate84.errors = [{ instancePath: instancePath + "/descriptor/method", schemaPath: "#/properties/descriptor/properties/method/enum", keyword: "enum", params: { allowedValues: schema128.properties.descriptor.properties.method.enum }, message: "must be equal to one of the allowed values" }];
+                                                    validate84.errors = [{ instancePath: instancePath + "/descriptor/method", schemaPath: "#/properties/descriptor/properties/method/enum", keyword: "enum", params: { allowedValues: schema129.properties.descriptor.properties.method.enum }, message: "must be equal to one of the allowed values" }];
                                                     return false;
                                                 }
                                                 var valid1 = _errs8 === errors;
@@ -12458,7 +12588,7 @@ function validate84(data, { instancePath = "", parentData, parentDataProperty, r
                                                                     return false;
                                                                 }
                                                                 if (!((((((data7 === "createdAscending") || (data7 === "createdDescending")) || (data7 === "publishedAscending")) || (data7 === "publishedDescending")) || (data7 === "updatedAscending")) || (data7 === "updatedDescending"))) {
-                                                                    validate84.errors = [{ instancePath: instancePath + "/descriptor/dateSort", schemaPath: "#/properties/descriptor/properties/dateSort/enum", keyword: "enum", params: { allowedValues: schema128.properties.descriptor.properties.dateSort.enum }, message: "must be equal to one of the allowed values" }];
+                                                                    validate84.errors = [{ instancePath: instancePath + "/descriptor/dateSort", schemaPath: "#/properties/descriptor/properties/dateSort/enum", keyword: "enum", params: { allowedValues: schema129.properties.descriptor.properties.dateSort.enum }, message: "must be equal to one of the allowed values" }];
                                                                     return false;
                                                                 }
                                                                 var valid1 = _errs16 === errors;
@@ -12497,7 +12627,7 @@ validate84.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": f
 export const RecordsFilter = validate41;
 export const PublicJwk = validate32;
 export const GenericSignaturePayload = validate87;
-const schema130 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/signature-payloads/generic-signature-payload.json", "type": "object", "additionalProperties": false, "required": ["descriptorCid"], "properties": { "descriptorCid": { "type": "string" }, "delegatedGrantId": { "type": "string" }, "permissionGrantId": { "type": "string" }, "protocolRole": { "$comment": "Used in the Records interface to authorize role-authorized actions for protocol records", "type": "string" } } };
+const schema131 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/signature-payloads/generic-signature-payload.json", "type": "object", "additionalProperties": false, "required": ["descriptorCid"], "properties": { "descriptorCid": { "type": "string" }, "delegatedGrantId": { "type": "string" }, "permissionGrantId": { "type": "string" }, "protocolRole": { "$comment": "Used in the Records interface to authorize role-authorized actions for protocol records", "type": "string" } } };
 function validate87(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/signature-payloads/generic-signature-payload.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate87.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -12579,7 +12709,7 @@ function validate87(data, { instancePath = "", parentData, parentDataProperty, r
 } validate87.errors = vErrors; return errors === 0; }
 validate87.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const RecordsWriteSignaturePayload = validate88;
-const schema131 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/signature-payloads/records-write-signature-payload.json", "type": "object", "additionalProperties": false, "required": ["descriptorCid", "recordId"], "properties": { "descriptorCid": { "type": "string" }, "recordId": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "attestationCid": { "type": "string" }, "encryptionCid": { "type": "string" }, "delegatedGrantId": { "type": "string" }, "permissionGrantId": { "type": "string" }, "protocolRole": { "type": "string" } } };
+const schema132 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/signature-payloads/records-write-signature-payload.json", "type": "object", "additionalProperties": false, "required": ["descriptorCid", "recordId"], "properties": { "descriptorCid": { "type": "string" }, "recordId": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "attestationCid": { "type": "string" }, "encryptionCid": { "type": "string" }, "delegatedGrantId": { "type": "string" }, "permissionGrantId": { "type": "string" }, "protocolRole": { "type": "string" } } };
 function validate88(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/signature-payloads/records-write-signature-payload.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate88.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {