@enbox/dwn-sdk-js 0.4.3 → 0.4.4

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

@@ -7962,7 +7962,7 @@ function validate67(data, { instancePath = "", parentData, parentDataProperty, r
 } validate67.errors = vErrors; return errors === 0; }
 validate67.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const PermissionGrantData = validate68;
-const schema94 = { "$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" }, "delegateKeyDelivery": { "type": "object", "additionalProperties": false, "required": ["rootKeyId", "publicKeyJwk"], "properties": { "rootKeyId": { "type": "string" }, "publicKeyJwk": { "type": "object" } } } } };
+const schema94 = { "$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" }, "delegateKeyDelivery": { "type": "object", "additionalProperties": false, "required": ["rootKeyId", "publicKeyJwk"], "properties": { "rootKeyId": { "type": "string" }, "publicKeyJwk": { "type": "object" } } }, "connectSession": { "type": "object", "additionalProperties": false, "required": ["id", "createdAt", "expiresAt"], "properties": { "id": { "type": "string", "maxLength": 128 }, "appName": { "type": "string", "maxLength": 128 }, "appIcon": { "type": "string", "maxLength": 2048 }, "origin": { "type": "string", "maxLength": 512 }, "userAgent": { "type": "string", "maxLength": 512 }, "platform": { "type": "string", "maxLength": 128 }, "language": { "type": "string", "maxLength": 64 }, "languages": { "type": "array", "maxItems": 16, "items": { "type": "string", "maxLength": 64 } }, "timezone": { "type": "string", "maxLength": 128 }, "transport": { "enum": ["relay", "postMessage"] }, "createdAt": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "expiresAt": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" } } } } };
 const schema105 = { "type": "object", "additionalProperties": false, "properties": { "publication": { "enum": ["Required", "Prohibited"], "type": "string" } } };
 const schema97 = { "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/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" }] };
 const schema99 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Messages" }, "method": { "const": "Read" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } }, "allOf": [{ "not": { "required": ["contextId", "protocolPath"] } }, { "if": { "anyOf": [{ "required": ["contextId"] }, { "required": ["protocolPath"] }] }, "then": { "required": ["protocol"] } }] };
