@sphereon/ssi-sdk.credential-validation 0.33.1-next.3 → 0.33.1-next.73

package/dist/index.cjs

@@ -0,0 +1,1759 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// plugin.schema.json
+var require_plugin_schema = __commonJS({
+  "plugin.schema.json"(exports, module2) {
+    module2.exports = {
+      ICredentialValidation: {
+        components: {
+          schemas: {
+            VerifyCredentialArgs: {
+              type: "object",
+              properties: {
+                credential: {
+                  $ref: "#/components/schemas/OriginalVerifiableCredential"
+                },
+                hasher: {
+                  $ref: "#/components/schemas/HasherSync"
+                },
+                fetchRemoteContexts: {
+                  type: "boolean"
+                },
+                policies: {
+                  $ref: "#/components/schemas/VerificationPolicies"
+                }
+              },
+              required: ["credential", "fetchRemoteContexts"],
+              additionalProperties: false
+            },
+            OriginalVerifiableCredential: {
+              anyOf: [
+                {
+                  $ref: "#/components/schemas/W3CVerifiableCredential"
+                },
+                {
+                  $ref: "#/components/schemas/JwtDecodedVerifiableCredential"
+                },
+                {
+                  $ref: "#/components/schemas/SdJwtDecodedVerifiableCredential"
+                },
+                {
+                  $ref: "#/components/schemas/MdocOid4vpIssuerSigned"
+                },
+                {
+                  $ref: "#/components/schemas/MdocDocument"
+                }
+              ]
+            },
+            W3CVerifiableCredential: {
+              anyOf: [
+                {
+                  $ref: "#/components/schemas/IVerifiableCredential"
+                },
+                {
+                  $ref: "#/components/schemas/CompactJWT"
+                }
+              ],
+              description: "Represents a signed Verifiable Credential (includes proof), in either JSON, compact JWT or compact SD-JWT VC format. See  {@link https://www.w3.org/TR/vc-data-model/#credentials | VC data model }  See  {@link https://www.w3.org/TR/vc-data-model/#proof-formats | proof formats }"
+            },
+            IVerifiableCredential: {
+              type: "object",
+              properties: {
+                proof: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/IProof"
+                    },
+                    {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/IProof"
+                      }
+                    }
+                  ]
+                },
+                "@context": {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/ICredentialContextType"
+                    },
+                    {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/ICredentialContextType"
+                      }
+                    }
+                  ]
+                },
+                type: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
+                credentialSchema: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/ICredentialSchemaType"
+                    },
+                    {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/ICredentialSchemaType"
+                      }
+                    }
+                  ]
+                },
+                issuer: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/IIssuerId"
+                    },
+                    {
+                      $ref: "#/components/schemas/IIssuer"
+                    }
+                  ]
+                },
+                issuanceDate: {
+                  type: "string"
+                },
+                credentialSubject: {
+                  anyOf: [
+                    {
+                      type: "object",
+                      properties: {
+                        id: {
+                          type: "string"
+                        }
+                      }
+                    },
+                    {
+                      type: "array",
+                      items: {
+                        type: "object",
+                        properties: {
+                          id: {
+                            type: "string"
+                          }
+                        }
+                      }
+                    }
+                  ]
+                },
+                expirationDate: {
+                  type: "string"
+                },
+                id: {
+                  type: "string"
+                },
+                credentialStatus: {
+                  $ref: "#/components/schemas/ICredentialStatus"
+                },
+                description: {
+                  type: "string"
+                },
+                name: {
+                  type: "string"
+                }
+              },
+              required: ["@context", "credentialSubject", "issuanceDate", "issuer", "proof", "type"]
+            },
+            IProof: {
+              type: "object",
+              properties: {
+                type: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/IProofType"
+                    },
+                    {
+                      type: "string"
+                    }
+                  ]
+                },
+                created: {
+                  type: "string"
+                },
+                proofPurpose: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/IProofPurpose"
+                    },
+                    {
+                      type: "string"
+                    }
+                  ]
+                },
+                verificationMethod: {
+                  type: "string"
+                },
+                challenge: {
+                  type: "string"
+                },
+                domain: {
+                  type: "string"
+                },
+                proofValue: {
+                  type: "string"
+                },
+                jws: {
+                  type: "string"
+                },
+                jwt: {
+                  type: "string"
+                },
+                mso_mdoc: {
+                  type: "string"
+                },
+                nonce: {
+                  type: "string"
+                },
+                requiredRevealStatements: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                }
+              },
+              required: ["type", "created", "proofPurpose", "verificationMethod"]
+            },
+            IProofType: {
+              type: "string",
+              enum: [
+                "Ed25519Signature2018",
+                "Ed25519Signature2020",
+                "EcdsaSecp256k1Signature2019",
+                "EcdsaSecp256k1RecoverySignature2020",
+                "JsonWebSignature2020",
+                "RsaSignature2018",
+                "GpgSignature2020",
+                "JcsEd25519Signature2020",
+                "BbsBlsSignatureProof2020",
+                "BbsBlsBoundSignatureProof2020",
+                "JwtProof2020",
+                "SdJwtProof2024",
+                "MsoMdocProof2024"
+              ]
+            },
+            IProofPurpose: {
+              type: "string",
+              enum: [
+                "verificationMethod",
+                "assertionMethod",
+                "authentication",
+                "keyAgreement",
+                "contactAgreement",
+                "capabilityInvocation",
+                "capabilityDelegation"
+              ]
+            },
+            ICredentialContextType: {
+              anyOf: [
+                {
+                  type: "object",
+                  properties: {
+                    name: {
+                      type: "string"
+                    },
+                    did: {
+                      type: "string"
+                    }
+                  }
+                },
+                {
+                  type: "string"
+                }
+              ]
+            },
+            ICredentialSchemaType: {
+              anyOf: [
+                {
+                  $ref: "#/components/schemas/ICredentialSchema"
+                },
+                {
+                  type: "string"
+                }
+              ]
+            },
+            ICredentialSchema: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                type: {
+                  type: "string"
+                }
+              },
+              required: ["id"],
+              additionalProperties: false
+            },
+            IIssuerId: {
+              type: "string"
+            },
+            IIssuer: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                }
+              },
+              required: ["id"]
+            },
+            ICredentialStatus: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                type: {
+                  type: "string"
+                }
+              },
+              required: ["id", "type"]
+            },
+            CompactJWT: {
+              type: "string",
+              description: "Represents a Json Web Token in compact form."
+            },
+            JwtDecodedVerifiableCredential: {
+              type: "object",
+              properties: {
+                vc: {
+                  $ref: "#/components/schemas/IVerifiableCredential"
+                },
+                exp: {
+                  type: "string"
+                },
+                iss: {
+                  type: "string"
+                },
+                nbf: {
+                  type: "string"
+                },
+                sub: {
+                  type: "string"
+                },
+                jti: {
+                  type: "string"
+                }
+              },
+              required: ["vc", "exp", "iss", "nbf", "sub", "jti"]
+            },
+            SdJwtDecodedVerifiableCredential: {
+              type: "object",
+              properties: {
+                compactSdJwtVc: {
+                  type: "string",
+                  description: "The compact sd jwt is the sd-jwt encoded as string. It is a normal JWT, with the disclosures and kb-jwt appended separated by ~"
+                },
+                disclosures: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/SdJwtDisclosure"
+                  },
+                  description: "The disclosures included within the SD-JWT in both encoded and decoded format. The digests are also included, and allows the disclosures to be linked against the digests in the signed payload."
+                },
+                signedPayload: {
+                  $ref: "#/components/schemas/SdJwtSignedVerifiableCredentialPayload",
+                  description: "The signed payload is the payload of the sd-jwt that is actually signed, and that includes the `_sd` and `...` digests."
+                },
+                decodedPayload: {
+                  $ref: "#/components/schemas/SdJwtDecodedVerifiableCredentialPayload",
+                  description: "The decoded payload is the payload when all `_sd` and `...` digests have been replaced by the actual values from the disclosures. This format could also be seen as the 'pretty` version of the SD JWT payload.\n\nThis is useful for displaying the contents of the SD JWT VC to the user, or for example for querying the contents of the SD JWT VC using a PEX presentation definition path."
+                },
+                kbJwt: {
+                  type: "object",
+                  properties: {
+                    header: {
+                      $ref: "#/components/schemas/SdJwtVcKbJwtHeader"
+                    },
+                    payload: {
+                      $ref: "#/components/schemas/SdJwtVcKbJwtPayload"
+                    },
+                    compact: {
+                      $ref: "#/components/schemas/CompactJWT"
+                    }
+                  },
+                  required: ["header", "payload"],
+                  additionalProperties: false,
+                  description: "Key binding JWT"
+                }
+              },
+              required: ["compactSdJwtVc", "disclosures", "signedPayload", "decodedPayload"],
+              additionalProperties: false,
+              description: "The decoded SD JWT Verifiable Credential. This representation includes multiple representations of the same SD-JWT, and allows to fully process an SD-JWT, as well as create a presentation SD-JWT  (minus the KB-JWT) by removing certain disclosures from the compact SD-JWT.\n\nThis representation is useful as it doesn't require a hasher implementation to match the different digests in the signed SD-JWT payload, with the different disclosures."
+            },
+            SdJwtDisclosure: {
+              type: "object",
+              properties: {
+                encoded: {
+                  type: "string"
+                },
+                decoded: {
+                  $ref: "#/components/schemas/SdJwtDecodedDisclosure"
+                },
+                digest: {
+                  type: "string"
+                }
+              },
+              required: ["encoded", "decoded", "digest"],
+              additionalProperties: false
+            },
+            SdJwtDecodedDisclosure: {
+              anyOf: [
+                {
+                  type: "array",
+                  minItems: 3,
+                  items: [
+                    {
+                      type: "string"
+                    },
+                    {
+                      type: "string"
+                    },
+                    {
+                      $ref: "#/components/schemas/JsonValue"
+                    }
+                  ],
+                  maxItems: 3
+                },
+                {
+                  type: "array",
+                  minItems: 2,
+                  items: [
+                    {
+                      type: "string"
+                    },
+                    {
+                      $ref: "#/components/schemas/JsonValue"
+                    }
+                  ],
+                  maxItems: 2
+                }
+              ]
+            },
+            JsonValue: {
+              anyOf: [
+                {
+                  type: "string"
+                },
+                {
+                  type: "number"
+                },
+                {
+                  type: "boolean"
+                },
+                {
+                  type: "object",
+                  additionalProperties: {
+                    anyOf: [
+                      {
+                        $ref: "#/components/schemas/JsonValue"
+                      },
+                      {
+                        not: {}
+                      }
+                    ]
+                  }
+                },
+                {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/JsonValue"
+                  }
+                }
+              ]
+            },
+            SdJwtSignedVerifiableCredentialPayload: {
+              type: "object",
+              properties: {
+                vct: {
+                  type: "string"
+                },
+                iss: {
+                  type: "string"
+                },
+                iat: {
+                  type: "number"
+                },
+                nbf: {
+                  type: "number"
+                },
+                exp: {
+                  type: "number"
+                },
+                cnf: {
+                  type: "object",
+                  properties: {
+                    jwk: {},
+                    kid: {
+                      type: "string"
+                    }
+                  },
+                  additionalProperties: false
+                },
+                status: {
+                  type: "object",
+                  properties: {
+                    idx: {
+                      type: "number"
+                    },
+                    uri: {
+                      type: "string"
+                    }
+                  },
+                  required: ["idx", "uri"],
+                  additionalProperties: false
+                },
+                sub: {
+                  type: "string"
+                },
+                _sd: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
+                _sd_alg: {
+                  type: "string"
+                }
+              },
+              additionalProperties: {
+                anyOf: [
+                  {
+                    $ref: "#/components/schemas/SdJwtJsonValue"
+                  },
+                  {
+                    not: {}
+                  },
+                  {
+                    $ref: "#/components/schemas/JsonValue"
+                  },
+                  {
+                    not: {}
+                  }
+                ]
+              },
+              required: ["iat", "iss", "vct"],
+              description: "The signed payload of an SD-JWT. Includes fields such as `_sd`, `...` and `_sd_alg`"
+            },
+            SdJwtJsonValue: {
+              anyOf: [
+                {
+                  type: "string"
+                },
+                {
+                  type: "number"
+                },
+                {
+                  type: "boolean"
+                },
+                {
+                  type: "object",
+                  properties: {
+                    _sd: {
+                      type: "array",
+                      items: {
+                        type: "string"
+                      }
+                    }
+                  },
+                  additionalProperties: {
+                    anyOf: [
+                      {
+                        $ref: "#/components/schemas/SdJwtJsonValue"
+                      },
+                      {
+                        not: {}
+                      }
+                    ]
+                  }
+                },
+                {
+                  type: "array",
+                  items: {
+                    anyOf: [
+                      {
+                        $ref: "#/components/schemas/SdJwtJsonValue"
+                      },
+                      {
+                        type: "object",
+                        properties: {
+                          "...": {
+                            type: "string"
+                          }
+                        },
+                        required: ["..."],
+                        additionalProperties: false
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            SdJwtDecodedVerifiableCredentialPayload: {
+              type: "object",
+              properties: {
+                vct: {
+                  type: "string"
+                },
+                iss: {
+                  type: "string"
+                },
+                iat: {
+                  type: "number"
+                },
+                nbf: {
+                  type: "number"
+                },
+                exp: {
+                  type: "number"
+                },
+                cnf: {
+                  type: "object",
+                  properties: {
+                    jwk: {},
+                    kid: {
+                      type: "string"
+                    }
+                  },
+                  additionalProperties: false
+                },
+                status: {
+                  type: "object",
+                  properties: {
+                    idx: {
+                      type: "number"
+                    },
+                    uri: {
+                      type: "string"
+                    }
+                  },
+                  required: ["idx", "uri"],
+                  additionalProperties: false
+                },
+                sub: {
+                  type: "string"
+                }
+              },
+              required: ["vct", "iss", "iat"],
+              additionalProperties: {
+                anyOf: [
+                  {
+                    $ref: "#/components/schemas/JsonValue"
+                  },
+                  {
+                    not: {}
+                  }
+                ]
+              },
+              description: "Decoded 'pretty' SD JWT Verifiable Credential. This representation has all the `_sd` properties removed, and includes the disclosures directly within the payload."
+            },
+            SdJwtVcKbJwtHeader: {
+              type: "object",
+              properties: {
+                typ: {
+                  type: "string",
+                  const: "kb+jwt"
+                },
+                alg: {
+                  type: "string"
+                }
+              },
+              required: ["typ", "alg"]
+            },
+            SdJwtVcKbJwtPayload: {
+              type: "object",
+              properties: {
+                iat: {
+                  type: "number"
+                },
+                aud: {
+                  type: "string"
+                },
+                nonce: {
+                  type: "string"
+                },
+                sd_hash: {
+                  type: "string"
+                }
+              },
+              required: ["iat", "aud", "nonce", "sd_hash"],
+              additionalProperties: {}
+            },
+            MdocOid4vpIssuerSigned: {
+              type: "string",
+              description: "Represents a selective disclosure JWT vc in compact form."
+            },
+            MdocDocument: {
+              $ref: "#/components/schemas/com.sphereon.mdoc.data.device.DocumentCbor"
+            },
+            "com.sphereon.mdoc.data.device.DocumentCbor": {
+              type: "object",
+              additionalProperties: false,
+              properties: {}
+            },
+            HasherSync: {
+              $comment: "(data: string | ArrayBuffer, alg: string) => Uint8Array",
+              type: "object",
+              properties: {
+                namedArgs: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      anyOf: [
+                        {
+                          type: "string"
+                        },
+                        {
+                          $ref: "#/components/schemas/ArrayBuffer"
+                        }
+                      ]
+                    },
+                    alg: {
+                      type: "string"
+                    }
+                  },
+                  required: ["data", "alg"],
+                  additionalProperties: false
+                }
+              }
+            },
+            ArrayBuffer: {
+              type: "object",
+              properties: {
+                byteLength: {
+                  type: "number"
+                }
+              },
+              required: ["byteLength"],
+              additionalProperties: false
+            },
+            VerificationPolicies: {
+              type: "object",
+              properties: {
+                schemaValidation: {
+                  $ref: "#/components/schemas/SchemaValidation"
+                },
+                credentialStatus: {
+                  type: "boolean"
+                },
+                expirationDate: {
+                  type: "boolean"
+                },
+                issuanceDate: {
+                  type: "boolean"
+                }
+              },
+              required: ["expirationDate", "issuanceDate"],
+              additionalProperties: false
+            },
+            SchemaValidation: {
+              type: "string",
+              enum: ["ALWAYS", "NEVER", "WHEN_PRESENT"]
+            },
+            VerificationResult: {
+              type: "object",
+              properties: {
+                result: {
+                  type: "boolean"
+                },
+                source: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/WrappedVerifiableCredential"
+                    },
+                    {
+                      $ref: "#/components/schemas/WrappedVerifiablePresentation"
+                    }
+                  ]
+                },
+                subResults: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/VerificationSubResult"
+                  }
+                },
+                error: {
+                  type: "string"
+                },
+                errorDetails: {
+                  type: "string"
+                }
+              },
+              required: ["result", "source", "subResults"],
+              additionalProperties: false
+            },
+            WrappedVerifiableCredential: {
+              anyOf: [
+                {
+                  $ref: "#/components/schemas/WrappedW3CVerifiableCredential"
+                },
+                {
+                  $ref: "#/components/schemas/WrappedSdJwtVerifiableCredential"
+                },
+                {
+                  $ref: "#/components/schemas/WrappedMdocCredential"
+                }
+              ]
+            },
+            WrappedW3CVerifiableCredential: {
+              type: "object",
+              properties: {
+                original: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/W3CVerifiableCredential"
+                    },
+                    {
+                      $ref: "#/components/schemas/JwtDecodedVerifiableCredential"
+                    }
+                  ],
+                  description: "Original VC that we've received"
+                },
+                decoded: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/JwtDecodedVerifiableCredential"
+                    },
+                    {
+                      $ref: "#/components/schemas/IVerifiableCredential"
+                    }
+                  ],
+                  description: "In case of JWT credential it will be the decoded version. In other cases it will be the same as original one"
+                },
+                type: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/OriginalType.JSONLD"
+                    },
+                    {
+                      $ref: "#/components/schemas/OriginalType.JWT_ENCODED"
+                    },
+                    {
+                      $ref: "#/components/schemas/OriginalType.JWT_DECODED"
+                    }
+                  ],
+                  description: "Type of this credential. Supported types are json-ld, jwt (decoded/encoded)"
+                },
+                format: {
+                  type: "string",
+                  enum: ["jwt_vc", "ldp_vc", "ldp", "jwt"],
+                  description: "The claim format, typically used during exchange transport protocols"
+                },
+                credential: {
+                  $ref: "#/components/schemas/IVerifiableCredential",
+                  description: "Internal stable representation of a Credential"
+                }
+              },
+              required: ["original", "decoded", "type", "format", "credential"],
+              additionalProperties: false
+            },
+            "OriginalType.JSONLD": {
+              type: "string",
+              const: "json-ld"
+            },
+            "OriginalType.JWT_ENCODED": {
+              type: "string",
+              const: "jwt-encoded"
+            },
+            "OriginalType.JWT_DECODED": {
+              type: "string",
+              const: "jwt-decoded"
+            },
+            WrappedSdJwtVerifiableCredential: {
+              type: "object",
+              properties: {
+                original: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/SdJwtDecodedVerifiableCredential"
+                    },
+                    {
+                      $ref: "#/components/schemas/CompactSdJwtVc"
+                    }
+                  ],
+                  description: "Original VC that we've received. Can be either the encoded or decoded variant."
+                },
+                decoded: {
+                  $ref: "#/components/schemas/SdJwtDecodedVerifiableCredentialPayload",
+                  description: "Decoded version of the SD-JWT payload. This is the decoded payload, rather than the whole SD-JWT as the `decoded` property is used in e.g. PEX to check for path filters from fields. The full decoded credential can be found in the `credential` field."
+                },
+                type: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/OriginalType.SD_JWT_VC_DECODED"
+                    },
+                    {
+                      $ref: "#/components/schemas/OriginalType.SD_JWT_VC_ENCODED"
+                    }
+                  ],
+                  description: "Type of this credential."
+                },
+                format: {
+                  type: "string",
+                  const: "vc+sd-jwt",
+                  description: "The claim format, typically used during exchange transport protocols"
+                },
+                credential: {
+                  $ref: "#/components/schemas/SdJwtDecodedVerifiableCredential",
+                  description: "Internal stable representation of a Credential"
+                }
+              },
+              required: ["original", "decoded", "type", "format", "credential"],
+              additionalProperties: false
+            },
+            CompactSdJwtVc: {
+              type: "string",
+              description: "Represents a selective disclosure JWT vc in compact form."
+            },
+            "OriginalType.SD_JWT_VC_DECODED": {
+              type: "string",
+              const: "sd-jwt-vc-decoded"
+            },
+            "OriginalType.SD_JWT_VC_ENCODED": {
+              type: "string",
+              const: "sd-jwt-vc-encoded"
+            },
+            WrappedMdocCredential: {
+              type: "object",
+              properties: {
+                original: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/MdocDocument"
+                    },
+                    {
+                      $ref: "#/components/schemas/MdocOid4vpIssuerSigned"
+                    }
+                  ],
+                  description: "Original IssuerSigned to Mdoc that we've received. Can be either the encoded or decoded variant."
+                },
+                decoded: {
+                  $ref: "#/components/schemas/MdocDecodedPayload",
+                  description: "Record where keys are the namespaces and the values are objects again with the namespace values"
+                },
+                type: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/OriginalType.MSO_MDOC_DECODED"
+                    },
+                    {
+                      $ref: "#/components/schemas/OriginalType.MSO_MDOC_ENCODED"
+                    }
+                  ],
+                  description: "Type of this credential."
+                },
+                format: {
+                  type: "string",
+                  const: "mso_mdoc",
+                  description: "The claim format, typically used during exchange transport protocols"
+                },
+                credential: {
+                  $ref: "#/components/schemas/MdocDocument",
+                  description: "Internal stable representation of a Credential"
+                }
+              },
+              required: ["original", "decoded", "type", "format", "credential"],
+              additionalProperties: false
+            },
+            MdocDecodedPayload: {
+              $ref: "#/components/schemas/Record<string,Record<string,(string|number|boolean)>>",
+              description: "Record where keys are the namespaces and the values are objects again with the namespace values"
+            },
+            "Record<string,Record<string,(string|number|boolean)>>": {
+              type: "object",
+              additionalProperties: {
+                $ref: "#/components/schemas/Record<string,(string|number|boolean)>"
+              }
+            },
+            "Record<string,(string|number|boolean)>": {
+              type: "object",
+              additionalProperties: {
+                type: ["string", "number", "boolean"]
+              }
+            },
+            "OriginalType.MSO_MDOC_DECODED": {
+              type: "string",
+              const: "mso_mdoc-decoded"
+            },
+            "OriginalType.MSO_MDOC_ENCODED": {
+              type: "string",
+              const: "mso_mdoc-encoded"
+            },
+            WrappedVerifiablePresentation: {
+              anyOf: [
+                {
+                  $ref: "#/components/schemas/WrappedW3CVerifiablePresentation"
+                },
+                {
+                  $ref: "#/components/schemas/WrappedSdJwtVerifiablePresentation"
+                },
+                {
+                  $ref: "#/components/schemas/WrappedMdocPresentation"
+                }
+              ]
+            },
+            WrappedW3CVerifiablePresentation: {
+              type: "object",
+              properties: {
+                original: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/W3CVerifiablePresentation"
+                    },
+                    {
+                      $ref: "#/components/schemas/JwtDecodedVerifiablePresentation"
+                    }
+                  ],
+                  description: "Original VP that we've received"
+                },
+                decoded: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/JwtDecodedVerifiablePresentation"
+                    },
+                    {
+                      $ref: "#/components/schemas/IVerifiablePresentation"
+                    }
+                  ],
+                  description: "In case of JWT VP it will be the decoded version. In other cases it will be the same as original one"
+                },
+                type: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/OriginalType.JSONLD"
+                    },
+                    {
+                      $ref: "#/components/schemas/OriginalType.JWT_ENCODED"
+                    },
+                    {
+                      $ref: "#/components/schemas/OriginalType.JWT_DECODED"
+                    }
+                  ],
+                  description: "Type of this Presentation. Supported types are json-ld and jwt (decoded/encoded) and sd-jwt-vc (decoded/encoded)"
+                },
+                format: {
+                  type: "string",
+                  enum: ["jwt_vp", "ldp_vp"],
+                  description: "The claim format, typically used during exchange transport protocols"
+                },
+                presentation: {
+                  $ref: "#/components/schemas/UniformVerifiablePresentation",
+                  description: "Internal stable representation of a Presentation without proofs, created based on https://www.w3.org/TR/vc-data-model/#jwt-decoding"
+                },
+                vcs: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/WrappedW3CVerifiableCredential"
+                  },
+                  description: "Wrapped Verifiable Credentials belonging to the Presentation"
+                }
+              },
+              required: ["original", "decoded", "type", "format", "presentation", "vcs"],
+              additionalProperties: false
+            },
+            W3CVerifiablePresentation: {
+              anyOf: [
+                {
+                  $ref: "#/components/schemas/IVerifiablePresentation"
+                },
+                {
+                  $ref: "#/components/schemas/CompactJWT"
+                }
+              ],
+              description: "Represents a signed Verifiable Presentation (includes proof), in either JSON or compact JWT format. See  {@link https://www.w3.org/TR/vc-data-model/#presentations | VC data model }  See  {@link https://www.w3.org/TR/vc-data-model/#proof-formats | proof formats }"
+            },
+            IVerifiablePresentation: {
+              type: "object",
+              properties: {
+                proof: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/IProof"
+                    },
+                    {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/IProof"
+                      }
+                    }
+                  ]
+                },
+                id: {
+                  type: "string"
+                },
+                "@context": {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/ICredentialContextType"
+                    },
+                    {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/ICredentialContextType"
+                      }
+                    }
+                  ]
+                },
+                type: {
+                  anyOf: [
+                    {
+                      type: "string"
+                    },
+                    {
+                      type: "array",
+                      items: {
+                        type: "string"
+                      }
+                    }
+                  ]
+                },
+                verifiableCredential: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/W3CVerifiableCredential"
+                  }
+                },
+                presentation_submission: {
+                  $ref: "#/components/schemas/PresentationSubmission"
+                },
+                holder: {
+                  type: "string"
+                },
+                verifier: {
+                  type: "string"
+                }
+              },
+              required: ["@context", "proof"]
+            },
+            PresentationSubmission: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string",
+                  description: "A UUID or some other unique ID to identify this Presentation Submission"
+                },
+                definition_id: {
+                  type: "string",
+                  description: "A UUID or some other unique ID to identify this Presentation Definition"
+                },
+                descriptor_map: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/Descriptor"
+                  },
+                  description: "List of descriptors of how the claims are being mapped to presentation definition"
+                }
+              },
+              required: ["id", "definition_id", "descriptor_map"],
+              additionalProperties: false,
+              description: "It expresses how the inputs are presented as proofs to a Verifier."
+            },
+            Descriptor: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string",
+                  description: "ID to identify the descriptor from Presentation Definition Input Descriptor it coresponds to."
+                },
+                path: {
+                  type: "string",
+                  description: "The path where the verifiable credential is located in the presentation submission json"
+                },
+                path_nested: {
+                  $ref: "#/components/schemas/Descriptor"
+                },
+                format: {
+                  type: "string",
+                  description: "The Proof or JWT algorith that the proof is in"
+                }
+              },
+              required: ["id", "path", "format"],
+              additionalProperties: false,
+              description: "descriptor map laying out the structure of the presentation submission."
+            },
+            JwtDecodedVerifiablePresentation: {
+              type: "object",
+              properties: {
+                vp: {
+                  $ref: "#/components/schemas/IVerifiablePresentation"
+                },
+                exp: {
+                  type: "string"
+                },
+                iss: {
+                  type: "string"
+                },
+                nbf: {
+                  type: "string"
+                },
+                sub: {
+                  type: "string"
+                },
+                jti: {
+                  type: "string"
+                },
+                aud: {
+                  type: "string"
+                },
+                iat: {
+                  type: "string"
+                }
+              },
+              required: ["vp", "exp", "iss", "nbf", "sub", "jti", "aud", "iat"]
+            },
+            UniformVerifiablePresentation: {
+              type: "object",
+              properties: {
+                "@context": {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/ICredentialContextType"
+                    },
+                    {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/ICredentialContextType"
+                      }
+                    }
+                  ]
+                },
+                type: {
+                  anyOf: [
+                    {
+                      type: "string"
+                    },
+                    {
+                      type: "array",
+                      items: {
+                        type: "string"
+                      }
+                    }
+                  ]
+                },
+                verifiableCredential: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/WrappedW3CVerifiableCredential"
+                  }
+                },
+                presentation_submission: {
+                  $ref: "#/components/schemas/PresentationSubmission"
+                },
+                holder: {
+                  type: "string"
+                }
+              },
+              required: ["@context", "type", "verifiableCredential"],
+              additionalProperties: false
+            },
+            WrappedSdJwtVerifiablePresentation: {
+              type: "object",
+              properties: {
+                original: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/SdJwtDecodedVerifiableCredential"
+                    },
+                    {
+                      $ref: "#/components/schemas/CompactSdJwtVc"
+                    }
+                  ],
+                  description: "Original VP that we've received. Can be either the encoded or decoded variant."
+                },
+                decoded: {
+                  $ref: "#/components/schemas/SdJwtDecodedVerifiableCredentialPayload",
+                  description: "Decoded version of the SD-JWT payload. This is the decoded payload, rather than the whole SD-JWT."
+                },
+                type: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/OriginalType.SD_JWT_VC_DECODED"
+                    },
+                    {
+                      $ref: "#/components/schemas/OriginalType.SD_JWT_VC_ENCODED"
+                    }
+                  ],
+                  description: "Type of this Presentation."
+                },
+                format: {
+                  type: "string",
+                  const: "vc+sd-jwt",
+                  description: "The claim format, typically used during exchange transport protocols"
+                },
+                presentation: {
+                  $ref: "#/components/schemas/SdJwtDecodedVerifiableCredential",
+                  description: "Internal stable representation of a Presentation"
+                },
+                vcs: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/WrappedSdJwtVerifiableCredential"
+                  },
+                  minItems: 1,
+                  maxItems: 1,
+                  description: "Wrapped Verifiable Credentials belonging to the Presentation. Will always be an array with a single SdJwtVerifiableCredential entry."
+                }
+              },
+              required: ["original", "decoded", "type", "format", "presentation", "vcs"],
+              additionalProperties: false
+            },
+            WrappedMdocPresentation: {
+              type: "object",
+              properties: {
+                original: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/MdocDeviceResponse"
+                    },
+                    {
+                      $ref: "#/components/schemas/MdocOid4vpMdocVpToken"
+                    }
+                  ],
+                  description: "Original VP that we've received. Can be either the encoded or decoded variant."
+                },
+                decoded: {
+                  $ref: "#/components/schemas/MdocDeviceResponse",
+                  description: "Decoded version of the SD-JWT payload. This is the decoded payload, rather than the whole SD-JWT."
+                },
+                type: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/OriginalType.MSO_MDOC_ENCODED"
+                    },
+                    {
+                      $ref: "#/components/schemas/OriginalType.MSO_MDOC_DECODED"
+                    }
+                  ],
+                  description: "Type of this Presentation."
+                },
+                format: {
+                  type: "string",
+                  const: "mso_mdoc",
+                  description: "The claim format, typically used during exchange transport protocols"
+                },
+                presentation: {
+                  $ref: "#/components/schemas/MdocDeviceResponse",
+                  description: "Internal stable representation of a Presentation"
+                },
+                vcs: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/WrappedMdocCredential"
+                  },
+                  description: "Wrapped Mdocs belonging to the Presentation. There can be multiple documents in a single device response"
+                }
+              },
+              required: ["original", "decoded", "type", "format", "presentation", "vcs"],
+              additionalProperties: false
+            },
+            MdocDeviceResponse: {
+              $ref: "#/components/schemas/com.sphereon.mdoc.data.device.DeviceResponseCbor"
+            },
+            "com.sphereon.mdoc.data.device.DeviceResponseCbor": {
+              type: "object",
+              additionalProperties: false,
+              properties: {}
+            },
+            MdocOid4vpMdocVpToken: {
+              type: "string"
+            },
+            VerificationSubResult: {
+              type: "object",
+              properties: {
+                result: {
+                  type: "boolean"
+                },
+                error: {
+                  type: "string"
+                },
+                errorDetails: {
+                  type: "string"
+                }
+              },
+              required: ["result"],
+              additionalProperties: false
+            },
+            VerifyMdocCredentialArgs: {
+              type: "object",
+              properties: {
+                credential: {
+                  type: "string"
+                }
+              },
+              required: ["credential"],
+              additionalProperties: false
+            },
+            ValidateSchemaArgs: {
+              type: "object",
+              properties: {
+                credential: {
+                  $ref: "#/components/schemas/OriginalVerifiableCredential"
+                },
+                validationPolicy: {
+                  $ref: "#/components/schemas/SchemaValidation"
+                },
+                hasher: {
+                  $ref: "#/components/schemas/HasherSync"
+                }
+              },
+              required: ["credential"],
+              additionalProperties: false
+            },
+            VerifySDJWTCredentialArgs: {
+              type: "object",
+              properties: {
+                credential: {
+                  type: "string"
+                },
+                hasher: {
+                  $ref: "#/components/schemas/HasherSync"
+                }
+              },
+              required: ["credential"],
+              additionalProperties: false
+            },
+            VerifyW3CCredentialArgs: {
+              type: "object",
+              additionalProperties: false
+            }
+          },
+          methods: {
+            cvVerifyCredential: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/VerifyCredentialArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/VerificationResult"
+              }
+            },
+            cvVerifyMdoc: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/VerifyMdocCredentialArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/VerificationResult"
+              }
+            },
+            cvVerifySchema: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/ValidateSchemaArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/VerificationResult"
+              }
+            },
+            cvVerifySDJWTCredential: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/VerifySDJWTCredentialArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/VerificationResult"
+              }
+            },
+            cvVerifyW3CCredential: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/VerifyW3CCredentialArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/VerificationResult"
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CredentialValidation: () => CredentialValidation,
+  SchemaValidation: () => SchemaValidation,
+  credentialValidationMethods: () => credentialValidationMethods,
+  schema: () => schema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/agent/CredentialValidation.ts
+var import_kmp_mdoc_core = require("@sphereon/kmp-mdoc-core");
+var import_ssi_types = require("@sphereon/ssi-types");
+var import_ajv_formats = __toESM(require("ajv-formats"), 1);
+var import__ = __toESM(require("ajv/dist/2020"), 1);
+var import_cross_fetch = __toESM(require("cross-fetch"), 1);
+var import_ssi_sdk = require("@sphereon/ssi-sdk.core");
+var decodeFrom = import_kmp_mdoc_core.com.sphereon.kmp.decodeFrom;
+var IssuerSignedCbor = import_kmp_mdoc_core.com.sphereon.mdoc.data.device.IssuerSignedCbor;
+var credentialValidationMethods = [
+  "cvVerifyCredential",
+  "cvVerifySchema",
+  "cvVerifyMdoc",
+  "cvVerifySDJWTCredential",
+  "cvVerifyW3CCredential"
+];
+var CredentialValidation = class {
+  static {
+    __name(this, "CredentialValidation");
+  }
+  schema = schema.ICredentialValidation;
+  methods = {
+    cvVerifyCredential: this.cvVerifyCredential.bind(this),
+    cvVerifySchema: this.cvVerifySchema.bind(this),
+    cvVerifyMdoc: this.cvVerifyMdoc.bind(this),
+    cvVerifySDJWTCredential: this.cvVerifySDJWTCredential.bind(this),
+    cvVerifyW3CCredential: this.cvVerifyW3CCredential.bind(this)
+  };
+  detectSchemas(wrappedVC) {
+    if ("credential" in wrappedVC) {
+      const { credential } = wrappedVC;
+      if ("credentialSchema" in credential) {
+        const { credentialSchema } = credential;
+        if (Array.isArray(credentialSchema)) {
+          return credentialSchema;
+        } else if (credentialSchema) {
+          return [
+            credentialSchema
+          ];
+        }
+      }
+    }
+    return void 0;
+  }
+  async cvVerifyCredential(args, context) {
+    const { credential, hasher = import_ssi_sdk.defaultHasher, policies } = args;
+    const schemaResult = await this.cvVerifySchema({
+      credential,
+      validationPolicy: policies?.schemaValidation ?? SchemaValidation.WHEN_PRESENT,
+      hasher
+    });
+    if (!schemaResult.result) {
+      return schemaResult;
+    }
+    if (import_ssi_types.CredentialMapper.isMsoMdocOid4VPEncoded(credential)) {
+      return await this.cvVerifyMdoc({
+        credential
+      }, context);
+    } else if (import_ssi_types.CredentialMapper.isSdJwtEncoded(credential)) {
+      return await this.cvVerifySDJWTCredential({
+        credential,
+        hasher
+      }, context);
+    } else {
+      return await this.cvVerifyW3CCredential({
+        ...args,
+        credential
+      }, context);
+    }
+  }
+  async cvVerifySchema(args) {
+    const { credential, hasher = import_ssi_sdk.defaultHasher, validationPolicy } = args;
+    const wrappedCredential = import_ssi_types.CredentialMapper.toWrappedVerifiableCredential(credential, {
+      hasher
+    });
+    if (validationPolicy === SchemaValidation.NEVER) {
+      return {
+        result: true,
+        source: wrappedCredential,
+        subResults: []
+      };
+    }
+    return this.validateSchema(wrappedCredential, validationPolicy);
+  }
+  async validateSchema(wrappedVC, validationPolicy) {
+    const schemas = this.detectSchemas(wrappedVC);
+    if (!schemas) {
+      if (validationPolicy === SchemaValidation.ALWAYS) {
+        console.error(`No schema found for credential, but validation policy is set to ALWAYS. Returning false. Credential: ${JSON.stringify(wrappedVC.credential, null, 2)}`);
+        return {
+          result: false,
+          source: wrappedVC,
+          subResults: []
+        };
+      } else {
+        return {
+          result: true,
+          source: wrappedVC,
+          subResults: []
+        };
+      }
+    }
+    const subResults = await Promise.all(schemas.map((schema2) => this.verifyCredentialAgainstSchema(wrappedVC, schema2)));
+    return {
+      result: subResults.every((subResult) => subResult.result),
+      source: wrappedVC,
+      subResults
+    };
+  }
+  async fetchSchema(uri) {
+    const response = await (0, import_cross_fetch.default)(uri);
+    if (!response.ok) {
+      throw new Error(`Unable to fetch schema from ${uri}`);
+    }
+    return response.json();
+  }
+  async verifyCredentialAgainstSchema(wrappedVC, schema2) {
+    const schemaUrl = typeof schema2 === "string" ? schema2 : schema2.id;
+    let schemaValue;
+    try {
+      schemaValue = await this.fetchSchema(schemaUrl);
+    } catch (error) {
+      console.error(error);
+      return {
+        result: false,
+        error
+      };
+    }
+    const ajv = new import__.default({
+      loadSchema: this.fetchSchema
+    });
+    (0, import_ajv_formats.default)(ajv);
+    const validate = await ajv.compileAsync(schemaValue);
+    const valid = validate(wrappedVC.credential);
+    if (!valid) {
+      console.error(`Schema validation failed for `, wrappedVC.credential);
+    }
+    return {
+      result: valid
+    };
+  }
+  async cvVerifyMdoc(args, context) {
+    const { credential } = args;
+    const issuerSigned = IssuerSignedCbor.Static.cborDecode(decodeFrom(credential, import_kmp_mdoc_core.com.sphereon.kmp.Encoding.BASE64URL));
+    const verification = await context.agent.mdocVerifyIssuerSigned({
+      input: issuerSigned.toJson().issuerAuth
+    }).catch((error) => {
+      console.error(error);
+      return {
+        name: "mdoc",
+        critical: true,
+        error: true,
+        message: error.message ?? "Mdoc Issuer Signed VC could not be verified"
+      };
+    });
+    return {
+      source: import_ssi_types.CredentialMapper.toWrappedVerifiableCredential(credential, {
+        hasher: import_ssi_sdk.defaultHasher
+      }),
+      result: !verification.error,
+      subResults: [],
+      ...verification.error && {
+        error: verification.message ?? `Could not verify mdoc from issuer`
+      }
+    };
+  }
+  async cvVerifyW3CCredential(args, context) {
+    const { credential, policies } = args;
+    const result = await context.agent.verifyCredential(args);
+    if (typeof result === "boolean") {
+      return {
+        // FIXME the source is never used, need to start using this as the source of truth
+        source: import_ssi_types.CredentialMapper.toWrappedVerifiableCredential(args.credential, {
+          hasher: import_ssi_sdk.defaultHasher
+        }),
+        result,
+        ...!result && {
+          error: "Invalid JWT VC",
+          errorDetails: `JWT VC was not valid with policies: ${JSON.stringify(policies)}`
+        },
+        subResults: []
+      };
+    } else {
+      let error;
+      let errorDetails;
+      const subResults = [];
+      if (result.error) {
+        error = result.error?.message ?? "";
+        errorDetails = result.error?.details?.code ?? "";
+        errorDetails = (errorDetails !== "" ? `${errorDetails}, ` : "") + (result.error?.details?.url ?? "");
+        if (result.error?.errors) {
+          error = (error !== "" ? `${error}, ` : "") + result.error?.errors?.map((error2) => error2.message ?? error2.name).join(", ");
+          errorDetails = (errorDetails !== "" ? `${errorDetails}, ` : "") + result.error?.errors?.map((error2) => (error2?.details?.code ? `${error2.details.code}, ` : "") + (error2?.details?.url ?? "")).join(", ");
+        }
+        console.error(error);
+      }
+      return {
+        source: import_ssi_types.CredentialMapper.toWrappedVerifiableCredential(credential, {
+          hasher: import_ssi_sdk.defaultHasher
+        }),
+        result: result.verified,
+        subResults,
+        error,
+        errorDetails
+      };
+    }
+  }
+  async cvVerifySDJWTCredential(args, context) {
+    const { credential, hasher = import_ssi_sdk.defaultHasher } = args;
+    const verification = await context.agent.verifySdJwtVc({
+      credential
+    }).catch((error) => {
+      console.error(error);
+      return {
+        error: "Invalid SD-JWT VC",
+        errorDetails: error.message ?? "SD-JWT VC could not be verified"
+      };
+    });
+    const result = "header" in verification && "payload" in verification;
+    return {
+      source: import_ssi_types.CredentialMapper.toWrappedVerifiableCredential(credential, {
+        hasher: hasher ?? import_ssi_sdk.defaultHasher
+      }),
+      result,
+      subResults: [],
+      ...!result && {
+        ...verification
+      }
+    };
+  }
+};
+
+// src/types/ICredentialValidation.ts
+var SchemaValidation = /* @__PURE__ */ function(SchemaValidation2) {
+  SchemaValidation2["ALWAYS"] = "ALWAYS";
+  SchemaValidation2["NEVER"] = "NEVER";
+  SchemaValidation2["WHEN_PRESENT"] = "WHEN_PRESENT";
+  return SchemaValidation2;
+}({});
+
+// src/index.ts
+var schema = require_plugin_schema();
+//# sourceMappingURL=index.cjs.map