@enbox/dwn-sdk-js 0.4.2 → 0.4.4

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

@@ -7962,18 +7962,15 @@ 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 schema108 = { "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" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope" }] };
+const schema94 = { "$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"] } }] };
 const schema100 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Protocols" }, "method": { "const": "Configure" }, "protocol": { "type": "string" } } };
 const schema101 = { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Protocols" }, "method": { "const": "Query" }, "protocol": { "type": "string" } } };
 const schema102 = { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Read" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } } };
 const schema103 = { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Delete" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } } };
 const schema104 = { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Write" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } } };
-const schema105 = { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Query" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } } };
-const schema106 = { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Subscribe" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } } };
-const schema107 = { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Count" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } } };
 function validate70(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate70.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -9043,816 +9040,585 @@ else {
                             props0 = true;
                         }
                     }
-                    const _errs75 = errors;
-                    const _errs76 = errors;
-                    if (errors === _errs76) {
-                        if (data && typeof data == "object" && !Array.isArray(data)) {
-                            let missing10;
-                            if ((((data.interface === undefined) && (missing10 = "interface")) || ((data.method === undefined) && (missing10 = "method"))) || ((data.protocol === undefined) && (missing10 = "protocol"))) {
-                                const err59 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/required", keyword: "required", params: { missingProperty: missing10 }, message: "must have required property '" + missing10 + "'" };
-                                if (vErrors === null) {
-                                    vErrors = [err59];
+                }
+            }
+        }
+    }
+} if (!valid0) {
+    const err59 = { instancePath, schemaPath: "#/oneOf", keyword: "oneOf", params: { passingSchemas: passing0 }, message: "must match exactly one schema in oneOf" };
+    if (vErrors === null) {
+        vErrors = [err59];
+    }
+    else {
+        vErrors.push(err59);
+    }
+    errors++;
+    validate70.errors = vErrors;
+    return false;
+}
+else {
+    errors = _errs0;
+    if (vErrors !== null) {
+        if (_errs0) {
+            vErrors.length = _errs0;
+        }
+        else {
+            vErrors = null;
+        }
+    }
+} validate70.errors = vErrors; evaluated0.props = props0; return errors === 0; }
+validate70.evaluated = { "dynamicProps": true, "dynamicItems": false };
+function validate68(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/permission-grant-data.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate68.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if (((data.dateExpires === undefined) && (missing0 = "dateExpires")) || ((data.scope === undefined) && (missing0 = "scope"))) {
+            validate68.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            const _errs1 = errors;
+            for (const key0 in data) {
+                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;
+                }
+            }
+            if (_errs1 === errors) {
+                if (data.description !== undefined) {
+                    const _errs2 = errors;
+                    if (typeof data.description !== "string") {
+                        validate68.errors = [{ instancePath: instancePath + "/description", schemaPath: "#/properties/description/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                        return false;
+                    }
+                    var valid0 = _errs2 === errors;
+                }
+                else {
+                    var valid0 = true;
+                }
+                if (valid0) {
+                    if (data.dateExpires !== undefined) {
+                        let data1 = data.dateExpires;
+                        const _errs4 = errors;
+                        const _errs5 = errors;
+                        if (errors === _errs5) {
+                            if (typeof data1 === "string") {
+                                if (!pattern14.test(data1)) {
+                                    validate68.errors = [{ instancePath: instancePath + "/dateExpires", 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 {
-                                    vErrors.push(err59);
+                            }
+                            else {
+                                validate68.errors = [{ instancePath: instancePath + "/dateExpires", 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 valid0 = _errs4 === errors;
+                    }
+                    else {
+                        var valid0 = true;
+                    }
+                    if (valid0) {
+                        if (data.requestId !== undefined) {
+                            const _errs7 = errors;
+                            if (typeof data.requestId !== "string") {
+                                validate68.errors = [{ instancePath: instancePath + "/requestId", schemaPath: "#/properties/requestId/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                return false;
+                            }
+                            var valid0 = _errs7 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                        if (valid0) {
+                            if (data.delegated !== undefined) {
+                                const _errs9 = errors;
+                                if (typeof data.delegated !== "boolean") {
+                                    validate68.errors = [{ instancePath: instancePath + "/delegated", schemaPath: "#/properties/delegated/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                    return false;
                                 }
-                                errors++;
+                                var valid0 = _errs9 === errors;
                             }
                             else {
-                                const _errs78 = errors;
-                                for (const key6 in data) {
-                                    if (!(((((key6 === "interface") || (key6 === "method")) || (key6 === "protocol")) || (key6 === "contextId")) || (key6 === "protocolPath"))) {
-                                        const err60 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key6 }, message: "must NOT have additional properties" };
-                                        if (vErrors === null) {
-                                            vErrors = [err60];
-                                        }
-                                        else {
-                                            vErrors.push(err60);
-                                        }
-                                        errors++;
-                                        break;
+                                var valid0 = true;
+                            }
+                            if (valid0) {
+                                if (data.scope !== undefined) {
+                                    const _errs11 = errors;
+                                    if (!(validate70(data.scope, { instancePath: instancePath + "/scope", parentData: data, parentDataProperty: "scope", rootData, dynamicAnchors }))) {
+                                        vErrors = vErrors === null ? validate70.errors : vErrors.concat(validate70.errors);
+                                        errors = vErrors.length;
                                     }
+                                    var valid0 = _errs11 === errors;
                                 }
-                                if (_errs78 === errors) {
-                                    if (data.interface !== undefined) {
-                                        const _errs79 = errors;
-                                        if ("Records" !== data.interface) {
-                                            const err61 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Records" }, message: "must be equal to constant" };
-                                            if (vErrors === null) {
-                                                vErrors = [err61];
+                                else {
+                                    var valid0 = true;
+                                }
+                                if (valid0) {
+                                    if (data.conditions !== undefined) {
+                                        let data5 = data.conditions;
+                                        const _errs12 = errors;
+                                        const _errs13 = errors;
+                                        if (errors === _errs13) {
+                                            if (data5 && typeof data5 == "object" && !Array.isArray(data5)) {
+                                                const _errs15 = errors;
+                                                for (const key1 in data5) {
+                                                    if (!(key1 === "publication")) {
+                                                        validate68.errors = [{ instancePath: instancePath + "/conditions", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                        return false;
+                                                        break;
+                                                    }
+                                                }
+                                                if (_errs15 === errors) {
+                                                    if (data5.publication !== undefined) {
+                                                        let data6 = data5.publication;
+                                                        if (typeof data6 !== "string") {
+                                                            validate68.errors = [{ instancePath: instancePath + "/conditions/publication", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions/properties/publication/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                            return false;
+                                                        }
+                                                        if (!((data6 === "Required") || (data6 === "Prohibited"))) {
+                                                            validate68.errors = [{ instancePath: instancePath + "/conditions/publication", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions/properties/publication/enum", keyword: "enum", params: { allowedValues: schema105.properties.publication.enum }, message: "must be equal to one of the allowed values" }];
+                                                            return false;
+                                                        }
+                                                    }
+                                                }
                                             }
                                             else {
-                                                vErrors.push(err61);
+                                                validate68.errors = [{ instancePath: instancePath + "/conditions", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                return false;
                                             }
-                                            errors++;
                                         }
-                                        var valid18 = _errs79 === errors;
+                                        var valid0 = _errs12 === errors;
                                     }
                                     else {
-                                        var valid18 = true;
+                                        var valid0 = true;
                                     }
-                                    if (valid18) {
-                                        if (data.method !== undefined) {
-                                            const _errs80 = errors;
-                                            if ("Query" !== data.method) {
-                                                const err62 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/properties/method/const", keyword: "const", params: { allowedValue: "Query" }, message: "must be equal to constant" };
-                                                if (vErrors === null) {
-                                                    vErrors = [err62];
-                                                }
-                                                else {
-                                                    vErrors.push(err62);
-                                                }
-                                                errors++;
-                                            }
-                                            var valid18 = _errs80 === errors;
-                                        }
-                                        else {
-                                            var valid18 = true;
-                                        }
-                                        if (valid18) {
-                                            if (data.protocol !== undefined) {
-                                                const _errs81 = errors;
-                                                if (typeof data.protocol !== "string") {
-                                                    const err63 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                    if (vErrors === null) {
-                                                        vErrors = [err63];
+                                    if (valid0) {
+                                        if (data.delegateKeyDelivery !== undefined) {
+                                            let data7 = data.delegateKeyDelivery;
+                                            const _errs18 = errors;
+                                            if (errors === _errs18) {
+                                                if (data7 && typeof data7 == "object" && !Array.isArray(data7)) {
+                                                    let missing1;
+                                                    if (((data7.rootKeyId === undefined) && (missing1 = "rootKeyId")) || ((data7.publicKeyJwk === undefined) && (missing1 = "publicKeyJwk"))) {
+                                                        validate68.errors = [{ instancePath: instancePath + "/delegateKeyDelivery", schemaPath: "#/properties/delegateKeyDelivery/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                                                        return false;
                                                     }
                                                     else {
-                                                        vErrors.push(err63);
-                                                    }
-                                                    errors++;
-                                                }
-                                                var valid18 = _errs81 === errors;
-                                            }
-                                            else {
-                                                var valid18 = true;
-                                            }
-                                            if (valid18) {
-                                                if (data.contextId !== undefined) {
-                                                    let data29 = data.contextId;
-                                                    const _errs83 = errors;
-                                                    if (errors === _errs83) {
-                                                        if (typeof data29 === "string") {
-                                                            if (func1(data29) > 600) {
-                                                                const err64 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/properties/contextId/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                                if (vErrors === null) {
-                                                                    vErrors = [err64];
-                                                                }
-                                                                else {
-                                                                    vErrors.push(err64);
-                                                                }
-                                                                errors++;
+                                                        const _errs20 = errors;
+                                                        for (const key2 in data7) {
+                                                            if (!((key2 === "rootKeyId") || (key2 === "publicKeyJwk"))) {
+                                                                validate68.errors = [{ instancePath: instancePath + "/delegateKeyDelivery", schemaPath: "#/properties/delegateKeyDelivery/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" }];
+                                                                return false;
+                                                                break;
                                                             }
                                                         }
-                                                        else {
-                                                            const err65 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/properties/contextId/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                            if (vErrors === null) {
-                                                                vErrors = [err65];
+                                                        if (_errs20 === errors) {
+                                                            if (data7.rootKeyId !== undefined) {
+                                                                const _errs21 = errors;
+                                                                if (typeof data7.rootKeyId !== "string") {
+                                                                    validate68.errors = [{ instancePath: instancePath + "/delegateKeyDelivery/rootKeyId", schemaPath: "#/properties/delegateKeyDelivery/properties/rootKeyId/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                    return false;
+                                                                }
+                                                                var valid4 = _errs21 === errors;
                                                             }
                                                             else {
-                                                                vErrors.push(err65);
+                                                                var valid4 = true;
                                                             }
-                                                            errors++;
-                                                        }
-                                                    }
-                                                    var valid18 = _errs83 === errors;
-                                                }
-                                                else {
-                                                    var valid18 = true;
-                                                }
-                                                if (valid18) {
-                                                    if (data.protocolPath !== undefined) {
-                                                        let data30 = data.protocolPath;
-                                                        const _errs85 = errors;
-                                                        if (errors === _errs85) {
-                                                            if (typeof data30 === "string") {
-                                                                if (func1(data30) > 600) {
-                                                                    const err66 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/properties/protocolPath/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                                    if (vErrors === null) {
-                                                                        vErrors = [err66];
-                                                                    }
-                                                                    else {
-                                                                        vErrors.push(err66);
+                                                            if (valid4) {
+                                                                if (data7.publicKeyJwk !== undefined) {
+                                                                    let data9 = data7.publicKeyJwk;
+                                                                    const _errs23 = errors;
+                                                                    if (!(data9 && typeof data9 == "object" && !Array.isArray(data9))) {
+                                                                        validate68.errors = [{ instancePath: instancePath + "/delegateKeyDelivery/publicKeyJwk", schemaPath: "#/properties/delegateKeyDelivery/properties/publicKeyJwk/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                        return false;
                                                                     }
-                                                                    errors++;
-                                                                }
-                                                            }
-                                                            else {
-                                                                const err67 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/properties/protocolPath/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                                if (vErrors === null) {
-                                                                    vErrors = [err67];
+                                                                    var valid4 = _errs23 === errors;
                                                                 }
                                                                 else {
-                                                                    vErrors.push(err67);
+                                                                    var valid4 = true;
                                                                 }
-                                                                errors++;
                                                             }
                                                         }
-                                                        var valid18 = _errs85 === errors;
-                                                    }
-                                                    else {
-                                                        var valid18 = true;
                                                     }
                                                 }
+                                                else {
+                                                    validate68.errors = [{ instancePath: instancePath + "/delegateKeyDelivery", schemaPath: "#/properties/delegateKeyDelivery/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                    return false;
+                                                }
                                             }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        else {
-                            const err68 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-                            if (vErrors === null) {
-                                vErrors = [err68];
-                            }
-                            else {
-                                vErrors.push(err68);
-                            }
-                            errors++;
-                        }
-                    }
-                    var _valid0 = _errs75 === errors;
-                    if (_valid0 && valid0) {
-                        valid0 = false;
-                        passing0 = [passing0, 6];
-                    }
-                    else {
-                        if (_valid0) {
-                            valid0 = true;
-                            passing0 = 6;
-                            if (props0 !== true) {
-                                props0 = true;
-                            }
-                        }
-                        const _errs87 = errors;
-                        const _errs88 = errors;
-                        if (errors === _errs88) {
-                            if (data && typeof data == "object" && !Array.isArray(data)) {
-                                let missing11;
-                                if ((((data.interface === undefined) && (missing11 = "interface")) || ((data.method === undefined) && (missing11 = "method"))) || ((data.protocol === undefined) && (missing11 = "protocol"))) {
-                                    const err69 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/required", keyword: "required", params: { missingProperty: missing11 }, message: "must have required property '" + missing11 + "'" };
-                                    if (vErrors === null) {
-                                        vErrors = [err69];
-                                    }
-                                    else {
-                                        vErrors.push(err69);
-                                    }
-                                    errors++;
-                                }
-                                else {
-                                    const _errs90 = errors;
-                                    for (const key7 in data) {
-                                        if (!(((((key7 === "interface") || (key7 === "method")) || (key7 === "protocol")) || (key7 === "contextId")) || (key7 === "protocolPath"))) {
-                                            const err70 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key7 }, message: "must NOT have additional properties" };
-                                            if (vErrors === null) {
-                                                vErrors = [err70];
-                                            }
-                                            else {
-                                                vErrors.push(err70);
-                                            }
-                                            errors++;
-                                            break;
-                                        }
-                                    }
-                                    if (_errs90 === errors) {
-                                        if (data.interface !== undefined) {
-                                            const _errs91 = errors;
-                                            if ("Records" !== data.interface) {
-                                                const err71 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Records" }, message: "must be equal to constant" };
-                                                if (vErrors === null) {
-                                                    vErrors = [err71];
-                                                }
-                                                else {
-                                                    vErrors.push(err71);
-                                                }
-                                                errors++;
-                                            }
-                                            var valid20 = _errs91 === errors;
+                                            var valid0 = _errs18 === errors;
                                         }
                                         else {
-                                            var valid20 = true;
+                                            var valid0 = true;
                                         }
-                                        if (valid20) {
-                                            if (data.method !== undefined) {
-                                                const _errs92 = errors;
-                                                if ("Subscribe" !== data.method) {
-                                                    const err72 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/properties/method/const", keyword: "const", params: { allowedValue: "Subscribe" }, message: "must be equal to constant" };
-                                                    if (vErrors === null) {
-                                                        vErrors = [err72];
-                                                    }
-                                                    else {
-                                                        vErrors.push(err72);
-                                                    }
-                                                    errors++;
-                                                }
-                                                var valid20 = _errs92 === errors;
-                                            }
-                                            else {
-                                                var valid20 = true;
-                                            }
-                                            if (valid20) {
-                                                if (data.protocol !== undefined) {
-                                                    const _errs93 = errors;
-                                                    if (typeof data.protocol !== "string") {
-                                                        const err73 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                        if (vErrors === null) {
-                                                            vErrors = [err73];
+                                        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 {
-                                                            vErrors.push(err73);
-                                                        }
-                                                        errors++;
-                                                    }
-                                                    var valid20 = _errs93 === errors;
-                                                }
-                                                else {
-                                                    var valid20 = true;
-                                                }
-                                                if (valid20) {
-                                                    if (data.contextId !== undefined) {
-                                                        let data34 = data.contextId;
-                                                        const _errs95 = errors;
-                                                        if (errors === _errs95) {
-                                                            if (typeof data34 === "string") {
-                                                                if (func1(data34) > 600) {
-                                                                    const err74 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/properties/contextId/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                                    if (vErrors === null) {
-                                                                        vErrors = [err74];
-                                                                    }
-                                                                    else {
-                                                                        vErrors.push(err74);
-                                                                    }
-                                                                    errors++;
-                                                                }
-                                                            }
-                                                            else {
-                                                                const err75 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/properties/contextId/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                                if (vErrors === null) {
-                                                                    vErrors = [err75];
-                                                                }
-                                                                else {
-                                                                    vErrors.push(err75);
+                                                            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;
                                                                 }
-                                                                errors++;
                                                             }
-                                                        }
-                                                        var valid20 = _errs95 === errors;
-                                                    }
-                                                    else {
-                                                        var valid20 = true;
-                                                    }
-                                                    if (valid20) {
-                                                        if (data.protocolPath !== undefined) {
-                                                            let data35 = data.protocolPath;
-                                                            const _errs97 = errors;
-                                                            if (errors === _errs97) {
-                                                                if (typeof data35 === "string") {
-                                                                    if (func1(data35) > 600) {
-                                                                        const err76 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/properties/protocolPath/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                                        if (vErrors === null) {
-                                                                            vErrors = [err76];
+                                                            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 {
-                                                                            vErrors.push(err76);
+                                                                            validate68.errors = [{ instancePath: instancePath + "/connectSession/id", schemaPath: "#/properties/connectSession/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                            return false;
                                                                         }
-                                                                        errors++;
                                                                     }
+                                                                    var valid5 = _errs28 === errors;
                                                                 }
                                                                 else {
-                                                                    const err77 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/properties/protocolPath/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                                    if (vErrors === null) {
-                                                                        vErrors = [err77];
+                                                                    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 {
-                                                                        vErrors.push(err77);
+                                                                        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;
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                        }
                                                                     }
-                                                                    errors++;
                                                                 }
                                                             }
-                                                            var valid20 = _errs97 === errors;
-                                                        }
-                                                        else {
-                                                            var valid20 = 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;
                                             }
                                         }
                                     }
                                 }
                             }
-                            else {
-                                const err78 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-                                if (vErrors === null) {
-                                    vErrors = [err78];
-                                }
-                                else {
-                                    vErrors.push(err78);
-                                }
-                                errors++;
-                            }
-                        }
-                        var _valid0 = _errs87 === errors;
-                        if (_valid0 && valid0) {
-                            valid0 = false;
-                            passing0 = [passing0, 7];
-                        }
-                        else {
-                            if (_valid0) {
-                                valid0 = true;
-                                passing0 = 7;
-                                if (props0 !== true) {
-                                    props0 = true;
-                                }
-                            }
-                            const _errs99 = errors;
-                            const _errs100 = errors;
-                            if (errors === _errs100) {
-                                if (data && typeof data == "object" && !Array.isArray(data)) {
-                                    let missing12;
-                                    if ((((data.interface === undefined) && (missing12 = "interface")) || ((data.method === undefined) && (missing12 = "method"))) || ((data.protocol === undefined) && (missing12 = "protocol"))) {
-                                        const err79 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/required", keyword: "required", params: { missingProperty: missing12 }, message: "must have required property '" + missing12 + "'" };
-                                        if (vErrors === null) {
-                                            vErrors = [err79];
-                                        }
-                                        else {
-                                            vErrors.push(err79);
-                                        }
-                                        errors++;
-                                    }
-                                    else {
-                                        const _errs102 = errors;
-                                        for (const key8 in data) {
-                                            if (!(((((key8 === "interface") || (key8 === "method")) || (key8 === "protocol")) || (key8 === "contextId")) || (key8 === "protocolPath"))) {
-                                                const err80 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key8 }, message: "must NOT have additional properties" };
-                                                if (vErrors === null) {
-                                                    vErrors = [err80];
-                                                }
-                                                else {
-                                                    vErrors.push(err80);
-                                                }
-                                                errors++;
-                                                break;
-                                            }
-                                        }
-                                        if (_errs102 === errors) {
-                                            if (data.interface !== undefined) {
-                                                const _errs103 = errors;
-                                                if ("Records" !== data.interface) {
-                                                    const err81 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Records" }, message: "must be equal to constant" };
-                                                    if (vErrors === null) {
-                                                        vErrors = [err81];
-                                                    }
-                                                    else {
-                                                        vErrors.push(err81);
-                                                    }
-                                                    errors++;
-                                                }
-                                                var valid22 = _errs103 === errors;
-                                            }
-                                            else {
-                                                var valid22 = true;
-                                            }
-                                            if (valid22) {
-                                                if (data.method !== undefined) {
-                                                    const _errs104 = errors;
-                                                    if ("Count" !== data.method) {
-                                                        const err82 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/properties/method/const", keyword: "const", params: { allowedValue: "Count" }, message: "must be equal to constant" };
-                                                        if (vErrors === null) {
-                                                            vErrors = [err82];
-                                                        }
-                                                        else {
-                                                            vErrors.push(err82);
-                                                        }
-                                                        errors++;
-                                                    }
-                                                    var valid22 = _errs104 === errors;
-                                                }
-                                                else {
-                                                    var valid22 = true;
-                                                }
-                                                if (valid22) {
-                                                    if (data.protocol !== undefined) {
-                                                        const _errs105 = errors;
-                                                        if (typeof data.protocol !== "string") {
-                                                            const err83 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                            if (vErrors === null) {
-                                                                vErrors = [err83];
-                                                            }
-                                                            else {
-                                                                vErrors.push(err83);
-                                                            }
-                                                            errors++;
-                                                        }
-                                                        var valid22 = _errs105 === errors;
-                                                    }
-                                                    else {
-                                                        var valid22 = true;
-                                                    }
-                                                    if (valid22) {
-                                                        if (data.contextId !== undefined) {
-                                                            let data39 = data.contextId;
-                                                            const _errs107 = errors;
-                                                            if (errors === _errs107) {
-                                                                if (typeof data39 === "string") {
-                                                                    if (func1(data39) > 600) {
-                                                                        const err84 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/properties/contextId/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                                        if (vErrors === null) {
-                                                                            vErrors = [err84];
-                                                                        }
-                                                                        else {
-                                                                            vErrors.push(err84);
-                                                                        }
-                                                                        errors++;
-                                                                    }
-                                                                }
-                                                                else {
-                                                                    const err85 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/properties/contextId/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                                    if (vErrors === null) {
-                                                                        vErrors = [err85];
-                                                                    }
-                                                                    else {
-                                                                        vErrors.push(err85);
-                                                                    }
-                                                                    errors++;
-                                                                }
-                                                            }
-                                                            var valid22 = _errs107 === errors;
-                                                        }
-                                                        else {
-                                                            var valid22 = true;
-                                                        }
-                                                        if (valid22) {
-                                                            if (data.protocolPath !== undefined) {
-                                                                let data40 = data.protocolPath;
-                                                                const _errs109 = errors;
-                                                                if (errors === _errs109) {
-                                                                    if (typeof data40 === "string") {
-                                                                        if (func1(data40) > 600) {
-                                                                            const err86 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/properties/protocolPath/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                                            if (vErrors === null) {
-                                                                                vErrors = [err86];
-                                                                            }
-                                                                            else {
-                                                                                vErrors.push(err86);
-                                                                            }
-                                                                            errors++;
-                                                                        }
-                                                                    }
-                                                                    else {
-                                                                        const err87 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/properties/protocolPath/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                                        if (vErrors === null) {
-                                                                            vErrors = [err87];
-                                                                        }
-                                                                        else {
-                                                                            vErrors.push(err87);
-                                                                        }
-                                                                        errors++;
-                                                                    }
-                                                                }
-                                                                var valid22 = _errs109 === errors;
-                                                            }
-                                                            else {
-                                                                var valid22 = true;
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                                else {
-                                    const err88 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-                                    if (vErrors === null) {
-                                        vErrors = [err88];
-                                    }
-                                    else {
-                                        vErrors.push(err88);
-                                    }
-                                    errors++;
-                                }
-                            }
-                            var _valid0 = _errs99 === errors;
-                            if (_valid0 && valid0) {
-                                valid0 = false;
-                                passing0 = [passing0, 8];
-                            }
-                            else {
-                                if (_valid0) {
-                                    valid0 = true;
-                                    passing0 = 8;
-                                    if (props0 !== true) {
-                                        props0 = true;
-                                    }
-                                }
-                            }
                         }
                     }
                 }
             }
         }
     }
-} if (!valid0) {
-    const err89 = { instancePath, schemaPath: "#/oneOf", keyword: "oneOf", params: { passingSchemas: passing0 }, message: "must match exactly one schema in oneOf" };
+    else {
+        validate68.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate68.errors = vErrors; return errors === 0; }
+validate68.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+export const PermissionRequestData = validate73;
+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) {
+    evaluated0.items = undefined;
+} const _errs0 = errors; let valid0 = false; let passing0 = null; const _errs1 = errors; const _errs2 = errors; const _errs4 = errors; const _errs5 = errors; const _errs6 = errors; if (data && typeof data == "object" && !Array.isArray(data)) {
+    let missing0;
+    if (((data.contextId === undefined) && (missing0 = "contextId")) || ((data.protocolPath === undefined) && (missing0 = "protocolPath"))) {
+        const err0 = {};
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+} var valid3 = _errs6 === errors; if (valid3) {
+    const err1 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/allOf/0/not", keyword: "not", params: {}, message: "must NOT be valid" };
     if (vErrors === null) {
-        vErrors = [err89];
+        vErrors = [err1];
     }
     else {
-        vErrors.push(err89);
+        vErrors.push(err1);
     }
     errors++;
-    validate70.errors = vErrors;
-    return false;
 }
 else {
-    errors = _errs0;
+    errors = _errs5;
     if (vErrors !== null) {
-        if (_errs0) {
-            vErrors.length = _errs0;
-        }
-        else {
-            vErrors = null;
-        }
-    }
-} validate70.errors = vErrors; evaluated0.props = props0; return errors === 0; }
-validate70.evaluated = { "dynamicProps": true, "dynamicItems": false };
-function validate68(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/permission-grant-data.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate68.evaluated; if (evaluated0.dynamicProps) {
-    evaluated0.props = undefined;
-} if (evaluated0.dynamicItems) {
-    evaluated0.items = undefined;
-} if (errors === 0) {
-    if (data && typeof data == "object" && !Array.isArray(data)) {
-        let missing0;
-        if (((data.dateExpires === undefined) && (missing0 = "dateExpires")) || ((data.scope === undefined) && (missing0 = "scope"))) {
-            validate68.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
-            return false;
-        }
-        else {
-            const _errs1 = errors;
-            for (const key0 in data) {
-                if (!(((((((key0 === "description") || (key0 === "dateExpires")) || (key0 === "requestId")) || (key0 === "delegated")) || (key0 === "scope")) || (key0 === "conditions")) || (key0 === "delegateKeyDelivery"))) {
-                    validate68.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
-                    return false;
-                    break;
-                }
-            }
-            if (_errs1 === errors) {
-                if (data.description !== undefined) {
-                    const _errs2 = errors;
-                    if (typeof data.description !== "string") {
-                        validate68.errors = [{ instancePath: instancePath + "/description", schemaPath: "#/properties/description/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
-                        return false;
-                    }
-                    var valid0 = _errs2 === errors;
-                }
-                else {
-                    var valid0 = true;
-                }
-                if (valid0) {
-                    if (data.dateExpires !== undefined) {
-                        let data1 = data.dateExpires;
-                        const _errs4 = errors;
-                        const _errs5 = errors;
-                        if (errors === _errs5) {
-                            if (typeof data1 === "string") {
-                                if (!pattern14.test(data1)) {
-                                    validate68.errors = [{ instancePath: instancePath + "/dateExpires", 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 + "/dateExpires", 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 valid0 = _errs4 === errors;
-                    }
-                    else {
-                        var valid0 = true;
-                    }
-                    if (valid0) {
-                        if (data.requestId !== undefined) {
-                            const _errs7 = errors;
-                            if (typeof data.requestId !== "string") {
-                                validate68.errors = [{ instancePath: instancePath + "/requestId", schemaPath: "#/properties/requestId/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
-                                return false;
-                            }
-                            var valid0 = _errs7 === errors;
-                        }
-                        else {
-                            var valid0 = true;
-                        }
-                        if (valid0) {
-                            if (data.delegated !== undefined) {
-                                const _errs9 = errors;
-                                if (typeof data.delegated !== "boolean") {
-                                    validate68.errors = [{ instancePath: instancePath + "/delegated", schemaPath: "#/properties/delegated/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
-                                    return false;
-                                }
-                                var valid0 = _errs9 === errors;
-                            }
-                            else {
-                                var valid0 = true;
-                            }
-                            if (valid0) {
-                                if (data.scope !== undefined) {
-                                    const _errs11 = errors;
-                                    if (!(validate70(data.scope, { instancePath: instancePath + "/scope", parentData: data, parentDataProperty: "scope", rootData, dynamicAnchors }))) {
-                                        vErrors = vErrors === null ? validate70.errors : vErrors.concat(validate70.errors);
-                                        errors = vErrors.length;
-                                    }
-                                    var valid0 = _errs11 === errors;
-                                }
-                                else {
-                                    var valid0 = true;
-                                }
-                                if (valid0) {
-                                    if (data.conditions !== undefined) {
-                                        let data5 = data.conditions;
-                                        const _errs12 = errors;
-                                        const _errs13 = errors;
-                                        if (errors === _errs13) {
-                                            if (data5 && typeof data5 == "object" && !Array.isArray(data5)) {
-                                                const _errs15 = errors;
-                                                for (const key1 in data5) {
-                                                    if (!(key1 === "publication")) {
-                                                        validate68.errors = [{ instancePath: instancePath + "/conditions", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
-                                                        return false;
-                                                        break;
-                                                    }
-                                                }
-                                                if (_errs15 === errors) {
-                                                    if (data5.publication !== undefined) {
-                                                        let data6 = data5.publication;
-                                                        if (typeof data6 !== "string") {
-                                                            validate68.errors = [{ instancePath: instancePath + "/conditions/publication", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions/properties/publication/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
-                                                            return false;
-                                                        }
-                                                        if (!((data6 === "Required") || (data6 === "Prohibited"))) {
-                                                            validate68.errors = [{ instancePath: instancePath + "/conditions/publication", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions/properties/publication/enum", keyword: "enum", params: { allowedValues: schema108.properties.publication.enum }, message: "must be equal to one of the allowed values" }];
-                                                            return false;
-                                                        }
-                                                    }
-                                                }
-                                            }
-                                            else {
-                                                validate68.errors = [{ instancePath: instancePath + "/conditions", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
-                                                return false;
-                                            }
-                                        }
-                                        var valid0 = _errs12 === errors;
-                                    }
-                                    else {
-                                        var valid0 = true;
-                                    }
-                                    if (valid0) {
-                                        if (data.delegateKeyDelivery !== undefined) {
-                                            let data7 = data.delegateKeyDelivery;
-                                            const _errs18 = errors;
-                                            if (errors === _errs18) {
-                                                if (data7 && typeof data7 == "object" && !Array.isArray(data7)) {
-                                                    let missing1;
-                                                    if (((data7.rootKeyId === undefined) && (missing1 = "rootKeyId")) || ((data7.publicKeyJwk === undefined) && (missing1 = "publicKeyJwk"))) {
-                                                        validate68.errors = [{ instancePath: instancePath + "/delegateKeyDelivery", schemaPath: "#/properties/delegateKeyDelivery/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
-                                                        return false;
-                                                    }
-                                                    else {
-                                                        const _errs20 = errors;
-                                                        for (const key2 in data7) {
-                                                            if (!((key2 === "rootKeyId") || (key2 === "publicKeyJwk"))) {
-                                                                validate68.errors = [{ instancePath: instancePath + "/delegateKeyDelivery", schemaPath: "#/properties/delegateKeyDelivery/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" }];
-                                                                return false;
-                                                                break;
-                                                            }
-                                                        }
-                                                        if (_errs20 === errors) {
-                                                            if (data7.rootKeyId !== undefined) {
-                                                                const _errs21 = errors;
-                                                                if (typeof data7.rootKeyId !== "string") {
-                                                                    validate68.errors = [{ instancePath: instancePath + "/delegateKeyDelivery/rootKeyId", schemaPath: "#/properties/delegateKeyDelivery/properties/rootKeyId/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
-                                                                    return false;
-                                                                }
-                                                                var valid4 = _errs21 === errors;
-                                                            }
-                                                            else {
-                                                                var valid4 = true;
-                                                            }
-                                                            if (valid4) {
-                                                                if (data7.publicKeyJwk !== undefined) {
-                                                                    let data9 = data7.publicKeyJwk;
-                                                                    const _errs23 = errors;
-                                                                    if (!(data9 && typeof data9 == "object" && !Array.isArray(data9))) {
-                                                                        validate68.errors = [{ instancePath: instancePath + "/delegateKeyDelivery/publicKeyJwk", schemaPath: "#/properties/delegateKeyDelivery/properties/publicKeyJwk/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
-                                                                        return false;
-                                                                    }
-                                                                    var valid4 = _errs23 === errors;
-                                                                }
-                                                                else {
-                                                                    var valid4 = true;
-                                                                }
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                                else {
-                                                    validate68.errors = [{ instancePath: instancePath + "/delegateKeyDelivery", schemaPath: "#/properties/delegateKeyDelivery/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
-                                                    return false;
-                                                }
-                                            }
-                                            var valid0 = _errs18 === errors;
-                                        }
-                                        else {
-                                            var valid0 = true;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    else {
-        validate68.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
-        return false;
-    }
-} validate68.errors = vErrors; return errors === 0; }
-validate68.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
-export const PermissionRequestData = validate73;
-const schema109 = { "$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) {
-    evaluated0.items = undefined;
-} const _errs0 = errors; let valid0 = false; let passing0 = null; const _errs1 = errors; const _errs2 = errors; const _errs4 = errors; const _errs5 = errors; const _errs6 = errors; if (data && typeof data == "object" && !Array.isArray(data)) {
-    let missing0;
-    if (((data.contextId === undefined) && (missing0 = "contextId")) || ((data.protocolPath === undefined) && (missing0 = "protocolPath"))) {
-        const err0 = {};
-        if (vErrors === null) {
-            vErrors = [err0];
-        }
-        else {
-            vErrors.push(err0);
-        }
-        errors++;
-    }
-} var valid3 = _errs6 === errors; if (valid3) {
-    const err1 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/allOf/0/not", keyword: "not", params: {}, message: "must NOT be valid" };
-    if (vErrors === null) {
-        vErrors = [err1];
-    }
-    else {
-        vErrors.push(err1);
-    }
-    errors++;
-}
-else {
-    errors = _errs5;
-    if (vErrors !== null) {
-        if (_errs5) {
-            vErrors.length = _errs5;
+        if (_errs5) {
+            vErrors.length = _errs5;
         }
         else {
             vErrors = null;
@@ -9860,1594 +9626,1048 @@ else {
     }
 } var valid2 = _errs4 === errors; if (valid2) {
     const _errs7 = errors;
-    const _errs8 = errors;
-    let valid4 = true;
-    const _errs9 = errors;
-    const _errs10 = errors;
-    let valid5 = false;
-    const _errs11 = errors;
-    if (data && typeof data == "object" && !Array.isArray(data)) {
-        let missing1;
-        if ((data.contextId === undefined) && (missing1 = "contextId")) {
-            const err2 = {};
-            if (vErrors === null) {
-                vErrors = [err2];
-            }
-            else {
-                vErrors.push(err2);
-            }
-            errors++;
-        }
-    }
-    var _valid2 = _errs11 === errors;
-    valid5 = valid5 || _valid2;
-    const _errs12 = errors;
-    if (data && typeof data == "object" && !Array.isArray(data)) {
-        let missing2;
-        if ((data.protocolPath === undefined) && (missing2 = "protocolPath")) {
-            const err3 = {};
-            if (vErrors === null) {
-                vErrors = [err3];
-            }
-            else {
-                vErrors.push(err3);
-            }
-            errors++;
-        }
-    }
-    var _valid2 = _errs12 === errors;
-    valid5 = valid5 || _valid2;
-    if (!valid5) {
-        const err4 = {};
-        if (vErrors === null) {
-            vErrors = [err4];
-        }
-        else {
-            vErrors.push(err4);
-        }
-        errors++;
-    }
-    else {
-        errors = _errs10;
-        if (vErrors !== null) {
-            if (_errs10) {
-                vErrors.length = _errs10;
-            }
-            else {
-                vErrors = null;
-            }
-        }
-    }
-    var _valid1 = _errs9 === errors;
-    errors = _errs8;
-    if (vErrors !== null) {
-        if (_errs8) {
-            vErrors.length = _errs8;
-        }
-        else {
-            vErrors = null;
-        }
-    }
-    if (_valid1) {
-        const _errs13 = errors;
-        if (data && typeof data == "object" && !Array.isArray(data)) {
-            let missing3;
-            if ((data.protocol === undefined) && (missing3 = "protocol")) {
-                const err5 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/allOf/1/then/required", keyword: "required", params: { missingProperty: missing3 }, message: "must have required property '" + missing3 + "'" };
-                if (vErrors === null) {
-                    vErrors = [err5];
-                }
-                else {
-                    vErrors.push(err5);
-                }
-                errors++;
-            }
-        }
-        var _valid1 = _errs13 === errors;
-        valid4 = _valid1;
-    }
-    if (!valid4) {
-        const err6 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/allOf/1/if", keyword: "if", params: { failingKeyword: "then" }, message: "must match \"then\" schema" };
-        if (vErrors === null) {
-            vErrors = [err6];
-        }
-        else {
-            vErrors.push(err6);
-        }
-        errors++;
-    }
-    var valid2 = _errs7 === errors;
-} if (errors === _errs2) {
-    if (data && typeof data == "object" && !Array.isArray(data)) {
-        let missing4;
-        if (((data.interface === undefined) && (missing4 = "interface")) || ((data.method === undefined) && (missing4 = "method"))) {
-            const err7 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/required", keyword: "required", params: { missingProperty: missing4 }, message: "must have required property '" + missing4 + "'" };
-            if (vErrors === null) {
-                vErrors = [err7];
-            }
-            else {
-                vErrors.push(err7);
-            }
-            errors++;
-        }
-        else {
-            const _errs14 = errors;
-            for (const key0 in data) {
-                if (!(((((key0 === "interface") || (key0 === "method")) || (key0 === "protocol")) || (key0 === "contextId")) || (key0 === "protocolPath"))) {
-                    const err8 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
-                    if (vErrors === null) {
-                        vErrors = [err8];
-                    }
-                    else {
-                        vErrors.push(err8);
-                    }
-                    errors++;
-                    break;
-                }
-            }
-            if (_errs14 === errors) {
-                if (data.interface !== undefined) {
-                    const _errs15 = errors;
-                    if ("Messages" !== data.interface) {
-                        const err9 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Messages" }, message: "must be equal to constant" };
-                        if (vErrors === null) {
-                            vErrors = [err9];
-                        }
-                        else {
-                            vErrors.push(err9);
-                        }
-                        errors++;
-                    }
-                    var valid6 = _errs15 === errors;
-                }
-                else {
-                    var valid6 = true;
-                }
-                if (valid6) {
-                    if (data.method !== undefined) {
-                        const _errs16 = errors;
-                        if ("Read" !== data.method) {
-                            const err10 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/properties/method/const", keyword: "const", params: { allowedValue: "Read" }, message: "must be equal to constant" };
-                            if (vErrors === null) {
-                                vErrors = [err10];
-                            }
-                            else {
-                                vErrors.push(err10);
-                            }
-                            errors++;
-                        }
-                        var valid6 = _errs16 === errors;
-                    }
-                    else {
-                        var valid6 = true;
-                    }
-                    if (valid6) {
-                        if (data.protocol !== undefined) {
-                            const _errs17 = errors;
-                            if (typeof data.protocol !== "string") {
-                                const err11 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                if (vErrors === null) {
-                                    vErrors = [err11];
-                                }
-                                else {
-                                    vErrors.push(err11);
-                                }
-                                errors++;
-                            }
-                            var valid6 = _errs17 === errors;
-                        }
-                        else {
-                            var valid6 = true;
-                        }
-                        if (valid6) {
-                            if (data.contextId !== undefined) {
-                                let data3 = data.contextId;
-                                const _errs19 = errors;
-                                if (errors === _errs19) {
-                                    if (typeof data3 === "string") {
-                                        if (func1(data3) > 600) {
-                                            const err12 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/properties/contextId/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                            if (vErrors === null) {
-                                                vErrors = [err12];
-                                            }
-                                            else {
-                                                vErrors.push(err12);
-                                            }
-                                            errors++;
-                                        }
-                                    }
-                                    else {
-                                        const err13 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/properties/contextId/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                        if (vErrors === null) {
-                                            vErrors = [err13];
-                                        }
-                                        else {
-                                            vErrors.push(err13);
-                                        }
-                                        errors++;
-                                    }
-                                }
-                                var valid6 = _errs19 === errors;
-                            }
-                            else {
-                                var valid6 = true;
-                            }
-                            if (valid6) {
-                                if (data.protocolPath !== undefined) {
-                                    let data4 = data.protocolPath;
-                                    const _errs21 = errors;
-                                    if (errors === _errs21) {
-                                        if (typeof data4 === "string") {
-                                            if (func1(data4) > 600) {
-                                                const err14 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/properties/protocolPath/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                if (vErrors === null) {
-                                                    vErrors = [err14];
-                                                }
-                                                else {
-                                                    vErrors.push(err14);
-                                                }
-                                                errors++;
-                                            }
-                                        }
-                                        else {
-                                            const err15 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/properties/protocolPath/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                            if (vErrors === null) {
-                                                vErrors = [err15];
-                                            }
-                                            else {
-                                                vErrors.push(err15);
-                                            }
-                                            errors++;
-                                        }
-                                    }
-                                    var valid6 = _errs21 === errors;
-                                }
-                                else {
-                                    var valid6 = true;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    else {
-        const err16 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-        if (vErrors === null) {
-            vErrors = [err16];
-        }
-        else {
-            vErrors.push(err16);
-        }
-        errors++;
-    }
-} var _valid0 = _errs1 === errors; if (_valid0) {
-    valid0 = true;
-    passing0 = 0;
-    var props0 = true;
-} const _errs23 = errors; const _errs24 = errors; if (errors === _errs24) {
-    if (data && typeof data == "object" && !Array.isArray(data)) {
-        let missing5;
-        if (((data.interface === undefined) && (missing5 = "interface")) || ((data.method === undefined) && (missing5 = "method"))) {
-            const err17 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-configure-scope/required", keyword: "required", params: { missingProperty: missing5 }, message: "must have required property '" + missing5 + "'" };
-            if (vErrors === null) {
-                vErrors = [err17];
-            }
-            else {
-                vErrors.push(err17);
-            }
-            errors++;
-        }
-        else {
-            const _errs26 = errors;
-            for (const key1 in data) {
-                if (!(((key1 === "interface") || (key1 === "method")) || (key1 === "protocol"))) {
-                    const err18 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-configure-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
-                    if (vErrors === null) {
-                        vErrors = [err18];
-                    }
-                    else {
-                        vErrors.push(err18);
-                    }
-                    errors++;
-                    break;
-                }
-            }
-            if (_errs26 === errors) {
-                if (data.interface !== undefined) {
-                    const _errs27 = errors;
-                    if ("Protocols" !== data.interface) {
-                        const err19 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-configure-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Protocols" }, message: "must be equal to constant" };
-                        if (vErrors === null) {
-                            vErrors = [err19];
-                        }
-                        else {
-                            vErrors.push(err19);
-                        }
-                        errors++;
-                    }
-                    var valid8 = _errs27 === errors;
-                }
-                else {
-                    var valid8 = true;
-                }
-                if (valid8) {
-                    if (data.method !== undefined) {
-                        const _errs28 = errors;
-                        if ("Configure" !== data.method) {
-                            const err20 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-configure-scope/properties/method/const", keyword: "const", params: { allowedValue: "Configure" }, message: "must be equal to constant" };
-                            if (vErrors === null) {
-                                vErrors = [err20];
-                            }
-                            else {
-                                vErrors.push(err20);
-                            }
-                            errors++;
-                        }
-                        var valid8 = _errs28 === errors;
-                    }
-                    else {
-                        var valid8 = true;
-                    }
-                    if (valid8) {
-                        if (data.protocol !== undefined) {
-                            const _errs29 = errors;
-                            if (typeof data.protocol !== "string") {
-                                const err21 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-configure-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                if (vErrors === null) {
-                                    vErrors = [err21];
-                                }
-                                else {
-                                    vErrors.push(err21);
-                                }
-                                errors++;
-                            }
-                            var valid8 = _errs29 === errors;
-                        }
-                        else {
-                            var valid8 = true;
-                        }
-                    }
-                }
-            }
-        }
-    }
-    else {
-        const err22 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-configure-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-        if (vErrors === null) {
-            vErrors = [err22];
-        }
-        else {
-            vErrors.push(err22);
-        }
-        errors++;
-    }
-} var _valid0 = _errs23 === errors; if (_valid0 && valid0) {
-    valid0 = false;
-    passing0 = [passing0, 1];
-}
-else {
-    if (_valid0) {
-        valid0 = true;
-        passing0 = 1;
-        if (props0 !== true) {
-            props0 = true;
-        }
-    }
-    const _errs31 = errors;
-    const _errs32 = errors;
-    if (errors === _errs32) {
-        if (data && typeof data == "object" && !Array.isArray(data)) {
-            let missing6;
-            if (((data.interface === undefined) && (missing6 = "interface")) || ((data.method === undefined) && (missing6 = "method"))) {
-                const err23 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-query-scope/required", keyword: "required", params: { missingProperty: missing6 }, message: "must have required property '" + missing6 + "'" };
-                if (vErrors === null) {
-                    vErrors = [err23];
-                }
-                else {
-                    vErrors.push(err23);
-                }
-                errors++;
-            }
-            else {
-                const _errs34 = errors;
-                for (const key2 in data) {
-                    if (!(((key2 === "interface") || (key2 === "method")) || (key2 === "protocol"))) {
-                        const err24 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-query-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" };
-                        if (vErrors === null) {
-                            vErrors = [err24];
-                        }
-                        else {
-                            vErrors.push(err24);
-                        }
-                        errors++;
-                        break;
-                    }
-                }
-                if (_errs34 === errors) {
-                    if (data.interface !== undefined) {
-                        const _errs35 = errors;
-                        if ("Protocols" !== data.interface) {
-                            const err25 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-query-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Protocols" }, message: "must be equal to constant" };
-                            if (vErrors === null) {
-                                vErrors = [err25];
-                            }
-                            else {
-                                vErrors.push(err25);
-                            }
-                            errors++;
-                        }
-                        var valid10 = _errs35 === errors;
-                    }
-                    else {
-                        var valid10 = true;
-                    }
-                    if (valid10) {
-                        if (data.method !== undefined) {
-                            const _errs36 = errors;
-                            if ("Query" !== data.method) {
-                                const err26 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-query-scope/properties/method/const", keyword: "const", params: { allowedValue: "Query" }, message: "must be equal to constant" };
-                                if (vErrors === null) {
-                                    vErrors = [err26];
-                                }
-                                else {
-                                    vErrors.push(err26);
-                                }
-                                errors++;
-                            }
-                            var valid10 = _errs36 === errors;
-                        }
-                        else {
-                            var valid10 = true;
-                        }
-                        if (valid10) {
-                            if (data.protocol !== undefined) {
-                                const _errs37 = errors;
-                                if (typeof data.protocol !== "string") {
-                                    const err27 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-query-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                    if (vErrors === null) {
-                                        vErrors = [err27];
-                                    }
-                                    else {
-                                        vErrors.push(err27);
-                                    }
-                                    errors++;
-                                }
-                                var valid10 = _errs37 === errors;
-                            }
-                            else {
-                                var valid10 = true;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        else {
-            const err28 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-query-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-            if (vErrors === null) {
-                vErrors = [err28];
-            }
-            else {
-                vErrors.push(err28);
-            }
-            errors++;
-        }
-    }
-    var _valid0 = _errs31 === errors;
-    if (_valid0 && valid0) {
-        valid0 = false;
-        passing0 = [passing0, 2];
-    }
-    else {
-        if (_valid0) {
-            valid0 = true;
-            passing0 = 2;
-            if (props0 !== true) {
-                props0 = true;
-            }
-        }
-        const _errs39 = errors;
-        const _errs40 = errors;
-        if (errors === _errs40) {
-            if (data && typeof data == "object" && !Array.isArray(data)) {
-                let missing7;
-                if ((((data.interface === undefined) && (missing7 = "interface")) || ((data.method === undefined) && (missing7 = "method"))) || ((data.protocol === undefined) && (missing7 = "protocol"))) {
-                    const err29 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/required", keyword: "required", params: { missingProperty: missing7 }, message: "must have required property '" + missing7 + "'" };
-                    if (vErrors === null) {
-                        vErrors = [err29];
-                    }
-                    else {
-                        vErrors.push(err29);
-                    }
-                    errors++;
-                }
-                else {
-                    const _errs42 = errors;
-                    for (const key3 in data) {
-                        if (!(((((key3 === "interface") || (key3 === "method")) || (key3 === "protocol")) || (key3 === "contextId")) || (key3 === "protocolPath"))) {
-                            const err30 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key3 }, message: "must NOT have additional properties" };
-                            if (vErrors === null) {
-                                vErrors = [err30];
-                            }
-                            else {
-                                vErrors.push(err30);
-                            }
-                            errors++;
-                            break;
-                        }
-                    }
-                    if (_errs42 === errors) {
-                        if (data.interface !== undefined) {
-                            const _errs43 = errors;
-                            if ("Records" !== data.interface) {
-                                const err31 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Records" }, message: "must be equal to constant" };
-                                if (vErrors === null) {
-                                    vErrors = [err31];
-                                }
-                                else {
-                                    vErrors.push(err31);
-                                }
-                                errors++;
-                            }
-                            var valid12 = _errs43 === errors;
-                        }
-                        else {
-                            var valid12 = true;
-                        }
-                        if (valid12) {
-                            if (data.method !== undefined) {
-                                const _errs44 = errors;
-                                if ("Read" !== data.method) {
-                                    const err32 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/properties/method/const", keyword: "const", params: { allowedValue: "Read" }, message: "must be equal to constant" };
-                                    if (vErrors === null) {
-                                        vErrors = [err32];
-                                    }
-                                    else {
-                                        vErrors.push(err32);
-                                    }
-                                    errors++;
-                                }
-                                var valid12 = _errs44 === errors;
-                            }
-                            else {
-                                var valid12 = true;
-                            }
-                            if (valid12) {
-                                if (data.protocol !== undefined) {
-                                    const _errs45 = errors;
-                                    if (typeof data.protocol !== "string") {
-                                        const err33 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                        if (vErrors === null) {
-                                            vErrors = [err33];
-                                        }
-                                        else {
-                                            vErrors.push(err33);
-                                        }
-                                        errors++;
-                                    }
-                                    var valid12 = _errs45 === errors;
-                                }
-                                else {
-                                    var valid12 = true;
-                                }
-                                if (valid12) {
-                                    if (data.contextId !== undefined) {
-                                        let data14 = data.contextId;
-                                        const _errs47 = errors;
-                                        if (errors === _errs47) {
-                                            if (typeof data14 === "string") {
-                                                if (func1(data14) > 600) {
-                                                    const err34 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/properties/contextId/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                    if (vErrors === null) {
-                                                        vErrors = [err34];
-                                                    }
-                                                    else {
-                                                        vErrors.push(err34);
-                                                    }
-                                                    errors++;
-                                                }
-                                            }
-                                            else {
-                                                const err35 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/properties/contextId/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                if (vErrors === null) {
-                                                    vErrors = [err35];
-                                                }
-                                                else {
-                                                    vErrors.push(err35);
-                                                }
-                                                errors++;
-                                            }
-                                        }
-                                        var valid12 = _errs47 === errors;
-                                    }
-                                    else {
-                                        var valid12 = true;
-                                    }
-                                    if (valid12) {
-                                        if (data.protocolPath !== undefined) {
-                                            let data15 = data.protocolPath;
-                                            const _errs49 = errors;
-                                            if (errors === _errs49) {
-                                                if (typeof data15 === "string") {
-                                                    if (func1(data15) > 600) {
-                                                        const err36 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/properties/protocolPath/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                        if (vErrors === null) {
-                                                            vErrors = [err36];
-                                                        }
-                                                        else {
-                                                            vErrors.push(err36);
-                                                        }
-                                                        errors++;
-                                                    }
-                                                }
-                                                else {
-                                                    const err37 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/properties/protocolPath/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                    if (vErrors === null) {
-                                                        vErrors = [err37];
-                                                    }
-                                                    else {
-                                                        vErrors.push(err37);
-                                                    }
-                                                    errors++;
-                                                }
-                                            }
-                                            var valid12 = _errs49 === errors;
-                                        }
-                                        else {
-                                            var valid12 = true;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
+    const _errs8 = errors;
+    let valid4 = true;
+    const _errs9 = errors;
+    const _errs10 = errors;
+    let valid5 = false;
+    const _errs11 = errors;
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing1;
+        if ((data.contextId === undefined) && (missing1 = "contextId")) {
+            const err2 = {};
+            if (vErrors === null) {
+                vErrors = [err2];
             }
             else {
-                const err38 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                vErrors.push(err2);
+            }
+            errors++;
+        }
+    }
+    var _valid2 = _errs11 === errors;
+    valid5 = valid5 || _valid2;
+    const _errs12 = errors;
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing2;
+        if ((data.protocolPath === undefined) && (missing2 = "protocolPath")) {
+            const err3 = {};
+            if (vErrors === null) {
+                vErrors = [err3];
+            }
+            else {
+                vErrors.push(err3);
+            }
+            errors++;
+        }
+    }
+    var _valid2 = _errs12 === errors;
+    valid5 = valid5 || _valid2;
+    if (!valid5) {
+        const err4 = {};
+        if (vErrors === null) {
+            vErrors = [err4];
+        }
+        else {
+            vErrors.push(err4);
+        }
+        errors++;
+    }
+    else {
+        errors = _errs10;
+        if (vErrors !== null) {
+            if (_errs10) {
+                vErrors.length = _errs10;
+            }
+            else {
+                vErrors = null;
+            }
+        }
+    }
+    var _valid1 = _errs9 === errors;
+    errors = _errs8;
+    if (vErrors !== null) {
+        if (_errs8) {
+            vErrors.length = _errs8;
+        }
+        else {
+            vErrors = null;
+        }
+    }
+    if (_valid1) {
+        const _errs13 = errors;
+        if (data && typeof data == "object" && !Array.isArray(data)) {
+            let missing3;
+            if ((data.protocol === undefined) && (missing3 = "protocol")) {
+                const err5 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/allOf/1/then/required", keyword: "required", params: { missingProperty: missing3 }, message: "must have required property '" + missing3 + "'" };
                 if (vErrors === null) {
-                    vErrors = [err38];
+                    vErrors = [err5];
                 }
                 else {
-                    vErrors.push(err38);
+                    vErrors.push(err5);
                 }
                 errors++;
             }
         }
-        var _valid0 = _errs39 === errors;
-        if (_valid0 && valid0) {
-            valid0 = false;
-            passing0 = [passing0, 3];
+        var _valid1 = _errs13 === errors;
+        valid4 = _valid1;
+    }
+    if (!valid4) {
+        const err6 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/allOf/1/if", keyword: "if", params: { failingKeyword: "then" }, message: "must match \"then\" schema" };
+        if (vErrors === null) {
+            vErrors = [err6];
         }
         else {
-            if (_valid0) {
-                valid0 = true;
-                passing0 = 3;
-                if (props0 !== true) {
-                    props0 = true;
+            vErrors.push(err6);
+        }
+        errors++;
+    }
+    var valid2 = _errs7 === errors;
+} if (errors === _errs2) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing4;
+        if (((data.interface === undefined) && (missing4 = "interface")) || ((data.method === undefined) && (missing4 = "method"))) {
+            const err7 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/required", keyword: "required", params: { missingProperty: missing4 }, message: "must have required property '" + missing4 + "'" };
+            if (vErrors === null) {
+                vErrors = [err7];
+            }
+            else {
+                vErrors.push(err7);
+            }
+            errors++;
+        }
+        else {
+            const _errs14 = errors;
+            for (const key0 in data) {
+                if (!(((((key0 === "interface") || (key0 === "method")) || (key0 === "protocol")) || (key0 === "contextId")) || (key0 === "protocolPath"))) {
+                    const err8 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+                    if (vErrors === null) {
+                        vErrors = [err8];
+                    }
+                    else {
+                        vErrors.push(err8);
+                    }
+                    errors++;
+                    break;
                 }
             }
-            const _errs51 = errors;
-            const _errs52 = errors;
-            if (errors === _errs52) {
-                if (data && typeof data == "object" && !Array.isArray(data)) {
-                    let missing8;
-                    if ((((data.interface === undefined) && (missing8 = "interface")) || ((data.method === undefined) && (missing8 = "method"))) || ((data.protocol === undefined) && (missing8 = "protocol"))) {
-                        const err39 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/required", keyword: "required", params: { missingProperty: missing8 }, message: "must have required property '" + missing8 + "'" };
+            if (_errs14 === errors) {
+                if (data.interface !== undefined) {
+                    const _errs15 = errors;
+                    if ("Messages" !== data.interface) {
+                        const err9 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Messages" }, message: "must be equal to constant" };
                         if (vErrors === null) {
-                            vErrors = [err39];
+                            vErrors = [err9];
                         }
                         else {
-                            vErrors.push(err39);
+                            vErrors.push(err9);
                         }
                         errors++;
                     }
+                    var valid6 = _errs15 === errors;
+                }
+                else {
+                    var valid6 = true;
+                }
+                if (valid6) {
+                    if (data.method !== undefined) {
+                        const _errs16 = errors;
+                        if ("Read" !== data.method) {
+                            const err10 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/properties/method/const", keyword: "const", params: { allowedValue: "Read" }, message: "must be equal to constant" };
+                            if (vErrors === null) {
+                                vErrors = [err10];
+                            }
+                            else {
+                                vErrors.push(err10);
+                            }
+                            errors++;
+                        }
+                        var valid6 = _errs16 === errors;
+                    }
                     else {
-                        const _errs54 = errors;
-                        for (const key4 in data) {
-                            if (!(((((key4 === "interface") || (key4 === "method")) || (key4 === "protocol")) || (key4 === "contextId")) || (key4 === "protocolPath"))) {
-                                const err40 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key4 }, message: "must NOT have additional properties" };
+                        var valid6 = true;
+                    }
+                    if (valid6) {
+                        if (data.protocol !== undefined) {
+                            const _errs17 = errors;
+                            if (typeof data.protocol !== "string") {
+                                const err11 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
                                 if (vErrors === null) {
-                                    vErrors = [err40];
+                                    vErrors = [err11];
                                 }
                                 else {
-                                    vErrors.push(err40);
+                                    vErrors.push(err11);
                                 }
                                 errors++;
-                                break;
                             }
+                            var valid6 = _errs17 === errors;
                         }
-                        if (_errs54 === errors) {
-                            if (data.interface !== undefined) {
-                                const _errs55 = errors;
-                                if ("Records" !== data.interface) {
-                                    const err41 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Records" }, message: "must be equal to constant" };
-                                    if (vErrors === null) {
-                                        vErrors = [err41];
-                                    }
-                                    else {
-                                        vErrors.push(err41);
-                                    }
-                                    errors++;
-                                }
-                                var valid14 = _errs55 === errors;
-                            }
-                            else {
-                                var valid14 = true;
-                            }
-                            if (valid14) {
-                                if (data.method !== undefined) {
-                                    const _errs56 = errors;
-                                    if ("Delete" !== data.method) {
-                                        const err42 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/properties/method/const", keyword: "const", params: { allowedValue: "Delete" }, message: "must be equal to constant" };
-                                        if (vErrors === null) {
-                                            vErrors = [err42];
-                                        }
-                                        else {
-                                            vErrors.push(err42);
-                                        }
-                                        errors++;
-                                    }
-                                    var valid14 = _errs56 === errors;
-                                }
-                                else {
-                                    var valid14 = true;
-                                }
-                                if (valid14) {
-                                    if (data.protocol !== undefined) {
-                                        const _errs57 = errors;
-                                        if (typeof data.protocol !== "string") {
-                                            const err43 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                        else {
+                            var valid6 = true;
+                        }
+                        if (valid6) {
+                            if (data.contextId !== undefined) {
+                                let data3 = data.contextId;
+                                const _errs19 = errors;
+                                if (errors === _errs19) {
+                                    if (typeof data3 === "string") {
+                                        if (func1(data3) > 600) {
+                                            const err12 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/properties/contextId/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
                                             if (vErrors === null) {
-                                                vErrors = [err43];
+                                                vErrors = [err12];
                                             }
                                             else {
-                                                vErrors.push(err43);
+                                                vErrors.push(err12);
                                             }
                                             errors++;
                                         }
-                                        var valid14 = _errs57 === errors;
                                     }
                                     else {
-                                        var valid14 = true;
-                                    }
-                                    if (valid14) {
-                                        if (data.contextId !== undefined) {
-                                            let data19 = data.contextId;
-                                            const _errs59 = errors;
-                                            if (errors === _errs59) {
-                                                if (typeof data19 === "string") {
-                                                    if (func1(data19) > 600) {
-                                                        const err44 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/properties/contextId/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                        if (vErrors === null) {
-                                                            vErrors = [err44];
-                                                        }
-                                                        else {
-                                                            vErrors.push(err44);
-                                                        }
-                                                        errors++;
-                                                    }
+                                        const err13 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/properties/contextId/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                        if (vErrors === null) {
+                                            vErrors = [err13];
+                                        }
+                                        else {
+                                            vErrors.push(err13);
+                                        }
+                                        errors++;
+                                    }
+                                }
+                                var valid6 = _errs19 === errors;
+                            }
+                            else {
+                                var valid6 = true;
+                            }
+                            if (valid6) {
+                                if (data.protocolPath !== undefined) {
+                                    let data4 = data.protocolPath;
+                                    const _errs21 = errors;
+                                    if (errors === _errs21) {
+                                        if (typeof data4 === "string") {
+                                            if (func1(data4) > 600) {
+                                                const err14 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/properties/protocolPath/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
+                                                if (vErrors === null) {
+                                                    vErrors = [err14];
                                                 }
                                                 else {
-                                                    const err45 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/properties/contextId/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                    if (vErrors === null) {
-                                                        vErrors = [err45];
-                                                    }
-                                                    else {
-                                                        vErrors.push(err45);
-                                                    }
-                                                    errors++;
+                                                    vErrors.push(err14);
                                                 }
+                                                errors++;
                                             }
-                                            var valid14 = _errs59 === errors;
                                         }
                                         else {
-                                            var valid14 = true;
-                                        }
-                                        if (valid14) {
-                                            if (data.protocolPath !== undefined) {
-                                                let data20 = data.protocolPath;
-                                                const _errs61 = errors;
-                                                if (errors === _errs61) {
-                                                    if (typeof data20 === "string") {
-                                                        if (func1(data20) > 600) {
-                                                            const err46 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/properties/protocolPath/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                            if (vErrors === null) {
-                                                                vErrors = [err46];
-                                                            }
-                                                            else {
-                                                                vErrors.push(err46);
-                                                            }
-                                                            errors++;
-                                                        }
-                                                    }
-                                                    else {
-                                                        const err47 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/properties/protocolPath/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                        if (vErrors === null) {
-                                                            vErrors = [err47];
-                                                        }
-                                                        else {
-                                                            vErrors.push(err47);
-                                                        }
-                                                        errors++;
-                                                    }
-                                                }
-                                                var valid14 = _errs61 === errors;
+                                            const err15 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/properties/protocolPath/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                            if (vErrors === null) {
+                                                vErrors = [err15];
                                             }
                                             else {
-                                                var valid14 = true;
+                                                vErrors.push(err15);
                                             }
+                                            errors++;
                                         }
                                     }
+                                    var valid6 = _errs21 === errors;
+                                }
+                                else {
+                                    var valid6 = true;
                                 }
                             }
                         }
                     }
                 }
-                else {
-                    const err48 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+            }
+        }
+    }
+    else {
+        const err16 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+            vErrors = [err16];
+        }
+        else {
+            vErrors.push(err16);
+        }
+        errors++;
+    }
+} var _valid0 = _errs1 === errors; if (_valid0) {
+    valid0 = true;
+    passing0 = 0;
+    var props0 = true;
+} const _errs23 = errors; const _errs24 = errors; if (errors === _errs24) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing5;
+        if (((data.interface === undefined) && (missing5 = "interface")) || ((data.method === undefined) && (missing5 = "method"))) {
+            const err17 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-configure-scope/required", keyword: "required", params: { missingProperty: missing5 }, message: "must have required property '" + missing5 + "'" };
+            if (vErrors === null) {
+                vErrors = [err17];
+            }
+            else {
+                vErrors.push(err17);
+            }
+            errors++;
+        }
+        else {
+            const _errs26 = errors;
+            for (const key1 in data) {
+                if (!(((key1 === "interface") || (key1 === "method")) || (key1 === "protocol"))) {
+                    const err18 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-configure-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
                     if (vErrors === null) {
-                        vErrors = [err48];
+                        vErrors = [err18];
                     }
                     else {
-                        vErrors.push(err48);
+                        vErrors.push(err18);
                     }
                     errors++;
+                    break;
                 }
             }
-            var _valid0 = _errs51 === errors;
-            if (_valid0 && valid0) {
-                valid0 = false;
-                passing0 = [passing0, 4];
+            if (_errs26 === errors) {
+                if (data.interface !== undefined) {
+                    const _errs27 = errors;
+                    if ("Protocols" !== data.interface) {
+                        const err19 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-configure-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Protocols" }, message: "must be equal to constant" };
+                        if (vErrors === null) {
+                            vErrors = [err19];
+                        }
+                        else {
+                            vErrors.push(err19);
+                        }
+                        errors++;
+                    }
+                    var valid8 = _errs27 === errors;
+                }
+                else {
+                    var valid8 = true;
+                }
+                if (valid8) {
+                    if (data.method !== undefined) {
+                        const _errs28 = errors;
+                        if ("Configure" !== data.method) {
+                            const err20 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-configure-scope/properties/method/const", keyword: "const", params: { allowedValue: "Configure" }, message: "must be equal to constant" };
+                            if (vErrors === null) {
+                                vErrors = [err20];
+                            }
+                            else {
+                                vErrors.push(err20);
+                            }
+                            errors++;
+                        }
+                        var valid8 = _errs28 === errors;
+                    }
+                    else {
+                        var valid8 = true;
+                    }
+                    if (valid8) {
+                        if (data.protocol !== undefined) {
+                            const _errs29 = errors;
+                            if (typeof data.protocol !== "string") {
+                                const err21 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-configure-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                if (vErrors === null) {
+                                    vErrors = [err21];
+                                }
+                                else {
+                                    vErrors.push(err21);
+                                }
+                                errors++;
+                            }
+                            var valid8 = _errs29 === errors;
+                        }
+                        else {
+                            var valid8 = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        const err22 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-configure-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+            vErrors = [err22];
+        }
+        else {
+            vErrors.push(err22);
+        }
+        errors++;
+    }
+} var _valid0 = _errs23 === errors; if (_valid0 && valid0) {
+    valid0 = false;
+    passing0 = [passing0, 1];
+}
+else {
+    if (_valid0) {
+        valid0 = true;
+        passing0 = 1;
+        if (props0 !== true) {
+            props0 = true;
+        }
+    }
+    const _errs31 = errors;
+    const _errs32 = errors;
+    if (errors === _errs32) {
+        if (data && typeof data == "object" && !Array.isArray(data)) {
+            let missing6;
+            if (((data.interface === undefined) && (missing6 = "interface")) || ((data.method === undefined) && (missing6 = "method"))) {
+                const err23 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-query-scope/required", keyword: "required", params: { missingProperty: missing6 }, message: "must have required property '" + missing6 + "'" };
+                if (vErrors === null) {
+                    vErrors = [err23];
+                }
+                else {
+                    vErrors.push(err23);
+                }
+                errors++;
             }
             else {
-                if (_valid0) {
-                    valid0 = true;
-                    passing0 = 4;
-                    if (props0 !== true) {
-                        props0 = true;
+                const _errs34 = errors;
+                for (const key2 in data) {
+                    if (!(((key2 === "interface") || (key2 === "method")) || (key2 === "protocol"))) {
+                        const err24 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-query-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" };
+                        if (vErrors === null) {
+                            vErrors = [err24];
+                        }
+                        else {
+                            vErrors.push(err24);
+                        }
+                        errors++;
+                        break;
                     }
                 }
-                const _errs63 = errors;
-                const _errs64 = errors;
-                if (errors === _errs64) {
-                    if (data && typeof data == "object" && !Array.isArray(data)) {
-                        let missing9;
-                        if ((((data.interface === undefined) && (missing9 = "interface")) || ((data.method === undefined) && (missing9 = "method"))) || ((data.protocol === undefined) && (missing9 = "protocol"))) {
-                            const err49 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/required", keyword: "required", params: { missingProperty: missing9 }, message: "must have required property '" + missing9 + "'" };
+                if (_errs34 === errors) {
+                    if (data.interface !== undefined) {
+                        const _errs35 = errors;
+                        if ("Protocols" !== data.interface) {
+                            const err25 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-query-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Protocols" }, message: "must be equal to constant" };
                             if (vErrors === null) {
-                                vErrors = [err49];
+                                vErrors = [err25];
                             }
                             else {
-                                vErrors.push(err49);
+                                vErrors.push(err25);
+                            }
+                            errors++;
+                        }
+                        var valid10 = _errs35 === errors;
+                    }
+                    else {
+                        var valid10 = true;
+                    }
+                    if (valid10) {
+                        if (data.method !== undefined) {
+                            const _errs36 = errors;
+                            if ("Query" !== data.method) {
+                                const err26 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-query-scope/properties/method/const", keyword: "const", params: { allowedValue: "Query" }, message: "must be equal to constant" };
+                                if (vErrors === null) {
+                                    vErrors = [err26];
+                                }
+                                else {
+                                    vErrors.push(err26);
+                                }
+                                errors++;
                             }
-                            errors++;
+                            var valid10 = _errs36 === errors;
                         }
                         else {
-                            const _errs66 = errors;
-                            for (const key5 in data) {
-                                if (!(((((key5 === "interface") || (key5 === "method")) || (key5 === "protocol")) || (key5 === "contextId")) || (key5 === "protocolPath"))) {
-                                    const err50 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key5 }, message: "must NOT have additional properties" };
+                            var valid10 = true;
+                        }
+                        if (valid10) {
+                            if (data.protocol !== undefined) {
+                                const _errs37 = errors;
+                                if (typeof data.protocol !== "string") {
+                                    const err27 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-query-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
                                     if (vErrors === null) {
-                                        vErrors = [err50];
+                                        vErrors = [err27];
                                     }
                                     else {
-                                        vErrors.push(err50);
+                                        vErrors.push(err27);
                                     }
                                     errors++;
-                                    break;
                                 }
+                                var valid10 = _errs37 === errors;
                             }
-                            if (_errs66 === errors) {
-                                if (data.interface !== undefined) {
-                                    const _errs67 = errors;
-                                    if ("Records" !== data.interface) {
-                                        const err51 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Records" }, message: "must be equal to constant" };
-                                        if (vErrors === null) {
-                                            vErrors = [err51];
-                                        }
-                                        else {
-                                            vErrors.push(err51);
-                                        }
-                                        errors++;
-                                    }
-                                    var valid16 = _errs67 === errors;
-                                }
-                                else {
-                                    var valid16 = true;
-                                }
-                                if (valid16) {
-                                    if (data.method !== undefined) {
-                                        const _errs68 = errors;
-                                        if ("Write" !== data.method) {
-                                            const err52 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/properties/method/const", keyword: "const", params: { allowedValue: "Write" }, message: "must be equal to constant" };
-                                            if (vErrors === null) {
-                                                vErrors = [err52];
-                                            }
-                                            else {
-                                                vErrors.push(err52);
-                                            }
-                                            errors++;
-                                        }
-                                        var valid16 = _errs68 === errors;
-                                    }
-                                    else {
-                                        var valid16 = true;
-                                    }
-                                    if (valid16) {
-                                        if (data.protocol !== undefined) {
-                                            const _errs69 = errors;
-                                            if (typeof data.protocol !== "string") {
-                                                const err53 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                if (vErrors === null) {
-                                                    vErrors = [err53];
-                                                }
-                                                else {
-                                                    vErrors.push(err53);
-                                                }
-                                                errors++;
-                                            }
-                                            var valid16 = _errs69 === errors;
-                                        }
-                                        else {
-                                            var valid16 = true;
-                                        }
-                                        if (valid16) {
-                                            if (data.contextId !== undefined) {
-                                                let data24 = data.contextId;
-                                                const _errs71 = errors;
-                                                if (errors === _errs71) {
-                                                    if (typeof data24 === "string") {
-                                                        if (func1(data24) > 600) {
-                                                            const err54 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/properties/contextId/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                            if (vErrors === null) {
-                                                                vErrors = [err54];
-                                                            }
-                                                            else {
-                                                                vErrors.push(err54);
-                                                            }
-                                                            errors++;
-                                                        }
-                                                    }
-                                                    else {
-                                                        const err55 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/properties/contextId/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                        if (vErrors === null) {
-                                                            vErrors = [err55];
-                                                        }
-                                                        else {
-                                                            vErrors.push(err55);
-                                                        }
-                                                        errors++;
-                                                    }
-                                                }
-                                                var valid16 = _errs71 === errors;
-                                            }
-                                            else {
-                                                var valid16 = true;
-                                            }
-                                            if (valid16) {
-                                                if (data.protocolPath !== undefined) {
-                                                    let data25 = data.protocolPath;
-                                                    const _errs73 = errors;
-                                                    if (errors === _errs73) {
-                                                        if (typeof data25 === "string") {
-                                                            if (func1(data25) > 600) {
-                                                                const err56 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/properties/protocolPath/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                                if (vErrors === null) {
-                                                                    vErrors = [err56];
-                                                                }
-                                                                else {
-                                                                    vErrors.push(err56);
-                                                                }
-                                                                errors++;
-                                                            }
-                                                        }
-                                                        else {
-                                                            const err57 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/properties/protocolPath/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                            if (vErrors === null) {
-                                                                vErrors = [err57];
-                                                            }
-                                                            else {
-                                                                vErrors.push(err57);
-                                                            }
-                                                            errors++;
-                                                        }
-                                                    }
-                                                    var valid16 = _errs73 === errors;
-                                                }
-                                                else {
-                                                    var valid16 = true;
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
+                            else {
+                                var valid10 = true;
                             }
                         }
                     }
+                }
+            }
+        }
+        else {
+            const err28 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-query-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+            if (vErrors === null) {
+                vErrors = [err28];
+            }
+            else {
+                vErrors.push(err28);
+            }
+            errors++;
+        }
+    }
+    var _valid0 = _errs31 === errors;
+    if (_valid0 && valid0) {
+        valid0 = false;
+        passing0 = [passing0, 2];
+    }
+    else {
+        if (_valid0) {
+            valid0 = true;
+            passing0 = 2;
+            if (props0 !== true) {
+                props0 = true;
+            }
+        }
+        const _errs39 = errors;
+        const _errs40 = errors;
+        if (errors === _errs40) {
+            if (data && typeof data == "object" && !Array.isArray(data)) {
+                let missing7;
+                if ((((data.interface === undefined) && (missing7 = "interface")) || ((data.method === undefined) && (missing7 = "method"))) || ((data.protocol === undefined) && (missing7 = "protocol"))) {
+                    const err29 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/required", keyword: "required", params: { missingProperty: missing7 }, message: "must have required property '" + missing7 + "'" };
+                    if (vErrors === null) {
+                        vErrors = [err29];
+                    }
                     else {
-                        const err58 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-                        if (vErrors === null) {
-                            vErrors = [err58];
-                        }
-                        else {
-                            vErrors.push(err58);
-                        }
-                        errors++;
+                        vErrors.push(err29);
                     }
-                }
-                var _valid0 = _errs63 === errors;
-                if (_valid0 && valid0) {
-                    valid0 = false;
-                    passing0 = [passing0, 5];
+                    errors++;
                 }
                 else {
-                    if (_valid0) {
-                        valid0 = true;
-                        passing0 = 5;
-                        if (props0 !== true) {
-                            props0 = true;
+                    const _errs42 = errors;
+                    for (const key3 in data) {
+                        if (!(((((key3 === "interface") || (key3 === "method")) || (key3 === "protocol")) || (key3 === "contextId")) || (key3 === "protocolPath"))) {
+                            const err30 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key3 }, message: "must NOT have additional properties" };
+                            if (vErrors === null) {
+                                vErrors = [err30];
+                            }
+                            else {
+                                vErrors.push(err30);
+                            }
+                            errors++;
+                            break;
                         }
                     }
-                    const _errs75 = errors;
-                    const _errs76 = errors;
-                    if (errors === _errs76) {
-                        if (data && typeof data == "object" && !Array.isArray(data)) {
-                            let missing10;
-                            if ((((data.interface === undefined) && (missing10 = "interface")) || ((data.method === undefined) && (missing10 = "method"))) || ((data.protocol === undefined) && (missing10 = "protocol"))) {
-                                const err59 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/required", keyword: "required", params: { missingProperty: missing10 }, message: "must have required property '" + missing10 + "'" };
+                    if (_errs42 === errors) {
+                        if (data.interface !== undefined) {
+                            const _errs43 = errors;
+                            if ("Records" !== data.interface) {
+                                const err31 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Records" }, message: "must be equal to constant" };
                                 if (vErrors === null) {
-                                    vErrors = [err59];
+                                    vErrors = [err31];
                                 }
                                 else {
-                                    vErrors.push(err59);
+                                    vErrors.push(err31);
                                 }
                                 errors++;
                             }
+                            var valid12 = _errs43 === errors;
+                        }
+                        else {
+                            var valid12 = true;
+                        }
+                        if (valid12) {
+                            if (data.method !== undefined) {
+                                const _errs44 = errors;
+                                if ("Read" !== data.method) {
+                                    const err32 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/properties/method/const", keyword: "const", params: { allowedValue: "Read" }, message: "must be equal to constant" };
+                                    if (vErrors === null) {
+                                        vErrors = [err32];
+                                    }
+                                    else {
+                                        vErrors.push(err32);
+                                    }
+                                    errors++;
+                                }
+                                var valid12 = _errs44 === errors;
+                            }
                             else {
-                                const _errs78 = errors;
-                                for (const key6 in data) {
-                                    if (!(((((key6 === "interface") || (key6 === "method")) || (key6 === "protocol")) || (key6 === "contextId")) || (key6 === "protocolPath"))) {
-                                        const err60 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key6 }, message: "must NOT have additional properties" };
+                                var valid12 = true;
+                            }
+                            if (valid12) {
+                                if (data.protocol !== undefined) {
+                                    const _errs45 = errors;
+                                    if (typeof data.protocol !== "string") {
+                                        const err33 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
                                         if (vErrors === null) {
-                                            vErrors = [err60];
+                                            vErrors = [err33];
                                         }
                                         else {
-                                            vErrors.push(err60);
+                                            vErrors.push(err33);
                                         }
                                         errors++;
-                                        break;
                                     }
+                                    var valid12 = _errs45 === errors;
                                 }
-                                if (_errs78 === errors) {
-                                    if (data.interface !== undefined) {
-                                        const _errs79 = errors;
-                                        if ("Records" !== data.interface) {
-                                            const err61 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Records" }, message: "must be equal to constant" };
-                                            if (vErrors === null) {
-                                                vErrors = [err61];
+                                else {
+                                    var valid12 = true;
+                                }
+                                if (valid12) {
+                                    if (data.contextId !== undefined) {
+                                        let data14 = data.contextId;
+                                        const _errs47 = errors;
+                                        if (errors === _errs47) {
+                                            if (typeof data14 === "string") {
+                                                if (func1(data14) > 600) {
+                                                    const err34 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/properties/contextId/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
+                                                    if (vErrors === null) {
+                                                        vErrors = [err34];
+                                                    }
+                                                    else {
+                                                        vErrors.push(err34);
+                                                    }
+                                                    errors++;
+                                                }
                                             }
                                             else {
-                                                vErrors.push(err61);
-                                            }
-                                            errors++;
-                                        }
-                                        var valid18 = _errs79 === errors;
-                                    }
-                                    else {
-                                        var valid18 = true;
-                                    }
-                                    if (valid18) {
-                                        if (data.method !== undefined) {
-                                            const _errs80 = errors;
-                                            if ("Query" !== data.method) {
-                                                const err62 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/properties/method/const", keyword: "const", params: { allowedValue: "Query" }, message: "must be equal to constant" };
+                                                const err35 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/properties/contextId/type", keyword: "type", params: { type: "string" }, message: "must be string" };
                                                 if (vErrors === null) {
-                                                    vErrors = [err62];
+                                                    vErrors = [err35];
                                                 }
                                                 else {
-                                                    vErrors.push(err62);
+                                                    vErrors.push(err35);
                                                 }
                                                 errors++;
                                             }
-                                            var valid18 = _errs80 === errors;
-                                        }
-                                        else {
-                                            var valid18 = true;
                                         }
-                                        if (valid18) {
-                                            if (data.protocol !== undefined) {
-                                                const _errs81 = errors;
-                                                if (typeof data.protocol !== "string") {
-                                                    const err63 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                    if (vErrors === null) {
-                                                        vErrors = [err63];
-                                                    }
-                                                    else {
-                                                        vErrors.push(err63);
-                                                    }
-                                                    errors++;
-                                                }
-                                                var valid18 = _errs81 === errors;
-                                            }
-                                            else {
-                                                var valid18 = true;
-                                            }
-                                            if (valid18) {
-                                                if (data.contextId !== undefined) {
-                                                    let data29 = data.contextId;
-                                                    const _errs83 = errors;
-                                                    if (errors === _errs83) {
-                                                        if (typeof data29 === "string") {
-                                                            if (func1(data29) > 600) {
-                                                                const err64 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/properties/contextId/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                                if (vErrors === null) {
-                                                                    vErrors = [err64];
-                                                                }
-                                                                else {
-                                                                    vErrors.push(err64);
-                                                                }
-                                                                errors++;
-                                                            }
+                                        var valid12 = _errs47 === errors;
+                                    }
+                                    else {
+                                        var valid12 = true;
+                                    }
+                                    if (valid12) {
+                                        if (data.protocolPath !== undefined) {
+                                            let data15 = data.protocolPath;
+                                            const _errs49 = errors;
+                                            if (errors === _errs49) {
+                                                if (typeof data15 === "string") {
+                                                    if (func1(data15) > 600) {
+                                                        const err36 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/properties/protocolPath/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
+                                                        if (vErrors === null) {
+                                                            vErrors = [err36];
                                                         }
                                                         else {
-                                                            const err65 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/properties/contextId/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                            if (vErrors === null) {
-                                                                vErrors = [err65];
-                                                            }
-                                                            else {
-                                                                vErrors.push(err65);
-                                                            }
-                                                            errors++;
+                                                            vErrors.push(err36);
                                                         }
+                                                        errors++;
                                                     }
-                                                    var valid18 = _errs83 === errors;
                                                 }
                                                 else {
-                                                    var valid18 = true;
-                                                }
-                                                if (valid18) {
-                                                    if (data.protocolPath !== undefined) {
-                                                        let data30 = data.protocolPath;
-                                                        const _errs85 = errors;
-                                                        if (errors === _errs85) {
-                                                            if (typeof data30 === "string") {
-                                                                if (func1(data30) > 600) {
-                                                                    const err66 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/properties/protocolPath/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                                    if (vErrors === null) {
-                                                                        vErrors = [err66];
-                                                                    }
-                                                                    else {
-                                                                        vErrors.push(err66);
-                                                                    }
-                                                                    errors++;
-                                                                }
-                                                            }
-                                                            else {
-                                                                const err67 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/properties/protocolPath/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                                if (vErrors === null) {
-                                                                    vErrors = [err67];
-                                                                }
-                                                                else {
-                                                                    vErrors.push(err67);
-                                                                }
-                                                                errors++;
-                                                            }
-                                                        }
-                                                        var valid18 = _errs85 === errors;
+                                                    const err37 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/properties/protocolPath/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                                    if (vErrors === null) {
+                                                        vErrors = [err37];
                                                     }
                                                     else {
-                                                        var valid18 = true;
+                                                        vErrors.push(err37);
                                                     }
+                                                    errors++;
                                                 }
                                             }
+                                            var valid12 = _errs49 === errors;
+                                        }
+                                        else {
+                                            var valid12 = true;
                                         }
                                     }
                                 }
                             }
                         }
+                    }
+                }
+            }
+            else {
+                const err38 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                if (vErrors === null) {
+                    vErrors = [err38];
+                }
+                else {
+                    vErrors.push(err38);
+                }
+                errors++;
+            }
+        }
+        var _valid0 = _errs39 === errors;
+        if (_valid0 && valid0) {
+            valid0 = false;
+            passing0 = [passing0, 3];
+        }
+        else {
+            if (_valid0) {
+                valid0 = true;
+                passing0 = 3;
+                if (props0 !== true) {
+                    props0 = true;
+                }
+            }
+            const _errs51 = errors;
+            const _errs52 = errors;
+            if (errors === _errs52) {
+                if (data && typeof data == "object" && !Array.isArray(data)) {
+                    let missing8;
+                    if ((((data.interface === undefined) && (missing8 = "interface")) || ((data.method === undefined) && (missing8 = "method"))) || ((data.protocol === undefined) && (missing8 = "protocol"))) {
+                        const err39 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/required", keyword: "required", params: { missingProperty: missing8 }, message: "must have required property '" + missing8 + "'" };
+                        if (vErrors === null) {
+                            vErrors = [err39];
+                        }
                         else {
-                            const err68 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-                            if (vErrors === null) {
-                                vErrors = [err68];
-                            }
-                            else {
-                                vErrors.push(err68);
-                            }
-                            errors++;
+                            vErrors.push(err39);
                         }
-                    }
-                    var _valid0 = _errs75 === errors;
-                    if (_valid0 && valid0) {
-                        valid0 = false;
-                        passing0 = [passing0, 6];
+                        errors++;
                     }
                     else {
-                        if (_valid0) {
-                            valid0 = true;
-                            passing0 = 6;
-                            if (props0 !== true) {
-                                props0 = true;
+                        const _errs54 = errors;
+                        for (const key4 in data) {
+                            if (!(((((key4 === "interface") || (key4 === "method")) || (key4 === "protocol")) || (key4 === "contextId")) || (key4 === "protocolPath"))) {
+                                const err40 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key4 }, message: "must NOT have additional properties" };
+                                if (vErrors === null) {
+                                    vErrors = [err40];
+                                }
+                                else {
+                                    vErrors.push(err40);
+                                }
+                                errors++;
+                                break;
                             }
                         }
-                        const _errs87 = errors;
-                        const _errs88 = errors;
-                        if (errors === _errs88) {
-                            if (data && typeof data == "object" && !Array.isArray(data)) {
-                                let missing11;
-                                if ((((data.interface === undefined) && (missing11 = "interface")) || ((data.method === undefined) && (missing11 = "method"))) || ((data.protocol === undefined) && (missing11 = "protocol"))) {
-                                    const err69 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/required", keyword: "required", params: { missingProperty: missing11 }, message: "must have required property '" + missing11 + "'" };
+                        if (_errs54 === errors) {
+                            if (data.interface !== undefined) {
+                                const _errs55 = errors;
+                                if ("Records" !== data.interface) {
+                                    const err41 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Records" }, message: "must be equal to constant" };
                                     if (vErrors === null) {
-                                        vErrors = [err69];
+                                        vErrors = [err41];
                                     }
                                     else {
-                                        vErrors.push(err69);
+                                        vErrors.push(err41);
                                     }
                                     errors++;
                                 }
+                                var valid14 = _errs55 === errors;
+                            }
+                            else {
+                                var valid14 = true;
+                            }
+                            if (valid14) {
+                                if (data.method !== undefined) {
+                                    const _errs56 = errors;
+                                    if ("Delete" !== data.method) {
+                                        const err42 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/properties/method/const", keyword: "const", params: { allowedValue: "Delete" }, message: "must be equal to constant" };
+                                        if (vErrors === null) {
+                                            vErrors = [err42];
+                                        }
+                                        else {
+                                            vErrors.push(err42);
+                                        }
+                                        errors++;
+                                    }
+                                    var valid14 = _errs56 === errors;
+                                }
                                 else {
-                                    const _errs90 = errors;
-                                    for (const key7 in data) {
-                                        if (!(((((key7 === "interface") || (key7 === "method")) || (key7 === "protocol")) || (key7 === "contextId")) || (key7 === "protocolPath"))) {
-                                            const err70 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key7 }, message: "must NOT have additional properties" };
+                                    var valid14 = true;
+                                }
+                                if (valid14) {
+                                    if (data.protocol !== undefined) {
+                                        const _errs57 = errors;
+                                        if (typeof data.protocol !== "string") {
+                                            const err43 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
                                             if (vErrors === null) {
-                                                vErrors = [err70];
+                                                vErrors = [err43];
                                             }
                                             else {
-                                                vErrors.push(err70);
+                                                vErrors.push(err43);
                                             }
                                             errors++;
-                                            break;
                                         }
+                                        var valid14 = _errs57 === errors;
                                     }
-                                    if (_errs90 === errors) {
-                                        if (data.interface !== undefined) {
-                                            const _errs91 = errors;
-                                            if ("Records" !== data.interface) {
-                                                const err71 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Records" }, message: "must be equal to constant" };
-                                                if (vErrors === null) {
-                                                    vErrors = [err71];
+                                    else {
+                                        var valid14 = true;
+                                    }
+                                    if (valid14) {
+                                        if (data.contextId !== undefined) {
+                                            let data19 = data.contextId;
+                                            const _errs59 = errors;
+                                            if (errors === _errs59) {
+                                                if (typeof data19 === "string") {
+                                                    if (func1(data19) > 600) {
+                                                        const err44 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/properties/contextId/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
+                                                        if (vErrors === null) {
+                                                            vErrors = [err44];
+                                                        }
+                                                        else {
+                                                            vErrors.push(err44);
+                                                        }
+                                                        errors++;
+                                                    }
                                                 }
                                                 else {
-                                                    vErrors.push(err71);
-                                                }
-                                                errors++;
-                                            }
-                                            var valid20 = _errs91 === errors;
-                                        }
-                                        else {
-                                            var valid20 = true;
-                                        }
-                                        if (valid20) {
-                                            if (data.method !== undefined) {
-                                                const _errs92 = errors;
-                                                if ("Subscribe" !== data.method) {
-                                                    const err72 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/properties/method/const", keyword: "const", params: { allowedValue: "Subscribe" }, message: "must be equal to constant" };
+                                                    const err45 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/properties/contextId/type", keyword: "type", params: { type: "string" }, message: "must be string" };
                                                     if (vErrors === null) {
-                                                        vErrors = [err72];
+                                                        vErrors = [err45];
                                                     }
                                                     else {
-                                                        vErrors.push(err72);
+                                                        vErrors.push(err45);
                                                     }
                                                     errors++;
                                                 }
-                                                var valid20 = _errs92 === errors;
-                                            }
-                                            else {
-                                                var valid20 = true;
                                             }
-                                            if (valid20) {
-                                                if (data.protocol !== undefined) {
-                                                    const _errs93 = errors;
-                                                    if (typeof data.protocol !== "string") {
-                                                        const err73 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                        if (vErrors === null) {
-                                                            vErrors = [err73];
-                                                        }
-                                                        else {
-                                                            vErrors.push(err73);
-                                                        }
-                                                        errors++;
-                                                    }
-                                                    var valid20 = _errs93 === errors;
-                                                }
-                                                else {
-                                                    var valid20 = true;
-                                                }
-                                                if (valid20) {
-                                                    if (data.contextId !== undefined) {
-                                                        let data34 = data.contextId;
-                                                        const _errs95 = errors;
-                                                        if (errors === _errs95) {
-                                                            if (typeof data34 === "string") {
-                                                                if (func1(data34) > 600) {
-                                                                    const err74 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/properties/contextId/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                                    if (vErrors === null) {
-                                                                        vErrors = [err74];
-                                                                    }
-                                                                    else {
-                                                                        vErrors.push(err74);
-                                                                    }
-                                                                    errors++;
-                                                                }
+                                            var valid14 = _errs59 === errors;
+                                        }
+                                        else {
+                                            var valid14 = true;
+                                        }
+                                        if (valid14) {
+                                            if (data.protocolPath !== undefined) {
+                                                let data20 = data.protocolPath;
+                                                const _errs61 = errors;
+                                                if (errors === _errs61) {
+                                                    if (typeof data20 === "string") {
+                                                        if (func1(data20) > 600) {
+                                                            const err46 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/properties/protocolPath/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
+                                                            if (vErrors === null) {
+                                                                vErrors = [err46];
                                                             }
                                                             else {
-                                                                const err75 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/properties/contextId/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                                if (vErrors === null) {
-                                                                    vErrors = [err75];
-                                                                }
-                                                                else {
-                                                                    vErrors.push(err75);
-                                                                }
-                                                                errors++;
+                                                                vErrors.push(err46);
                                                             }
+                                                            errors++;
                                                         }
-                                                        var valid20 = _errs95 === errors;
                                                     }
                                                     else {
-                                                        var valid20 = true;
-                                                    }
-                                                    if (valid20) {
-                                                        if (data.protocolPath !== undefined) {
-                                                            let data35 = data.protocolPath;
-                                                            const _errs97 = errors;
-                                                            if (errors === _errs97) {
-                                                                if (typeof data35 === "string") {
-                                                                    if (func1(data35) > 600) {
-                                                                        const err76 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/properties/protocolPath/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                                        if (vErrors === null) {
-                                                                            vErrors = [err76];
-                                                                        }
-                                                                        else {
-                                                                            vErrors.push(err76);
-                                                                        }
-                                                                        errors++;
-                                                                    }
-                                                                }
-                                                                else {
-                                                                    const err77 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/properties/protocolPath/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                                    if (vErrors === null) {
-                                                                        vErrors = [err77];
-                                                                    }
-                                                                    else {
-                                                                        vErrors.push(err77);
-                                                                    }
-                                                                    errors++;
-                                                                }
-                                                            }
-                                                            var valid20 = _errs97 === errors;
+                                                        const err47 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/properties/protocolPath/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                                        if (vErrors === null) {
+                                                            vErrors = [err47];
                                                         }
                                                         else {
-                                                            var valid20 = true;
+                                                            vErrors.push(err47);
                                                         }
+                                                        errors++;
                                                     }
                                                 }
+                                                var valid14 = _errs61 === errors;
+                                            }
+                                            else {
+                                                var valid14 = true;
                                             }
                                         }
                                     }
                                 }
                             }
+                        }
+                    }
+                }
+                else {
+                    const err48 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                    if (vErrors === null) {
+                        vErrors = [err48];
+                    }
+                    else {
+                        vErrors.push(err48);
+                    }
+                    errors++;
+                }
+            }
+            var _valid0 = _errs51 === errors;
+            if (_valid0 && valid0) {
+                valid0 = false;
+                passing0 = [passing0, 4];
+            }
+            else {
+                if (_valid0) {
+                    valid0 = true;
+                    passing0 = 4;
+                    if (props0 !== true) {
+                        props0 = true;
+                    }
+                }
+                const _errs63 = errors;
+                const _errs64 = errors;
+                if (errors === _errs64) {
+                    if (data && typeof data == "object" && !Array.isArray(data)) {
+                        let missing9;
+                        if ((((data.interface === undefined) && (missing9 = "interface")) || ((data.method === undefined) && (missing9 = "method"))) || ((data.protocol === undefined) && (missing9 = "protocol"))) {
+                            const err49 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/required", keyword: "required", params: { missingProperty: missing9 }, message: "must have required property '" + missing9 + "'" };
+                            if (vErrors === null) {
+                                vErrors = [err49];
+                            }
                             else {
-                                const err78 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-                                if (vErrors === null) {
-                                    vErrors = [err78];
-                                }
-                                else {
-                                    vErrors.push(err78);
-                                }
-                                errors++;
+                                vErrors.push(err49);
                             }
-                        }
-                        var _valid0 = _errs87 === errors;
-                        if (_valid0 && valid0) {
-                            valid0 = false;
-                            passing0 = [passing0, 7];
+                            errors++;
                         }
                         else {
-                            if (_valid0) {
-                                valid0 = true;
-                                passing0 = 7;
-                                if (props0 !== true) {
-                                    props0 = true;
+                            const _errs66 = errors;
+                            for (const key5 in data) {
+                                if (!(((((key5 === "interface") || (key5 === "method")) || (key5 === "protocol")) || (key5 === "contextId")) || (key5 === "protocolPath"))) {
+                                    const err50 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key5 }, message: "must NOT have additional properties" };
+                                    if (vErrors === null) {
+                                        vErrors = [err50];
+                                    }
+                                    else {
+                                        vErrors.push(err50);
+                                    }
+                                    errors++;
+                                    break;
                                 }
                             }
-                            const _errs99 = errors;
-                            const _errs100 = errors;
-                            if (errors === _errs100) {
-                                if (data && typeof data == "object" && !Array.isArray(data)) {
-                                    let missing12;
-                                    if ((((data.interface === undefined) && (missing12 = "interface")) || ((data.method === undefined) && (missing12 = "method"))) || ((data.protocol === undefined) && (missing12 = "protocol"))) {
-                                        const err79 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/required", keyword: "required", params: { missingProperty: missing12 }, message: "must have required property '" + missing12 + "'" };
+                            if (_errs66 === errors) {
+                                if (data.interface !== undefined) {
+                                    const _errs67 = errors;
+                                    if ("Records" !== data.interface) {
+                                        const err51 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Records" }, message: "must be equal to constant" };
                                         if (vErrors === null) {
-                                            vErrors = [err79];
+                                            vErrors = [err51];
                                         }
                                         else {
-                                            vErrors.push(err79);
+                                            vErrors.push(err51);
                                         }
                                         errors++;
                                     }
+                                    var valid16 = _errs67 === errors;
+                                }
+                                else {
+                                    var valid16 = true;
+                                }
+                                if (valid16) {
+                                    if (data.method !== undefined) {
+                                        const _errs68 = errors;
+                                        if ("Write" !== data.method) {
+                                            const err52 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/properties/method/const", keyword: "const", params: { allowedValue: "Write" }, message: "must be equal to constant" };
+                                            if (vErrors === null) {
+                                                vErrors = [err52];
+                                            }
+                                            else {
+                                                vErrors.push(err52);
+                                            }
+                                            errors++;
+                                        }
+                                        var valid16 = _errs68 === errors;
+                                    }
                                     else {
-                                        const _errs102 = errors;
-                                        for (const key8 in data) {
-                                            if (!(((((key8 === "interface") || (key8 === "method")) || (key8 === "protocol")) || (key8 === "contextId")) || (key8 === "protocolPath"))) {
-                                                const err80 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key8 }, message: "must NOT have additional properties" };
+                                        var valid16 = true;
+                                    }
+                                    if (valid16) {
+                                        if (data.protocol !== undefined) {
+                                            const _errs69 = errors;
+                                            if (typeof data.protocol !== "string") {
+                                                const err53 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
                                                 if (vErrors === null) {
-                                                    vErrors = [err80];
+                                                    vErrors = [err53];
                                                 }
                                                 else {
-                                                    vErrors.push(err80);
+                                                    vErrors.push(err53);
                                                 }
                                                 errors++;
-                                                break;
                                             }
+                                            var valid16 = _errs69 === errors;
                                         }
-                                        if (_errs102 === errors) {
-                                            if (data.interface !== undefined) {
-                                                const _errs103 = errors;
-                                                if ("Records" !== data.interface) {
-                                                    const err81 = { instancePath: instancePath + "/interface", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/properties/interface/const", keyword: "const", params: { allowedValue: "Records" }, message: "must be equal to constant" };
-                                                    if (vErrors === null) {
-                                                        vErrors = [err81];
+                                        else {
+                                            var valid16 = true;
+                                        }
+                                        if (valid16) {
+                                            if (data.contextId !== undefined) {
+                                                let data24 = data.contextId;
+                                                const _errs71 = errors;
+                                                if (errors === _errs71) {
+                                                    if (typeof data24 === "string") {
+                                                        if (func1(data24) > 600) {
+                                                            const err54 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/properties/contextId/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
+                                                            if (vErrors === null) {
+                                                                vErrors = [err54];
+                                                            }
+                                                            else {
+                                                                vErrors.push(err54);
+                                                            }
+                                                            errors++;
+                                                        }
                                                     }
                                                     else {
-                                                        vErrors.push(err81);
-                                                    }
-                                                    errors++;
-                                                }
-                                                var valid22 = _errs103 === errors;
-                                            }
-                                            else {
-                                                var valid22 = true;
-                                            }
-                                            if (valid22) {
-                                                if (data.method !== undefined) {
-                                                    const _errs104 = errors;
-                                                    if ("Count" !== data.method) {
-                                                        const err82 = { instancePath: instancePath + "/method", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/properties/method/const", keyword: "const", params: { allowedValue: "Count" }, message: "must be equal to constant" };
+                                                        const err55 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/properties/contextId/type", keyword: "type", params: { type: "string" }, message: "must be string" };
                                                         if (vErrors === null) {
-                                                            vErrors = [err82];
+                                                            vErrors = [err55];
                                                         }
                                                         else {
-                                                            vErrors.push(err82);
+                                                            vErrors.push(err55);
                                                         }
                                                         errors++;
                                                     }
-                                                    var valid22 = _errs104 === errors;
-                                                }
-                                                else {
-                                                    var valid22 = true;
                                                 }
-                                                if (valid22) {
-                                                    if (data.protocol !== undefined) {
-                                                        const _errs105 = errors;
-                                                        if (typeof data.protocol !== "string") {
-                                                            const err83 = { instancePath: instancePath + "/protocol", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/properties/protocol/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                            if (vErrors === null) {
-                                                                vErrors = [err83];
-                                                            }
-                                                            else {
-                                                                vErrors.push(err83);
-                                                            }
-                                                            errors++;
-                                                        }
-                                                        var valid22 = _errs105 === errors;
-                                                    }
-                                                    else {
-                                                        var valid22 = true;
-                                                    }
-                                                    if (valid22) {
-                                                        if (data.contextId !== undefined) {
-                                                            let data39 = data.contextId;
-                                                            const _errs107 = errors;
-                                                            if (errors === _errs107) {
-                                                                if (typeof data39 === "string") {
-                                                                    if (func1(data39) > 600) {
-                                                                        const err84 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/properties/contextId/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                                        if (vErrors === null) {
-                                                                            vErrors = [err84];
-                                                                        }
-                                                                        else {
-                                                                            vErrors.push(err84);
-                                                                        }
-                                                                        errors++;
-                                                                    }
+                                                var valid16 = _errs71 === errors;
+                                            }
+                                            else {
+                                                var valid16 = true;
+                                            }
+                                            if (valid16) {
+                                                if (data.protocolPath !== undefined) {
+                                                    let data25 = data.protocolPath;
+                                                    const _errs73 = errors;
+                                                    if (errors === _errs73) {
+                                                        if (typeof data25 === "string") {
+                                                            if (func1(data25) > 600) {
+                                                                const err56 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/properties/protocolPath/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
+                                                                if (vErrors === null) {
+                                                                    vErrors = [err56];
                                                                 }
                                                                 else {
-                                                                    const err85 = { instancePath: instancePath + "/contextId", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/properties/contextId/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                                    if (vErrors === null) {
-                                                                        vErrors = [err85];
-                                                                    }
-                                                                    else {
-                                                                        vErrors.push(err85);
-                                                                    }
-                                                                    errors++;
+                                                                    vErrors.push(err56);
                                                                 }
+                                                                errors++;
                                                             }
-                                                            var valid22 = _errs107 === errors;
                                                         }
                                                         else {
-                                                            var valid22 = true;
-                                                        }
-                                                        if (valid22) {
-                                                            if (data.protocolPath !== undefined) {
-                                                                let data40 = data.protocolPath;
-                                                                const _errs109 = errors;
-                                                                if (errors === _errs109) {
-                                                                    if (typeof data40 === "string") {
-                                                                        if (func1(data40) > 600) {
-                                                                            const err86 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/properties/protocolPath/maxLength", keyword: "maxLength", params: { limit: 600 }, message: "must NOT have more than 600 characters" };
-                                                                            if (vErrors === null) {
-                                                                                vErrors = [err86];
-                                                                            }
-                                                                            else {
-                                                                                vErrors.push(err86);
-                                                                            }
-                                                                            errors++;
-                                                                        }
-                                                                    }
-                                                                    else {
-                                                                        const err87 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/properties/protocolPath/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                                        if (vErrors === null) {
-                                                                            vErrors = [err87];
-                                                                        }
-                                                                        else {
-                                                                            vErrors.push(err87);
-                                                                        }
-                                                                        errors++;
-                                                                    }
-                                                                }
-                                                                var valid22 = _errs109 === errors;
+                                                            const err57 = { instancePath: instancePath + "/protocolPath", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/properties/protocolPath/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                                            if (vErrors === null) {
+                                                                vErrors = [err57];
                                                             }
                                                             else {
-                                                                var valid22 = true;
+                                                                vErrors.push(err57);
                                                             }
+                                                            errors++;
                                                         }
                                                     }
+                                                    var valid16 = _errs73 === errors;
+                                                }
+                                                else {
+                                                    var valid16 = true;
                                                 }
                                             }
                                         }
                                     }
                                 }
-                                else {
-                                    const err88 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-                                    if (vErrors === null) {
-                                        vErrors = [err88];
-                                    }
-                                    else {
-                                        vErrors.push(err88);
-                                    }
-                                    errors++;
-                                }
-                            }
-                            var _valid0 = _errs99 === errors;
-                            if (_valid0 && valid0) {
-                                valid0 = false;
-                                passing0 = [passing0, 8];
-                            }
-                            else {
-                                if (_valid0) {
-                                    valid0 = true;
-                                    passing0 = 8;
-                                    if (props0 !== true) {
-                                        props0 = true;
-                                    }
-                                }
                             }
                         }
                     }
+                    else {
+                        const err58 = { instancePath, schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                        if (vErrors === null) {
+                            vErrors = [err58];
+                        }
+                        else {
+                            vErrors.push(err58);
+                        }
+                        errors++;
+                    }
+                }
+                var _valid0 = _errs63 === errors;
+                if (_valid0 && valid0) {
+                    valid0 = false;
+                    passing0 = [passing0, 5];
+                }
+                else {
+                    if (_valid0) {
+                        valid0 = true;
+                        passing0 = 5;
+                        if (props0 !== true) {
+                            props0 = true;
+                        }
+                    }
                 }
             }
         }
     }
 } if (!valid0) {
-    const err89 = { instancePath, schemaPath: "#/oneOf", keyword: "oneOf", params: { passingSchemas: passing0 }, message: "must match exactly one schema in oneOf" };
+    const err59 = { instancePath, schemaPath: "#/oneOf", keyword: "oneOf", params: { passingSchemas: passing0 }, message: "must match exactly one schema in oneOf" };
     if (vErrors === null) {
-        vErrors = [err89];
+        vErrors = [err59];
     }
     else {
-        vErrors.push(err89);
+        vErrors.push(err59);
     }
     errors++;
     validate74.errors = vErrors;
@@ -11544,7 +10764,7 @@ function validate73(data, { instancePath = "", parentData, parentDataProperty, r
                                                     return false;
                                                 }
                                                 if (!((data4 === "Required") || (data4 === "Prohibited"))) {
-                                                    validate73.errors = [{ instancePath: instancePath + "/conditions/publication", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions/properties/publication/enum", keyword: "enum", params: { allowedValues: schema108.properties.publication.enum }, message: "must be equal to one of the allowed values" }];
+                                                    validate73.errors = [{ instancePath: instancePath + "/conditions/publication", schemaPath: "https://identity.foundation/dwn/json-schemas/permissions/defs.json#/$defs/conditions/properties/publication/enum", keyword: "enum", params: { allowedValues: schema105.properties.publication.enum }, message: "must be equal to one of the allowed values" }];
                                                     return false;
                                                 }
                                             }
@@ -11573,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 schema121 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/permission-revoke-data.json", "type": "object", "additionalProperties": false, "properties": { "description": { "type": "string" } } };
+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) {
@@ -11604,7 +10824,7 @@ function validate76(data, { instancePath = "", parentData, parentDataProperty, r
 } validate76.errors = vErrors; return errors === 0; }
 validate76.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const PermissionsDefinitions = validate69;
-const schema96 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/permissions/defs.json", "type": "object", "$defs": { "scope": { "oneOf": [{ "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-configure-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/protocols-query-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-read-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-delete-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-write-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-query-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-subscribe-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/records-count-scope" }] }, "conditions": { "type": "object", "additionalProperties": false, "properties": { "publication": { "enum": ["Required", "Prohibited"], "type": "string" } } } } };
+const schema96 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/permissions/defs.json", "type": "object", "$defs": { "scope": { "oneOf": [{ "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/messages-read-scope" }, { "$ref": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json#/$defs/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" }] }, "conditions": { "type": "object", "additionalProperties": false, "properties": { "publication": { "enum": ["Required", "Prohibited"], "type": "string" } } } } };
 function validate69(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/permissions/defs.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate69.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -11615,7 +10835,7 @@ function validate69(data, { instancePath = "", parentData, parentDataProperty, r
 } validate69.errors = vErrors; return errors === 0; }
 validate69.evaluated = { "dynamicProps": false, "dynamicItems": false };
 export const PermissionsScopes = validate71;
-const schema98 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json", "type": "object", "$defs": { "messages-read-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Messages" }, "method": { "const": "Read" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } }, "allOf": [{ "not": { "required": ["contextId", "protocolPath"] } }, { "if": { "anyOf": [{ "required": ["contextId"] }, { "required": ["protocolPath"] }] }, "then": { "required": ["protocol"] } }] }, "protocols-configure-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Protocols" }, "method": { "const": "Configure" }, "protocol": { "type": "string" } } }, "protocols-query-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Protocols" }, "method": { "const": "Query" }, "protocol": { "type": "string" } } }, "records-delete-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Delete" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } } }, "records-read-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Read" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } } }, "records-write-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Write" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } } }, "records-query-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Query" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } } }, "records-subscribe-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Subscribe" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } } }, "records-count-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Count" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } } } } };
+const schema98 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/permissions/scopes.json", "type": "object", "$defs": { "messages-read-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Messages" }, "method": { "const": "Read" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } }, "allOf": [{ "not": { "required": ["contextId", "protocolPath"] } }, { "if": { "anyOf": [{ "required": ["contextId"] }, { "required": ["protocolPath"] }] }, "then": { "required": ["protocol"] } }] }, "protocols-configure-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Protocols" }, "method": { "const": "Configure" }, "protocol": { "type": "string" } } }, "protocols-query-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method"], "properties": { "interface": { "const": "Protocols" }, "method": { "const": "Query" }, "protocol": { "type": "string" } } }, "records-delete-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Delete" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } } }, "records-read-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Read" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } } }, "records-write-scope": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "protocol"], "properties": { "interface": { "const": "Records" }, "method": { "const": "Write" }, "protocol": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "protocolPath": { "type": "string", "maxLength": 600 } } } } };
 function validate71(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/permissions/scopes.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate71.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
@@ -11626,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 schema122 = { "$id": "https://identity.foundation/dwn/json-schemas/protocol-definition.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object", "additionalProperties": false, "required": ["protocol", "published", "types", "structure"], "properties": { "protocol": { "type": "string" }, "published": { "type": "boolean" }, "uses": { "$comment": "Maps alias names to external protocol URIs for composition. Each alias can be used in $ref values and cross-protocol role/of references using 'alias:path' syntax.", "type": "object", "minProperties": 1, "patternProperties": { "^[a-zA-Z][a-zA-Z0-9_-]*$": { "type": "string" } }, "additionalProperties": false }, "types": { "type": "object", "patternProperties": { ".*": { "type": "object", "additionalProperties": false, "properties": { "schema": { "type": "string" }, "dataFormats": { "type": "array", "minItems": 1, "items": { "type": "string" } }, "encryptionRequired": { "type": "boolean" } } } } }, "structure": { "type": "object", "patternProperties": { ".*": { "$ref": "https://identity.foundation/dwn/json-schemas/protocol-rule-set.json" } } } } };
-const pattern38 = new RegExp("^[a-zA-Z][a-zA-Z0-9_-]*$", "u");
-const pattern40 = new RegExp(".*", "u");
-const schema123 = { "$id": "https://identity.foundation/dwn/json-schemas/protocol-rule-set.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object", "additionalProperties": false, "properties": { "$encryption": { "type": "object", "additionalProperties": false, "properties": { "rootKeyId": { "type": "string" }, "publicKeyJwk": { "$ref": "https://identity.foundation/dwn/json-schemas/public-jwk.json" } }, "required": ["rootKeyId", "publicKeyJwk"] }, "$actions": { "type": "array", "minItems": 1, "items": { "type": "object", "oneOf": [{ "required": ["who", "can"], "additionalProperties": false, "properties": { "who": { "type": "string", "enum": ["anyone", "author", "recipient"] }, "of": { "type": "string" }, "can": { "type": "array", "minItems": 1, "items": { "type": "string", "enum": ["co-delete", "co-prune", "co-update", "create", "delete", "prune", "read", "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;
@@ -11644,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(schema123.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;
@@ -11774,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: schema123.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];
                                                         }
@@ -11839,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: schema123.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];
                                                                                 }
@@ -11961,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: schema123.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];
                                                                             }
@@ -12069,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;
                                     }
@@ -12203,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: schema123.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;
@@ -12246,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: schema123.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;
@@ -12263,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: schema123.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;
@@ -12328,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;
@@ -12346,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: schema123.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;
@@ -12364,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: schema123.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;
@@ -12376,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;
                                                                                                                     }
                                                                                                                 }
@@ -12402,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: schema123.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;
@@ -12414,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;
                                                                                                                         }
                                                                                                                     }
@@ -12459,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);
@@ -12546,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;
@@ -12555,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" }];
@@ -12588,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) {
@@ -12692,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;
@@ -12726,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 schema124 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/protocols-configure.json", "type": "object", "additionalProperties": false, "required": ["authorization", "descriptor"], "properties": { "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization-delegated-grant.json" }, "descriptor": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "messageTimestamp", "definition"], "properties": { "interface": { "enum": ["Protocols"], "type": "string" }, "method": { "enum": ["Configure"], "type": "string" }, "messageTimestamp": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "definition": { "$ref": "https://identity.foundation/dwn/json-schemas/protocol-definition.json" }, "permissionGrantId": { "type": "string" } } } } };
+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) {
@@ -12788,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: schema124.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;
@@ -12805,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: schema124.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;
@@ -12887,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 schema126 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/protocols-query.json", "type": "object", "additionalProperties": false, "required": ["descriptor"], "properties": { "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization.json" }, "descriptor": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "messageTimestamp"], "properties": { "interface": { "enum": ["Protocols"], "type": "string" }, "method": { "enum": ["Query"], "type": "string" }, "messageTimestamp": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "filter": { "type": "object", "minProperties": 1, "additionalProperties": false, "properties": { "protocol": { "type": "string" }, "recipient": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/did" } } }, "permissionGrantId": { "type": "string" } } } } };
+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) {
@@ -12949,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: schema126.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;
@@ -12966,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: schema126.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;
@@ -13103,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 schema129 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/records-read.json", "type": "object", "additionalProperties": false, "required": ["descriptor"], "properties": { "authorization": { "$ref": "https://identity.foundation/dwn/json-schemas/authorization-delegated-grant.json" }, "descriptor": { "type": "object", "additionalProperties": false, "required": ["interface", "method", "messageTimestamp", "filter"], "properties": { "interface": { "enum": ["Records"], "type": "string" }, "method": { "enum": ["Read"], "type": "string" }, "messageTimestamp": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/date-time" }, "filter": { "$ref": "https://identity.foundation/dwn/json-schemas/records-filter.json" }, "permissionGrantId": { "type": "string" }, "dateSort": { "enum": ["createdAscending", "createdDescending", "publishedAscending", "publishedDescending", "updatedAscending", "updatedDescending"], "type": "string" } } } } };
+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) {
@@ -13165,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: schema129.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;
@@ -13182,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: schema129.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;
@@ -13245,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: schema129.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;
@@ -13284,7 +12504,7 @@ validate86.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": f
 export const RecordsFilter = validate41;
 export const PublicJwk = validate32;
 export const GenericSignaturePayload = validate89;
-const schema131 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/signature-payloads/generic-signature-payload.json", "type": "object", "additionalProperties": false, "required": ["descriptorCid"], "properties": { "descriptorCid": { "type": "string" }, "delegatedGrantId": { "type": "string" }, "permissionGrantId": { "$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) {
@@ -13423,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 schema132 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://identity.foundation/dwn/json-schemas/signature-payloads/records-write-signature-payload.json", "type": "object", "additionalProperties": false, "required": ["descriptorCid", "recordId"], "properties": { "descriptorCid": { "type": "string" }, "recordId": { "type": "string" }, "contextId": { "type": "string", "maxLength": 600 }, "attestationCid": { "type": "string" }, "encryptionCid": { "type": "string" }, "delegatedGrantId": { "type": "string" }, "permissionGrantId": { "type": "string" }, "protocolRole": { "type": "string" } } };
+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) {