@enbox/dwn-sdk-js 0.4.7 → 0.4.8

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

@@ -16520,4 +16520,323 @@ function validate109(data, { instancePath = "", parentData, parentDataProperty,
     }
 } validate109.errors = vErrors; return errors === 0; }
 validate109.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+export const WrappedGrantKeyEnvelope = validate110;
+const schema153 = { "$id": "https://identity.foundation/dwn/json-schemas/encryption/wrapped-grant-key-envelope.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object", "additionalProperties": false, "required": ["format", "keyEncryption", "contentEncryption", "ciphertext"], "properties": { "format": { "const": "enbox/wrapped-grant-key@1" }, "keyEncryption": { "type": "object", "additionalProperties": false, "required": ["algorithm", "keyId", "ephemeralPublicKey", "encryptedKey"], "properties": { "algorithm": { "const": "X25519-HKDF-SHA256+A256KW" }, "keyId": { "type": "string", "pattern": "^[A-Za-z0-9_-]{43}$" }, "ephemeralPublicKey": { "$ref": "#/$defs/x25519PublicKey" }, "encryptedKey": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url" } } }, "contentEncryption": { "type": "object", "additionalProperties": false, "required": ["algorithm", "initializationVector"], "properties": { "algorithm": { "const": "A256CTR" }, "initializationVector": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url" } } }, "ciphertext": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url" } }, "$defs": { "x25519PublicKey": { "allOf": [{ "$ref": "https://identity.foundation/dwn/json-schemas/public-jwk.json" }], "type": "object", "required": ["kty", "crv", "x"], "properties": { "kty": { "const": "OKP" }, "crv": { "const": "X25519" }, "x": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url" } } } } };
+const schema154 = { "allOf": [{ "$ref": "https://identity.foundation/dwn/json-schemas/public-jwk.json" }], "type": "object", "required": ["kty", "crv", "x"], "properties": { "kty": { "const": "OKP" }, "crv": { "const": "X25519" }, "x": { "$ref": "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url" } } };
+function validate111(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate111.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (!(validate33(data, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }))) {
+    vErrors = vErrors === null ? validate33.errors : vErrors.concat(validate33.errors);
+    errors = vErrors.length;
+}
+else {
+    var props0 = validate33.evaluated.props;
+} if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if ((((data.kty === undefined) && (missing0 = "kty")) || ((data.crv === undefined) && (missing0 = "crv"))) || ((data.x === undefined) && (missing0 = "x"))) {
+            validate111.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            if (props0 !== true) {
+                props0 = props0 || {};
+                props0.kty = true;
+                props0.crv = true;
+                props0.x = true;
+            }
+            if (data.kty !== undefined) {
+                const _errs2 = errors;
+                if ("OKP" !== data.kty) {
+                    validate111.errors = [{ instancePath: instancePath + "/kty", schemaPath: "#/properties/kty/const", keyword: "const", params: { allowedValue: "OKP" }, message: "must be equal to constant" }];
+                    return false;
+                }
+                var valid1 = _errs2 === errors;
+            }
+            else {
+                var valid1 = true;
+            }
+            if (valid1) {
+                if (data.crv !== undefined) {
+                    const _errs3 = errors;
+                    if ("X25519" !== data.crv) {
+                        validate111.errors = [{ instancePath: instancePath + "/crv", schemaPath: "#/properties/crv/const", keyword: "const", params: { allowedValue: "X25519" }, message: "must be equal to constant" }];
+                        return false;
+                    }
+                    var valid1 = _errs3 === errors;
+                }
+                else {
+                    var valid1 = true;
+                }
+                if (valid1) {
+                    if (data.x !== undefined) {
+                        let data2 = data.x;
+                        const _errs4 = errors;
+                        const _errs5 = errors;
+                        if (errors === _errs5) {
+                            if (typeof data2 === "string") {
+                                if (!pattern4.test(data2)) {
+                                    validate111.errors = [{ instancePath: instancePath + "/x", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: "must match pattern \"" + "^[A-Za-z0-9_-]+$" + "\"" }];
+                                    return false;
+                                }
+                            }
+                            else {
+                                validate111.errors = [{ instancePath: instancePath + "/x", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                return false;
+                            }
+                        }
+                        var valid1 = _errs4 === errors;
+                    }
+                    else {
+                        var valid1 = true;
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate111.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate111.errors = vErrors; evaluated0.props = props0; return errors === 0; }
+validate111.evaluated = { "dynamicProps": true, "dynamicItems": false };
+function validate110(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://identity.foundation/dwn/json-schemas/encryption/wrapped-grant-key-envelope.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate110.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.format === undefined) && (missing0 = "format")) || ((data.keyEncryption === undefined) && (missing0 = "keyEncryption"))) || ((data.contentEncryption === undefined) && (missing0 = "contentEncryption"))) || ((data.ciphertext === undefined) && (missing0 = "ciphertext"))) {
+            validate110.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 === "format") || (key0 === "keyEncryption")) || (key0 === "contentEncryption")) || (key0 === "ciphertext"))) {
+                    validate110.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                    return false;
+                    break;
+                }
+            }
+            if (_errs1 === errors) {
+                if (data.format !== undefined) {
+                    const _errs2 = errors;
+                    if ("enbox/wrapped-grant-key@1" !== data.format) {
+                        validate110.errors = [{ instancePath: instancePath + "/format", schemaPath: "#/properties/format/const", keyword: "const", params: { allowedValue: "enbox/wrapped-grant-key@1" }, message: "must be equal to constant" }];
+                        return false;
+                    }
+                    var valid0 = _errs2 === errors;
+                }
+                else {
+                    var valid0 = true;
+                }
+                if (valid0) {
+                    if (data.keyEncryption !== undefined) {
+                        let data1 = data.keyEncryption;
+                        const _errs3 = errors;
+                        if (errors === _errs3) {
+                            if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
+                                let missing1;
+                                if (((((data1.algorithm === undefined) && (missing1 = "algorithm")) || ((data1.keyId === undefined) && (missing1 = "keyId"))) || ((data1.ephemeralPublicKey === undefined) && (missing1 = "ephemeralPublicKey"))) || ((data1.encryptedKey === undefined) && (missing1 = "encryptedKey"))) {
+                                    validate110.errors = [{ instancePath: instancePath + "/keyEncryption", schemaPath: "#/properties/keyEncryption/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                                    return false;
+                                }
+                                else {
+                                    const _errs5 = errors;
+                                    for (const key1 in data1) {
+                                        if (!((((key1 === "algorithm") || (key1 === "keyId")) || (key1 === "ephemeralPublicKey")) || (key1 === "encryptedKey"))) {
+                                            validate110.errors = [{ instancePath: instancePath + "/keyEncryption", schemaPath: "#/properties/keyEncryption/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                            return false;
+                                            break;
+                                        }
+                                    }
+                                    if (_errs5 === errors) {
+                                        if (data1.algorithm !== undefined) {
+                                            const _errs6 = errors;
+                                            if ("X25519-HKDF-SHA256+A256KW" !== data1.algorithm) {
+                                                validate110.errors = [{ instancePath: instancePath + "/keyEncryption/algorithm", schemaPath: "#/properties/keyEncryption/properties/algorithm/const", keyword: "const", params: { allowedValue: "X25519-HKDF-SHA256+A256KW" }, message: "must be equal to constant" }];
+                                                return false;
+                                            }
+                                            var valid1 = _errs6 === errors;
+                                        }
+                                        else {
+                                            var valid1 = true;
+                                        }
+                                        if (valid1) {
+                                            if (data1.keyId !== undefined) {
+                                                let data3 = data1.keyId;
+                                                const _errs7 = errors;
+                                                if (errors === _errs7) {
+                                                    if (typeof data3 === "string") {
+                                                        if (!pattern9.test(data3)) {
+                                                            validate110.errors = [{ instancePath: instancePath + "/keyEncryption/keyId", schemaPath: "#/properties/keyEncryption/properties/keyId/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]{43}$" }, message: "must match pattern \"" + "^[A-Za-z0-9_-]{43}$" + "\"" }];
+                                                            return false;
+                                                        }
+                                                    }
+                                                    else {
+                                                        validate110.errors = [{ instancePath: instancePath + "/keyEncryption/keyId", schemaPath: "#/properties/keyEncryption/properties/keyId/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                        return false;
+                                                    }
+                                                }
+                                                var valid1 = _errs7 === errors;
+                                            }
+                                            else {
+                                                var valid1 = true;
+                                            }
+                                            if (valid1) {
+                                                if (data1.ephemeralPublicKey !== undefined) {
+                                                    const _errs9 = errors;
+                                                    if (!(validate111(data1.ephemeralPublicKey, { instancePath: instancePath + "/keyEncryption/ephemeralPublicKey", parentData: data1, parentDataProperty: "ephemeralPublicKey", rootData, dynamicAnchors }))) {
+                                                        vErrors = vErrors === null ? validate111.errors : vErrors.concat(validate111.errors);
+                                                        errors = vErrors.length;
+                                                    }
+                                                    var valid1 = _errs9 === errors;
+                                                }
+                                                else {
+                                                    var valid1 = true;
+                                                }
+                                                if (valid1) {
+                                                    if (data1.encryptedKey !== undefined) {
+                                                        let data5 = data1.encryptedKey;
+                                                        const _errs10 = errors;
+                                                        const _errs11 = errors;
+                                                        if (errors === _errs11) {
+                                                            if (typeof data5 === "string") {
+                                                                if (!pattern4.test(data5)) {
+                                                                    validate110.errors = [{ instancePath: instancePath + "/keyEncryption/encryptedKey", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: "must match pattern \"" + "^[A-Za-z0-9_-]+$" + "\"" }];
+                                                                    return false;
+                                                                }
+                                                            }
+                                                            else {
+                                                                validate110.errors = [{ instancePath: instancePath + "/keyEncryption/encryptedKey", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                return false;
+                                                            }
+                                                        }
+                                                        var valid1 = _errs10 === errors;
+                                                    }
+                                                    else {
+                                                        var valid1 = true;
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                validate110.errors = [{ instancePath: instancePath + "/keyEncryption", schemaPath: "#/properties/keyEncryption/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                return false;
+                            }
+                        }
+                        var valid0 = _errs3 === errors;
+                    }
+                    else {
+                        var valid0 = true;
+                    }
+                    if (valid0) {
+                        if (data.contentEncryption !== undefined) {
+                            let data6 = data.contentEncryption;
+                            const _errs13 = errors;
+                            if (errors === _errs13) {
+                                if (data6 && typeof data6 == "object" && !Array.isArray(data6)) {
+                                    let missing2;
+                                    if (((data6.algorithm === undefined) && (missing2 = "algorithm")) || ((data6.initializationVector === undefined) && (missing2 = "initializationVector"))) {
+                                        validate110.errors = [{ instancePath: instancePath + "/contentEncryption", schemaPath: "#/properties/contentEncryption/required", keyword: "required", params: { missingProperty: missing2 }, message: "must have required property '" + missing2 + "'" }];
+                                        return false;
+                                    }
+                                    else {
+                                        const _errs15 = errors;
+                                        for (const key2 in data6) {
+                                            if (!((key2 === "algorithm") || (key2 === "initializationVector"))) {
+                                                validate110.errors = [{ instancePath: instancePath + "/contentEncryption", schemaPath: "#/properties/contentEncryption/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" }];
+                                                return false;
+                                                break;
+                                            }
+                                        }
+                                        if (_errs15 === errors) {
+                                            if (data6.algorithm !== undefined) {
+                                                const _errs16 = errors;
+                                                if ("A256CTR" !== data6.algorithm) {
+                                                    validate110.errors = [{ instancePath: instancePath + "/contentEncryption/algorithm", schemaPath: "#/properties/contentEncryption/properties/algorithm/const", keyword: "const", params: { allowedValue: "A256CTR" }, message: "must be equal to constant" }];
+                                                    return false;
+                                                }
+                                                var valid3 = _errs16 === errors;
+                                            }
+                                            else {
+                                                var valid3 = true;
+                                            }
+                                            if (valid3) {
+                                                if (data6.initializationVector !== undefined) {
+                                                    let data8 = data6.initializationVector;
+                                                    const _errs17 = errors;
+                                                    const _errs18 = errors;
+                                                    if (errors === _errs18) {
+                                                        if (typeof data8 === "string") {
+                                                            if (!pattern4.test(data8)) {
+                                                                validate110.errors = [{ instancePath: instancePath + "/contentEncryption/initializationVector", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: "must match pattern \"" + "^[A-Za-z0-9_-]+$" + "\"" }];
+                                                                return false;
+                                                            }
+                                                        }
+                                                        else {
+                                                            validate110.errors = [{ instancePath: instancePath + "/contentEncryption/initializationVector", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                            return false;
+                                                        }
+                                                    }
+                                                    var valid3 = _errs17 === errors;
+                                                }
+                                                else {
+                                                    var valid3 = true;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                else {
+                                    validate110.errors = [{ instancePath: instancePath + "/contentEncryption", schemaPath: "#/properties/contentEncryption/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                    return false;
+                                }
+                            }
+                            var valid0 = _errs13 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                        if (valid0) {
+                            if (data.ciphertext !== undefined) {
+                                let data9 = data.ciphertext;
+                                const _errs20 = errors;
+                                const _errs21 = errors;
+                                if (errors === _errs21) {
+                                    if (typeof data9 === "string") {
+                                        if (!pattern4.test(data9)) {
+                                            validate110.errors = [{ instancePath: instancePath + "/ciphertext", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: "must match pattern \"" + "^[A-Za-z0-9_-]+$" + "\"" }];
+                                            return false;
+                                        }
+                                    }
+                                    else {
+                                        validate110.errors = [{ instancePath: instancePath + "/ciphertext", schemaPath: "https://identity.foundation/dwn/json-schemas/defs.json#/$defs/base64url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                        return false;
+                                    }
+                                }
+                                var valid0 = _errs20 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate110.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate110.errors = vErrors; return errors === 0; }
+validate110.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 //# sourceMappingURL=precompiled-validators.js.map