@@ -9082,7 +9082,7 @@ function validate68(data, { instancePath = "", parentData, parentDataProperty, r
         else {
             const _errs1 = errors;
             for (const key0 in data) {
-                if (!(((((((key0 === "description") || (key0 === "dateExpires")) || (key0 === "requestId")) || (key0 === "delegated")) || (key0 === "scope")) || (key0 === "conditions")) || (key0 === "delegateKeyDelivery"))) {
+                if (!((((((((key0 === "description") || (key0 === "dateExpires")) || (key0 === "requestId")) || (key0 === "delegated")) || (key0 === "scope")) || (key0 === "conditions")) || (key0 === "delegateKeyDelivery")) || (key0 === "connectSession"))) {
                     validate68.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
                     return false;
                     break;
@@ -9256,6 +9256,321 @@ function validate68(data, { instancePath = "", parentData, parentDataProperty, r
                                         else {
                                             var valid0 = true;
                                         }
+                                        if (valid0) {
+                                            if (data.connectSession !== undefined) {
+                                                let data10 = data.connectSession;
+                                                const _errs25 = errors;
+                                                if (errors === _errs25) {
+                                                    if (data10 && typeof data10 == "object" && !Array.isArray(data10)) {
+                                                        let missing2;
+                                                        if ((((data10.id === undefined) && (missing2 = "id")) || ((data10.createdAt === undefined) && (missing2 = "createdAt"))) || ((data10.expiresAt === undefined) && (missing2 = "expiresAt"))) {
+                                                            validate68.errors = [{ instancePath: instancePath + "/connectSession", schemaPath: "#/properties/connectSession/required", keyword: "required", params: { missingProperty: missing2 }, message: "must have required property '" + missing2 + "'" }];
+                                                            return false;
+                                                        }
+                                                        else {
+                                                            const _errs27 = errors;
+                                                            for (const key3 in data10) {
+                                                                if (!(func2.call(schema94.properties.connectSession.properties, key3))) {
+                                                                    validate68.errors = [{ instancePath: instancePath + "/connectSession", schemaPath: "#/properties/connectSession/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key3 }, message: "must NOT have additional properties" }];
+                                                                    return false;
+                                                                    break;
+                                                                }
+                                                            }
+                                                            if (_errs27 === errors) {
+                                                                if (data10.id !== undefined) {
+                                                                    let data11 = data10.id;
+                                                                    const _errs28 = errors;
+                                                                    if (errors === _errs28) {
+                                                                        if (typeof data11 === "string") {
+                                                                            if (func1(data11) > 128) {
+                                                                                validate68.errors = [{ instancePath: instancePath + "/connectSession/id", schemaPath: "#/properties/connectSession/properties/id/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                                                                                return false;
+                                                                            }
+                                                                        }
+                                                                        else {
+                                                                            validate68.errors = [{ instancePath: instancePath + "/connectSession/id", schemaPath: "#/properties/connectSession/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                            return false;
+                                                                        }
+                                                                    }
+                                                                    var valid5 = _errs28 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid5 = true;
+                                                                }
+                                                                if (valid5) {
+                                                                    if (data10.appName !== undefined) {
+                                                                        let data12 = data10.appName;
+                                                                        const _errs30 = errors;
+                                                                        if (errors === _errs30) {
+                                                                            if (typeof data12 === "string") {
+                                                                                if (func1(data12) > 128) {
+                                                                                    validate68.errors = [{ instancePath: instancePath + "/connectSession/appName", schemaPath: "#/properties/connectSession/properties/appName/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                                                                                    return false;
+                                                                                }
+                                                                            }
+                                                                            else {
+                                                                                validate68.errors = [{ instancePath: instancePath + "/connectSession/appName", schemaPath: "#/properties/connectSession/properties/appName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                return false;
+                                                                            }
+                                                                        }
+                                                                        var valid5 = _errs30 === errors;
+                                                                    }
+                                                                    else {
+                                                                        var valid5 = true;
+                                                                    }
+                                                                    if (valid5) {
+                                                                        if (data10.appIcon !== undefined) {
+                                                                            let data13 = data10.appIcon;
+                                                                            const _errs32 = errors;
+                                                                            if (errors === _errs32) {
+                                                                                if (typeof data13 === "string") {
+                                                                                    if (func1(data13) > 2048) {
+                                                                                        validate68.errors = [{ instancePath: instancePath + "/connectSession/appIcon", schemaPath: "#/properties/connectSession/properties/appIcon/maxLength", keyword: "maxLength", params: { limit: 2048 }, message: "must NOT have more than 2048 characters" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                }
+                                                                                else {
+                                                                                    validate68.errors = [{ instancePath: instancePath + "/connectSession/appIcon", schemaPath: "#/properties/connectSession/properties/appIcon/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                    return false;
+                                                                                }
+                                                                            }
+                                                                            var valid5 = _errs32 === errors;
+                                                                        }
+                                                                        else {
+                                                                            var valid5 = true;
+                                                                        }
+                                                                        if (valid5) {
+                                                                            if (data10.origin !== undefined) {
+                                                                                let data14 = data10.origin;
+                                                                                const _errs34 = errors;
+                                                                                if (errors === _errs34) {
+                                                                                    if (typeof data14 === "string") {
+                                                                                        if (func1(data14) > 512) {
+                                                                                            validate68.errors = [{ instancePath: instancePath + "/connectSession/origin", schemaPath: "#/properties/connectSession/properties/origin/maxLength", keyword: "maxLength", params: { limit: 512 }, message: "must NOT have more than 512 characters" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                    }
+                                                                                    else {
+                                                                                        validate68.errors = [{ instancePath: instancePath + "/connectSession/origin", schemaPath: "#/properties/connectSession/properties/origin/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                }
+                                                                                var valid5 = _errs34 === errors;
+                                                                            }
+                                                                            else {
+                                                                                var valid5 = true;
+                                                                            }
+                                                                            if (valid5) {
+                                                                                if (data10.userAgent !== undefined) {
+                                                                                    let data15 = data10.userAgent;
+                                                                                    const _errs36 = errors;
+                                                                                    if (errors === _errs36) {
+                                                                                        if (typeof data15 === "string") {
+                                                                                            if (func1(data15) > 512) {
+                                                                                                validate68.errors = [{ instancePath: instancePath + "/connectSession/userAgent", schemaPath: "#/properties/connectSession/properties/userAgent/maxLength", keyword: "maxLength", params: { limit: 512 }, message: "must NOT have more than 512 characters" }];
+                                                                                                return false;
+                                                                                            }
+                                                                                        }
+                                                                                        else {
+                                                                                            validate68.errors = [{ instancePath: instancePath + "/connectSession/userAgent", schemaPath: "#/properties/connectSession/properties/userAgent/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                    }
+                                                                                    var valid5 = _errs36 === errors;
+                                                                                }
+                                                                                else {
+                                                                                    var valid5 = true;
+                                                                                }
+                                                                                if (valid5) {
+                                                                                    if (data10.platform !== undefined) {
+                                                                                        let data16 = data10.platform;
+                                                                                        const _errs38 = errors;
+                                                                                        if (errors === _errs38) {
+                                                                                            if (typeof data16 === "string") {
+                                                                                                if (func1(data16) > 128) {
+                                                                                                    validate68.errors = [{ instancePath: instancePath + "/connectSession/platform", schemaPath: "#/properties/connectSession/properties/platform/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                                                                                                    return false;
+                                                                                                }
+                                                                                            }
+                                                                                            else {
+                                                                                                validate68.errors = [{ instancePath: instancePath + "/connectSession/platform", schemaPath: "#/properties/connectSession/properties/platform/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                return false;
+                                                                                            }
+                                                                                        }
+                                                                                        var valid5 = _errs38 === errors;
+                                                                                    }
+                                                                                    else {
+                                                                                        var valid5 = true;
+                                                                                    }
+                                                                                    if (valid5) {
+                                                                                        if (data10.language !== undefined) {
+                                                                                            let data17 = data10.language;
+                                                                                            const _errs40 = errors;
+                                                                                            if (errors === _errs40) {
+                                                                                                if (typeof data17 === "string") {
+                                                                                                    if (func1(data17) > 64) {
+                                                                                                        validate68.errors = [{ instancePath: instancePath + "/connectSession/language", schemaPath: "#/properties/connectSession/properties/language/maxLength", keyword: "maxLength", params: { limit: 64 }, message: "must NOT have more than 64 characters" }];
+                                                                                                        return false;
+                                                                                                    }
+                                                                                                }
+                                                                                                else {
+                                                                                                    validate68.errors = [{ instancePath: instancePath + "/connectSession/language", schemaPath: "#/properties/connectSession/properties/language/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                    return false;
+                                                                                                }
+                                                                                            }
+                                                                                            var valid5 = _errs40 === errors;
+                                                                                        }
+                                                                                        else {
+                                                                                            var valid5 = true;
+                                                                                        }
+                                                                                        if (valid5) {
+                                                                                            if (data10.languages !== undefined) {
+                                                                                                let data18 = data10.languages;
+                                                                                                const _errs42 = errors;
+                                                                                                if (errors === _errs42) {
+                                                                                                    if (Array.isArray(data18)) {
+                                                                                                        if (data18.length > 16) {
+                                                                                                            validate68.errors = [{ instancePath: instancePath + "/connectSession/languages", schemaPath: "#/properties/connectSession/properties/languages/maxItems", keyword: "maxItems", params: { limit: 16 }, message: "must NOT have more than 16 items" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            var valid6 = true;
+                                                                                                            const len0 = data18.length;
+                                                                                                            for (let i0 = 0; i0 < len0; i0++) {
+                                                                                                                let data19 = data18[i0];
+                                                                                                                const _errs44 = errors;
+                                                                                                                if (errors === _errs44) {
+                                                                                                                    if (typeof data19 === "string") {
+                                                                                                                        if (func1(data19) > 64) {
+                                                                                                                            validate68.errors = [{ instancePath: instancePath + "/connectSession/languages/" + i0, schemaPath: "#/properties/connectSession/properties/languages/items/maxLength", keyword: "maxLength", params: { limit: 64 }, message: "must NOT have more than 64 characters" }];
+                                                                                                                            return false;
+                                                                                                                        }
+                                                                                                                    }
+                                                                                                                    else {
+                                                                                                                        validate68.errors = [{ instancePath: instancePath + "/connectSession/languages/" + i0, schemaPath: "#/properties/connectSession/properties/languages/items/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                        return false;
+                                                                                                                    }
+                                                                                                                }
+                                                                                                                var valid6 = _errs44 === errors;
+                                                                                                                if (!valid6) {
+                                                                                                                    break;
+                                                                                                                }
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        validate68.errors = [{ instancePath: instancePath + "/connectSession/languages", schemaPath: "#/properties/connectSession/properties/languages/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                                                                        return false;
+                                                                                                    }
+                                                                                                }
+                                                                                                var valid5 = _errs42 === errors;
+                                                                                            }
+                                                                                            else {
+                                                                                                var valid5 = true;
+                                                                                            }
+                                                                                            if (valid5) {
+                                                                                                if (data10.timezone !== undefined) {
+                                                                                                    let data20 = data10.timezone;
+                                                                                                    const _errs46 = errors;
+                                                                                                    if (errors === _errs46) {
+                                                                                                        if (typeof data20 === "string") {
+                                                                                                            if (func1(data20) > 128) {
+                                                                                                                validate68.errors = [{ instancePath: instancePath + "/connectSession/timezone", schemaPath: "#/properties/connectSession/properties/timezone/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                                                                                                                return false;
+                                                                                                            }
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            validate68.errors = [{ instancePath: instancePath + "/connectSession/timezone", schemaPath: "#/properties/connectSession/properties/timezone/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                    }
+                                                                                                    var valid5 = _errs46 === errors;
+                                                                                                }
+                                                                                                else {
+                                                                                                    var valid5 = true;
+                                                                                                }
+                                                                                                if (valid5) {
+                                                                                                    if (data10.transport !== undefined) {
+                                                                                                        let data21 = data10.transport;
+                                                                                                        const _errs48 = errors;
+                                                                                                        if (!((data21 === "relay") || (data21 === "postMessage"))) {
+                                                                                                            validate68.errors = [{ instancePath: instancePath + "/connectSession/transport", schemaPath: "#/properties/connectSession/properties/transport/enum", keyword: "enum", params: { allowedValues: schema94.properties.connectSession.properties.transport.enum }, message: "must be equal to one of the allowed values" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                        var valid5 = _errs48 === errors;
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        var valid5 = true;
+                                                                                                    }
+                                                                                                    if (valid5) {
+                                                                                                        if (data10.createdAt !== undefined) {
+                                                                                                            let data22 = data10.createdAt;
+                                                                                                            const _errs49 = errors;
+                                                                                                            const _errs50 = errors;
+                                                                                                            if (errors === _errs50) {
+                                                                                                                if (typeof data22 === "string") {
+                                                                                                                    if (!pattern14.test(data22)) {
+                                                                                                                        validate68.errors = [{ instancePath: instancePath + "/connectSession/createdAt", 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;
+                                                                                                                    }
+                                                                                                                }
+                                                                                                                else {
+                                                                                                                    validate68.errors = [{ instancePath: instancePath + "/connectSession/createdAt", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                    return false;
+                                                                                                                }
+                                                                                                            }
+                                                                                                            var valid5 = _errs49 === errors;
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            var valid5 = true;
+                                                                                                        }
+                                                                                                        if (valid5) {
+                                                                                                            if (data10.expiresAt !== undefined) {
+                                                                                                                let data23 = data10.expiresAt;
+                                                                                                                const _errs52 = errors;
+                                                                                                                const _errs53 = errors;
+                                                                                                                if (errors === _errs53) {
+                                                                                                                    if (typeof data23 === "string") {
+                                                                                                                        if (!pattern14.test(data23)) {
+                                                                                                                            validate68.errors = [{ instancePath: instancePath + "/connectSession/expiresAt", 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;
+                                                                                                                        }
+                                                                                                                    }
+                                                                                                                    else {
+                                                                                                                        validate68.errors = [{ instancePath: instancePath + "/connectSession/expiresAt", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                        return false;
+                                                                                                                    }
+                                                                                                                }
+                                                                                                                var valid5 = _errs52 === errors;
+                                                                                                            }
+                                                                                                            else {
+                                                                                                                var valid5 = true;
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                    else {
+                                                        validate68.errors = [{ instancePath: instancePath + "/connectSession", schemaPath: "#/properties/connectSession/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                        return false;
+                                                    }
+                                                }
+                                                var valid0 = _errs25 === errors;
+                                            }
+                                            else {
+                                                var valid0 = true;
+                                            }
+                                        }
                                     }
                                 }
                             }
@@ -9272,7 +9587,7 @@ function validate68(data, { instancePath = "", parentData, parentDataProperty, r
 } validate68.errors = vErrors; return errors === 0; }
 validate68.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const PermissionRequestData = validate73;
-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 schema108 = { "$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 validate74(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate74.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -10478,7 +10793,7 @@ function validate73(data, { instancePath = "", parentData, parentDataProperty, r
 } validate73.errors = vErrors; return errors === 0; }
 validate73.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const PermissionRevocationData = validate76;
-const schema115 = { "$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 schema117 = { "$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 validate76(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 = validate76.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -10531,15 +10846,15 @@ function validate71(data, { instancePath = "", parentData, parentDataProperty, r
 } validate71.errors = vErrors; return errors === 0; }
 validate71.evaluated = { "dynamicProps": false, "dynamicItems": false };
 export const ProtocolDefinition = validate77;
-const schema116 = { "$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 pattern38 = new RegExp("^[a-zA-Z][a-zA-Z0-9_-]*$", "u");
-const pattern40 = new RegExp(".*", "u");
-const schema117 = { "$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", "squash", "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", "squash", "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 } } }, "$recordLimit": { "type": "object", "additionalProperties": false, "required": ["max", "strategy"], "properties": { "max": { "type": "integer", "minimum": 1 }, "strategy": { "type": "string", "enum": ["reject", "purgeOldest"] } } }, "$immutable": { "$comment": "When true, records at this protocol path cannot be updated after initial write", "type": "boolean" }, "$delivery": { "$comment": "Delivery strategy hint for records at this protocol path. 'direct' = origin pushes to all participant DWN endpoints; 'subscribe' = participant providers subscribe to the origin DWN.", "type": "string", "enum": ["direct", "subscribe"] }, "$squash": { "$comment": "When true, enables squash writes at this protocol path — a RecordsWrite with squash: true atomically creates a snapshot and deletes all older sibling records", "type": "boolean", "enum": [true] }, "$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 pattern42 = new RegExp("^[^$].*$", "u");
-const pattern43 = new RegExp("^[a-zA-Z][a-zA-Z0-9_-]*:.+$", "u");
-const pattern44 = new RegExp("^(?!\\$requiredTags$|\\$allowUndefinedTags$).*$", "u");
-const pattern45 = new RegExp("^(enum|minimum|maximum|exclusiveMinimum|exclusiveMaximum|minLength|maxLength|minItems|maxItems|uniqueItems|minContains|maxContains)$", "u");
-const pattern46 = new RegExp("^(enum|minimum|maximum|exclusiveMinimum|exclusiveMaximum|minLength|maxLength)$", "u");
+const schema118 = { "$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 pattern40 = new RegExp("^[a-zA-Z][a-zA-Z0-9_-]*$", "u");
+const pattern42 = new RegExp(".*", "u");
+const schema119 = { "$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", "squash", "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", "squash", "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 } } }, "$recordLimit": { "type": "object", "additionalProperties": false, "required": ["max", "strategy"], "properties": { "max": { "type": "integer", "minimum": 1 }, "strategy": { "type": "string", "enum": ["reject", "purgeOldest"] } } }, "$immutable": { "$comment": "When true, records at this protocol path cannot be updated after initial write", "type": "boolean" }, "$delivery": { "$comment": "Delivery strategy hint for records at this protocol path. 'direct' = origin pushes to all participant DWN endpoints; 'subscribe' = participant providers subscribe to the origin DWN.", "type": "string", "enum": ["direct", "subscribe"] }, "$squash": { "$comment": "When true, enables squash writes at this protocol path — a RecordsWrite with squash: true atomically creates a snapshot and deletes all older sibling records", "type": "boolean", "enum": [true] }, "$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 pattern44 = new RegExp("^[^$].*$", "u");
+const pattern45 = new RegExp("^[a-zA-Z][a-zA-Z0-9_-]*:.+$", "u");
+const pattern46 = new RegExp("^(?!\\$requiredTags$|\\$allowUndefinedTags$).*$", "u");
+const pattern47 = new RegExp("^(enum|minimum|maximum|exclusiveMinimum|exclusiveMaximum|minLength|maxLength|minItems|maxItems|uniqueItems|minContains|maxContains)$", "u");
+const pattern48 = new RegExp("^(enum|minimum|maximum|exclusiveMinimum|exclusiveMaximum|minLength|maxLength)$", "u");
 const wrapper2 = { validate: validate78 };
 function validate78(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/protocol-rule-set.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate78.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
@@ -10549,7 +10864,7 @@ function validate78(data, { instancePath = "", parentData, parentDataProperty, r
     if (data && typeof data == "object" && !Array.isArray(data)) {
         const _errs1 = errors;
         for (const key0 in data) {
-            if (!((func2.call(schema117.properties, key0)) || (pattern42.test(key0)))) {
+            if (!((func2.call(schema119.properties, key0)) || (pattern44.test(key0)))) {
                 validate78.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
                 return false;
                 break;
@@ -10679,7 +10994,7 @@ function validate78(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: schema117.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: schema119.properties.$actions.items.oneOf[0].properties.who.enum }, message: "must be equal to one of the allowed values" };
                                                         if (vErrors === null) {
                                                             vErrors = [err3];
                                                         }
@@ -10744,7 +11059,7 @@ function validate78(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 === "squash")) || (data8 === "update"))) {
-                                                                                const err7 = { instancePath: instancePath + "/$actions/" + i0 + "/can/" + i1, schemaPath: "#/properties/%24actions/items/oneOf/0/properties/can/items/enum", keyword: "enum", params: { allowedValues: schema117.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: schema119.properties.$actions.items.oneOf[0].properties.can.items.enum }, message: "must be equal to one of the allowed values" };
                                                                                 if (vErrors === null) {
                                                                                     vErrors = [err7];
                                                                                 }
@@ -10866,7 +11181,7 @@ function validate78(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 === "squash")) || (data11 === "update"))) {
-                                                                            const err14 = { instancePath: instancePath + "/$actions/" + i0 + "/can/" + i2, schemaPath: "#/properties/%24actions/items/oneOf/1/properties/can/items/enum", keyword: "enum", params: { allowedValues: schema117.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: schema119.properties.$actions.items.oneOf[1].properties.can.items.enum }, message: "must be equal to one of the allowed values" };
                                                                             if (vErrors === null) {
                                                                                 vErrors = [err14];
                                                                             }
@@ -10974,7 +11289,7 @@ function validate78(data, { instancePath = "", parentData, parentDataProperty, r
                             const _errs35 = errors;
                             if (errors === _errs35) {
                                 if (typeof data13 === "string") {
-                                    if (!pattern43.test(data13)) {
+                                    if (!pattern45.test(data13)) {
                                         validate78.errors = [{ instancePath: instancePath + "/$ref", schemaPath: "#/properties/%24ref/pattern", keyword: "pattern", params: { pattern: "^[a-zA-Z][a-zA-Z0-9_-]*:.+$" }, message: "must match pattern \"" + "^[a-zA-Z][a-zA-Z0-9_-]*:.+$" + "\"" }];
                                         return false;
                                     }
@@ -11108,7 +11423,7 @@ function validate78(data, { instancePath = "", parentData, parentDataProperty, r
                                                                 return false;
                                                             }
                                                             if (!((data19 === "reject") || (data19 === "purgeOldest"))) {
-                                                                validate78.errors = [{ instancePath: instancePath + "/$recordLimit/strategy", schemaPath: "#/properties/%24recordLimit/properties/strategy/enum", keyword: "enum", params: { allowedValues: schema117.properties.$recordLimit.properties.strategy.enum }, message: "must be equal to one of the allowed values" }];
+                                                                validate78.errors = [{ instancePath: instancePath + "/$recordLimit/strategy", schemaPath: "#/properties/%24recordLimit/properties/strategy/enum", keyword: "enum", params: { allowedValues: schema119.properties.$recordLimit.properties.strategy.enum }, message: "must be equal to one of the allowed values" }];
                                                                 return false;
                                                             }
                                                             var valid9 = _errs50 === errors;
@@ -11151,7 +11466,7 @@ function validate78(data, { instancePath = "", parentData, parentDataProperty, r
                                                 return false;
                                             }
                                             if (!((data21 === "direct") || (data21 === "subscribe"))) {
-                                                validate78.errors = [{ instancePath: instancePath + "/$delivery", schemaPath: "#/properties/%24delivery/enum", keyword: "enum", params: { allowedValues: schema117.properties.$delivery.enum }, message: "must be equal to one of the allowed values" }];
+                                                validate78.errors = [{ instancePath: instancePath + "/$delivery", schemaPath: "#/properties/%24delivery/enum", keyword: "enum", params: { allowedValues: schema119.properties.$delivery.enum }, message: "must be equal to one of the allowed values" }];
                                                 return false;
                                             }
                                             var valid0 = _errs55 === errors;
@@ -11168,7 +11483,7 @@ function validate78(data, { instancePath = "", parentData, parentDataProperty, r
                                                     return false;
                                                 }
                                                 if (!(data22 === true)) {
-                                                    validate78.errors = [{ instancePath: instancePath + "/$squash", schemaPath: "#/properties/%24squash/enum", keyword: "enum", params: { allowedValues: schema117.properties.$squash.enum }, message: "must be equal to one of the allowed values" }];
+                                                    validate78.errors = [{ instancePath: instancePath + "/$squash", schemaPath: "#/properties/%24squash/enum", keyword: "enum", params: { allowedValues: schema119.properties.$squash.enum }, message: "must be equal to one of the allowed values" }];
                                                     return false;
                                                 }
                                                 var valid0 = _errs58 === errors;
@@ -11233,14 +11548,14 @@ function validate78(data, { instancePath = "", parentData, parentDataProperty, r
                                                                         props2.$requiredTags = true;
                                                                         props2.$allowUndefinedTags = true;
                                                                         for (const key6 in data23) {
-                                                                            if (pattern44.test(key6)) {
+                                                                            if (pattern46.test(key6)) {
                                                                                 let data27 = data23[key6];
                                                                                 const _errs69 = errors;
                                                                                 if (errors === _errs69) {
                                                                                     if (data27 && typeof data27 == "object" && !Array.isArray(data27)) {
                                                                                         const _errs71 = errors;
                                                                                         for (const key7 in data27) {
-                                                                                            if (!((((key7 === "type") || (key7 === "items")) || (key7 === "contains")) || (pattern45.test(key7)))) {
+                                                                                            if (!((((key7 === "type") || (key7 === "items")) || (key7 === "contains")) || (pattern47.test(key7)))) {
                                                                                                 validate78.errors = [{ instancePath: instancePath + "/$tags/" + key6.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/%24tags/patternProperties/%5E(%3F!%5C%24requiredTags%24%7C%5C%24allowUndefinedTags%24).*%24/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key7 }, message: "must NOT have additional properties" }];
                                                                                                 return false;
                                                                                                 break;
@@ -11251,7 +11566,7 @@ function validate78(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                 let data28 = data27.type;
                                                                                                 const _errs72 = errors;
                                                                                                 if (!(((((data28 === "string") || (data28 === "number")) || (data28 === "integer")) || (data28 === "boolean")) || (data28 === "array"))) {
-                                                                                                    validate78.errors = [{ instancePath: instancePath + "/$tags/" + key6.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: schema117.properties.$tags.patternProperties["^(?!\\$requiredTags$|\\$allowUndefinedTags$).*$"].properties.type.enum }, message: "must be equal to one of the allowed values" }];
+                                                                                                    validate78.errors = [{ instancePath: instancePath + "/$tags/" + key6.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: schema119.properties.$tags.patternProperties["^(?!\\$requiredTags$|\\$allowUndefinedTags$).*$"].properties.type.enum }, message: "must be equal to one of the allowed values" }];
                                                                                                     return false;
                                                                                                 }
                                                                                                 var valid13 = _errs72 === errors;
@@ -11269,7 +11584,7 @@ function validate78(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                 let data30 = data29.type;
                                                                                                                 const _errs75 = errors;
                                                                                                                 if (!(((data30 === "string") || (data30 === "number")) || (data30 === "integer"))) {
-                                                                                                                    validate78.errors = [{ instancePath: instancePath + "/$tags/" + key6.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: schema117.properties.$tags.patternProperties["^(?!\\$requiredTags$|\\$allowUndefinedTags$).*$"].properties.items.properties.type.enum }, message: "must be equal to one of the allowed values" }];
+                                                                                                                    validate78.errors = [{ instancePath: instancePath + "/$tags/" + key6.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: schema119.properties.$tags.patternProperties["^(?!\\$requiredTags$|\\$allowUndefinedTags$).*$"].properties.items.properties.type.enum }, message: "must be equal to one of the allowed values" }];
                                                                                                                     return false;
                                                                                                                 }
                                                                                                                 var valid14 = _errs75 === errors;
@@ -11281,7 +11596,7 @@ function validate78(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                 var props3 = {};
                                                                                                                 props3.type = true;
                                                                                                                 for (const key8 in data29) {
-                                                                                                                    if (pattern46.test(key8)) {
+                                                                                                                    if (pattern48.test(key8)) {
                                                                                                                         props3[key8] = true;
                                                                                                                     }
                                                                                                                 }
@@ -11307,7 +11622,7 @@ function validate78(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                     let data32 = data31.type;
                                                                                                                     const _errs78 = errors;
                                                                                                                     if (!(((data32 === "string") || (data32 === "number")) || (data32 === "integer"))) {
-                                                                                                                        validate78.errors = [{ instancePath: instancePath + "/$tags/" + key6.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: schema117.properties.$tags.patternProperties["^(?!\\$requiredTags$|\\$allowUndefinedTags$).*$"].properties.contains.properties.type.enum }, message: "must be equal to one of the allowed values" }];
+                                                                                                                        validate78.errors = [{ instancePath: instancePath + "/$tags/" + key6.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: schema119.properties.$tags.patternProperties["^(?!\\$requiredTags$|\\$allowUndefinedTags$).*$"].properties.contains.properties.type.enum }, message: "must be equal to one of the allowed values" }];
                                                                                                                         return false;
                                                                                                                     }
                                                                                                                     var valid16 = _errs78 === errors;
@@ -11319,7 +11634,7 @@ function validate78(data, { instancePath = "", parentData, parentDataProperty, r
                                                                                                                     var props4 = {};
                                                                                                                     props4.type = true;
                                                                                                                     for (const key9 in data31) {
-                                                                                                                        if (pattern46.test(key9)) {
+                                                                                                                        if (pattern48.test(key9)) {
                                                                                                                             props4[key9] = true;
                                                                                                                         }
                                                                                                                     }
@@ -11364,7 +11679,7 @@ function validate78(data, { instancePath = "", parentData, parentDataProperty, r
                                                 if (valid0) {
                                                     var valid18 = true;
                                                     for (const key10 in data) {
-                                                        if (pattern42.test(key10)) {
+                                                        if (pattern44.test(key10)) {
                                                             const _errs79 = errors;
                                                             if (!(wrapper2.validate(data[key10], { instancePath: instancePath + "/" + key10.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data, parentDataProperty: key10, rootData, dynamicAnchors }))) {
                                                                 vErrors = vErrors === null ? wrapper2.validate.errors : vErrors.concat(wrapper2.validate.errors);
@@ -11451,7 +11766,7 @@ function validate77(data, { instancePath = "", parentData, parentDataProperty, r
                                     else {
                                         const _errs9 = errors;
                                         for (const key1 in data2) {
-                                            if (!(pattern38.test(key1))) {
+                                            if (!(pattern40.test(key1))) {
                                                 validate77.errors = [{ instancePath: instancePath + "/uses", schemaPath: "#/properties/uses/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
                                                 return false;
                                                 break;
@@ -11460,7 +11775,7 @@ function validate77(data, { instancePath = "", parentData, parentDataProperty, r
                                         if (_errs9 === errors) {
                                             var valid1 = true;
                                             for (const key2 in data2) {
-                                                if (pattern38.test(key2)) {
+                                                if (pattern40.test(key2)) {
                                                     const _errs10 = errors;
                                                     if (typeof data2[key2] !== "string") {
                                                         validate77.errors = [{ instancePath: instancePath + "/uses/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/uses/patternProperties/%5E%5Ba-zA-Z%5D%5Ba-zA-Z0-9_-%5D*%24/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
@@ -11493,7 +11808,7 @@ function validate77(data, { instancePath = "", parentData, parentDataProperty, r
                                     if (data4 && typeof data4 == "object" && !Array.isArray(data4)) {
                                         var props0 = {};
                                         for (const key3 in data4) {
-                                            if (pattern40.test(key3)) {
+                                            if (pattern42.test(key3)) {
                                                 let data5 = data4[key3];
                                                 const _errs14 = errors;
                                                 if (errors === _errs14) {
@@ -11597,7 +11912,7 @@ function validate77(data, { instancePath = "", parentData, parentDataProperty, r
                                         if (data10 && typeof data10 == "object" && !Array.isArray(data10)) {
                                             var props1 = {};
                                             for (const key5 in data10) {
-                                                if (pattern40.test(key5)) {
+                                                if (pattern42.test(key5)) {
                                                     if (!(validate78(data10[key5], { instancePath: instancePath + "/structure/" + key5.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data10, parentDataProperty: key5, rootData, dynamicAnchors }))) {
                                                         vErrors = vErrors === null ? validate78.errors : vErrors.concat(validate78.errors);
                                                         errors = vErrors.length;
@@ -11631,7 +11946,7 @@ function validate77(data, { instancePath = "", parentData, parentDataProperty, r
 validate77.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const ProtocolRuleSet = validate78;
 export const ProtocolsConfigure = validate81;
-const schema118 = { "$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 schema120 = { "$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 validate81(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 = validate81.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -11693,7 +12008,7 @@ function validate81(data, { instancePath = "", parentData, parentDataProperty, r
                                                 return false;
                                             }
                                             if (!(data2 === "Protocols")) {
-                                                validate81.errors = [{ instancePath: instancePath + "/descriptor/interface", schemaPath: "#/properties/descriptor/properties/interface/enum", keyword: "enum", params: { allowedValues: schema118.properties.descriptor.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
+                                                validate81.errors = [{ instancePath: instancePath + "/descriptor/interface", schemaPath: "#/properties/descriptor/properties/interface/enum", keyword: "enum", params: { allowedValues: schema120.properties.descriptor.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
                                                 return false;
                                             }
                                             var valid1 = _errs6 === errors;
@@ -11710,7 +12025,7 @@ function validate81(data, { instancePath = "", parentData, parentDataProperty, r
                                                     return false;
                                                 }
                                                 if (!(data3 === "Configure")) {
-                                                    validate81.errors = [{ instancePath: instancePath + "/descriptor/method", schemaPath: "#/properties/descriptor/properties/method/enum", keyword: "enum", params: { allowedValues: schema118.properties.descriptor.properties.method.enum }, message: "must be equal to one of the allowed values" }];
+                                                    validate81.errors = [{ instancePath: instancePath + "/descriptor/method", schemaPath: "#/properties/descriptor/properties/method/enum", keyword: "enum", params: { allowedValues: schema120.properties.descriptor.properties.method.enum }, message: "must be equal to one of the allowed values" }];
                                                     return false;
                                                 }
                                                 var valid1 = _errs8 === errors;
@@ -11792,7 +12107,7 @@ function validate81(data, { instancePath = "", parentData, parentDataProperty, r
 } validate81.errors = vErrors; return errors === 0; }
 validate81.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const ProtocolsQuery = validate84;
-const schema120 = { "$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 schema122 = { "$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 validate84(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 = validate84.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -11854,7 +12169,7 @@ function validate84(data, { instancePath = "", parentData, parentDataProperty, r
                                                 return false;
                                             }
                                             if (!(data2 === "Protocols")) {
-                                                validate84.errors = [{ instancePath: instancePath + "/descriptor/interface", schemaPath: "#/properties/descriptor/properties/interface/enum", keyword: "enum", params: { allowedValues: schema120.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: schema122.properties.descriptor.properties.interface.enum }, message: "must be equal to one of the allowed values" }];
                                                 return false;
                                             }
                                             var valid1 = _errs6 === errors;
@@ -11871,7 +12186,7 @@ function validate84(data, { instancePath = "", parentData, parentDataProperty, r
                                                     return false;
                                                 }
                                                 if (!(data3 === "Query")) {
-                                                    validate84.errors = [{ instancePath: instancePath + "/descriptor/method", schemaPath: "#/properties/descriptor/properties/method/enum", keyword: "enum", params: { allowedValues: schema120.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: schema122.properties.descriptor.properties.method.enum }, message: "must be equal to one of the allowed values" }];
                                                     return false;
                                                 }
                                                 var valid1 = _errs8 === errors;
@@ -12008,7 +12323,7 @@ function validate84(data, { instancePath = "", parentData, parentDataProperty, r
 } validate84.errors = vErrors; return errors === 0; }
 validate84.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const RecordsRead = validate86;
-const schema123 = { "$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 schema125 = { "$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 validate86(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 = validate86.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -12070,7 +12385,7 @@ function validate86(data, { instancePath = "", parentData, parentDataProperty, r
                                                 return false;
                                             }
                                             if (!(data2 === "Records")) {
-                                                validate86.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" }];
+                                                validate86.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" }];
                                                 return false;
                                             }
                                             var valid1 = _errs6 === errors;
@@ -12087,7 +12402,7 @@ function validate86(data, { instancePath = "", parentData, parentDataProperty, r
                                                     return false;
                                                 }
                                                 if (!(data3 === "Read")) {
-                                                    validate86.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" }];
+                                                    validate86.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" }];
                                                     return false;
                                                 }
                                                 var valid1 = _errs8 === errors;
@@ -12150,7 +12465,7 @@ function validate86(data, { instancePath = "", parentData, parentDataProperty, r
                                                                     return false;
                                                                 }
                                                                 if (!((((((data7 === "createdAscending") || (data7 === "createdDescending")) || (data7 === "publishedAscending")) || (data7 === "publishedDescending")) || (data7 === "updatedAscending")) || (data7 === "updatedDescending"))) {
-                                                                    validate86.errors = [{ instancePath: instancePath + "/descriptor/dateSort", schemaPath: "#/properties/descriptor/properties/dateSort/enum", keyword: "enum", params: { allowedValues: schema123.properties.descriptor.properties.dateSort.enum }, message: "must be equal to one of the allowed values" }];
+                                                                    validate86.errors = [{ instancePath: instancePath + "/descriptor/dateSort", schemaPath: "#/properties/descriptor/properties/dateSort/enum", keyword: "enum", params: { allowedValues: schema125.properties.descriptor.properties.dateSort.enum }, message: "must be equal to one of the allowed values" }];
                                                                     return false;
                                                                 }
                                                                 var valid1 = _errs16 === errors;
@@ -12189,7 +12504,7 @@ validate86.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": f
 export const RecordsFilter = validate41;
 export const PublicJwk = validate32;
 export const GenericSignaturePayload = validate89;
-const schema125 = { "$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": { "$comment": "Direct Records and Protocols operations invoke a single grant with permissionGrantId. Message.createSignature rejects payloads that also include permissionGrantIds.", "type": "string" }, "permissionGrantIds": { "$comment": "Messages operations invoke grants with permissionGrantIds, including the single-grant case. Message.createSignature rejects payloads that also include permissionGrantId.", "type": "array", "items": { "type": "string" }, "minItems": 1, "uniqueItems": true }, "protocolRole": { "$comment": "Used in the Records interface to authorize role-authorized actions for protocol records", "type": "string" } } };
+const schema127 = { "$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": { "$comment": "Direct Records and Protocols operations invoke a single grant with permissionGrantId. Message.createSignature rejects payloads that also include permissionGrantIds.", "type": "string" }, "permissionGrantIds": { "$comment": "Messages operations invoke grants with permissionGrantIds, including the single-grant case. Message.createSignature rejects payloads that also include permissionGrantId.", "type": "array", "items": { "type": "string" }, "minItems": 1, "uniqueItems": true }, "protocolRole": { "$comment": "Used in the Records interface to authorize role-authorized actions for protocol records", "type": "string" } } };
 function validate89(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 = validate89.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -12328,7 +12643,7 @@ function validate89(data, { instancePath = "", parentData, parentDataProperty, r
 } validate89.errors = vErrors; return errors === 0; }
 validate89.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const RecordsWriteSignaturePayload = validate90;
-const schema126 = { "$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 schema128 = { "$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 validate90(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 = validate90.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {