@qed-proof/sdk 0.1.1 → 0.1.3

package/dist/index.js

@@ -171,399 +171,1314 @@ function rootFromInclusion(index, size, leaf, path) {
   return sn === 0 ? r : null;
 }
 
-// src/schema.ts
-import Ajv2020 from "ajv/dist/2020.js";
-import addFormats from "ajv-formats";
-
-// src/generated/receipt-schema.ts
-var receiptSchema = {
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "urn:poaw:schema:0.1:receipt",
-  "title": "PoAW receipt (poaw/0.1)",
-  "description": "Structural schema for a Proof of Agent Work receipt. Signature, inclusion and anchor checks are defined in SPEC.md and are not expressible in JSON Schema.",
-  "type": "object",
-  "required": [
-    "body",
-    "signature"
-  ],
-  "additionalProperties": false,
-  "properties": {
-    "body": {
-      "$ref": "#/$defs/body"
-    },
-    "signature": {
-      "$ref": "#/$defs/signature"
-    },
-    "proof": {
-      "$ref": "#/$defs/proof"
+// src/generated/receipt-validator.js
+function ucs2length(str) {
+  const len = str.length;
+  let length = 0;
+  let pos = 0;
+  let value;
+  while (pos < len) {
+    length++;
+    value = str.charCodeAt(pos++);
+    if (value >= 55296 && value <= 56319 && pos < len) {
+      value = str.charCodeAt(pos);
+      if ((value & 64512) === 56320) pos++;
     }
-  },
-  "$defs": {
-    "timestamp": {
-      "type": "string",
-      "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,3})?Z$"
-    },
-    "b64url": {
-      "type": "string",
-      "pattern": "^[A-Za-z0-9_-]+$"
-    },
-    "keyId": {
-      "type": "string",
-      "pattern": "^ed25519:[A-Za-z0-9_-]{43}$"
-    },
-    "fingerprint": {
-      "type": "string",
-      "pattern": "^sha256:[A-Za-z0-9_-]{43}$"
-    },
-    "action": {
-      "type": "string",
-      "pattern": "^[a-z0-9]+(\\.[a-z0-9_]+){2}$"
-    },
-    "verdictValue": {
-      "enum": [
-        "verified",
-        "late",
-        "mismatch",
-        "failed",
-        "unverifiable"
-      ]
-    },
-    "reasonCode": {
-      "enum": [
-        "not_found",
-        "content_mismatch",
-        "target_mismatch",
-        "observed_after_tolerance",
-        "no_connection",
-        "permission_denied",
-        "rate_limited",
-        "destination_unavailable",
-        "unsupported_action",
-        "claim_ambiguous",
-        "verifier_error"
-      ]
-    },
-    "body": {
-      "type": "object",
-      "required": [
-        "spec_version",
-        "receipt_id",
-        "issued_at",
-        "issuer",
-        "agent",
-        "claim",
-        "observation",
-        "verdict",
-        "trust_level"
-      ],
-      "properties": {
-        "spec_version": {
-          "const": "poaw/0.1"
-        },
-        "receipt_id": {
-          "type": "string",
-          "minLength": 1,
-          "maxLength": 128
-        },
-        "issued_at": {
-          "$ref": "#/$defs/timestamp"
-        },
-        "issuer": {
-          "type": "object",
-          "required": [
-            "key_id"
-          ],
-          "properties": {
-            "key_id": {
-              "$ref": "#/$defs/keyId"
-            },
-            "name": {
-              "type": "string",
-              "maxLength": 128
-            }
+  }
+  return length;
+}
+var validate = validate20;
+var schema42 = { "enum": ["verified", "late", "mismatch", "failed", "unverifiable"] };
+var schema43 = { "enum": ["not_found", "content_mismatch", "target_mismatch", "observed_after_tolerance", "no_connection", "permission_denied", "rate_limited", "destination_unavailable", "unsupported_action", "claim_ambiguous", "verifier_error"] };
+var func1 = ucs2length;
+var pattern4 = new RegExp("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,3})?Z$", "u");
+var pattern5 = new RegExp("^ed25519:[A-Za-z0-9_-]{43}$", "u");
+var pattern6 = new RegExp("^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}$", "u");
+var pattern7 = new RegExp("^[a-z0-9]+(\\.[a-z0-9_]+){2}$", "u");
+var pattern9 = new RegExp("^[A-Za-z0-9_-]+$", "u");
+var pattern11 = new RegExp("^\\d+$", "u");
+var pattern12 = new RegExp("^sha256:[A-Za-z0-9_-]{43}$", "u");
+function validate21(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate21.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  const _errs1 = errors;
+  let valid0 = true;
+  const _errs2 = errors;
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.trust_level !== void 0) {
+      let data0 = data.trust_level;
+      if (typeof data0 == "number") {
+        if (data0 < 3 || isNaN(data0)) {
+          const err0 = {};
+          if (vErrors === null) {
+            vErrors = [err0];
+          } else {
+            vErrors.push(err0);
           }
-        },
-        "agent": {
-          "type": "object",
-          "required": [
-            "id"
-          ],
-          "properties": {
-            "id": {
-              "type": "string",
-              "minLength": 1,
-              "maxLength": 256
-            },
-            "erc8004": {
-              "type": "object",
-              "required": [
-                "chain",
-                "registry",
-                "agent_id"
-              ],
-              "properties": {
-                "chain": {
-                  "type": "string",
-                  "pattern": "^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}$"
-                },
-                "registry": {
-                  "type": "string"
-                },
-                "agent_id": {
-                  "type": "string"
+          errors++;
+        }
+      }
+    }
+  }
+  var _valid0 = _errs2 === errors;
+  errors = _errs1;
+  if (vErrors !== null) {
+    if (_errs1) {
+      vErrors.length = _errs1;
+    } else {
+      vErrors = null;
+    }
+  }
+  if (_valid0) {
+    const _errs4 = errors;
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing0;
+      if (data.attestation === void 0 && (missing0 = "attestation")) {
+        validate21.errors = [{ instancePath, schemaPath: "#/then/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        return false;
+      } else {
+        if (data.observation !== void 0) {
+          let data1 = data.observation;
+          if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
+            if (data1.verifier !== void 0) {
+              let data2 = data1.verifier;
+              if (data2 && typeof data2 == "object" && !Array.isArray(data2)) {
+                let missing1;
+                if (data2.id === void 0 && (missing1 = "id") || data2.version === void 0 && (missing1 = "version") || data2.code_hash === void 0 && (missing1 = "code_hash")) {
+                  validate21.errors = [{ instancePath: instancePath + "/observation/verifier", schemaPath: "#/then/properties/observation/properties/verifier/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                  return false;
                 }
               }
             }
           }
-        },
-        "operator": {
-          "type": "string",
-          "maxLength": 256
-        },
-        "claim": {
-          "type": "object",
-          "required": [
-            "action",
-            "target",
-            "params",
-            "claimed_at",
-            "claim_digest"
-          ],
-          "properties": {
-            "action": {
-              "$ref": "#/$defs/action"
-            },
-            "target": {
-              "type": "string",
-              "minLength": 1,
-              "maxLength": 512
-            },
-            "params": {
-              "type": "object"
-            },
-            "claimed_at": {
-              "$ref": "#/$defs/timestamp"
-            },
-            "client_claim_id": {
-              "type": "string",
-              "maxLength": 256
-            },
-            "claim_digest": {
-              "$ref": "#/$defs/b64url"
-            }
+        }
+      }
+    }
+    var _valid0 = _errs4 === errors;
+    valid0 = _valid0;
+    if (valid0) {
+      var props0 = {};
+      props0.observation = true;
+      props0.trust_level = true;
+    }
+  }
+  if (!valid0) {
+    const err1 = { instancePath, schemaPath: "#/if", keyword: "if", params: { failingKeyword: "then" }, message: 'must match "then" schema' };
+    if (vErrors === null) {
+      vErrors = [err1];
+    } else {
+      vErrors.push(err1);
+    }
+    errors++;
+    validate21.errors = vErrors;
+    return false;
+  }
+  if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing2;
+      if (data.spec_version === void 0 && (missing2 = "spec_version") || data.receipt_id === void 0 && (missing2 = "receipt_id") || data.issued_at === void 0 && (missing2 = "issued_at") || data.issuer === void 0 && (missing2 = "issuer") || data.agent === void 0 && (missing2 = "agent") || data.claim === void 0 && (missing2 = "claim") || data.observation === void 0 && (missing2 = "observation") || data.verdict === void 0 && (missing2 = "verdict") || data.trust_level === void 0 && (missing2 = "trust_level")) {
+        validate21.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing2 }, message: "must have required property '" + missing2 + "'" }];
+        return false;
+      } else {
+        if (props0 !== true) {
+          props0 = props0 || {};
+          props0.spec_version = true;
+          props0.receipt_id = true;
+          props0.issued_at = true;
+          props0.issuer = true;
+          props0.agent = true;
+          props0.operator = true;
+          props0.claim = true;
+          props0.observation = true;
+          props0.verdict = true;
+          props0.trust_level = true;
+          props0.attestation = true;
+          props0.supersedes = true;
+        }
+        if (data.spec_version !== void 0) {
+          const _errs7 = errors;
+          if ("poaw/0.1" !== data.spec_version) {
+            validate21.errors = [{ instancePath: instancePath + "/spec_version", schemaPath: "#/properties/spec_version/const", keyword: "const", params: { allowedValue: "poaw/0.1" }, message: "must be equal to constant" }];
+            return false;
           }
-        },
-        "observation": {
-          "type": "object",
-          "required": [
-            "verifier",
-            "observed_at",
-            "deadline_at",
-            "attempts",
-            "facts"
-          ],
-          "properties": {
-            "verifier": {
-              "type": "object",
-              "required": [
-                "id",
-                "version"
-              ],
-              "properties": {
-                "id": {
-                  "$ref": "#/$defs/action"
-                },
-                "version": {
-                  "type": "string",
-                  "pattern": "^\\d+$"
-                },
-                "code_hash": {
-                  "$ref": "#/$defs/fingerprint"
+          var valid4 = _errs7 === errors;
+        } else {
+          var valid4 = true;
+        }
+        if (valid4) {
+          if (data.receipt_id !== void 0) {
+            let data4 = data.receipt_id;
+            const _errs8 = errors;
+            if (errors === _errs8) {
+              if (typeof data4 === "string") {
+                if (func1(data4) > 128) {
+                  validate21.errors = [{ instancePath: instancePath + "/receipt_id", schemaPath: "#/properties/receipt_id/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                  return false;
+                } else {
+                  if (func1(data4) < 1) {
+                    validate21.errors = [{ instancePath: instancePath + "/receipt_id", schemaPath: "#/properties/receipt_id/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                    return false;
+                  }
                 }
+              } else {
+                validate21.errors = [{ instancePath: instancePath + "/receipt_id", schemaPath: "#/properties/receipt_id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                return false;
               }
-            },
-            "observed_at": {
-              "$ref": "#/$defs/timestamp"
-            },
-            "deadline_at": {
-              "$ref": "#/$defs/timestamp"
-            },
-            "attempts": {
-              "type": "integer",
-              "minimum": 1
-            },
-            "facts": {
-              "type": "object"
             }
+            var valid4 = _errs8 === errors;
+          } else {
+            var valid4 = true;
           }
-        },
-        "verdict": {
-          "type": "object",
-          "required": [
-            "value"
-          ],
-          "properties": {
-            "value": {
-              "$ref": "#/$defs/verdictValue"
-            },
-            "reason_code": {
-              "$ref": "#/$defs/reasonCode"
+          if (valid4) {
+            if (data.issued_at !== void 0) {
+              let data5 = data.issued_at;
+              const _errs10 = errors;
+              const _errs11 = errors;
+              if (errors === _errs11) {
+                if (typeof data5 === "string") {
+                  if (!pattern4.test(data5)) {
+                    validate21.errors = [{ instancePath: instancePath + "/issued_at", schemaPath: "#/$defs/timestamp/pattern", keyword: "pattern", params: { pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,3})?Z$" }, message: 'must match pattern "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,3})?Z$"' }];
+                    return false;
+                  }
+                } else {
+                  validate21.errors = [{ instancePath: instancePath + "/issued_at", schemaPath: "#/$defs/timestamp/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                  return false;
+                }
+              }
+              var valid4 = _errs10 === errors;
+            } else {
+              var valid4 = true;
             }
-          },
-          "if": {
-            "properties": {
-              "value": {
-                "const": "unverifiable"
+            if (valid4) {
+              if (data.issuer !== void 0) {
+                let data6 = data.issuer;
+                const _errs13 = errors;
+                if (errors === _errs13) {
+                  if (data6 && typeof data6 == "object" && !Array.isArray(data6)) {
+                    let missing3;
+                    if (data6.key_id === void 0 && (missing3 = "key_id")) {
+                      validate21.errors = [{ instancePath: instancePath + "/issuer", schemaPath: "#/properties/issuer/required", keyword: "required", params: { missingProperty: missing3 }, message: "must have required property '" + missing3 + "'" }];
+                      return false;
+                    } else {
+                      if (data6.key_id !== void 0) {
+                        let data7 = data6.key_id;
+                        const _errs15 = errors;
+                        const _errs16 = errors;
+                        if (errors === _errs16) {
+                          if (typeof data7 === "string") {
+                            if (!pattern5.test(data7)) {
+                              validate21.errors = [{ instancePath: instancePath + "/issuer/key_id", schemaPath: "#/$defs/keyId/pattern", keyword: "pattern", params: { pattern: "^ed25519:[A-Za-z0-9_-]{43}$" }, message: 'must match pattern "^ed25519:[A-Za-z0-9_-]{43}$"' }];
+                              return false;
+                            }
+                          } else {
+                            validate21.errors = [{ instancePath: instancePath + "/issuer/key_id", schemaPath: "#/$defs/keyId/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                            return false;
+                          }
+                        }
+                        var valid6 = _errs15 === errors;
+                      } else {
+                        var valid6 = true;
+                      }
+                      if (valid6) {
+                        if (data6.name !== void 0) {
+                          let data8 = data6.name;
+                          const _errs18 = errors;
+                          if (errors === _errs18) {
+                            if (typeof data8 === "string") {
+                              if (func1(data8) > 128) {
+                                validate21.errors = [{ instancePath: instancePath + "/issuer/name", schemaPath: "#/properties/issuer/properties/name/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                                return false;
+                              }
+                            } else {
+                              validate21.errors = [{ instancePath: instancePath + "/issuer/name", schemaPath: "#/properties/issuer/properties/name/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                              return false;
+                            }
+                          }
+                          var valid6 = _errs18 === errors;
+                        } else {
+                          var valid6 = true;
+                        }
+                      }
+                    }
+                  } else {
+                    validate21.errors = [{ instancePath: instancePath + "/issuer", schemaPath: "#/properties/issuer/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                    return false;
+                  }
+                }
+                var valid4 = _errs13 === errors;
+              } else {
+                var valid4 = true;
+              }
+              if (valid4) {
+                if (data.agent !== void 0) {
+                  let data9 = data.agent;
+                  const _errs20 = errors;
+                  if (errors === _errs20) {
+                    if (data9 && typeof data9 == "object" && !Array.isArray(data9)) {
+                      let missing4;
+                      if (data9.id === void 0 && (missing4 = "id")) {
+                        validate21.errors = [{ instancePath: instancePath + "/agent", schemaPath: "#/properties/agent/required", keyword: "required", params: { missingProperty: missing4 }, message: "must have required property '" + missing4 + "'" }];
+                        return false;
+                      } else {
+                        if (data9.id !== void 0) {
+                          let data10 = data9.id;
+                          const _errs22 = errors;
+                          if (errors === _errs22) {
+                            if (typeof data10 === "string") {
+                              if (func1(data10) > 256) {
+                                validate21.errors = [{ instancePath: instancePath + "/agent/id", schemaPath: "#/properties/agent/properties/id/maxLength", keyword: "maxLength", params: { limit: 256 }, message: "must NOT have more than 256 characters" }];
+                                return false;
+                              } else {
+                                if (func1(data10) < 1) {
+                                  validate21.errors = [{ instancePath: instancePath + "/agent/id", schemaPath: "#/properties/agent/properties/id/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                  return false;
+                                }
+                              }
+                            } else {
+                              validate21.errors = [{ instancePath: instancePath + "/agent/id", schemaPath: "#/properties/agent/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                              return false;
+                            }
+                          }
+                          var valid8 = _errs22 === errors;
+                        } else {
+                          var valid8 = true;
+                        }
+                        if (valid8) {
+                          if (data9.erc8004 !== void 0) {
+                            let data11 = data9.erc8004;
+                            const _errs24 = errors;
+                            if (errors === _errs24) {
+                              if (data11 && typeof data11 == "object" && !Array.isArray(data11)) {
+                                let missing5;
+                                if (data11.chain === void 0 && (missing5 = "chain") || data11.registry === void 0 && (missing5 = "registry") || data11.agent_id === void 0 && (missing5 = "agent_id")) {
+                                  validate21.errors = [{ instancePath: instancePath + "/agent/erc8004", schemaPath: "#/properties/agent/properties/erc8004/required", keyword: "required", params: { missingProperty: missing5 }, message: "must have required property '" + missing5 + "'" }];
+                                  return false;
+                                } else {
+                                  if (data11.chain !== void 0) {
+                                    let data12 = data11.chain;
+                                    const _errs26 = errors;
+                                    if (errors === _errs26) {
+                                      if (typeof data12 === "string") {
+                                        if (!pattern6.test(data12)) {
+                                          validate21.errors = [{ instancePath: instancePath + "/agent/erc8004/chain", schemaPath: "#/properties/agent/properties/erc8004/properties/chain/pattern", keyword: "pattern", params: { pattern: "^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}$" }, message: 'must match pattern "^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}$"' }];
+                                          return false;
+                                        }
+                                      } else {
+                                        validate21.errors = [{ instancePath: instancePath + "/agent/erc8004/chain", schemaPath: "#/properties/agent/properties/erc8004/properties/chain/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                        return false;
+                                      }
+                                    }
+                                    var valid9 = _errs26 === errors;
+                                  } else {
+                                    var valid9 = true;
+                                  }
+                                  if (valid9) {
+                                    if (data11.registry !== void 0) {
+                                      const _errs28 = errors;
+                                      if (typeof data11.registry !== "string") {
+                                        validate21.errors = [{ instancePath: instancePath + "/agent/erc8004/registry", schemaPath: "#/properties/agent/properties/erc8004/properties/registry/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                        return false;
+                                      }
+                                      var valid9 = _errs28 === errors;
+                                    } else {
+                                      var valid9 = true;
+                                    }
+                                    if (valid9) {
+                                      if (data11.agent_id !== void 0) {
+                                        const _errs30 = errors;
+                                        if (typeof data11.agent_id !== "string") {
+                                          validate21.errors = [{ instancePath: instancePath + "/agent/erc8004/agent_id", schemaPath: "#/properties/agent/properties/erc8004/properties/agent_id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                          return false;
+                                        }
+                                        var valid9 = _errs30 === errors;
+                                      } else {
+                                        var valid9 = true;
+                                      }
+                                    }
+                                  }
+                                }
+                              } else {
+                                validate21.errors = [{ instancePath: instancePath + "/agent/erc8004", schemaPath: "#/properties/agent/properties/erc8004/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                return false;
+                              }
+                            }
+                            var valid8 = _errs24 === errors;
+                          } else {
+                            var valid8 = true;
+                          }
+                        }
+                      }
+                    } else {
+                      validate21.errors = [{ instancePath: instancePath + "/agent", schemaPath: "#/properties/agent/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                      return false;
+                    }
+                  }
+                  var valid4 = _errs20 === errors;
+                } else {
+                  var valid4 = true;
+                }
+                if (valid4) {
+                  if (data.operator !== void 0) {
+                    let data15 = data.operator;
+                    const _errs32 = errors;
+                    if (errors === _errs32) {
+                      if (typeof data15 === "string") {
+                        if (func1(data15) > 256) {
+                          validate21.errors = [{ instancePath: instancePath + "/operator", schemaPath: "#/properties/operator/maxLength", keyword: "maxLength", params: { limit: 256 }, message: "must NOT have more than 256 characters" }];
+                          return false;
+                        }
+                      } else {
+                        validate21.errors = [{ instancePath: instancePath + "/operator", schemaPath: "#/properties/operator/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                        return false;
+                      }
+                    }
+                    var valid4 = _errs32 === errors;
+                  } else {
+                    var valid4 = true;
+                  }
+                  if (valid4) {
+                    if (data.claim !== void 0) {
+                      let data16 = data.claim;
+                      const _errs34 = errors;
+                      if (errors === _errs34) {
+                        if (data16 && typeof data16 == "object" && !Array.isArray(data16)) {
+                          let missing6;
+                          if (data16.action === void 0 && (missing6 = "action") || data16.target === void 0 && (missing6 = "target") || data16.params === void 0 && (missing6 = "params") || data16.claimed_at === void 0 && (missing6 = "claimed_at") || data16.claim_digest === void 0 && (missing6 = "claim_digest")) {
+                            validate21.errors = [{ instancePath: instancePath + "/claim", schemaPath: "#/properties/claim/required", keyword: "required", params: { missingProperty: missing6 }, message: "must have required property '" + missing6 + "'" }];
+                            return false;
+                          } else {
+                            if (data16.action !== void 0) {
+                              let data17 = data16.action;
+                              const _errs36 = errors;
+                              const _errs37 = errors;
+                              if (errors === _errs37) {
+                                if (typeof data17 === "string") {
+                                  if (!pattern7.test(data17)) {
+                                    validate21.errors = [{ instancePath: instancePath + "/claim/action", schemaPath: "#/$defs/action/pattern", keyword: "pattern", params: { pattern: "^[a-z0-9]+(\\.[a-z0-9_]+){2}$" }, message: 'must match pattern "^[a-z0-9]+(\\.[a-z0-9_]+){2}$"' }];
+                                    return false;
+                                  }
+                                } else {
+                                  validate21.errors = [{ instancePath: instancePath + "/claim/action", schemaPath: "#/$defs/action/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                  return false;
+                                }
+                              }
+                              var valid10 = _errs36 === errors;
+                            } else {
+                              var valid10 = true;
+                            }
+                            if (valid10) {
+                              if (data16.target !== void 0) {
+                                let data18 = data16.target;
+                                const _errs39 = errors;
+                                if (errors === _errs39) {
+                                  if (typeof data18 === "string") {
+                                    if (func1(data18) > 512) {
+                                      validate21.errors = [{ instancePath: instancePath + "/claim/target", schemaPath: "#/properties/claim/properties/target/maxLength", keyword: "maxLength", params: { limit: 512 }, message: "must NOT have more than 512 characters" }];
+                                      return false;
+                                    } else {
+                                      if (func1(data18) < 1) {
+                                        validate21.errors = [{ instancePath: instancePath + "/claim/target", schemaPath: "#/properties/claim/properties/target/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                        return false;
+                                      }
+                                    }
+                                  } else {
+                                    validate21.errors = [{ instancePath: instancePath + "/claim/target", schemaPath: "#/properties/claim/properties/target/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                    return false;
+                                  }
+                                }
+                                var valid10 = _errs39 === errors;
+                              } else {
+                                var valid10 = true;
+                              }
+                              if (valid10) {
+                                if (data16.params !== void 0) {
+                                  let data19 = data16.params;
+                                  const _errs41 = errors;
+                                  if (!(data19 && typeof data19 == "object" && !Array.isArray(data19))) {
+                                    validate21.errors = [{ instancePath: instancePath + "/claim/params", schemaPath: "#/properties/claim/properties/params/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                    return false;
+                                  }
+                                  var valid10 = _errs41 === errors;
+                                } else {
+                                  var valid10 = true;
+                                }
+                                if (valid10) {
+                                  if (data16.claimed_at !== void 0) {
+                                    let data20 = data16.claimed_at;
+                                    const _errs43 = errors;
+                                    const _errs44 = errors;
+                                    if (errors === _errs44) {
+                                      if (typeof data20 === "string") {
+                                        if (!pattern4.test(data20)) {
+                                          validate21.errors = [{ instancePath: instancePath + "/claim/claimed_at", schemaPath: "#/$defs/timestamp/pattern", keyword: "pattern", params: { pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,3})?Z$" }, message: 'must match pattern "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,3})?Z$"' }];
+                                          return false;
+                                        }
+                                      } else {
+                                        validate21.errors = [{ instancePath: instancePath + "/claim/claimed_at", schemaPath: "#/$defs/timestamp/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                        return false;
+                                      }
+                                    }
+                                    var valid10 = _errs43 === errors;
+                                  } else {
+                                    var valid10 = true;
+                                  }
+                                  if (valid10) {
+                                    if (data16.client_claim_id !== void 0) {
+                                      let data21 = data16.client_claim_id;
+                                      const _errs46 = errors;
+                                      if (errors === _errs46) {
+                                        if (typeof data21 === "string") {
+                                          if (func1(data21) > 256) {
+                                            validate21.errors = [{ instancePath: instancePath + "/claim/client_claim_id", schemaPath: "#/properties/claim/properties/client_claim_id/maxLength", keyword: "maxLength", params: { limit: 256 }, message: "must NOT have more than 256 characters" }];
+                                            return false;
+                                          }
+                                        } else {
+                                          validate21.errors = [{ instancePath: instancePath + "/claim/client_claim_id", schemaPath: "#/properties/claim/properties/client_claim_id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                          return false;
+                                        }
+                                      }
+                                      var valid10 = _errs46 === errors;
+                                    } else {
+                                      var valid10 = true;
+                                    }
+                                    if (valid10) {
+                                      if (data16.claim_digest !== void 0) {
+                                        let data22 = data16.claim_digest;
+                                        const _errs48 = errors;
+                                        const _errs49 = errors;
+                                        if (errors === _errs49) {
+                                          if (typeof data22 === "string") {
+                                            if (!pattern9.test(data22)) {
+                                              validate21.errors = [{ instancePath: instancePath + "/claim/claim_digest", schemaPath: "#/$defs/b64url/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: 'must match pattern "^[A-Za-z0-9_-]+$"' }];
+                                              return false;
+                                            }
+                                          } else {
+                                            validate21.errors = [{ instancePath: instancePath + "/claim/claim_digest", schemaPath: "#/$defs/b64url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                            return false;
+                                          }
+                                        }
+                                        var valid10 = _errs48 === errors;
+                                      } else {
+                                        var valid10 = true;
+                                      }
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        } else {
+                          validate21.errors = [{ instancePath: instancePath + "/claim", schemaPath: "#/properties/claim/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                          return false;
+                        }
+                      }
+                      var valid4 = _errs34 === errors;
+                    } else {
+                      var valid4 = true;
+                    }
+                    if (valid4) {
+                      if (data.observation !== void 0) {
+                        let data23 = data.observation;
+                        const _errs51 = errors;
+                        if (errors === _errs51) {
+                          if (data23 && typeof data23 == "object" && !Array.isArray(data23)) {
+                            let missing7;
+                            if (data23.verifier === void 0 && (missing7 = "verifier") || data23.observed_at === void 0 && (missing7 = "observed_at") || data23.deadline_at === void 0 && (missing7 = "deadline_at") || data23.attempts === void 0 && (missing7 = "attempts") || data23.facts === void 0 && (missing7 = "facts")) {
+                              validate21.errors = [{ instancePath: instancePath + "/observation", schemaPath: "#/properties/observation/required", keyword: "required", params: { missingProperty: missing7 }, message: "must have required property '" + missing7 + "'" }];
+                              return false;
+                            } else {
+                              if (data23.verifier !== void 0) {
+                                let data24 = data23.verifier;
+                                const _errs53 = errors;
+                                if (errors === _errs53) {
+                                  if (data24 && typeof data24 == "object" && !Array.isArray(data24)) {
+                                    let missing8;
+                                    if (data24.id === void 0 && (missing8 = "id") || data24.version === void 0 && (missing8 = "version")) {
+                                      validate21.errors = [{ instancePath: instancePath + "/observation/verifier", schemaPath: "#/properties/observation/properties/verifier/required", keyword: "required", params: { missingProperty: missing8 }, message: "must have required property '" + missing8 + "'" }];
+                                      return false;
+                                    } else {
+                                      if (data24.id !== void 0) {
+                                        let data25 = data24.id;
+                                        const _errs55 = errors;
+                                        const _errs56 = errors;
+                                        if (errors === _errs56) {
+                                          if (typeof data25 === "string") {
+                                            if (!pattern7.test(data25)) {
+                                              validate21.errors = [{ instancePath: instancePath + "/observation/verifier/id", schemaPath: "#/$defs/action/pattern", keyword: "pattern", params: { pattern: "^[a-z0-9]+(\\.[a-z0-9_]+){2}$" }, message: 'must match pattern "^[a-z0-9]+(\\.[a-z0-9_]+){2}$"' }];
+                                              return false;
+                                            }
+                                          } else {
+                                            validate21.errors = [{ instancePath: instancePath + "/observation/verifier/id", schemaPath: "#/$defs/action/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                            return false;
+                                          }
+                                        }
+                                        var valid15 = _errs55 === errors;
+                                      } else {
+                                        var valid15 = true;
+                                      }
+                                      if (valid15) {
+                                        if (data24.version !== void 0) {
+                                          let data26 = data24.version;
+                                          const _errs58 = errors;
+                                          if (errors === _errs58) {
+                                            if (typeof data26 === "string") {
+                                              if (!pattern11.test(data26)) {
+                                                validate21.errors = [{ instancePath: instancePath + "/observation/verifier/version", schemaPath: "#/properties/observation/properties/verifier/properties/version/pattern", keyword: "pattern", params: { pattern: "^\\d+$" }, message: 'must match pattern "^\\d+$"' }];
+                                                return false;
+                                              }
+                                            } else {
+                                              validate21.errors = [{ instancePath: instancePath + "/observation/verifier/version", schemaPath: "#/properties/observation/properties/verifier/properties/version/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                              return false;
+                                            }
+                                          }
+                                          var valid15 = _errs58 === errors;
+                                        } else {
+                                          var valid15 = true;
+                                        }
+                                        if (valid15) {
+                                          if (data24.code_hash !== void 0) {
+                                            let data27 = data24.code_hash;
+                                            const _errs60 = errors;
+                                            const _errs61 = errors;
+                                            if (errors === _errs61) {
+                                              if (typeof data27 === "string") {
+                                                if (!pattern12.test(data27)) {
+                                                  validate21.errors = [{ instancePath: instancePath + "/observation/verifier/code_hash", schemaPath: "#/$defs/fingerprint/pattern", keyword: "pattern", params: { pattern: "^sha256:[A-Za-z0-9_-]{43}$" }, message: 'must match pattern "^sha256:[A-Za-z0-9_-]{43}$"' }];
+                                                  return false;
+                                                }
+                                              } else {
+                                                validate21.errors = [{ instancePath: instancePath + "/observation/verifier/code_hash", schemaPath: "#/$defs/fingerprint/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                return false;
+                                              }
+                                            }
+                                            var valid15 = _errs60 === errors;
+                                          } else {
+                                            var valid15 = true;
+                                          }
+                                        }
+                                      }
+                                    }
+                                  } else {
+                                    validate21.errors = [{ instancePath: instancePath + "/observation/verifier", schemaPath: "#/properties/observation/properties/verifier/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                    return false;
+                                  }
+                                }
+                                var valid14 = _errs53 === errors;
+                              } else {
+                                var valid14 = true;
+                              }
+                              if (valid14) {
+                                if (data23.observed_at !== void 0) {
+                                  let data28 = data23.observed_at;
+                                  const _errs63 = errors;
+                                  const _errs64 = errors;
+                                  if (errors === _errs64) {
+                                    if (typeof data28 === "string") {
+                                      if (!pattern4.test(data28)) {
+                                        validate21.errors = [{ instancePath: instancePath + "/observation/observed_at", schemaPath: "#/$defs/timestamp/pattern", keyword: "pattern", params: { pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,3})?Z$" }, message: 'must match pattern "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,3})?Z$"' }];
+                                        return false;
+                                      }
+                                    } else {
+                                      validate21.errors = [{ instancePath: instancePath + "/observation/observed_at", schemaPath: "#/$defs/timestamp/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                      return false;
+                                    }
+                                  }
+                                  var valid14 = _errs63 === errors;
+                                } else {
+                                  var valid14 = true;
+                                }
+                                if (valid14) {
+                                  if (data23.deadline_at !== void 0) {
+                                    let data29 = data23.deadline_at;
+                                    const _errs66 = errors;
+                                    const _errs67 = errors;
+                                    if (errors === _errs67) {
+                                      if (typeof data29 === "string") {
+                                        if (!pattern4.test(data29)) {
+                                          validate21.errors = [{ instancePath: instancePath + "/observation/deadline_at", schemaPath: "#/$defs/timestamp/pattern", keyword: "pattern", params: { pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,3})?Z$" }, message: 'must match pattern "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,3})?Z$"' }];
+                                          return false;
+                                        }
+                                      } else {
+                                        validate21.errors = [{ instancePath: instancePath + "/observation/deadline_at", schemaPath: "#/$defs/timestamp/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                        return false;
+                                      }
+                                    }
+                                    var valid14 = _errs66 === errors;
+                                  } else {
+                                    var valid14 = true;
+                                  }
+                                  if (valid14) {
+                                    if (data23.attempts !== void 0) {
+                                      let data30 = data23.attempts;
+                                      const _errs69 = errors;
+                                      if (!(typeof data30 == "number" && (!(data30 % 1) && !isNaN(data30)))) {
+                                        validate21.errors = [{ instancePath: instancePath + "/observation/attempts", schemaPath: "#/properties/observation/properties/attempts/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+                                        return false;
+                                      }
+                                      if (errors === _errs69) {
+                                        if (typeof data30 == "number") {
+                                          if (data30 < 1 || isNaN(data30)) {
+                                            validate21.errors = [{ instancePath: instancePath + "/observation/attempts", schemaPath: "#/properties/observation/properties/attempts/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                            return false;
+                                          }
+                                        }
+                                      }
+                                      var valid14 = _errs69 === errors;
+                                    } else {
+                                      var valid14 = true;
+                                    }
+                                    if (valid14) {
+                                      if (data23.facts !== void 0) {
+                                        let data31 = data23.facts;
+                                        const _errs71 = errors;
+                                        if (!(data31 && typeof data31 == "object" && !Array.isArray(data31))) {
+                                          validate21.errors = [{ instancePath: instancePath + "/observation/facts", schemaPath: "#/properties/observation/properties/facts/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                          return false;
+                                        }
+                                        var valid14 = _errs71 === errors;
+                                      } else {
+                                        var valid14 = true;
+                                      }
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          } else {
+                            validate21.errors = [{ instancePath: instancePath + "/observation", schemaPath: "#/properties/observation/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                            return false;
+                          }
+                        }
+                        var valid4 = _errs51 === errors;
+                      } else {
+                        var valid4 = true;
+                      }
+                      if (valid4) {
+                        if (data.verdict !== void 0) {
+                          let data32 = data.verdict;
+                          const _errs73 = errors;
+                          const _errs75 = errors;
+                          let valid20 = true;
+                          const _errs76 = errors;
+                          if (data32 && typeof data32 == "object" && !Array.isArray(data32)) {
+                            if (data32.value !== void 0) {
+                              if ("unverifiable" !== data32.value) {
+                                const err2 = {};
+                                if (vErrors === null) {
+                                  vErrors = [err2];
+                                } else {
+                                  vErrors.push(err2);
+                                }
+                                errors++;
+                              }
+                            }
+                          }
+                          var _valid1 = _errs76 === errors;
+                          errors = _errs75;
+                          if (vErrors !== null) {
+                            if (_errs75) {
+                              vErrors.length = _errs75;
+                            } else {
+                              vErrors = null;
+                            }
+                          }
+                          if (_valid1) {
+                            const _errs78 = errors;
+                            if (data32 && typeof data32 == "object" && !Array.isArray(data32)) {
+                              let missing9;
+                              if (data32.value === void 0 && (missing9 = "value") || data32.reason_code === void 0 && (missing9 = "reason_code")) {
+                                validate21.errors = [{ instancePath: instancePath + "/verdict", schemaPath: "#/properties/verdict/then/required", keyword: "required", params: { missingProperty: missing9 }, message: "must have required property '" + missing9 + "'" }];
+                                return false;
+                              }
+                            }
+                            var _valid1 = _errs78 === errors;
+                            valid20 = _valid1;
+                          }
+                          if (!valid20) {
+                            const err3 = { instancePath: instancePath + "/verdict", schemaPath: "#/properties/verdict/if", keyword: "if", params: { failingKeyword: "then" }, message: 'must match "then" schema' };
+                            if (vErrors === null) {
+                              vErrors = [err3];
+                            } else {
+                              vErrors.push(err3);
+                            }
+                            errors++;
+                            validate21.errors = vErrors;
+                            return false;
+                          }
+                          if (errors === _errs73) {
+                            if (data32 && typeof data32 == "object" && !Array.isArray(data32)) {
+                              let missing10;
+                              if (data32.value === void 0 && (missing10 = "value")) {
+                                validate21.errors = [{ instancePath: instancePath + "/verdict", schemaPath: "#/properties/verdict/required", keyword: "required", params: { missingProperty: missing10 }, message: "must have required property '" + missing10 + "'" }];
+                                return false;
+                              } else {
+                                if (data32.value !== void 0) {
+                                  let data34 = data32.value;
+                                  const _errs79 = errors;
+                                  if (!(data34 === "verified" || data34 === "late" || data34 === "mismatch" || data34 === "failed" || data34 === "unverifiable")) {
+                                    validate21.errors = [{ instancePath: instancePath + "/verdict/value", schemaPath: "#/$defs/verdictValue/enum", keyword: "enum", params: { allowedValues: schema42.enum }, message: "must be equal to one of the allowed values" }];
+                                    return false;
+                                  }
+                                  var valid22 = _errs79 === errors;
+                                } else {
+                                  var valid22 = true;
+                                }
+                                if (valid22) {
+                                  if (data32.reason_code !== void 0) {
+                                    let data35 = data32.reason_code;
+                                    const _errs81 = errors;
+                                    if (!(data35 === "not_found" || data35 === "content_mismatch" || data35 === "target_mismatch" || data35 === "observed_after_tolerance" || data35 === "no_connection" || data35 === "permission_denied" || data35 === "rate_limited" || data35 === "destination_unavailable" || data35 === "unsupported_action" || data35 === "claim_ambiguous" || data35 === "verifier_error")) {
+                                      validate21.errors = [{ instancePath: instancePath + "/verdict/reason_code", schemaPath: "#/$defs/reasonCode/enum", keyword: "enum", params: { allowedValues: schema43.enum }, message: "must be equal to one of the allowed values" }];
+                                      return false;
+                                    }
+                                    var valid22 = _errs81 === errors;
+                                  } else {
+                                    var valid22 = true;
+                                  }
+                                }
+                              }
+                            } else {
+                              validate21.errors = [{ instancePath: instancePath + "/verdict", schemaPath: "#/properties/verdict/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                              return false;
+                            }
+                          }
+                          var valid4 = _errs73 === errors;
+                        } else {
+                          var valid4 = true;
+                        }
+                        if (valid4) {
+                          if (data.trust_level !== void 0) {
+                            let data36 = data.trust_level;
+                            const _errs83 = errors;
+                            if (!(typeof data36 == "number" && (!(data36 % 1) && !isNaN(data36)))) {
+                              validate21.errors = [{ instancePath: instancePath + "/trust_level", schemaPath: "#/properties/trust_level/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+                              return false;
+                            }
+                            if (errors === _errs83) {
+                              if (typeof data36 == "number") {
+                                if (data36 > 4 || isNaN(data36)) {
+                                  validate21.errors = [{ instancePath: instancePath + "/trust_level", schemaPath: "#/properties/trust_level/maximum", keyword: "maximum", params: { comparison: "<=", limit: 4 }, message: "must be <= 4" }];
+                                  return false;
+                                } else {
+                                  if (data36 < 1 || isNaN(data36)) {
+                                    validate21.errors = [{ instancePath: instancePath + "/trust_level", schemaPath: "#/properties/trust_level/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                    return false;
+                                  }
+                                }
+                              }
+                            }
+                            var valid4 = _errs83 === errors;
+                          } else {
+                            var valid4 = true;
+                          }
+                          if (valid4) {
+                            if (data.attestation !== void 0) {
+                              let data37 = data.attestation;
+                              const _errs85 = errors;
+                              if (errors === _errs85) {
+                                if (data37 && typeof data37 == "object" && !Array.isArray(data37)) {
+                                  let missing11;
+                                  if (data37.type === void 0 && (missing11 = "type") || data37.document === void 0 && (missing11 = "document")) {
+                                    validate21.errors = [{ instancePath: instancePath + "/attestation", schemaPath: "#/properties/attestation/required", keyword: "required", params: { missingProperty: missing11 }, message: "must have required property '" + missing11 + "'" }];
+                                    return false;
+                                  } else {
+                                    if (data37.type !== void 0) {
+                                      const _errs87 = errors;
+                                      if (typeof data37.type !== "string") {
+                                        validate21.errors = [{ instancePath: instancePath + "/attestation/type", schemaPath: "#/properties/attestation/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                        return false;
+                                      }
+                                      var valid25 = _errs87 === errors;
+                                    } else {
+                                      var valid25 = true;
+                                    }
+                                    if (valid25) {
+                                      if (data37.document !== void 0) {
+                                        let data39 = data37.document;
+                                        const _errs89 = errors;
+                                        const _errs90 = errors;
+                                        if (errors === _errs90) {
+                                          if (typeof data39 === "string") {
+                                            if (!pattern9.test(data39)) {
+                                              validate21.errors = [{ instancePath: instancePath + "/attestation/document", schemaPath: "#/$defs/b64url/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: 'must match pattern "^[A-Za-z0-9_-]+$"' }];
+                                              return false;
+                                            }
+                                          } else {
+                                            validate21.errors = [{ instancePath: instancePath + "/attestation/document", schemaPath: "#/$defs/b64url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                            return false;
+                                          }
+                                        }
+                                        var valid25 = _errs89 === errors;
+                                      } else {
+                                        var valid25 = true;
+                                      }
+                                    }
+                                  }
+                                } else {
+                                  validate21.errors = [{ instancePath: instancePath + "/attestation", schemaPath: "#/properties/attestation/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                  return false;
+                                }
+                              }
+                              var valid4 = _errs85 === errors;
+                            } else {
+                              var valid4 = true;
+                            }
+                            if (valid4) {
+                              if (data.supersedes !== void 0) {
+                                const _errs92 = errors;
+                                if (typeof data.supersedes !== "string") {
+                                  validate21.errors = [{ instancePath: instancePath + "/supersedes", schemaPath: "#/properties/supersedes/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                  return false;
+                                }
+                                var valid4 = _errs92 === errors;
+                              } else {
+                                var valid4 = true;
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
               }
             }
-          },
-          "then": {
-            "required": [
-              "value",
-              "reason_code"
-            ]
           }
-        },
-        "trust_level": {
-          "type": "integer",
-          "minimum": 1,
-          "maximum": 4
-        },
-        "attestation": {
-          "type": "object",
-          "required": [
-            "type",
-            "document"
-          ],
-          "properties": {
-            "type": {
-              "type": "string"
-            },
-            "document": {
-              "$ref": "#/$defs/b64url"
+        }
+      }
+    } else {
+      validate21.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      return false;
+    }
+  }
+  validate21.errors = vErrors;
+  evaluated0.props = props0;
+  return errors === 0;
+}
+validate21.evaluated = { "dynamicProps": true, "dynamicItems": false };
+var pattern17 = new RegExp("^[A-Za-z0-9_-]{86}$", "u");
+function validate23(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate23.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing0;
+      if (data.alg === void 0 && (missing0 = "alg") || data.key_id === void 0 && (missing0 = "key_id") || data.value === void 0 && (missing0 = "value")) {
+        validate23.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 === "alg" || key0 === "key_id" || key0 === "value")) {
+            validate23.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            return false;
+            break;
+          }
+        }
+        if (_errs1 === errors) {
+          if (data.alg !== void 0) {
+            const _errs2 = errors;
+            if ("Ed25519" !== data.alg) {
+              validate23.errors = [{ instancePath: instancePath + "/alg", schemaPath: "#/properties/alg/const", keyword: "const", params: { allowedValue: "Ed25519" }, message: "must be equal to constant" }];
+              return false;
+            }
+            var valid0 = _errs2 === errors;
+          } else {
+            var valid0 = true;
+          }
+          if (valid0) {
+            if (data.key_id !== void 0) {
+              let data1 = data.key_id;
+              const _errs3 = errors;
+              const _errs4 = errors;
+              if (errors === _errs4) {
+                if (typeof data1 === "string") {
+                  if (!pattern5.test(data1)) {
+                    validate23.errors = [{ instancePath: instancePath + "/key_id", schemaPath: "#/$defs/keyId/pattern", keyword: "pattern", params: { pattern: "^ed25519:[A-Za-z0-9_-]{43}$" }, message: 'must match pattern "^ed25519:[A-Za-z0-9_-]{43}$"' }];
+                    return false;
+                  }
+                } else {
+                  validate23.errors = [{ instancePath: instancePath + "/key_id", schemaPath: "#/$defs/keyId/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                  return false;
+                }
+              }
+              var valid0 = _errs3 === errors;
+            } else {
+              var valid0 = true;
+            }
+            if (valid0) {
+              if (data.value !== void 0) {
+                let data2 = data.value;
+                const _errs6 = errors;
+                if (errors === _errs6) {
+                  if (typeof data2 === "string") {
+                    if (!pattern17.test(data2)) {
+                      validate23.errors = [{ instancePath: instancePath + "/value", schemaPath: "#/properties/value/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]{86}$" }, message: 'must match pattern "^[A-Za-z0-9_-]{86}$"' }];
+                      return false;
+                    }
+                  } else {
+                    validate23.errors = [{ instancePath: instancePath + "/value", schemaPath: "#/properties/value/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                    return false;
+                  }
+                }
+                var valid0 = _errs6 === errors;
+              } else {
+                var valid0 = true;
+              }
             }
           }
-        },
-        "supersedes": {
-          "type": "string"
         }
-      },
-      "if": {
-        "properties": {
-          "trust_level": {
-            "minimum": 3
+      }
+    } else {
+      validate23.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      return false;
+    }
+  }
+  validate23.errors = vErrors;
+  return errors === 0;
+}
+validate23.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+var pattern21 = new RegExp("^0x[0-9a-fA-F]{64}$", "u");
+function validate25(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate25.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing0;
+      if (data.log_id === void 0 && (missing0 = "log_id") || data.leaf_index === void 0 && (missing0 = "leaf_index") || data.tree_size === void 0 && (missing0 = "tree_size") || data.root_hash === void 0 && (missing0 = "root_hash") || data.inclusion === void 0 && (missing0 = "inclusion")) {
+        validate25.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        return false;
+      } else {
+        if (data.log_id !== void 0) {
+          let data0 = data.log_id;
+          const _errs1 = errors;
+          const _errs2 = errors;
+          if (errors === _errs2) {
+            if (typeof data0 === "string") {
+              if (!pattern9.test(data0)) {
+                validate25.errors = [{ instancePath: instancePath + "/log_id", schemaPath: "#/$defs/b64url/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: 'must match pattern "^[A-Za-z0-9_-]+$"' }];
+                return false;
+              }
+            } else {
+              validate25.errors = [{ instancePath: instancePath + "/log_id", schemaPath: "#/$defs/b64url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              return false;
+            }
           }
+          var valid0 = _errs1 === errors;
+        } else {
+          var valid0 = true;
         }
-      },
-      "then": {
-        "required": [
-          "attestation"
-        ],
-        "properties": {
-          "observation": {
-            "properties": {
-              "verifier": {
-                "required": [
-                  "id",
-                  "version",
-                  "code_hash"
-                ]
+        if (valid0) {
+          if (data.leaf_index !== void 0) {
+            let data1 = data.leaf_index;
+            const _errs4 = errors;
+            if (!(typeof data1 == "number" && (!(data1 % 1) && !isNaN(data1)))) {
+              validate25.errors = [{ instancePath: instancePath + "/leaf_index", schemaPath: "#/properties/leaf_index/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+              return false;
+            }
+            if (errors === _errs4) {
+              if (typeof data1 == "number") {
+                if (data1 < 0 || isNaN(data1)) {
+                  validate25.errors = [{ instancePath: instancePath + "/leaf_index", schemaPath: "#/properties/leaf_index/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" }];
+                  return false;
+                }
+              }
+            }
+            var valid0 = _errs4 === errors;
+          } else {
+            var valid0 = true;
+          }
+          if (valid0) {
+            if (data.tree_size !== void 0) {
+              let data2 = data.tree_size;
+              const _errs6 = errors;
+              if (!(typeof data2 == "number" && (!(data2 % 1) && !isNaN(data2)))) {
+                validate25.errors = [{ instancePath: instancePath + "/tree_size", schemaPath: "#/properties/tree_size/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+                return false;
+              }
+              if (errors === _errs6) {
+                if (typeof data2 == "number") {
+                  if (data2 < 1 || isNaN(data2)) {
+                    validate25.errors = [{ instancePath: instancePath + "/tree_size", schemaPath: "#/properties/tree_size/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                    return false;
+                  }
+                }
+              }
+              var valid0 = _errs6 === errors;
+            } else {
+              var valid0 = true;
+            }
+            if (valid0) {
+              if (data.root_hash !== void 0) {
+                let data3 = data.root_hash;
+                const _errs8 = errors;
+                const _errs9 = errors;
+                if (errors === _errs9) {
+                  if (typeof data3 === "string") {
+                    if (!pattern9.test(data3)) {
+                      validate25.errors = [{ instancePath: instancePath + "/root_hash", schemaPath: "#/$defs/b64url/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: 'must match pattern "^[A-Za-z0-9_-]+$"' }];
+                      return false;
+                    }
+                  } else {
+                    validate25.errors = [{ instancePath: instancePath + "/root_hash", schemaPath: "#/$defs/b64url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                    return false;
+                  }
+                }
+                var valid0 = _errs8 === errors;
+              } else {
+                var valid0 = true;
+              }
+              if (valid0) {
+                if (data.inclusion !== void 0) {
+                  let data4 = data.inclusion;
+                  const _errs11 = errors;
+                  if (errors === _errs11) {
+                    if (Array.isArray(data4)) {
+                      var valid3 = true;
+                      const len0 = data4.length;
+                      for (let i0 = 0; i0 < len0; i0++) {
+                        let data5 = data4[i0];
+                        const _errs13 = errors;
+                        const _errs14 = errors;
+                        if (errors === _errs14) {
+                          if (typeof data5 === "string") {
+                            if (!pattern9.test(data5)) {
+                              validate25.errors = [{ instancePath: instancePath + "/inclusion/" + i0, schemaPath: "#/$defs/b64url/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: 'must match pattern "^[A-Za-z0-9_-]+$"' }];
+                              return false;
+                            }
+                          } else {
+                            validate25.errors = [{ instancePath: instancePath + "/inclusion/" + i0, schemaPath: "#/$defs/b64url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                            return false;
+                          }
+                        }
+                        var valid3 = _errs13 === errors;
+                        if (!valid3) {
+                          break;
+                        }
+                      }
+                    } else {
+                      validate25.errors = [{ instancePath: instancePath + "/inclusion", schemaPath: "#/properties/inclusion/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                      return false;
+                    }
+                  }
+                  var valid0 = _errs11 === errors;
+                } else {
+                  var valid0 = true;
+                }
+                if (valid0) {
+                  if (data.anchor !== void 0) {
+                    let data6 = data.anchor;
+                    const _errs16 = errors;
+                    if (errors === _errs16) {
+                      if (data6 && typeof data6 == "object" && !Array.isArray(data6)) {
+                        let missing1;
+                        if (data6.chain === void 0 && (missing1 = "chain") || data6.scheme === void 0 && (missing1 = "scheme") || data6.uid === void 0 && (missing1 = "uid") || data6.tx_hash === void 0 && (missing1 = "tx_hash") || data6.tree_size === void 0 && (missing1 = "tree_size")) {
+                          validate25.errors = [{ instancePath: instancePath + "/anchor", schemaPath: "#/properties/anchor/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                          return false;
+                        } else {
+                          if (data6.chain !== void 0) {
+                            const _errs18 = errors;
+                            if (typeof data6.chain !== "string") {
+                              validate25.errors = [{ instancePath: instancePath + "/anchor/chain", schemaPath: "#/properties/anchor/properties/chain/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                              return false;
+                            }
+                            var valid5 = _errs18 === errors;
+                          } else {
+                            var valid5 = true;
+                          }
+                          if (valid5) {
+                            if (data6.scheme !== void 0) {
+                              const _errs20 = errors;
+                              if ("eas" !== data6.scheme) {
+                                validate25.errors = [{ instancePath: instancePath + "/anchor/scheme", schemaPath: "#/properties/anchor/properties/scheme/const", keyword: "const", params: { allowedValue: "eas" }, message: "must be equal to constant" }];
+                                return false;
+                              }
+                              var valid5 = _errs20 === errors;
+                            } else {
+                              var valid5 = true;
+                            }
+                            if (valid5) {
+                              if (data6.uid !== void 0) {
+                                let data9 = data6.uid;
+                                const _errs21 = errors;
+                                if (errors === _errs21) {
+                                  if (typeof data9 === "string") {
+                                    if (!pattern21.test(data9)) {
+                                      validate25.errors = [{ instancePath: instancePath + "/anchor/uid", schemaPath: "#/properties/anchor/properties/uid/pattern", keyword: "pattern", params: { pattern: "^0x[0-9a-fA-F]{64}$" }, message: 'must match pattern "^0x[0-9a-fA-F]{64}$"' }];
+                                      return false;
+                                    }
+                                  } else {
+                                    validate25.errors = [{ instancePath: instancePath + "/anchor/uid", schemaPath: "#/properties/anchor/properties/uid/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                    return false;
+                                  }
+                                }
+                                var valid5 = _errs21 === errors;
+                              } else {
+                                var valid5 = true;
+                              }
+                              if (valid5) {
+                                if (data6.tx_hash !== void 0) {
+                                  let data10 = data6.tx_hash;
+                                  const _errs23 = errors;
+                                  if (errors === _errs23) {
+                                    if (typeof data10 === "string") {
+                                      if (!pattern21.test(data10)) {
+                                        validate25.errors = [{ instancePath: instancePath + "/anchor/tx_hash", schemaPath: "#/properties/anchor/properties/tx_hash/pattern", keyword: "pattern", params: { pattern: "^0x[0-9a-fA-F]{64}$" }, message: 'must match pattern "^0x[0-9a-fA-F]{64}$"' }];
+                                        return false;
+                                      }
+                                    } else {
+                                      validate25.errors = [{ instancePath: instancePath + "/anchor/tx_hash", schemaPath: "#/properties/anchor/properties/tx_hash/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                      return false;
+                                    }
+                                  }
+                                  var valid5 = _errs23 === errors;
+                                } else {
+                                  var valid5 = true;
+                                }
+                                if (valid5) {
+                                  if (data6.tree_size !== void 0) {
+                                    let data11 = data6.tree_size;
+                                    const _errs25 = errors;
+                                    if (!(typeof data11 == "number" && (!(data11 % 1) && !isNaN(data11)))) {
+                                      validate25.errors = [{ instancePath: instancePath + "/anchor/tree_size", schemaPath: "#/properties/anchor/properties/tree_size/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+                                      return false;
+                                    }
+                                    if (errors === _errs25) {
+                                      if (typeof data11 == "number") {
+                                        if (data11 < 1 || isNaN(data11)) {
+                                          validate25.errors = [{ instancePath: instancePath + "/anchor/tree_size", schemaPath: "#/properties/anchor/properties/tree_size/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                          return false;
+                                        }
+                                      }
+                                    }
+                                    var valid5 = _errs25 === errors;
+                                  } else {
+                                    var valid5 = true;
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      } else {
+                        validate25.errors = [{ instancePath: instancePath + "/anchor", schemaPath: "#/properties/anchor/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                        return false;
+                      }
+                    }
+                    var valid0 = _errs16 === errors;
+                  } else {
+                    var valid0 = true;
+                  }
+                }
               }
             }
           }
         }
       }
-    },
-    "signature": {
-      "type": "object",
-      "required": [
-        "alg",
-        "key_id",
-        "value"
-      ],
-      "additionalProperties": false,
-      "properties": {
-        "alg": {
-          "const": "Ed25519"
-        },
-        "key_id": {
-          "$ref": "#/$defs/keyId"
-        },
-        "value": {
-          "type": "string",
-          "pattern": "^[A-Za-z0-9_-]{86}$"
+    } else {
+      validate25.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      return false;
+    }
+  }
+  validate25.errors = vErrors;
+  return errors === 0;
+}
+validate25.evaluated = { "props": { "log_id": true, "leaf_index": true, "tree_size": true, "root_hash": true, "inclusion": true, "anchor": true }, "dynamicProps": false, "dynamicItems": false };
+function validate20(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate20.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing0;
+      if (data.body === void 0 && (missing0 = "body") || data.signature === void 0 && (missing0 = "signature")) {
+        validate20.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 === "body" || key0 === "signature" || key0 === "proof")) {
+            validate20.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            return false;
+            break;
+          }
         }
-      }
-    },
-    "proof": {
-      "type": "object",
-      "required": [
-        "log_id",
-        "leaf_index",
-        "tree_size",
-        "root_hash",
-        "inclusion"
-      ],
-      "properties": {
-        "log_id": {
-          "$ref": "#/$defs/b64url"
-        },
-        "leaf_index": {
-          "type": "integer",
-          "minimum": 0
-        },
-        "tree_size": {
-          "type": "integer",
-          "minimum": 1
-        },
-        "root_hash": {
-          "$ref": "#/$defs/b64url"
-        },
-        "inclusion": {
-          "type": "array",
-          "items": {
-            "$ref": "#/$defs/b64url"
+        if (_errs1 === errors) {
+          if (data.body !== void 0) {
+            const _errs2 = errors;
+            if (!validate21(data.body, { instancePath: instancePath + "/body", parentData: data, parentDataProperty: "body", rootData, dynamicAnchors })) {
+              vErrors = vErrors === null ? validate21.errors : vErrors.concat(validate21.errors);
+              errors = vErrors.length;
+            }
+            var valid0 = _errs2 === errors;
+          } else {
+            var valid0 = true;
           }
-        },
-        "anchor": {
-          "type": "object",
-          "required": [
-            "chain",
-            "scheme",
-            "uid",
-            "tx_hash",
-            "tree_size"
-          ],
-          "properties": {
-            "chain": {
-              "type": "string"
-            },
-            "scheme": {
-              "const": "eas"
-            },
-            "uid": {
-              "type": "string",
-              "pattern": "^0x[0-9a-fA-F]{64}$"
-            },
-            "tx_hash": {
-              "type": "string",
-              "pattern": "^0x[0-9a-fA-F]{64}$"
-            },
-            "tree_size": {
-              "type": "integer",
-              "minimum": 1
+          if (valid0) {
+            if (data.signature !== void 0) {
+              const _errs3 = errors;
+              if (!validate23(data.signature, { instancePath: instancePath + "/signature", parentData: data, parentDataProperty: "signature", rootData, dynamicAnchors })) {
+                vErrors = vErrors === null ? validate23.errors : vErrors.concat(validate23.errors);
+                errors = vErrors.length;
+              }
+              var valid0 = _errs3 === errors;
+            } else {
+              var valid0 = true;
+            }
+            if (valid0) {
+              if (data.proof !== void 0) {
+                const _errs4 = errors;
+                if (!validate25(data.proof, { instancePath: instancePath + "/proof", parentData: data, parentDataProperty: "proof", rootData, dynamicAnchors })) {
+                  vErrors = vErrors === null ? validate25.errors : vErrors.concat(validate25.errors);
+                  errors = vErrors.length;
+                }
+                var valid0 = _errs4 === errors;
+              } else {
+                var valid0 = true;
+              }
             }
           }
         }
       }
+    } else {
+      validate20.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      return false;
     }
   }
-};
+  validate20.errors = vErrors;
+  return errors === 0;
+}
+validate20.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 
 // src/schema.ts
-var ajv = new Ajv2020({ allErrors: false, strict: false });
-addFormats(ajv);
-var validate = ajv.compile(receiptSchema);
 function schemaValid(receipt) {
   return Boolean(validate(receipt));
 }