lighthouse 13.5.0-dev.20261008 → 13.5.0-dev.20261009

package/third-party/ard/schema-validator.js

@@ -11,360 +11,224 @@
 import {fullFormats} from 'ajv-formats/dist/formats.js';
 
 "use strict";
-export const validate = validate20;
-export default validate20;
-const schema31 = {
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://raw.githubusercontent.com/ards-project/ard-spec/main/spec/schemas/ai-catalog.schema.json",
-  "title": "AICatalogManifest",
-  "description": "JSON Schema for the ai-catalog.json capability manifest, defining how AI artifacts are advertised.",
+export const ArdManifest = validate25;
+const schema35 = {
   "type": "object",
+  "description": "The document published at /.well-known/ard.json (or any entry source). ARD requires only an `entries` array of ARD entries; any other top-level members are transport-defined and ignored by ARD, so additionalProperties is open.",
   "required": [
-    "specVersion",
     "entries"
   ],
   "properties": {
-    "specVersion": {
-      "type": "string",
-      "description": "Version of the ai-catalog specification used in this manifest.",
-      "enum": [
-        "1.0"
-      ]
-    },
-    "host": {
-      "type": "object",
-      "description": "Information about the catalog publisher or hosting entity.",
-      "required": [
-        "displayName"
-      ],
-      "properties": {
-        "displayName": {
-          "type": "string",
-          "description": "Human-readable name of the host."
-        },
-        "identifier": {
-          "type": "string",
-          "description": "Cryptographic or verifiable identifier of the host (e.g. did:web:domain.com)."
-        },
-        "documentationUrl": {
-          "type": "string",
-          "format": "uri",
-          "description": "URL to publisher documentation."
-        },
-        "logoUrl": {
-          "type": "string",
-          "format": "uri",
-          "description": "URL to the publisher's logo image."
-        },
-        "trustManifest": {
-          "$ref": "#/$defs/trustManifest"
-        }
-      },
-      "additionalProperties": false
-    },
     "entries": {
       "type": "array",
-      "description": "List of AI agent or capability catalog entries.",
       "items": {
-        "$ref": "#/$defs/catalogEntry"
+        "$ref": "#/$defs/ArdEntry"
       }
     }
   },
-  "additionalProperties": false,
-  "$defs": {
-    "catalogEntry": {
-      "type": "object",
-      "description": "A single AI capability entry within the catalog.",
+  "additionalProperties": true
+};
+const schema32 = {
+  "description": "A complete ARD entry, as published. Requires the discovery-critical terms and exactly one of url/data.",
+  "allOf": [
+    {
+      "$ref": "#/$defs/EntryFields"
+    }
+  ],
+  "required": [
+    "identifier",
+    "displayName",
+    "type"
+  ],
+  "oneOf": [
+    {
       "required": [
-        "identifier",
-        "displayName",
-        "type"
-      ],
-      "oneOf": [
-        {
-          "required": [
-            "url"
-          ],
-          "not": {
-            "required": [
-              "data"
-            ]
-          }
-        },
-        {
-          "required": [
-            "data"
-          ],
-          "not": {
-            "required": [
-              "url"
-            ]
-          }
-        }
+        "url"
       ],
-      "properties": {
-        "identifier": {
-          "type": "string",
-          "pattern": "^urn:air:[a-zA-Z0-9.-]+(:[a-zA-Z0-9._-]+)+$",
-          "description": "RFC 8141-compliant unique logical URN formatted as: urn:air:<publisher>:<namespace>:<agent-name>"
-        },
-        "displayName": {
-          "type": "string",
-          "description": "Human-friendly display name."
-        },
-        "type": {
-          "type": "string",
-          "description": "IANA Media Type indicating the specific protocol wrapper or payload structure (e.g. application/mcp-server-card+json)."
-        },
-        "url": {
-          "type": "string",
-          "format": "uri",
-          "description": "HTTP URL reference to retrieve the full artifact document."
-        },
-        "data": {
-          "type": "object",
-          "description": "Embedded JSON object containing the complete artifact specification inline."
-        },
-        "description": {
-          "type": "string",
-          "description": "Brief natural-language description of the capability."
-        },
-        "tags": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "description": "Tags or keywords for basic categorizing and filtering."
-        },
-        "capabilities": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "description": "Explicit high-performance indexing tags representing skills, tools, or functions (e.g. ['WeatherTool', 'ForecastTool'])."
-        },
-        "representativeQueries": {
-          "type": "array",
-          "minItems": 2,
-          "maxItems": 5,
-          "items": {
-            "type": "string"
-          },
-          "description": "Representative natural-language search queries used for indexing and vector embedding generation."
-        },
-        "version": {
-          "type": "string",
-          "description": "Semantic version of the capability."
-        },
-        "updatedAt": {
-          "type": "string",
-          "format": "date-time",
-          "description": "ISO 8601 timestamp of the last modification."
-        },
-        "metadata": {
-          "type": "object",
-          "description": "Arbitrary key-value pairs for custom extensions.",
-          "additionalProperties": {
-            "type": [
-              "string",
-              "number",
-              "boolean",
-              "null"
-            ]
-          }
-        },
-        "trustManifest": {
-          "$ref": "#/$defs/trustManifest"
-        }
+      "not": {
+        "required": [
+          "data"
+        ]
       }
     },
-    "trustManifest": {
-      "type": "object",
-      "description": "Zero-trust security, identity, and compliance envelope metadata.",
+    {
       "required": [
-        "identity"
+        "data"
       ],
-      "properties": {
-        "identity": {
-          "type": "string",
-          "description": "Globally unique cryptographic workload identifier principal (e.g. SPIFFE ID or DID URI)."
-        },
-        "identityType": {
+      "not": {
+        "required": [
+          "url"
+        ]
+      }
+    }
+  ]
+};
+const schema33 = {
+  "type": "object",
+  "description": "The terms an ARD entry may carry. This definition imposes no required terms; ArdEntry layers its own requirements on top.",
+  "properties": {
+    "@context": {
+      "description": "Optional JSON-LD context. Absent, the entry's unprefixed terms resolve to the default namespace. Present, it MAY declare additional namespaces whose prefixed terms describe the resource and become available as filter dimensions.",
+      "oneOf": [
+        {
           "type": "string",
-          "enum": [
-            "spiffe",
-            "did",
-            "https",
-            "other"
-          ],
-          "description": "Hint representing the cryptographic format of the identity."
-        },
-        "trustSchema": {
-          "$ref": "#/$defs/trustSchema"
-        },
-        "attestations": {
-          "type": "array",
-          "description": "List of verifiable claims (SOC 2 audits, compliance statements, HIPAA checks).",
-          "items": {
-            "type": "object",
-            "required": [
-              "type",
-              "uri",
-              "mediaType"
-            ],
-            "properties": {
-              "type": {
-                "type": "string",
-                "description": "Attestation standard type (e.g., SOC2-Type2, HIPAA)."
-              },
-              "uri": {
-                "type": "string",
-                "format": "uri",
-                "description": "Location of the attestation certificate or document."
-              },
-              "mediaType": {
-                "type": "string",
-                "description": "Format of the attestation document (e.g. application/pdf, text/html)."
-              },
-              "digest": {
-                "type": "string",
-                "description": "Cryptographic sha256 digest for document integrity verification."
-              }
-            },
-            "additionalProperties": false
-          }
+          "format": "uri"
         },
-        "provenance": {
-          "type": "array",
-          "description": "Cryptographic lineage trail of the artifact.",
-          "items": {
-            "type": "object",
-            "required": [
-              "relation",
-              "sourceId"
-            ],
-            "properties": {
-              "relation": {
-                "type": "string",
-                "enum": [
-                  "derivedFrom",
-                  "publishedFrom",
-                  "copiedFrom"
-                ],
-                "description": "Lineage relation."
-              },
-              "sourceId": {
-                "type": "string",
-                "description": "Identifier of the source artifact."
-              },
-              "sourceDigest": {
-                "type": "string",
-                "description": "Optional sha256 digest for safety."
-              }
-            },
-            "additionalProperties": false
-          }
+        {
+          "type": "object"
         },
-        "signature": {
-          "type": "string",
-          "description": "Detached JWS signature generated over the fields of the trustManifest."
+        {
+          "type": "array"
         }
+      ]
+    },
+    "@id": {
+      "type": "string",
+      "description": "Optional JSON-LD node identifier. When present alongside `identifier`, both MUST denote the same resource."
+    },
+    "identifier": {
+      "type": "string",
+      "pattern": "^urn:air:[a-zA-Z0-9.-]+(:[a-zA-Z0-9._-]+)+$",
+      "description": "Globally unique discovery handle. Domain-anchored URN: urn:air:<publisher>:<namespace>:<agent-name>. The <publisher> segment is the authority anchor used for publisher-authority binding."
+    },
+    "displayName": {
+      "type": "string",
+      "description": "Human-readable name."
+    },
+    "type": {
+      "type": "string",
+      "description": "Artifact type as an IANA Media Type (e.g. application/mcp-server-card+json). Names what the artifact is without constraining its internal schema."
+    },
+    "url": {
+      "type": "string",
+      "format": "uri",
+      "description": "Reference to the full artifact document. Mutually exclusive with `data`."
+    },
+    "data": {
+      "type": "object",
+      "description": "The complete artifact document, inline. Mutually exclusive with `url`."
+    },
+    "representativeQueries": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Sample natural-language queries this resource can serve — the signal a registry builds its semantic index from. RECOMMENDED on every entry; SHOULD contain 2-5 examples. Neither presence nor count is enforced here so that emitted entries validate; the conformance tester flags absence, or a count outside 2-5, as a warning (§D.2)."
+    },
+    "capabilities": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Short skill or tool tokens (e.g. [\"WeatherTool\"]) enabling structured filtering without fetching the full artifact."
+    },
+    "description": {
+      "type": "string",
+      "description": "Short natural-language description. Contributes to the semantic index."
+    },
+    "tags": {
+      "type": "array",
+      "items": {
+        "type": "string"
       },
-      "additionalProperties": false
+      "description": "Keywords for filtering and faceting."
+    },
+    "version": {
+      "type": "string",
+      "description": "Version of the artifact."
+    },
+    "updatedAt": {
+      "type": "string",
+      "format": "date-time",
+      "description": "ISO 8601 timestamp of the last modification."
+    },
+    "metadata": {
+      "type": "object",
+      "description": "Custom key-value pairs, available as metadata.* filter keys.",
+      "additionalProperties": {
+        "type": [
+          "string",
+          "number",
+          "boolean",
+          "null"
+        ]
+      }
+    },
+    "TrustManifest": {
+      "$ref": "#/$defs/TrustManifest"
+    }
+  },
+  "additionalProperties": true,
+  "$comment": "additionalProperties is intentionally true. Terms drawn from namespaces declared in the entry's @context (e.g. okf:taxonomy) are valid and become filter dimensions. Constraining this to false would defeat the namespace extension mechanism."
+};
+const schema34 = {
+  "type": "object",
+  "description": "Identity, compliance, and provenance envelope. ARD requires only `identity` (for publisher-authority binding) and does not constrain the internal schema; validation is intentionally permissive (additionalProperties: true) so a trust manifest defined by any framework is structurally valid, including members ARD does not enumerate such as trustSchema. This does not mean consumers ignore it: a federated registry is expected to inspect the manifest and verify it per the framework named in trustSchema (attestations, provenance, signature). Signing and verification procedures are defined by that framework, not by ARD.",
+  "required": [
+    "identity"
+  ],
+  "properties": {
+    "identity": {
+      "type": "string",
+      "description": "Globally unique cryptographic workload identifier (SPIFFE ID, DID, or HTTPS FQDN URI). Its trust domain MUST align with the <publisher> segment of the entry's identifier."
+    },
+    "identityType": {
+      "type": "string",
+      "description": "Hint for the cryptographic format of the identity (e.g. spiffe, did, https)."
     },
     "trustSchema": {
       "type": "object",
-      "description": "Describes the trust framework applied to the artifact.",
-      "required": [
-        "identifier",
-        "version"
-      ],
+      "description": "The trust framework the manifest conforms to, and the source of its verification procedure.",
       "properties": {
         "identifier": {
-          "type": "string",
-          "description": "Unique identifier of the trust schema/framework (e.g. URN)."
+          "type": "string"
         },
         "version": {
-          "type": "string",
-          "description": "Version of the trust schema/framework."
+          "type": "string"
         },
         "governanceUri": {
           "type": "string",
-          "format": "uri",
-          "description": "URI pointing to the governance policy document."
+          "format": "uri"
         },
         "verificationMethods": {
           "type": "array",
           "items": {
             "type": "string"
-          },
-          "description": "Verification methods supported by the schema (e.g., ['did', 'x509', 'dns-01'])."
+          }
         }
       },
-      "additionalProperties": false
-    }
-  }
-};
-const formats0 = fullFormats.uri;
-const schema32 = {
-  "type": "object",
-  "description": "Zero-trust security, identity, and compliance envelope metadata.",
-  "required": [
-    "identity"
-  ],
-  "properties": {
-    "identity": {
-      "type": "string",
-      "description": "Globally unique cryptographic workload identifier principal (e.g. SPIFFE ID or DID URI)."
-    },
-    "identityType": {
-      "type": "string",
-      "enum": [
-        "spiffe",
-        "did",
-        "https",
-        "other"
-      ],
-      "description": "Hint representing the cryptographic format of the identity."
-    },
-    "trustSchema": {
-      "$ref": "#/$defs/trustSchema"
+      "additionalProperties": true
     },
     "attestations": {
       "type": "array",
-      "description": "List of verifiable claims (SOC 2 audits, compliance statements, HIPAA checks).",
+      "description": "Verifiable claims (compliance audits, certifications).",
       "items": {
         "type": "object",
         "required": [
           "type",
-          "uri",
-          "mediaType"
+          "uri"
         ],
         "properties": {
           "type": {
-            "type": "string",
-            "description": "Attestation standard type (e.g., SOC2-Type2, HIPAA)."
+            "type": "string"
           },
           "uri": {
             "type": "string",
-            "format": "uri",
-            "description": "Location of the attestation certificate or document."
+            "format": "uri"
           },
           "mediaType": {
-            "type": "string",
-            "description": "Format of the attestation document (e.g. application/pdf, text/html)."
+            "type": "string"
           },
           "digest": {
-            "type": "string",
-            "description": "Cryptographic sha256 digest for document integrity verification."
+            "type": "string"
           }
         },
-        "additionalProperties": false
+        "additionalProperties": true
       }
     },
     "provenance": {
       "type": "array",
-      "description": "Cryptographic lineage trail of the artifact.",
+      "description": "Lineage trail of the artifact.",
       "items": {
         "type": "object",
         "required": [
@@ -373,69 +237,33 @@ const schema32 = {
         ],
         "properties": {
           "relation": {
-            "type": "string",
-            "enum": [
-              "derivedFrom",
-              "publishedFrom",
-              "copiedFrom"
-            ],
-            "description": "Lineage relation."
+            "type": "string"
           },
           "sourceId": {
-            "type": "string",
-            "description": "Identifier of the source artifact."
+            "type": "string"
           },
           "sourceDigest": {
-            "type": "string",
-            "description": "Optional sha256 digest for safety."
+            "type": "string"
           }
         },
-        "additionalProperties": false
+        "additionalProperties": true
       }
     },
     "signature": {
       "type": "string",
-      "description": "Detached JWS signature generated over the fields of the trustManifest."
-    }
-  },
-  "additionalProperties": false
-};
-const schema33 = {
-  "type": "object",
-  "description": "Describes the trust framework applied to the artifact.",
-  "required": [
-    "identifier",
-    "version"
-  ],
-  "properties": {
-    "identifier": {
-      "type": "string",
-      "description": "Unique identifier of the trust schema/framework (e.g. URN)."
-    },
-    "version": {
-      "type": "string",
-      "description": "Version of the trust schema/framework."
-    },
-    "governanceUri": {
-      "type": "string",
-      "format": "uri",
-      "description": "URI pointing to the governance policy document."
-    },
-    "verificationMethods": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      },
-      "description": "Verification methods supported by the schema (e.g., ['did', 'x509', 'dns-01'])."
+      "description": "Detached signature over the trust manifest content, per the framework named in trustSchema."
     }
   },
-  "additionalProperties": false
+  "additionalProperties": true
 };
+const formats0 = fullFormats.uri;
+const formats4 = fullFormats["date-time"];
+const pattern4 = new RegExp("^urn:air:[a-zA-Z0-9.-]+(:[a-zA-Z0-9._-]+)+$", "u");
 
-function validate21(data, {instancePath="", parentData, parentDataProperty, rootData=data, dynamicAnchors={}}={}) {
+function validate22(data, {instancePath="", parentData, parentDataProperty, rootData=data, dynamicAnchors={}}={}) {
   let vErrors = null;
   let errors = 0;
-  const evaluated0 = validate21.evaluated;
+  const evaluated0 = validate22.evaluated;
   if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
   }
@@ -443,19 +271,26 @@ function validate21(data, {instancePath="", parentData, parentDataProperty, root
     evaluated0.items = undefined;
   }
   if (data && typeof data == "object" && !Array.isArray(data)) {
-    if (data.identity === undefined) {
-      const err0 = {instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: "identity"},message:"must have required property '"+"identity"+"'"};
-      if (vErrors === null) {
-        vErrors = [err0];
-      }
-      else {
-        vErrors.push(err0);
-      }
-      errors++;
-    }
-    for (const key0 in data) {
-      if (!((((((key0 === "identity") || (key0 === "identityType")) || (key0 === "trustSchema")) || (key0 === "attestations")) || (key0 === "provenance")) || (key0 === "signature"))) {
-        const err1 = {instancePath,schemaPath:"#/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key0},message:"must NOT have additional properties"};
+    if (data["@context"] !== undefined) {
+      let data0 = data["@context"];
+      const _errs4 = errors;
+      let valid1 = false;
+      let passing0 = null;
+      const _errs5 = errors;
+      if (typeof data0 === "string") {
+        if (!(formats0(data0))) {
+          const err0 = {instancePath:instancePath+"/@context",schemaPath:"#/properties/%40context/oneOf/0/format",keyword:"format",params:{format: "uri"},message:"must match format \""+"uri"+"\""};
+          if (vErrors === null) {
+            vErrors = [err0];
+          }
+          else {
+            vErrors.push(err0);
+          }
+          errors++;
+        }
+      }
+      else {
+        const err1 = {instancePath:instancePath+"/@context",schemaPath:"#/properties/%40context/oneOf/0/type",keyword:"type",params:{type: "string"},message:"must be string"};
         if (vErrors === null) {
           vErrors = [err1];
         }
@@ -464,10 +299,14 @@ function validate21(data, {instancePath="", parentData, parentDataProperty, root
         }
         errors++;
       }
-    }
-    if (data.identity !== undefined) {
-      if (typeof data.identity !== "string") {
-        const err2 = {instancePath:instancePath+"/identity",schemaPath:"#/properties/identity/type",keyword:"type",params:{type: "string"},message:"must be string"};
+      var _valid0 = _errs5 === errors;
+      if (_valid0) {
+        valid1 = true;
+        passing0 = 0;
+      }
+      const _errs7 = errors;
+      if (!(data0 && typeof data0 == "object" && !Array.isArray(data0))) {
+        const err2 = {instancePath:instancePath+"/@context",schemaPath:"#/properties/%40context/oneOf/1/type",keyword:"type",params:{type: "object"},message:"must be object"};
         if (vErrors === null) {
           vErrors = [err2];
         }
@@ -476,21 +315,41 @@ function validate21(data, {instancePath="", parentData, parentDataProperty, root
         }
         errors++;
       }
-    }
-    if (data.identityType !== undefined) {
-      let data1 = data.identityType;
-      if (typeof data1 !== "string") {
-        const err3 = {instancePath:instancePath+"/identityType",schemaPath:"#/properties/identityType/type",keyword:"type",params:{type: "string"},message:"must be string"};
-        if (vErrors === null) {
-          vErrors = [err3];
+      var _valid0 = _errs7 === errors;
+      if (_valid0 && valid1) {
+        valid1 = false;
+        passing0 = [passing0, 1];
+      }
+      else {
+        if (_valid0) {
+          valid1 = true;
+          passing0 = 1;
+        }
+        const _errs9 = errors;
+        if (!(Array.isArray(data0))) {
+          const err3 = {instancePath:instancePath+"/@context",schemaPath:"#/properties/%40context/oneOf/2/type",keyword:"type",params:{type: "array"},message:"must be array"};
+          if (vErrors === null) {
+            vErrors = [err3];
+          }
+          else {
+            vErrors.push(err3);
+          }
+          errors++;
+        }
+        var _valid0 = _errs9 === errors;
+        if (_valid0 && valid1) {
+          valid1 = false;
+          passing0 = [passing0, 2];
         }
         else {
-          vErrors.push(err3);
+          if (_valid0) {
+            valid1 = true;
+            passing0 = 2;
+          }
         }
-        errors++;
       }
-      if (!((((data1 === "spiffe") || (data1 === "did")) || (data1 === "https")) || (data1 === "other"))) {
-        const err4 = {instancePath:instancePath+"/identityType",schemaPath:"#/properties/identityType/enum",keyword:"enum",params:{allowedValues: schema32.properties.identityType.enum},message:"must be equal to one of the allowed values"};
+      if (!valid1) {
+        const err4 = {instancePath:instancePath+"/@context",schemaPath:"#/properties/%40context/oneOf",keyword:"oneOf",params:{passingSchemas: passing0},message:"must match exactly one schema in oneOf"};
         if (vErrors === null) {
           vErrors = [err4];
         }
@@ -499,528 +358,663 @@ function validate21(data, {instancePath="", parentData, parentDataProperty, root
         }
         errors++;
       }
+      else {
+        errors = _errs4;
+        if (vErrors !== null) {
+          if (_errs4) {
+            vErrors.length = _errs4;
+          }
+          else {
+            vErrors = null;
+          }
+        }
+      }
+    }
+    if (data["@id"] !== undefined) {
+      if (typeof data["@id"] !== "string") {
+        const err5 = {instancePath:instancePath+"/@id",schemaPath:"#/properties/%40id/type",keyword:"type",params:{type: "string"},message:"must be string"};
+        if (vErrors === null) {
+          vErrors = [err5];
+        }
+        else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
     }
-    if (data.trustSchema !== undefined) {
-      let data2 = data.trustSchema;
-      if (data2 && typeof data2 == "object" && !Array.isArray(data2)) {
-        if (data2.identifier === undefined) {
-          const err5 = {instancePath:instancePath+"/trustSchema",schemaPath:"#/$defs/trustSchema/required",keyword:"required",params:{missingProperty: "identifier"},message:"must have required property '"+"identifier"+"'"};
+    if (data.identifier !== undefined) {
+      let data2 = data.identifier;
+      if (typeof data2 === "string") {
+        if (!pattern4.test(data2)) {
+          const err6 = {instancePath:instancePath+"/identifier",schemaPath:"#/properties/identifier/pattern",keyword:"pattern",params:{pattern: "^urn:air:[a-zA-Z0-9.-]+(:[a-zA-Z0-9._-]+)+$"},message:"must match pattern \""+"^urn:air:[a-zA-Z0-9.-]+(:[a-zA-Z0-9._-]+)+$"+"\""};
           if (vErrors === null) {
-            vErrors = [err5];
+            vErrors = [err6];
           }
           else {
-            vErrors.push(err5);
+            vErrors.push(err6);
           }
           errors++;
         }
-        if (data2.version === undefined) {
-          const err6 = {instancePath:instancePath+"/trustSchema",schemaPath:"#/$defs/trustSchema/required",keyword:"required",params:{missingProperty: "version"},message:"must have required property '"+"version"+"'"};
+      }
+      else {
+        const err7 = {instancePath:instancePath+"/identifier",schemaPath:"#/properties/identifier/type",keyword:"type",params:{type: "string"},message:"must be string"};
+        if (vErrors === null) {
+          vErrors = [err7];
+        }
+        else {
+          vErrors.push(err7);
+        }
+        errors++;
+      }
+    }
+    if (data.displayName !== undefined) {
+      if (typeof data.displayName !== "string") {
+        const err8 = {instancePath:instancePath+"/displayName",schemaPath:"#/properties/displayName/type",keyword:"type",params:{type: "string"},message:"must be string"};
+        if (vErrors === null) {
+          vErrors = [err8];
+        }
+        else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+    }
+    if (data.type !== undefined) {
+      if (typeof data.type !== "string") {
+        const err9 = {instancePath:instancePath+"/type",schemaPath:"#/properties/type/type",keyword:"type",params:{type: "string"},message:"must be string"};
+        if (vErrors === null) {
+          vErrors = [err9];
+        }
+        else {
+          vErrors.push(err9);
+        }
+        errors++;
+      }
+    }
+    if (data.url !== undefined) {
+      let data5 = data.url;
+      if (typeof data5 === "string") {
+        if (!(formats0(data5))) {
+          const err10 = {instancePath:instancePath+"/url",schemaPath:"#/properties/url/format",keyword:"format",params:{format: "uri"},message:"must match format \""+"uri"+"\""};
           if (vErrors === null) {
-            vErrors = [err6];
+            vErrors = [err10];
           }
           else {
-            vErrors.push(err6);
+            vErrors.push(err10);
           }
           errors++;
         }
-        for (const key1 in data2) {
-          if (!((((key1 === "identifier") || (key1 === "version")) || (key1 === "governanceUri")) || (key1 === "verificationMethods"))) {
-            const err7 = {instancePath:instancePath+"/trustSchema",schemaPath:"#/$defs/trustSchema/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key1},message:"must NOT have additional properties"};
+      }
+      else {
+        const err11 = {instancePath:instancePath+"/url",schemaPath:"#/properties/url/type",keyword:"type",params:{type: "string"},message:"must be string"};
+        if (vErrors === null) {
+          vErrors = [err11];
+        }
+        else {
+          vErrors.push(err11);
+        }
+        errors++;
+      }
+    }
+    if (data.data !== undefined) {
+      let data6 = data.data;
+      if (!(data6 && typeof data6 == "object" && !Array.isArray(data6))) {
+        const err12 = {instancePath:instancePath+"/data",schemaPath:"#/properties/data/type",keyword:"type",params:{type: "object"},message:"must be object"};
+        if (vErrors === null) {
+          vErrors = [err12];
+        }
+        else {
+          vErrors.push(err12);
+        }
+        errors++;
+      }
+    }
+    if (data.representativeQueries !== undefined) {
+      let data7 = data.representativeQueries;
+      if (Array.isArray(data7)) {
+        const len0 = data7.length;
+        for (let i0=0; i0<len0; i0++) {
+          if (typeof data7[i0] !== "string") {
+            const err13 = {instancePath:instancePath+"/representativeQueries/" + i0,schemaPath:"#/properties/representativeQueries/items/type",keyword:"type",params:{type: "string"},message:"must be string"};
             if (vErrors === null) {
-              vErrors = [err7];
+              vErrors = [err13];
             }
             else {
-              vErrors.push(err7);
+              vErrors.push(err13);
             }
             errors++;
           }
         }
-        if (data2.identifier !== undefined) {
-          if (typeof data2.identifier !== "string") {
-            const err8 = {instancePath:instancePath+"/trustSchema/identifier",schemaPath:"#/$defs/trustSchema/properties/identifier/type",keyword:"type",params:{type: "string"},message:"must be string"};
+      }
+      else {
+        const err14 = {instancePath:instancePath+"/representativeQueries",schemaPath:"#/properties/representativeQueries/type",keyword:"type",params:{type: "array"},message:"must be array"};
+        if (vErrors === null) {
+          vErrors = [err14];
+        }
+        else {
+          vErrors.push(err14);
+        }
+        errors++;
+      }
+    }
+    if (data.capabilities !== undefined) {
+      let data9 = data.capabilities;
+      if (Array.isArray(data9)) {
+        const len1 = data9.length;
+        for (let i1=0; i1<len1; i1++) {
+          if (typeof data9[i1] !== "string") {
+            const err15 = {instancePath:instancePath+"/capabilities/" + i1,schemaPath:"#/properties/capabilities/items/type",keyword:"type",params:{type: "string"},message:"must be string"};
             if (vErrors === null) {
-              vErrors = [err8];
+              vErrors = [err15];
             }
             else {
-              vErrors.push(err8);
+              vErrors.push(err15);
             }
             errors++;
           }
         }
-        if (data2.version !== undefined) {
-          if (typeof data2.version !== "string") {
-            const err9 = {instancePath:instancePath+"/trustSchema/version",schemaPath:"#/$defs/trustSchema/properties/version/type",keyword:"type",params:{type: "string"},message:"must be string"};
+      }
+      else {
+        const err16 = {instancePath:instancePath+"/capabilities",schemaPath:"#/properties/capabilities/type",keyword:"type",params:{type: "array"},message:"must be array"};
+        if (vErrors === null) {
+          vErrors = [err16];
+        }
+        else {
+          vErrors.push(err16);
+        }
+        errors++;
+      }
+    }
+    if (data.description !== undefined) {
+      if (typeof data.description !== "string") {
+        const err17 = {instancePath:instancePath+"/description",schemaPath:"#/properties/description/type",keyword:"type",params:{type: "string"},message:"must be string"};
+        if (vErrors === null) {
+          vErrors = [err17];
+        }
+        else {
+          vErrors.push(err17);
+        }
+        errors++;
+      }
+    }
+    if (data.tags !== undefined) {
+      let data12 = data.tags;
+      if (Array.isArray(data12)) {
+        const len2 = data12.length;
+        for (let i2=0; i2<len2; i2++) {
+          if (typeof data12[i2] !== "string") {
+            const err18 = {instancePath:instancePath+"/tags/" + i2,schemaPath:"#/properties/tags/items/type",keyword:"type",params:{type: "string"},message:"must be string"};
             if (vErrors === null) {
-              vErrors = [err9];
+              vErrors = [err18];
             }
             else {
-              vErrors.push(err9);
+              vErrors.push(err18);
             }
             errors++;
           }
         }
-        if (data2.governanceUri !== undefined) {
-          let data5 = data2.governanceUri;
-          if (typeof data5 === "string") {
-            if (!(formats0(data5))) {
-              const err10 = {instancePath:instancePath+"/trustSchema/governanceUri",schemaPath:"#/$defs/trustSchema/properties/governanceUri/format",keyword:"format",params:{format: "uri"},message:"must match format \""+"uri"+"\""};
-              if (vErrors === null) {
-                vErrors = [err10];
-              }
-              else {
-                vErrors.push(err10);
-              }
-              errors++;
-            }
+      }
+      else {
+        const err19 = {instancePath:instancePath+"/tags",schemaPath:"#/properties/tags/type",keyword:"type",params:{type: "array"},message:"must be array"};
+        if (vErrors === null) {
+          vErrors = [err19];
+        }
+        else {
+          vErrors.push(err19);
+        }
+        errors++;
+      }
+    }
+    if (data.version !== undefined) {
+      if (typeof data.version !== "string") {
+        const err20 = {instancePath:instancePath+"/version",schemaPath:"#/properties/version/type",keyword:"type",params:{type: "string"},message:"must be string"};
+        if (vErrors === null) {
+          vErrors = [err20];
+        }
+        else {
+          vErrors.push(err20);
+        }
+        errors++;
+      }
+    }
+    if (data.updatedAt !== undefined) {
+      let data15 = data.updatedAt;
+      if (typeof data15 === "string") {
+        if (!(formats4.validate(data15))) {
+          const err21 = {instancePath:instancePath+"/updatedAt",schemaPath:"#/properties/updatedAt/format",keyword:"format",params:{format: "date-time"},message:"must match format \""+"date-time"+"\""};
+          if (vErrors === null) {
+            vErrors = [err21];
           }
           else {
-            const err11 = {instancePath:instancePath+"/trustSchema/governanceUri",schemaPath:"#/$defs/trustSchema/properties/governanceUri/type",keyword:"type",params:{type: "string"},message:"must be string"};
-            if (vErrors === null) {
-              vErrors = [err11];
-            }
-            else {
-              vErrors.push(err11);
-            }
-            errors++;
+            vErrors.push(err21);
           }
+          errors++;
         }
-        if (data2.verificationMethods !== undefined) {
-          let data6 = data2.verificationMethods;
-          if (Array.isArray(data6)) {
-            const len0 = data6.length;
-            for (let i0=0; i0<len0; i0++) {
-              if (typeof data6[i0] !== "string") {
-                const err12 = {instancePath:instancePath+"/trustSchema/verificationMethods/" + i0,schemaPath:"#/$defs/trustSchema/properties/verificationMethods/items/type",keyword:"type",params:{type: "string"},message:"must be string"};
-                if (vErrors === null) {
-                  vErrors = [err12];
-                }
-                else {
-                  vErrors.push(err12);
-                }
-                errors++;
-              }
-            }
-          }
-          else {
-            const err13 = {instancePath:instancePath+"/trustSchema/verificationMethods",schemaPath:"#/$defs/trustSchema/properties/verificationMethods/type",keyword:"type",params:{type: "array"},message:"must be array"};
+      }
+      else {
+        const err22 = {instancePath:instancePath+"/updatedAt",schemaPath:"#/properties/updatedAt/type",keyword:"type",params:{type: "string"},message:"must be string"};
+        if (vErrors === null) {
+          vErrors = [err22];
+        }
+        else {
+          vErrors.push(err22);
+        }
+        errors++;
+      }
+    }
+    if (data.metadata !== undefined) {
+      let data16 = data.metadata;
+      if (data16 && typeof data16 == "object" && !Array.isArray(data16)) {
+        for (const key0 in data16) {
+          let data17 = data16[key0];
+          if ((((typeof data17 !== "string") && (!((typeof data17 == "number") && (isFinite(data17))))) && (typeof data17 !== "boolean")) && (data17 !== null)) {
+            const err23 = {instancePath:instancePath+"/metadata/" + key0.replace(/~/g, "~0").replace(/\//g, "~1"),schemaPath:"#/properties/metadata/additionalProperties/type",keyword:"type",params:{type: schema33.properties.metadata.additionalProperties.type},message:"must be string,number,boolean,null"};
             if (vErrors === null) {
-              vErrors = [err13];
+              vErrors = [err23];
             }
             else {
-              vErrors.push(err13);
+              vErrors.push(err23);
             }
             errors++;
           }
         }
       }
       else {
-        const err14 = {instancePath:instancePath+"/trustSchema",schemaPath:"#/$defs/trustSchema/type",keyword:"type",params:{type: "object"},message:"must be object"};
+        const err24 = {instancePath:instancePath+"/metadata",schemaPath:"#/properties/metadata/type",keyword:"type",params:{type: "object"},message:"must be object"};
         if (vErrors === null) {
-          vErrors = [err14];
+          vErrors = [err24];
         }
         else {
-          vErrors.push(err14);
+          vErrors.push(err24);
         }
         errors++;
       }
     }
-    if (data.attestations !== undefined) {
-      let data8 = data.attestations;
-      if (Array.isArray(data8)) {
-        const len1 = data8.length;
-        for (let i1=0; i1<len1; i1++) {
-          let data9 = data8[i1];
-          if (data9 && typeof data9 == "object" && !Array.isArray(data9)) {
-            if (data9.type === undefined) {
-              const err15 = {instancePath:instancePath+"/attestations/" + i1,schemaPath:"#/properties/attestations/items/required",keyword:"required",params:{missingProperty: "type"},message:"must have required property '"+"type"+"'"};
-              if (vErrors === null) {
-                vErrors = [err15];
-              }
-              else {
-                vErrors.push(err15);
-              }
-              errors++;
+    if (data.TrustManifest !== undefined) {
+      let data18 = data.TrustManifest;
+      if (data18 && typeof data18 == "object" && !Array.isArray(data18)) {
+        if (data18.identity === undefined) {
+          const err25 = {instancePath:instancePath+"/TrustManifest",schemaPath:"#/$defs/TrustManifest/required",keyword:"required",params:{missingProperty: "identity"},message:"must have required property '"+"identity"+"'"};
+          if (vErrors === null) {
+            vErrors = [err25];
+          }
+          else {
+            vErrors.push(err25);
+          }
+          errors++;
+        }
+        if (data18.identity !== undefined) {
+          if (typeof data18.identity !== "string") {
+            const err26 = {instancePath:instancePath+"/TrustManifest/identity",schemaPath:"#/$defs/TrustManifest/properties/identity/type",keyword:"type",params:{type: "string"},message:"must be string"};
+            if (vErrors === null) {
+              vErrors = [err26];
             }
-            if (data9.uri === undefined) {
-              const err16 = {instancePath:instancePath+"/attestations/" + i1,schemaPath:"#/properties/attestations/items/required",keyword:"required",params:{missingProperty: "uri"},message:"must have required property '"+"uri"+"'"};
-              if (vErrors === null) {
-                vErrors = [err16];
-              }
-              else {
-                vErrors.push(err16);
-              }
-              errors++;
+            else {
+              vErrors.push(err26);
             }
-            if (data9.mediaType === undefined) {
-              const err17 = {instancePath:instancePath+"/attestations/" + i1,schemaPath:"#/properties/attestations/items/required",keyword:"required",params:{missingProperty: "mediaType"},message:"must have required property '"+"mediaType"+"'"};
-              if (vErrors === null) {
-                vErrors = [err17];
-              }
-              else {
-                vErrors.push(err17);
-              }
-              errors++;
+            errors++;
+          }
+        }
+        if (data18.identityType !== undefined) {
+          if (typeof data18.identityType !== "string") {
+            const err27 = {instancePath:instancePath+"/TrustManifest/identityType",schemaPath:"#/$defs/TrustManifest/properties/identityType/type",keyword:"type",params:{type: "string"},message:"must be string"};
+            if (vErrors === null) {
+              vErrors = [err27];
+            }
+            else {
+              vErrors.push(err27);
             }
-            for (const key2 in data9) {
-              if (!((((key2 === "type") || (key2 === "uri")) || (key2 === "mediaType")) || (key2 === "digest"))) {
-                const err18 = {instancePath:instancePath+"/attestations/" + i1,schemaPath:"#/properties/attestations/items/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key2},message:"must NOT have additional properties"};
+            errors++;
+          }
+        }
+        if (data18.trustSchema !== undefined) {
+          let data21 = data18.trustSchema;
+          if (data21 && typeof data21 == "object" && !Array.isArray(data21)) {
+            if (data21.identifier !== undefined) {
+              if (typeof data21.identifier !== "string") {
+                const err28 = {instancePath:instancePath+"/TrustManifest/trustSchema/identifier",schemaPath:"#/$defs/TrustManifest/properties/trustSchema/properties/identifier/type",keyword:"type",params:{type: "string"},message:"must be string"};
                 if (vErrors === null) {
-                  vErrors = [err18];
+                  vErrors = [err28];
                 }
                 else {
-                  vErrors.push(err18);
+                  vErrors.push(err28);
                 }
                 errors++;
               }
             }
-            if (data9.type !== undefined) {
-              if (typeof data9.type !== "string") {
-                const err19 = {instancePath:instancePath+"/attestations/" + i1+"/type",schemaPath:"#/properties/attestations/items/properties/type/type",keyword:"type",params:{type: "string"},message:"must be string"};
+            if (data21.version !== undefined) {
+              if (typeof data21.version !== "string") {
+                const err29 = {instancePath:instancePath+"/TrustManifest/trustSchema/version",schemaPath:"#/$defs/TrustManifest/properties/trustSchema/properties/version/type",keyword:"type",params:{type: "string"},message:"must be string"};
                 if (vErrors === null) {
-                  vErrors = [err19];
+                  vErrors = [err29];
                 }
                 else {
-                  vErrors.push(err19);
+                  vErrors.push(err29);
                 }
                 errors++;
               }
             }
-            if (data9.uri !== undefined) {
-              let data11 = data9.uri;
-              if (typeof data11 === "string") {
-                if (!(formats0(data11))) {
-                  const err20 = {instancePath:instancePath+"/attestations/" + i1+"/uri",schemaPath:"#/properties/attestations/items/properties/uri/format",keyword:"format",params:{format: "uri"},message:"must match format \""+"uri"+"\""};
+            if (data21.governanceUri !== undefined) {
+              let data24 = data21.governanceUri;
+              if (typeof data24 === "string") {
+                if (!(formats0(data24))) {
+                  const err30 = {instancePath:instancePath+"/TrustManifest/trustSchema/governanceUri",schemaPath:"#/$defs/TrustManifest/properties/trustSchema/properties/governanceUri/format",keyword:"format",params:{format: "uri"},message:"must match format \""+"uri"+"\""};
                   if (vErrors === null) {
-                    vErrors = [err20];
+                    vErrors = [err30];
                   }
                   else {
-                    vErrors.push(err20);
+                    vErrors.push(err30);
                   }
                   errors++;
                 }
               }
               else {
-                const err21 = {instancePath:instancePath+"/attestations/" + i1+"/uri",schemaPath:"#/properties/attestations/items/properties/uri/type",keyword:"type",params:{type: "string"},message:"must be string"};
+                const err31 = {instancePath:instancePath+"/TrustManifest/trustSchema/governanceUri",schemaPath:"#/$defs/TrustManifest/properties/trustSchema/properties/governanceUri/type",keyword:"type",params:{type: "string"},message:"must be string"};
                 if (vErrors === null) {
-                  vErrors = [err21];
+                  vErrors = [err31];
                 }
                 else {
-                  vErrors.push(err21);
+                  vErrors.push(err31);
                 }
                 errors++;
               }
             }
-            if (data9.mediaType !== undefined) {
-              if (typeof data9.mediaType !== "string") {
-                const err22 = {instancePath:instancePath+"/attestations/" + i1+"/mediaType",schemaPath:"#/properties/attestations/items/properties/mediaType/type",keyword:"type",params:{type: "string"},message:"must be string"};
-                if (vErrors === null) {
-                  vErrors = [err22];
-                }
-                else {
-                  vErrors.push(err22);
+            if (data21.verificationMethods !== undefined) {
+              let data25 = data21.verificationMethods;
+              if (Array.isArray(data25)) {
+                const len3 = data25.length;
+                for (let i3=0; i3<len3; i3++) {
+                  if (typeof data25[i3] !== "string") {
+                    const err32 = {instancePath:instancePath+"/TrustManifest/trustSchema/verificationMethods/" + i3,schemaPath:"#/$defs/TrustManifest/properties/trustSchema/properties/verificationMethods/items/type",keyword:"type",params:{type: "string"},message:"must be string"};
+                    if (vErrors === null) {
+                      vErrors = [err32];
+                    }
+                    else {
+                      vErrors.push(err32);
+                    }
+                    errors++;
+                  }
                 }
-                errors++;
               }
-            }
-            if (data9.digest !== undefined) {
-              if (typeof data9.digest !== "string") {
-                const err23 = {instancePath:instancePath+"/attestations/" + i1+"/digest",schemaPath:"#/properties/attestations/items/properties/digest/type",keyword:"type",params:{type: "string"},message:"must be string"};
+              else {
+                const err33 = {instancePath:instancePath+"/TrustManifest/trustSchema/verificationMethods",schemaPath:"#/$defs/TrustManifest/properties/trustSchema/properties/verificationMethods/type",keyword:"type",params:{type: "array"},message:"must be array"};
                 if (vErrors === null) {
-                  vErrors = [err23];
+                  vErrors = [err33];
                 }
                 else {
-                  vErrors.push(err23);
+                  vErrors.push(err33);
                 }
                 errors++;
               }
             }
           }
           else {
-            const err24 = {instancePath:instancePath+"/attestations/" + i1,schemaPath:"#/properties/attestations/items/type",keyword:"type",params:{type: "object"},message:"must be object"};
+            const err34 = {instancePath:instancePath+"/TrustManifest/trustSchema",schemaPath:"#/$defs/TrustManifest/properties/trustSchema/type",keyword:"type",params:{type: "object"},message:"must be object"};
             if (vErrors === null) {
-              vErrors = [err24];
+              vErrors = [err34];
             }
             else {
-              vErrors.push(err24);
+              vErrors.push(err34);
             }
             errors++;
           }
         }
-      }
-      else {
-        const err25 = {instancePath:instancePath+"/attestations",schemaPath:"#/properties/attestations/type",keyword:"type",params:{type: "array"},message:"must be array"};
-        if (vErrors === null) {
-          vErrors = [err25];
-        }
-        else {
-          vErrors.push(err25);
-        }
-        errors++;
-      }
-    }
-    if (data.provenance !== undefined) {
-      let data14 = data.provenance;
-      if (Array.isArray(data14)) {
-        const len2 = data14.length;
-        for (let i2=0; i2<len2; i2++) {
-          let data15 = data14[i2];
-          if (data15 && typeof data15 == "object" && !Array.isArray(data15)) {
-            if (data15.relation === undefined) {
-              const err26 = {instancePath:instancePath+"/provenance/" + i2,schemaPath:"#/properties/provenance/items/required",keyword:"required",params:{missingProperty: "relation"},message:"must have required property '"+"relation"+"'"};
-              if (vErrors === null) {
-                vErrors = [err26];
-              }
-              else {
-                vErrors.push(err26);
-              }
-              errors++;
-            }
-            if (data15.sourceId === undefined) {
-              const err27 = {instancePath:instancePath+"/provenance/" + i2,schemaPath:"#/properties/provenance/items/required",keyword:"required",params:{missingProperty: "sourceId"},message:"must have required property '"+"sourceId"+"'"};
-              if (vErrors === null) {
-                vErrors = [err27];
-              }
-              else {
-                vErrors.push(err27);
-              }
-              errors++;
-            }
-            for (const key3 in data15) {
-              if (!(((key3 === "relation") || (key3 === "sourceId")) || (key3 === "sourceDigest"))) {
-                const err28 = {instancePath:instancePath+"/provenance/" + i2,schemaPath:"#/properties/provenance/items/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key3},message:"must NOT have additional properties"};
-                if (vErrors === null) {
-                  vErrors = [err28];
-                }
-                else {
-                  vErrors.push(err28);
+        if (data18.attestations !== undefined) {
+          let data27 = data18.attestations;
+          if (Array.isArray(data27)) {
+            const len4 = data27.length;
+            for (let i4=0; i4<len4; i4++) {
+              let data28 = data27[i4];
+              if (data28 && typeof data28 == "object" && !Array.isArray(data28)) {
+                if (data28.type === undefined) {
+                  const err35 = {instancePath:instancePath+"/TrustManifest/attestations/" + i4,schemaPath:"#/$defs/TrustManifest/properties/attestations/items/required",keyword:"required",params:{missingProperty: "type"},message:"must have required property '"+"type"+"'"};
+                  if (vErrors === null) {
+                    vErrors = [err35];
+                  }
+                  else {
+                    vErrors.push(err35);
+                  }
+                  errors++;
                 }
-                errors++;
-              }
-            }
-            if (data15.relation !== undefined) {
-              let data16 = data15.relation;
-              if (typeof data16 !== "string") {
-                const err29 = {instancePath:instancePath+"/provenance/" + i2+"/relation",schemaPath:"#/properties/provenance/items/properties/relation/type",keyword:"type",params:{type: "string"},message:"must be string"};
-                if (vErrors === null) {
-                  vErrors = [err29];
+                if (data28.uri === undefined) {
+                  const err36 = {instancePath:instancePath+"/TrustManifest/attestations/" + i4,schemaPath:"#/$defs/TrustManifest/properties/attestations/items/required",keyword:"required",params:{missingProperty: "uri"},message:"must have required property '"+"uri"+"'"};
+                  if (vErrors === null) {
+                    vErrors = [err36];
+                  }
+                  else {
+                    vErrors.push(err36);
+                  }
+                  errors++;
                 }
-                else {
-                  vErrors.push(err29);
+                if (data28.type !== undefined) {
+                  if (typeof data28.type !== "string") {
+                    const err37 = {instancePath:instancePath+"/TrustManifest/attestations/" + i4+"/type",schemaPath:"#/$defs/TrustManifest/properties/attestations/items/properties/type/type",keyword:"type",params:{type: "string"},message:"must be string"};
+                    if (vErrors === null) {
+                      vErrors = [err37];
+                    }
+                    else {
+                      vErrors.push(err37);
+                    }
+                    errors++;
+                  }
+                }
+                if (data28.uri !== undefined) {
+                  let data30 = data28.uri;
+                  if (typeof data30 === "string") {
+                    if (!(formats0(data30))) {
+                      const err38 = {instancePath:instancePath+"/TrustManifest/attestations/" + i4+"/uri",schemaPath:"#/$defs/TrustManifest/properties/attestations/items/properties/uri/format",keyword:"format",params:{format: "uri"},message:"must match format \""+"uri"+"\""};
+                      if (vErrors === null) {
+                        vErrors = [err38];
+                      }
+                      else {
+                        vErrors.push(err38);
+                      }
+                      errors++;
+                    }
+                  }
+                  else {
+                    const err39 = {instancePath:instancePath+"/TrustManifest/attestations/" + i4+"/uri",schemaPath:"#/$defs/TrustManifest/properties/attestations/items/properties/uri/type",keyword:"type",params:{type: "string"},message:"must be string"};
+                    if (vErrors === null) {
+                      vErrors = [err39];
+                    }
+                    else {
+                      vErrors.push(err39);
+                    }
+                    errors++;
+                  }
+                }
+                if (data28.mediaType !== undefined) {
+                  if (typeof data28.mediaType !== "string") {
+                    const err40 = {instancePath:instancePath+"/TrustManifest/attestations/" + i4+"/mediaType",schemaPath:"#/$defs/TrustManifest/properties/attestations/items/properties/mediaType/type",keyword:"type",params:{type: "string"},message:"must be string"};
+                    if (vErrors === null) {
+                      vErrors = [err40];
+                    }
+                    else {
+                      vErrors.push(err40);
+                    }
+                    errors++;
+                  }
+                }
+                if (data28.digest !== undefined) {
+                  if (typeof data28.digest !== "string") {
+                    const err41 = {instancePath:instancePath+"/TrustManifest/attestations/" + i4+"/digest",schemaPath:"#/$defs/TrustManifest/properties/attestations/items/properties/digest/type",keyword:"type",params:{type: "string"},message:"must be string"};
+                    if (vErrors === null) {
+                      vErrors = [err41];
+                    }
+                    else {
+                      vErrors.push(err41);
+                    }
+                    errors++;
+                  }
                 }
-                errors++;
               }
-              if (!(((data16 === "derivedFrom") || (data16 === "publishedFrom")) || (data16 === "copiedFrom"))) {
-                const err30 = {instancePath:instancePath+"/provenance/" + i2+"/relation",schemaPath:"#/properties/provenance/items/properties/relation/enum",keyword:"enum",params:{allowedValues: schema32.properties.provenance.items.properties.relation.enum},message:"must be equal to one of the allowed values"};
+              else {
+                const err42 = {instancePath:instancePath+"/TrustManifest/attestations/" + i4,schemaPath:"#/$defs/TrustManifest/properties/attestations/items/type",keyword:"type",params:{type: "object"},message:"must be object"};
                 if (vErrors === null) {
-                  vErrors = [err30];
+                  vErrors = [err42];
                 }
                 else {
-                  vErrors.push(err30);
+                  vErrors.push(err42);
                 }
                 errors++;
               }
             }
-            if (data15.sourceId !== undefined) {
-              if (typeof data15.sourceId !== "string") {
-                const err31 = {instancePath:instancePath+"/provenance/" + i2+"/sourceId",schemaPath:"#/properties/provenance/items/properties/sourceId/type",keyword:"type",params:{type: "string"},message:"must be string"};
-                if (vErrors === null) {
-                  vErrors = [err31];
+          }
+          else {
+            const err43 = {instancePath:instancePath+"/TrustManifest/attestations",schemaPath:"#/$defs/TrustManifest/properties/attestations/type",keyword:"type",params:{type: "array"},message:"must be array"};
+            if (vErrors === null) {
+              vErrors = [err43];
+            }
+            else {
+              vErrors.push(err43);
+            }
+            errors++;
+          }
+        }
+        if (data18.provenance !== undefined) {
+          let data33 = data18.provenance;
+          if (Array.isArray(data33)) {
+            const len5 = data33.length;
+            for (let i5=0; i5<len5; i5++) {
+              let data34 = data33[i5];
+              if (data34 && typeof data34 == "object" && !Array.isArray(data34)) {
+                if (data34.relation === undefined) {
+                  const err44 = {instancePath:instancePath+"/TrustManifest/provenance/" + i5,schemaPath:"#/$defs/TrustManifest/properties/provenance/items/required",keyword:"required",params:{missingProperty: "relation"},message:"must have required property '"+"relation"+"'"};
+                  if (vErrors === null) {
+                    vErrors = [err44];
+                  }
+                  else {
+                    vErrors.push(err44);
+                  }
+                  errors++;
                 }
-                else {
-                  vErrors.push(err31);
+                if (data34.sourceId === undefined) {
+                  const err45 = {instancePath:instancePath+"/TrustManifest/provenance/" + i5,schemaPath:"#/$defs/TrustManifest/properties/provenance/items/required",keyword:"required",params:{missingProperty: "sourceId"},message:"must have required property '"+"sourceId"+"'"};
+                  if (vErrors === null) {
+                    vErrors = [err45];
+                  }
+                  else {
+                    vErrors.push(err45);
+                  }
+                  errors++;
+                }
+                if (data34.relation !== undefined) {
+                  if (typeof data34.relation !== "string") {
+                    const err46 = {instancePath:instancePath+"/TrustManifest/provenance/" + i5+"/relation",schemaPath:"#/$defs/TrustManifest/properties/provenance/items/properties/relation/type",keyword:"type",params:{type: "string"},message:"must be string"};
+                    if (vErrors === null) {
+                      vErrors = [err46];
+                    }
+                    else {
+                      vErrors.push(err46);
+                    }
+                    errors++;
+                  }
+                }
+                if (data34.sourceId !== undefined) {
+                  if (typeof data34.sourceId !== "string") {
+                    const err47 = {instancePath:instancePath+"/TrustManifest/provenance/" + i5+"/sourceId",schemaPath:"#/$defs/TrustManifest/properties/provenance/items/properties/sourceId/type",keyword:"type",params:{type: "string"},message:"must be string"};
+                    if (vErrors === null) {
+                      vErrors = [err47];
+                    }
+                    else {
+                      vErrors.push(err47);
+                    }
+                    errors++;
+                  }
+                }
+                if (data34.sourceDigest !== undefined) {
+                  if (typeof data34.sourceDigest !== "string") {
+                    const err48 = {instancePath:instancePath+"/TrustManifest/provenance/" + i5+"/sourceDigest",schemaPath:"#/$defs/TrustManifest/properties/provenance/items/properties/sourceDigest/type",keyword:"type",params:{type: "string"},message:"must be string"};
+                    if (vErrors === null) {
+                      vErrors = [err48];
+                    }
+                    else {
+                      vErrors.push(err48);
+                    }
+                    errors++;
+                  }
                 }
-                errors++;
               }
-            }
-            if (data15.sourceDigest !== undefined) {
-              if (typeof data15.sourceDigest !== "string") {
-                const err32 = {instancePath:instancePath+"/provenance/" + i2+"/sourceDigest",schemaPath:"#/properties/provenance/items/properties/sourceDigest/type",keyword:"type",params:{type: "string"},message:"must be string"};
+              else {
+                const err49 = {instancePath:instancePath+"/TrustManifest/provenance/" + i5,schemaPath:"#/$defs/TrustManifest/properties/provenance/items/type",keyword:"type",params:{type: "object"},message:"must be object"};
                 if (vErrors === null) {
-                  vErrors = [err32];
+                  vErrors = [err49];
                 }
                 else {
-                  vErrors.push(err32);
+                  vErrors.push(err49);
                 }
                 errors++;
               }
             }
           }
           else {
-            const err33 = {instancePath:instancePath+"/provenance/" + i2,schemaPath:"#/properties/provenance/items/type",keyword:"type",params:{type: "object"},message:"must be object"};
+            const err50 = {instancePath:instancePath+"/TrustManifest/provenance",schemaPath:"#/$defs/TrustManifest/properties/provenance/type",keyword:"type",params:{type: "array"},message:"must be array"};
             if (vErrors === null) {
-              vErrors = [err33];
+              vErrors = [err50];
             }
             else {
-              vErrors.push(err33);
+              vErrors.push(err50);
             }
             errors++;
           }
         }
-      }
-      else {
-        const err34 = {instancePath:instancePath+"/provenance",schemaPath:"#/properties/provenance/type",keyword:"type",params:{type: "array"},message:"must be array"};
-        if (vErrors === null) {
-          vErrors = [err34];
-        }
-        else {
-          vErrors.push(err34);
+        if (data18.signature !== undefined) {
+          if (typeof data18.signature !== "string") {
+            const err51 = {instancePath:instancePath+"/TrustManifest/signature",schemaPath:"#/$defs/TrustManifest/properties/signature/type",keyword:"type",params:{type: "string"},message:"must be string"};
+            if (vErrors === null) {
+              vErrors = [err51];
+            }
+            else {
+              vErrors.push(err51);
+            }
+            errors++;
+          }
         }
-        errors++;
       }
-    }
-    if (data.signature !== undefined) {
-      if (typeof data.signature !== "string") {
-        const err35 = {instancePath:instancePath+"/signature",schemaPath:"#/properties/signature/type",keyword:"type",params:{type: "string"},message:"must be string"};
+      else {
+        const err52 = {instancePath:instancePath+"/TrustManifest",schemaPath:"#/$defs/TrustManifest/type",keyword:"type",params:{type: "object"},message:"must be object"};
         if (vErrors === null) {
-          vErrors = [err35];
+          vErrors = [err52];
         }
         else {
-          vErrors.push(err35);
+          vErrors.push(err52);
         }
         errors++;
       }
     }
   }
   else {
-    const err36 = {instancePath,schemaPath:"#/type",keyword:"type",params:{type: "object"},message:"must be object"};
+    const err53 = {instancePath,schemaPath:"#/type",keyword:"type",params:{type: "object"},message:"must be object"};
     if (vErrors === null) {
-      vErrors = [err36];
+      vErrors = [err53];
     }
     else {
-      vErrors.push(err36);
+      vErrors.push(err53);
     }
     errors++;
   }
-  validate21.errors = vErrors;
+  validate22.errors = vErrors;
   return errors === 0;
 }
-validate21.evaluated = {"props":true,"dynamicProps":false,"dynamicItems":false};
+validate22.evaluated = {"props":true,"dynamicProps":false,"dynamicItems":false};
 
-const schema34 = {
-  "type": "object",
-  "description": "A single AI capability entry within the catalog.",
-  "required": [
-    "identifier",
-    "displayName",
-    "type"
-  ],
-  "oneOf": [
-    {
-      "required": [
-        "url"
-      ],
-      "not": {
-        "required": [
-          "data"
-        ]
-      }
-    },
-    {
-      "required": [
-        "data"
-      ],
-      "not": {
-        "required": [
-          "url"
-        ]
-      }
-    }
-  ],
-  "properties": {
-    "identifier": {
-      "type": "string",
-      "pattern": "^urn:air:[a-zA-Z0-9.-]+(:[a-zA-Z0-9._-]+)+$",
-      "description": "RFC 8141-compliant unique logical URN formatted as: urn:air:<publisher>:<namespace>:<agent-name>"
-    },
-    "displayName": {
-      "type": "string",
-      "description": "Human-friendly display name."
-    },
-    "type": {
-      "type": "string",
-      "description": "IANA Media Type indicating the specific protocol wrapper or payload structure (e.g. application/mcp-server-card+json)."
-    },
-    "url": {
-      "type": "string",
-      "format": "uri",
-      "description": "HTTP URL reference to retrieve the full artifact document."
-    },
-    "data": {
-      "type": "object",
-      "description": "Embedded JSON object containing the complete artifact specification inline."
-    },
-    "description": {
-      "type": "string",
-      "description": "Brief natural-language description of the capability."
-    },
-    "tags": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      },
-      "description": "Tags or keywords for basic categorizing and filtering."
-    },
-    "capabilities": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      },
-      "description": "Explicit high-performance indexing tags representing skills, tools, or functions (e.g. ['WeatherTool', 'ForecastTool'])."
-    },
-    "representativeQueries": {
-      "type": "array",
-      "minItems": 2,
-      "maxItems": 5,
-      "items": {
-        "type": "string"
-      },
-      "description": "Representative natural-language search queries used for indexing and vector embedding generation."
-    },
-    "version": {
-      "type": "string",
-      "description": "Semantic version of the capability."
-    },
-    "updatedAt": {
-      "type": "string",
-      "format": "date-time",
-      "description": "ISO 8601 timestamp of the last modification."
-    },
-    "metadata": {
-      "type": "object",
-      "description": "Arbitrary key-value pairs for custom extensions.",
-      "additionalProperties": {
-        "type": [
-          "string",
-          "number",
-          "boolean",
-          "null"
-        ]
-      }
-    },
-    "trustManifest": {
-      "$ref": "#/$defs/trustManifest"
-    }
-  }
-};
-const pattern4 = new RegExp("^urn:air:[a-zA-Z0-9.-]+(:[a-zA-Z0-9._-]+)+$", "u");
-const formats10 = fullFormats["date-time"];
 
-function validate23(data, {instancePath="", parentData, parentDataProperty, rootData=data, dynamicAnchors={}}={}) {
+function validate21(data, {instancePath="", parentData, parentDataProperty, rootData=data, dynamicAnchors={}}={}) {
   let vErrors = null;
   let errors = 0;
-  const evaluated0 = validate23.evaluated;
+  const evaluated0 = validate21.evaluated;
   if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
   }
   if (evaluated0.dynamicItems) {
     evaluated0.items = undefined;
   }
-  const _errs1 = errors;
+  const _errs0 = errors;
   let valid0 = false;
   let passing0 = null;
+  const _errs1 = errors;
   const _errs2 = errors;
   const _errs3 = errors;
-  const _errs4 = errors;
   if (data && typeof data == "object" && !Array.isArray(data)) {
     let missing0;
     if ((data.data === undefined) && (missing0 = "data")) {
@@ -1034,7 +1028,7 @@ function validate23(data, {instancePath="", parentData, parentDataProperty, root
       errors++;
     }
   }
-  var valid1 = _errs4 === errors;
+  var valid1 = _errs3 === errors;
   if (valid1) {
     const err1 = {instancePath,schemaPath:"#/oneOf/0/not",keyword:"not",params:{},message:"must NOT be valid"};
     if (vErrors === null) {
@@ -1046,10 +1040,10 @@ function validate23(data, {instancePath="", parentData, parentDataProperty, root
     errors++;
   }
   else {
-    errors = _errs3;
+    errors = _errs2;
     if (vErrors !== null) {
-      if (_errs3) {
-        vErrors.length = _errs3;
+      if (_errs2) {
+        vErrors.length = _errs2;
       }
       else {
         vErrors = null;
@@ -1068,14 +1062,14 @@ function validate23(data, {instancePath="", parentData, parentDataProperty, root
       errors++;
     }
   }
-  var _valid0 = _errs2 === errors;
+  var _valid0 = _errs1 === errors;
   if (_valid0) {
     valid0 = true;
     passing0 = 0;
   }
+  const _errs4 = errors;
   const _errs5 = errors;
   const _errs6 = errors;
-  const _errs7 = errors;
   if (data && typeof data == "object" && !Array.isArray(data)) {
     let missing1;
     if ((data.url === undefined) && (missing1 = "url")) {
@@ -1089,7 +1083,7 @@ function validate23(data, {instancePath="", parentData, parentDataProperty, root
       errors++;
     }
   }
-  var valid2 = _errs7 === errors;
+  var valid2 = _errs6 === errors;
   if (valid2) {
     const err4 = {instancePath,schemaPath:"#/oneOf/1/not",keyword:"not",params:{},message:"must NOT be valid"};
     if (vErrors === null) {
@@ -1101,10 +1095,10 @@ function validate23(data, {instancePath="", parentData, parentDataProperty, root
     errors++;
   }
   else {
-    errors = _errs6;
+    errors = _errs5;
     if (vErrors !== null) {
-      if (_errs6) {
-        vErrors.length = _errs6;
+      if (_errs5) {
+        vErrors.length = _errs5;
       }
       else {
         vErrors = null;
@@ -1123,7 +1117,7 @@ function validate23(data, {instancePath="", parentData, parentDataProperty, root
       errors++;
     }
   }
-  var _valid0 = _errs5 === errors;
+  var _valid0 = _errs4 === errors;
   if (_valid0 && valid0) {
     valid0 = false;
     passing0 = [passing0, 1];
@@ -1145,16 +1139,20 @@ function validate23(data, {instancePath="", parentData, parentDataProperty, root
     errors++;
   }
   else {
-    errors = _errs1;
+    errors = _errs0;
     if (vErrors !== null) {
-      if (_errs1) {
-        vErrors.length = _errs1;
+      if (_errs0) {
+        vErrors.length = _errs0;
       }
       else {
         vErrors = null;
       }
     }
   }
+  if (!(validate22(data, {instancePath,parentData,parentDataProperty,rootData,dynamicAnchors}))) {
+    vErrors = vErrors === null ? validate22.errors : vErrors.concat(validate22.errors);
+    errors = vErrors.length;
+  }
   if (data && typeof data == "object" && !Array.isArray(data)) {
     if (data.identifier === undefined) {
       const err7 = {instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: "identifier"},message:"must have required property '"+"identifier"+"'"};
@@ -1186,311 +1184,94 @@ function validate23(data, {instancePath="", parentData, parentDataProperty, root
       }
       errors++;
     }
-    if (data.identifier !== undefined) {
-      let data0 = data.identifier;
-      if (typeof data0 === "string") {
-        if (!pattern4.test(data0)) {
-          const err10 = {instancePath:instancePath+"/identifier",schemaPath:"#/properties/identifier/pattern",keyword:"pattern",params:{pattern: "^urn:air:[a-zA-Z0-9.-]+(:[a-zA-Z0-9._-]+)+$"},message:"must match pattern \""+"^urn:air:[a-zA-Z0-9.-]+(:[a-zA-Z0-9._-]+)+$"+"\""};
-          if (vErrors === null) {
-            vErrors = [err10];
-          }
-          else {
-            vErrors.push(err10);
-          }
-          errors++;
-        }
+  }
+  validate21.errors = vErrors;
+  return errors === 0;
+}
+validate21.evaluated = {"props":true,"dynamicProps":false,"dynamicItems":false};
+
+
+function validate25(data, {instancePath="", parentData, parentDataProperty, rootData=data, dynamicAnchors={}}={}) {
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate25.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.entries === undefined) {
+      const err0 = {instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: "entries"},message:"must have required property '"+"entries"+"'"};
+      if (vErrors === null) {
+        vErrors = [err0];
       }
       else {
-        const err11 = {instancePath:instancePath+"/identifier",schemaPath:"#/properties/identifier/type",keyword:"type",params:{type: "string"},message:"must be string"};
-        if (vErrors === null) {
-          vErrors = [err11];
-        }
-        else {
-          vErrors.push(err11);
-        }
-        errors++;
-      }
-    }
-    if (data.displayName !== undefined) {
-      if (typeof data.displayName !== "string") {
-        const err12 = {instancePath:instancePath+"/displayName",schemaPath:"#/properties/displayName/type",keyword:"type",params:{type: "string"},message:"must be string"};
-        if (vErrors === null) {
-          vErrors = [err12];
-        }
-        else {
-          vErrors.push(err12);
-        }
-        errors++;
-      }
-    }
-    if (data.type !== undefined) {
-      if (typeof data.type !== "string") {
-        const err13 = {instancePath:instancePath+"/type",schemaPath:"#/properties/type/type",keyword:"type",params:{type: "string"},message:"must be string"};
-        if (vErrors === null) {
-          vErrors = [err13];
-        }
-        else {
-          vErrors.push(err13);
-        }
-        errors++;
+        vErrors.push(err0);
       }
+      errors++;
     }
-    if (data.url !== undefined) {
-      let data3 = data.url;
-      if (typeof data3 === "string") {
-        if (!(formats0(data3))) {
-          const err14 = {instancePath:instancePath+"/url",schemaPath:"#/properties/url/format",keyword:"format",params:{format: "uri"},message:"must match format \""+"uri"+"\""};
-          if (vErrors === null) {
-            vErrors = [err14];
-          }
-          else {
-            vErrors.push(err14);
+    if (data.entries !== undefined) {
+      let data0 = data.entries;
+      if (Array.isArray(data0)) {
+        const len0 = data0.length;
+        for (let i0=0; i0<len0; i0++) {
+          if (!(validate21(data0[i0], {instancePath:instancePath+"/entries/" + i0,parentData:data0,parentDataProperty:i0,rootData,dynamicAnchors}))) {
+            vErrors = vErrors === null ? validate21.errors : vErrors.concat(validate21.errors);
+            errors = vErrors.length;
           }
-          errors++;
         }
       }
       else {
-        const err15 = {instancePath:instancePath+"/url",schemaPath:"#/properties/url/type",keyword:"type",params:{type: "string"},message:"must be string"};
-        if (vErrors === null) {
-          vErrors = [err15];
-        }
-        else {
-          vErrors.push(err15);
-        }
-        errors++;
-      }
-    }
-    if (data.data !== undefined) {
-      let data4 = data.data;
-      if (!(data4 && typeof data4 == "object" && !Array.isArray(data4))) {
-        const err16 = {instancePath:instancePath+"/data",schemaPath:"#/properties/data/type",keyword:"type",params:{type: "object"},message:"must be object"};
+        const err1 = {instancePath:instancePath+"/entries",schemaPath:"#/properties/entries/type",keyword:"type",params:{type: "array"},message:"must be array"};
         if (vErrors === null) {
-          vErrors = [err16];
+          vErrors = [err1];
         }
         else {
-          vErrors.push(err16);
+          vErrors.push(err1);
         }
         errors++;
       }
     }
-    if (data.description !== undefined) {
-      if (typeof data.description !== "string") {
-        const err17 = {instancePath:instancePath+"/description",schemaPath:"#/properties/description/type",keyword:"type",params:{type: "string"},message:"must be string"};
-        if (vErrors === null) {
-          vErrors = [err17];
-        }
-        else {
-          vErrors.push(err17);
-        }
-        errors++;
-      }
-    }
-    if (data.tags !== undefined) {
-      let data6 = data.tags;
-      if (Array.isArray(data6)) {
-        const len0 = data6.length;
-        for (let i0=0; i0<len0; i0++) {
-          if (typeof data6[i0] !== "string") {
-            const err18 = {instancePath:instancePath+"/tags/" + i0,schemaPath:"#/properties/tags/items/type",keyword:"type",params:{type: "string"},message:"must be string"};
-            if (vErrors === null) {
-              vErrors = [err18];
-            }
-            else {
-              vErrors.push(err18);
-            }
-            errors++;
-          }
-        }
-      }
-      else {
-        const err19 = {instancePath:instancePath+"/tags",schemaPath:"#/properties/tags/type",keyword:"type",params:{type: "array"},message:"must be array"};
-        if (vErrors === null) {
-          vErrors = [err19];
-        }
-        else {
-          vErrors.push(err19);
-        }
-        errors++;
-      }
-    }
-    if (data.capabilities !== undefined) {
-      let data8 = data.capabilities;
-      if (Array.isArray(data8)) {
-        const len1 = data8.length;
-        for (let i1=0; i1<len1; i1++) {
-          if (typeof data8[i1] !== "string") {
-            const err20 = {instancePath:instancePath+"/capabilities/" + i1,schemaPath:"#/properties/capabilities/items/type",keyword:"type",params:{type: "string"},message:"must be string"};
-            if (vErrors === null) {
-              vErrors = [err20];
-            }
-            else {
-              vErrors.push(err20);
-            }
-            errors++;
-          }
-        }
-      }
-      else {
-        const err21 = {instancePath:instancePath+"/capabilities",schemaPath:"#/properties/capabilities/type",keyword:"type",params:{type: "array"},message:"must be array"};
-        if (vErrors === null) {
-          vErrors = [err21];
-        }
-        else {
-          vErrors.push(err21);
-        }
-        errors++;
-      }
-    }
-    if (data.representativeQueries !== undefined) {
-      let data10 = data.representativeQueries;
-      if (Array.isArray(data10)) {
-        if (data10.length > 5) {
-          const err22 = {instancePath:instancePath+"/representativeQueries",schemaPath:"#/properties/representativeQueries/maxItems",keyword:"maxItems",params:{limit: 5},message:"must NOT have more than 5 items"};
-          if (vErrors === null) {
-            vErrors = [err22];
-          }
-          else {
-            vErrors.push(err22);
-          }
-          errors++;
-        }
-        if (data10.length < 2) {
-          const err23 = {instancePath:instancePath+"/representativeQueries",schemaPath:"#/properties/representativeQueries/minItems",keyword:"minItems",params:{limit: 2},message:"must NOT have fewer than 2 items"};
-          if (vErrors === null) {
-            vErrors = [err23];
-          }
-          else {
-            vErrors.push(err23);
-          }
-          errors++;
-        }
-        const len2 = data10.length;
-        for (let i2=0; i2<len2; i2++) {
-          if (typeof data10[i2] !== "string") {
-            const err24 = {instancePath:instancePath+"/representativeQueries/" + i2,schemaPath:"#/properties/representativeQueries/items/type",keyword:"type",params:{type: "string"},message:"must be string"};
-            if (vErrors === null) {
-              vErrors = [err24];
-            }
-            else {
-              vErrors.push(err24);
-            }
-            errors++;
-          }
-        }
-      }
-      else {
-        const err25 = {instancePath:instancePath+"/representativeQueries",schemaPath:"#/properties/representativeQueries/type",keyword:"type",params:{type: "array"},message:"must be array"};
-        if (vErrors === null) {
-          vErrors = [err25];
-        }
-        else {
-          vErrors.push(err25);
-        }
-        errors++;
-      }
-    }
-    if (data.version !== undefined) {
-      if (typeof data.version !== "string") {
-        const err26 = {instancePath:instancePath+"/version",schemaPath:"#/properties/version/type",keyword:"type",params:{type: "string"},message:"must be string"};
-        if (vErrors === null) {
-          vErrors = [err26];
-        }
-        else {
-          vErrors.push(err26);
-        }
-        errors++;
-      }
-    }
-    if (data.updatedAt !== undefined) {
-      let data13 = data.updatedAt;
-      if (typeof data13 === "string") {
-        if (!(formats10.validate(data13))) {
-          const err27 = {instancePath:instancePath+"/updatedAt",schemaPath:"#/properties/updatedAt/format",keyword:"format",params:{format: "date-time"},message:"must match format \""+"date-time"+"\""};
-          if (vErrors === null) {
-            vErrors = [err27];
-          }
-          else {
-            vErrors.push(err27);
-          }
-          errors++;
-        }
-      }
-      else {
-        const err28 = {instancePath:instancePath+"/updatedAt",schemaPath:"#/properties/updatedAt/type",keyword:"type",params:{type: "string"},message:"must be string"};
-        if (vErrors === null) {
-          vErrors = [err28];
-        }
-        else {
-          vErrors.push(err28);
-        }
-        errors++;
-      }
-    }
-    if (data.metadata !== undefined) {
-      let data14 = data.metadata;
-      if (data14 && typeof data14 == "object" && !Array.isArray(data14)) {
-        for (const key0 in data14) {
-          let data15 = data14[key0];
-          if ((((typeof data15 !== "string") && (!((typeof data15 == "number") && (isFinite(data15))))) && (typeof data15 !== "boolean")) && (data15 !== null)) {
-            const err29 = {instancePath:instancePath+"/metadata/" + key0.replace(/~/g, "~0").replace(/\//g, "~1"),schemaPath:"#/properties/metadata/additionalProperties/type",keyword:"type",params:{type: schema34.properties.metadata.additionalProperties.type},message:"must be string,number,boolean,null"};
-            if (vErrors === null) {
-              vErrors = [err29];
-            }
-            else {
-              vErrors.push(err29);
-            }
-            errors++;
-          }
-        }
-      }
-      else {
-        const err30 = {instancePath:instancePath+"/metadata",schemaPath:"#/properties/metadata/type",keyword:"type",params:{type: "object"},message:"must be object"};
-        if (vErrors === null) {
-          vErrors = [err30];
-        }
-        else {
-          vErrors.push(err30);
-        }
-        errors++;
-      }
-    }
-    if (data.trustManifest !== undefined) {
-      if (!(validate21(data.trustManifest, {instancePath:instancePath+"/trustManifest",parentData:data,parentDataProperty:"trustManifest",rootData,dynamicAnchors}))) {
-        vErrors = vErrors === null ? validate21.errors : vErrors.concat(validate21.errors);
-        errors = vErrors.length;
-      }
-    }
   }
   else {
-    const err31 = {instancePath,schemaPath:"#/type",keyword:"type",params:{type: "object"},message:"must be object"};
+    const err2 = {instancePath,schemaPath:"#/type",keyword:"type",params:{type: "object"},message:"must be object"};
     if (vErrors === null) {
-      vErrors = [err31];
+      vErrors = [err2];
     }
     else {
-      vErrors.push(err31);
+      vErrors.push(err2);
     }
     errors++;
   }
-  validate23.errors = vErrors;
+  validate25.errors = vErrors;
   return errors === 0;
 }
-validate23.evaluated = {"props":{"identifier":true,"displayName":true,"type":true,"url":true,"data":true,"description":true,"tags":true,"capabilities":true,"representativeQueries":true,"version":true,"updatedAt":true,"metadata":true,"trustManifest":true},"dynamicProps":false,"dynamicItems":false};
+validate25.evaluated = {"props":true,"dynamicProps":false,"dynamicItems":false};
 
+export const ArdEntry = validate27;
 
-function validate20(data, {instancePath="", parentData, parentDataProperty, rootData=data, dynamicAnchors={}}={}) {
-  /*# sourceURL="https://raw.githubusercontent.com/ards-project/ard-spec/main/spec/schemas/ai-catalog.schema.json" */;
+function validate27(data, {instancePath="", parentData, parentDataProperty, rootData=data, dynamicAnchors={}}={}) {
   let vErrors = null;
   let errors = 0;
-  const evaluated0 = validate20.evaluated;
+  const evaluated0 = validate27.evaluated;
   if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
   }
   if (evaluated0.dynamicItems) {
     evaluated0.items = undefined;
   }
+  const _errs0 = errors;
+  let valid0 = false;
+  let passing0 = null;
+  const _errs1 = errors;
+  const _errs2 = errors;
+  const _errs3 = errors;
   if (data && typeof data == "object" && !Array.isArray(data)) {
-    if (data.specVersion === undefined) {
-      const err0 = {instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: "specVersion"},message:"must have required property '"+"specVersion"+"'"};
+    let missing0;
+    if ((data.data === undefined) && (missing0 = "data")) {
+      const err0 = {};
       if (vErrors === null) {
         vErrors = [err0];
       }
@@ -1499,202 +1280,165 @@ function validate20(data, {instancePath="", parentData, parentDataProperty, root
       }
       errors++;
     }
-    if (data.entries === undefined) {
-      const err1 = {instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: "entries"},message:"must have required property '"+"entries"+"'"};
-      if (vErrors === null) {
-        vErrors = [err1];
+  }
+  var valid1 = _errs3 === errors;
+  if (valid1) {
+    const err1 = {instancePath,schemaPath:"#/oneOf/0/not",keyword:"not",params:{},message:"must NOT be valid"};
+    if (vErrors === null) {
+      vErrors = [err1];
+    }
+    else {
+      vErrors.push(err1);
+    }
+    errors++;
+  }
+  else {
+    errors = _errs2;
+    if (vErrors !== null) {
+      if (_errs2) {
+        vErrors.length = _errs2;
       }
       else {
-        vErrors.push(err1);
+        vErrors = null;
       }
-      errors++;
     }
-    for (const key0 in data) {
-      if (!(((key0 === "specVersion") || (key0 === "host")) || (key0 === "entries"))) {
-        const err2 = {instancePath,schemaPath:"#/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key0},message:"must NOT have additional properties"};
-        if (vErrors === null) {
-          vErrors = [err2];
-        }
-        else {
-          vErrors.push(err2);
-        }
-        errors++;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.url === undefined) {
+      const err2 = {instancePath,schemaPath:"#/oneOf/0/required",keyword:"required",params:{missingProperty: "url"},message:"must have required property '"+"url"+"'"};
+      if (vErrors === null) {
+        vErrors = [err2];
       }
+      else {
+        vErrors.push(err2);
+      }
+      errors++;
     }
-    if (data.specVersion !== undefined) {
-      let data0 = data.specVersion;
-      if (typeof data0 !== "string") {
-        const err3 = {instancePath:instancePath+"/specVersion",schemaPath:"#/properties/specVersion/type",keyword:"type",params:{type: "string"},message:"must be string"};
-        if (vErrors === null) {
-          vErrors = [err3];
-        }
-        else {
-          vErrors.push(err3);
-        }
-        errors++;
+  }
+  var _valid0 = _errs1 === errors;
+  if (_valid0) {
+    valid0 = true;
+    passing0 = 0;
+  }
+  const _errs4 = errors;
+  const _errs5 = errors;
+  const _errs6 = errors;
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    let missing1;
+    if ((data.url === undefined) && (missing1 = "url")) {
+      const err3 = {};
+      if (vErrors === null) {
+        vErrors = [err3];
       }
-      if (!(data0 === "1.0")) {
-        const err4 = {instancePath:instancePath+"/specVersion",schemaPath:"#/properties/specVersion/enum",keyword:"enum",params:{allowedValues: schema31.properties.specVersion.enum},message:"must be equal to one of the allowed values"};
-        if (vErrors === null) {
-          vErrors = [err4];
-        }
-        else {
-          vErrors.push(err4);
-        }
-        errors++;
+      else {
+        vErrors.push(err3);
       }
+      errors++;
     }
-    if (data.host !== undefined) {
-      let data1 = data.host;
-      if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
-        if (data1.displayName === undefined) {
-          const err5 = {instancePath:instancePath+"/host",schemaPath:"#/properties/host/required",keyword:"required",params:{missingProperty: "displayName"},message:"must have required property '"+"displayName"+"'"};
-          if (vErrors === null) {
-            vErrors = [err5];
-          }
-          else {
-            vErrors.push(err5);
-          }
-          errors++;
-        }
-        for (const key1 in data1) {
-          if (!(((((key1 === "displayName") || (key1 === "identifier")) || (key1 === "documentationUrl")) || (key1 === "logoUrl")) || (key1 === "trustManifest"))) {
-            const err6 = {instancePath:instancePath+"/host",schemaPath:"#/properties/host/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key1},message:"must NOT have additional properties"};
-            if (vErrors === null) {
-              vErrors = [err6];
-            }
-            else {
-              vErrors.push(err6);
-            }
-            errors++;
-          }
-        }
-        if (data1.displayName !== undefined) {
-          if (typeof data1.displayName !== "string") {
-            const err7 = {instancePath:instancePath+"/host/displayName",schemaPath:"#/properties/host/properties/displayName/type",keyword:"type",params:{type: "string"},message:"must be string"};
-            if (vErrors === null) {
-              vErrors = [err7];
-            }
-            else {
-              vErrors.push(err7);
-            }
-            errors++;
-          }
-        }
-        if (data1.identifier !== undefined) {
-          if (typeof data1.identifier !== "string") {
-            const err8 = {instancePath:instancePath+"/host/identifier",schemaPath:"#/properties/host/properties/identifier/type",keyword:"type",params:{type: "string"},message:"must be string"};
-            if (vErrors === null) {
-              vErrors = [err8];
-            }
-            else {
-              vErrors.push(err8);
-            }
-            errors++;
-          }
-        }
-        if (data1.documentationUrl !== undefined) {
-          let data4 = data1.documentationUrl;
-          if (typeof data4 === "string") {
-            if (!(formats0(data4))) {
-              const err9 = {instancePath:instancePath+"/host/documentationUrl",schemaPath:"#/properties/host/properties/documentationUrl/format",keyword:"format",params:{format: "uri"},message:"must match format \""+"uri"+"\""};
-              if (vErrors === null) {
-                vErrors = [err9];
-              }
-              else {
-                vErrors.push(err9);
-              }
-              errors++;
-            }
-          }
-          else {
-            const err10 = {instancePath:instancePath+"/host/documentationUrl",schemaPath:"#/properties/host/properties/documentationUrl/type",keyword:"type",params:{type: "string"},message:"must be string"};
-            if (vErrors === null) {
-              vErrors = [err10];
-            }
-            else {
-              vErrors.push(err10);
-            }
-            errors++;
-          }
-        }
-        if (data1.logoUrl !== undefined) {
-          let data5 = data1.logoUrl;
-          if (typeof data5 === "string") {
-            if (!(formats0(data5))) {
-              const err11 = {instancePath:instancePath+"/host/logoUrl",schemaPath:"#/properties/host/properties/logoUrl/format",keyword:"format",params:{format: "uri"},message:"must match format \""+"uri"+"\""};
-              if (vErrors === null) {
-                vErrors = [err11];
-              }
-              else {
-                vErrors.push(err11);
-              }
-              errors++;
-            }
-          }
-          else {
-            const err12 = {instancePath:instancePath+"/host/logoUrl",schemaPath:"#/properties/host/properties/logoUrl/type",keyword:"type",params:{type: "string"},message:"must be string"};
-            if (vErrors === null) {
-              vErrors = [err12];
-            }
-            else {
-              vErrors.push(err12);
-            }
-            errors++;
-          }
-        }
-        if (data1.trustManifest !== undefined) {
-          if (!(validate21(data1.trustManifest, {instancePath:instancePath+"/host/trustManifest",parentData:data1,parentDataProperty:"trustManifest",rootData,dynamicAnchors}))) {
-            vErrors = vErrors === null ? validate21.errors : vErrors.concat(validate21.errors);
-            errors = vErrors.length;
-          }
-        }
+  }
+  var valid2 = _errs6 === errors;
+  if (valid2) {
+    const err4 = {instancePath,schemaPath:"#/oneOf/1/not",keyword:"not",params:{},message:"must NOT be valid"};
+    if (vErrors === null) {
+      vErrors = [err4];
+    }
+    else {
+      vErrors.push(err4);
+    }
+    errors++;
+  }
+  else {
+    errors = _errs5;
+    if (vErrors !== null) {
+      if (_errs5) {
+        vErrors.length = _errs5;
       }
       else {
-        const err13 = {instancePath:instancePath+"/host",schemaPath:"#/properties/host/type",keyword:"type",params:{type: "object"},message:"must be object"};
-        if (vErrors === null) {
-          vErrors = [err13];
-        }
-        else {
-          vErrors.push(err13);
-        }
-        errors++;
+        vErrors = null;
       }
     }
-    if (data.entries !== undefined) {
-      let data7 = data.entries;
-      if (Array.isArray(data7)) {
-        const len0 = data7.length;
-        for (let i0=0; i0<len0; i0++) {
-          if (!(validate23(data7[i0], {instancePath:instancePath+"/entries/" + i0,parentData:data7,parentDataProperty:i0,rootData,dynamicAnchors}))) {
-            vErrors = vErrors === null ? validate23.errors : vErrors.concat(validate23.errors);
-            errors = vErrors.length;
-          }
-        }
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.data === undefined) {
+      const err5 = {instancePath,schemaPath:"#/oneOf/1/required",keyword:"required",params:{missingProperty: "data"},message:"must have required property '"+"data"+"'"};
+      if (vErrors === null) {
+        vErrors = [err5];
       }
       else {
-        const err14 = {instancePath:instancePath+"/entries",schemaPath:"#/properties/entries/type",keyword:"type",params:{type: "array"},message:"must be array"};
-        if (vErrors === null) {
-          vErrors = [err14];
-        }
-        else {
-          vErrors.push(err14);
-        }
-        errors++;
+        vErrors.push(err5);
       }
+      errors++;
     }
   }
+  var _valid0 = _errs4 === errors;
+  if (_valid0 && valid0) {
+    valid0 = false;
+    passing0 = [passing0, 1];
+  }
   else {
-    const err15 = {instancePath,schemaPath:"#/type",keyword:"type",params:{type: "object"},message:"must be object"};
+    if (_valid0) {
+      valid0 = true;
+      passing0 = 1;
+    }
+  }
+  if (!valid0) {
+    const err6 = {instancePath,schemaPath:"#/oneOf",keyword:"oneOf",params:{passingSchemas: passing0},message:"must match exactly one schema in oneOf"};
     if (vErrors === null) {
-      vErrors = [err15];
+      vErrors = [err6];
     }
     else {
-      vErrors.push(err15);
+      vErrors.push(err6);
     }
     errors++;
   }
-  validate20.errors = vErrors;
+  else {
+    errors = _errs0;
+    if (vErrors !== null) {
+      if (_errs0) {
+        vErrors.length = _errs0;
+      }
+      else {
+        vErrors = null;
+      }
+    }
+  }
+  if (!(validate22(data, {instancePath,parentData,parentDataProperty,rootData,dynamicAnchors}))) {
+    vErrors = vErrors === null ? validate22.errors : vErrors.concat(validate22.errors);
+    errors = vErrors.length;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.identifier === undefined) {
+      const err7 = {instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: "identifier"},message:"must have required property '"+"identifier"+"'"};
+      if (vErrors === null) {
+        vErrors = [err7];
+      }
+      else {
+        vErrors.push(err7);
+      }
+      errors++;
+    }
+    if (data.displayName === undefined) {
+      const err8 = {instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: "displayName"},message:"must have required property '"+"displayName"+"'"};
+      if (vErrors === null) {
+        vErrors = [err8];
+      }
+      else {
+        vErrors.push(err8);
+      }
+      errors++;
+    }
+    if (data.type === undefined) {
+      const err9 = {instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: "type"},message:"must have required property '"+"type"+"'"};
+      if (vErrors === null) {
+        vErrors = [err9];
+      }
+      else {
+        vErrors.push(err9);
+      }
+      errors++;
+    }
+  }
+  validate27.errors = vErrors;
   return errors === 0;
 }
-validate20.evaluated = {"props":true,"dynamicProps":false,"dynamicItems":false};
+validate27.evaluated = {"props":true,"dynamicProps":false,"dynamicItems":false};