@sphereon/ssi-sdk.mdl-mdoc 0.33.1-feature.vcdm2.tsup.32 → 0.33.1-next.3

package/dist/index.js

@@ -1,2540 +1,27 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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;
-};
-
-// plugin.schema.json
-var require_plugin_schema = __commonJS({
-  "plugin.schema.json"(exports, module) {
-    module.exports = {
-      IEBSIAuthorizationClient: {
-        components: {
-          schemas: {
-            EBSIAuthAccessTokenGetArgs: {
-              type: "object",
-              properties: {
-                vc: {
-                  type: "string"
-                },
-                definitionId: {
-                  $ref: "#/components/schemas/ScopeByDefinition"
-                },
-                did: {
-                  type: "string"
-                },
-                kid: {
-                  type: "string"
-                },
-                scope: {
-                  $ref: "#/components/schemas/EBSIScope"
-                },
-                apiOpts: {
-                  $ref: '#/components/schemas/Optional<ApiOpts,"version">'
-                }
-              },
-              required: ["vc", "definitionId", "did", "kid", "scope", "apiOpts"]
-            },
-            ScopeByDefinition: {
-              type: "string",
-              enum: ["didr_invite", "didr_write", "tir_invite", "tir_write", "timestamp_write", "tnt_authorise", "tnt_create", "tnt_write"]
-            },
-            EBSIScope: {
-              type: "string",
-              enum: [
-                "didr_write",
-                "didr_invite",
-                "tir_write",
-                "tir_invite",
-                "timestamp_write",
-                "tnt_authorise",
-                "tnt_create",
-                "tnt_write",
-                "did_authn"
-              ],
-              description: "The OpenID scope"
-            },
-            'Optional<ApiOpts,"version">': {
-              type: "object",
-              properties: {
-                environment: {
-                  $ref: "#/components/schemas/EbsiEnvironment"
-                },
-                version: {
-                  $ref: "#/components/schemas/EbsiApiVersion"
-                }
-              }
-            },
-            EbsiEnvironment: {
-              type: "string",
-              enum: ["pilot", "conformance", "conformance-test"]
-            },
-            EbsiApiVersion: {
-              type: "string",
-              enum: ["v3", "v4", "v5"]
-            },
-            GetAccessTokenResponse: {
-              anyOf: [
-                {
-                  $ref: "#/components/schemas/GetAccessTokenSuccessResponse"
-                },
-                {
-                  $ref: "#/components/schemas/ExceptionResponse"
-                }
-              ]
-            },
-            GetAccessTokenSuccessResponse: {
-              type: "object",
-              properties: {
-                access_token: {
-                  type: "string"
-                },
-                token_type: {
-                  $ref: "#/components/schemas/TokenType"
-                },
-                expires_in: {
-                  type: "number"
-                },
-                scope: {
-                  $ref: "#/components/schemas/EBSIScope"
-                },
-                id_token: {
-                  type: "string"
-                },
-                apiOpts: {
-                  $ref: "#/components/schemas/ApiOpts"
-                }
-              },
-              required: ["access_token", "token_type", "scope", "id_token", "apiOpts"]
-            },
-            TokenType: {
-              type: "string",
-              const: "Bearer"
-            },
-            ApiOpts: {
-              type: "object",
-              properties: {
-                environment: {
-                  $ref: "#/components/schemas/EbsiEnvironment"
-                },
-                version: {
-                  $ref: "#/components/schemas/EbsiApiVersion"
-                }
-              },
-              required: ["version"]
-            },
-            ExceptionResponse: {
-              type: "object",
-              properties: {
-                type: {
-                  type: "string"
-                },
-                title: {
-                  type: "string"
-                },
-                status: {
-                  type: "number"
-                },
-                detail: {
-                  type: "string"
-                },
-                instance: {
-                  type: "string"
-                }
-              }
-            },
-            GetOIDProviderJwksResponse: {
-              anyOf: [
-                {
-                  $ref: "#/components/schemas/GetOIDProviderJwksSuccessResponse"
-                },
-                {
-                  $ref: "#/components/schemas/ExceptionResponse"
-                }
-              ]
-            },
-            GetOIDProviderJwksSuccessResponse: {
-              type: "object",
-              properties: {
-                keys: {
-                  type: "array",
-                  items: {
-                    $ref: "#/components/schemas/JWK"
-                  }
-                }
-              },
-              required: ["keys"]
-            },
-            JWK: {
-              type: "object",
-              properties: {
-                alg: {
-                  type: "string",
-                  description: 'JWK "alg" (Algorithm) Parameter.'
-                },
-                crv: {
-                  type: "string"
-                },
-                d: {
-                  type: "string"
-                },
-                dp: {
-                  type: "string"
-                },
-                dq: {
-                  type: "string"
-                },
-                e: {
-                  type: "string"
-                },
-                ext: {
-                  type: "boolean",
-                  description: 'JWK "ext" (Extractable) Parameter.'
-                },
-                k: {
-                  type: "string"
-                },
-                key_ops: {
-                  type: "array",
-                  items: {
-                    type: "string"
-                  },
-                  description: 'JWK "key_ops" (Key Operations) Parameter.'
-                },
-                kid: {
-                  type: "string",
-                  description: 'JWK "kid" (Key ID) Parameter.'
-                },
-                kty: {
-                  type: "string",
-                  description: 'JWK "kty" (Key Type) Parameter.'
-                },
-                n: {
-                  type: "string"
-                },
-                oth: {
-                  type: "array",
-                  items: {
-                    type: "object",
-                    properties: {
-                      d: {
-                        type: "string"
-                      },
-                      r: {
-                        type: "string"
-                      },
-                      t: {
-                        type: "string"
-                      }
-                    }
-                  }
-                },
-                p: {
-                  type: "string"
-                },
-                q: {
-                  type: "string"
-                },
-                qi: {
-                  type: "string"
-                },
-                use: {
-                  type: "string",
-                  description: 'JWK "use" (Public Key Use) Parameter.'
-                },
-                x: {
-                  type: "string"
-                },
-                y: {
-                  type: "string"
-                },
-                x5c: {
-                  type: "array",
-                  items: {
-                    type: "string"
-                  },
-                  description: 'JWK "x5c" (X.509 Certificate Chain) Parameter.'
-                },
-                x5t: {
-                  type: "string",
-                  description: 'JWK "x5t" (X.509 Certificate SHA-1 Thumbprint) Parameter.'
-                },
-                "x5t#S256": {
-                  type: "string",
-                  description: '"x5t#S256" (X.509 Certificate SHA-256 Thumbprint) Parameter.'
-                },
-                x5u: {
-                  type: "string",
-                  description: 'JWK "x5u" (X.509 URL) Parameter.'
-                }
-              },
-              additionalProperties: {},
-              description: 'JSON Web Key ( {@link https://www.rfc-editor.org/rfc/rfc7517 | JWK } ). "RSA", "EC", "OKP", and "oct" key types are supported.'
-            },
-            GetPresentationDefinitionArgs: {
-              type: "object",
-              properties: {
-                scope: {
-                  $ref: "#/components/schemas/EBSIScope"
-                },
-                apiOpts: {
-                  $ref: "#/components/schemas/ApiOpts"
-                }
-              },
-              required: ["scope"]
-            },
-            GetPresentationDefinitionResponse: {
-              $ref: "#/components/schemas/GetPresentationDefinitionSuccessResponse"
-            },
-            GetPresentationDefinitionSuccessResponse: {
-              type: "object",
-              properties: {
-                format: {
-                  $ref: "#/components/schemas/Format"
-                },
-                id: {
-                  type: "string"
-                },
-                name: {
-                  type: "string"
-                },
-                purpose: {
-                  type: "string"
-                },
-                submission_requirements: {
-                  type: "array",
-                  items: {
-                    $ref: "#/components/schemas/SubmissionRequirement"
-                  }
-                },
-                input_descriptors: {
-                  type: "array",
-                  items: {
-                    $ref: "#/components/schemas/InputDescriptorV2"
-                  }
-                },
-                frame: {
-                  type: "object"
-                }
-              },
-              required: ["id", "input_descriptors"]
-            },
-            Format: {
-              type: "object",
-              properties: {
-                jwt: {
-                  $ref: "#/components/schemas/JwtObject"
-                },
-                jwt_vc: {
-                  $ref: "#/components/schemas/JwtObject"
-                },
-                jwt_vc_json: {
-                  $ref: "#/components/schemas/JwtObject"
-                },
-                jwt_vp: {
-                  $ref: "#/components/schemas/JwtObject"
-                },
-                jwt_vp_json: {
-                  $ref: "#/components/schemas/JwtObject"
-                },
-                ldp: {
-                  $ref: "#/components/schemas/LdpObject"
-                },
-                ldp_vc: {
-                  $ref: "#/components/schemas/LdpObject"
-                },
-                ldp_vp: {
-                  $ref: "#/components/schemas/LdpObject"
-                },
-                di: {
-                  $ref: "#/components/schemas/DiObject"
-                },
-                di_vc: {
-                  $ref: "#/components/schemas/DiObject"
-                },
-                di_vp: {
-                  $ref: "#/components/schemas/DiObject"
-                },
-                "vc+sd-jwt": {
-                  $ref: "#/components/schemas/SdJwtObject"
-                }
-              }
-            },
-            JwtObject: {
-              type: "object",
-              properties: {
-                alg: {
-                  type: "array",
-                  items: {
-                    type: "string"
-                  }
-                }
-              },
-              required: ["alg"]
-            },
-            LdpObject: {
-              type: "object",
-              properties: {
-                proof_type: {
-                  type: "array",
-                  items: {
-                    type: "string"
-                  }
-                }
-              },
-              required: ["proof_type"]
-            },
-            DiObject: {
-              type: "object",
-              properties: {
-                proof_type: {
-                  type: "array",
-                  items: {
-                    type: "string"
-                  }
-                },
-                cryptosuite: {
-                  type: "array",
-                  items: {
-                    type: "string"
-                  }
-                }
-              },
-              required: ["proof_type", "cryptosuite"]
-            },
-            SdJwtObject: {
-              type: "object",
-              properties: {
-                "sd-jwt_alg_values": {
-                  type: "array",
-                  items: {
-                    type: "string"
-                  }
-                },
-                "kb-jwt_alg_values": {
-                  type: "array",
-                  items: {
-                    type: "string"
-                  }
-                }
-              }
-            },
-            SubmissionRequirement: {
-              type: "object",
-              properties: {
-                name: {
-                  type: "string"
-                },
-                purpose: {
-                  type: "string"
-                },
-                rule: {
-                  $ref: "#/components/schemas/Rules"
-                },
-                count: {
-                  type: "number"
-                },
-                min: {
-                  type: "number"
-                },
-                max: {
-                  type: "number"
-                },
-                from: {
-                  type: "string"
-                },
-                from_nested: {
-                  type: "array",
-                  items: {
-                    $ref: "#/components/schemas/SubmissionRequirement"
-                  }
-                }
-              },
-              required: ["rule"]
-            },
-            Rules: {
-              type: "string",
-              enum: ["all", "pick"]
-            },
-            InputDescriptorV2: {
-              type: "object",
-              properties: {
-                id: {
-                  type: "string"
-                },
-                name: {
-                  type: "string"
-                },
-                purpose: {
-                  type: "string"
-                },
-                format: {
-                  $ref: "#/components/schemas/Format"
-                },
-                group: {
-                  type: "array",
-                  items: {
-                    type: "string"
-                  }
-                },
-                issuance: {
-                  type: "array",
-                  items: {
-                    $ref: "#/components/schemas/Issuance"
-                  }
-                },
-                constraints: {
-                  $ref: "#/components/schemas/ConstraintsV2"
-                }
-              },
-              required: ["id", "constraints"]
-            },
-            Issuance: {
-              type: "object",
-              properties: {
-                manifest: {
-                  type: "string"
-                }
-              },
-              additionalProperties: {}
-            },
-            ConstraintsV2: {
-              type: "object",
-              properties: {
-                limit_disclosure: {
-                  $ref: "#/components/schemas/Optionality"
-                },
-                statuses: {
-                  $ref: "#/components/schemas/Statuses"
-                },
-                fields: {
-                  type: "array",
-                  items: {
-                    $ref: "#/components/schemas/FieldV2"
-                  }
-                },
-                subject_is_issuer: {
-                  $ref: "#/components/schemas/Optionality"
-                },
-                is_holder: {
-                  type: "array",
-                  items: {
-                    $ref: "#/components/schemas/HolderSubject"
-                  }
-                },
-                same_subject: {
-                  type: "array",
-                  items: {
-                    $ref: "#/components/schemas/HolderSubject"
-                  }
-                }
-              }
-            },
-            Optionality: {
-              type: "string",
-              enum: ["required", "preferred"]
-            },
-            Statuses: {
-              type: "object",
-              properties: {
-                active: {
-                  $ref: "#/components/schemas/PdStatus"
-                },
-                suspended: {
-                  $ref: "#/components/schemas/PdStatus"
-                },
-                revoked: {
-                  $ref: "#/components/schemas/PdStatus"
-                }
-              }
-            },
-            PdStatus: {
-              type: "object",
-              properties: {
-                directive: {
-                  $ref: "#/components/schemas/Directives"
-                }
-              }
-            },
-            Directives: {
-              type: "string",
-              enum: ["required", "allowed", "disallowed"]
-            },
-            FieldV2: {
-              type: "object",
-              properties: {
-                id: {
-                  type: "string"
-                },
-                path: {
-                  type: "array",
-                  items: {
-                    type: "string"
-                  }
-                },
-                purpose: {
-                  type: "string"
-                },
-                filter: {
-                  $ref: "#/components/schemas/FilterV2"
-                },
-                predicate: {
-                  $ref: "#/components/schemas/Optionality"
-                },
-                name: {
-                  type: "string"
-                },
-                optional: {
-                  type: "boolean"
-                }
-              },
-              required: ["path"]
-            },
-            FilterV2: {
-              type: "object",
-              properties: {
-                const: {
-                  $ref: "#/components/schemas/OneOfNumberStringBoolean"
-                },
-                enum: {
-                  type: "array",
-                  items: {
-                    $ref: "#/components/schemas/OneOfNumberStringBoolean"
-                  }
-                },
-                exclusiveMinimum: {
-                  $ref: "#/components/schemas/OneOfNumberString"
-                },
-                exclusiveMaximum: {
-                  $ref: "#/components/schemas/OneOfNumberString"
-                },
-                format: {
-                  type: "string"
-                },
-                formatMaximum: {
-                  type: "string"
-                },
-                formatMinimum: {
-                  type: "string"
-                },
-                formatExclusiveMaximum: {
-                  type: "string"
-                },
-                formatExclusiveMinimum: {
-                  type: "string"
-                },
-                minLength: {
-                  type: "number"
-                },
-                maxLength: {
-                  type: "number"
-                },
-                minimum: {
-                  $ref: "#/components/schemas/OneOfNumberString"
-                },
-                maximum: {
-                  $ref: "#/components/schemas/OneOfNumberString"
-                },
-                not: {
-                  type: "object"
-                },
-                pattern: {
-                  type: "string"
-                },
-                type: {
-                  type: "string"
-                },
-                contains: {
-                  $ref: "#/components/schemas/FilterV2Base"
-                },
-                items: {
-                  $ref: "#/components/schemas/FilterV2BaseItems"
-                }
-              },
-              required: ["type"]
-            },
-            OneOfNumberStringBoolean: {
-              type: ["boolean", "number", "string"]
-            },
-            OneOfNumberString: {
-              type: ["number", "string"]
-            },
-            FilterV2Base: {
-              type: "object",
-              properties: {
-                const: {
-                  $ref: "#/components/schemas/OneOfNumberStringBoolean"
-                },
-                enum: {
-                  type: "array",
-                  items: {
-                    $ref: "#/components/schemas/OneOfNumberStringBoolean"
-                  }
-                },
-                exclusiveMinimum: {
-                  $ref: "#/components/schemas/OneOfNumberString"
-                },
-                exclusiveMaximum: {
-                  $ref: "#/components/schemas/OneOfNumberString"
-                },
-                format: {
-                  type: "string"
-                },
-                formatMaximum: {
-                  type: "string"
-                },
-                formatMinimum: {
-                  type: "string"
-                },
-                formatExclusiveMaximum: {
-                  type: "string"
-                },
-                formatExclusiveMinimum: {
-                  type: "string"
-                },
-                minLength: {
-                  type: "number"
-                },
-                maxLength: {
-                  type: "number"
-                },
-                minimum: {
-                  $ref: "#/components/schemas/OneOfNumberString"
-                },
-                maximum: {
-                  $ref: "#/components/schemas/OneOfNumberString"
-                },
-                not: {
-                  type: "object"
-                },
-                pattern: {
-                  type: "string"
-                },
-                type: {
-                  type: "string"
-                },
-                contains: {
-                  $ref: "#/components/schemas/FilterV2Base"
-                },
-                items: {
-                  $ref: "#/components/schemas/FilterV2BaseItems"
-                }
-              }
-            },
-            FilterV2BaseItems: {
-              type: "object",
-              properties: {
-                const: {
-                  $ref: "#/components/schemas/OneOfNumberStringBoolean"
-                },
-                enum: {
-                  type: "array",
-                  items: {
-                    $ref: "#/components/schemas/OneOfNumberStringBoolean"
-                  }
-                },
-                exclusiveMinimum: {
-                  $ref: "#/components/schemas/OneOfNumberString"
-                },
-                exclusiveMaximum: {
-                  $ref: "#/components/schemas/OneOfNumberString"
-                },
-                format: {
-                  type: "string"
-                },
-                formatMaximum: {
-                  type: "string"
-                },
-                formatMinimum: {
-                  type: "string"
-                },
-                formatExclusiveMaximum: {
-                  type: "string"
-                },
-                formatExclusiveMinimum: {
-                  type: "string"
-                },
-                minLength: {
-                  type: "number"
-                },
-                maxLength: {
-                  type: "number"
-                },
-                minimum: {
-                  $ref: "#/components/schemas/OneOfNumberString"
-                },
-                maximum: {
-                  $ref: "#/components/schemas/OneOfNumberString"
-                },
-                not: {
-                  type: "object"
-                },
-                pattern: {
-                  type: "string"
-                },
-                type: {
-                  type: "string"
-                },
-                contains: {
-                  $ref: "#/components/schemas/FilterV2Base"
-                },
-                items: {
-                  $ref: "#/components/schemas/FilterV2BaseItems"
-                }
-              },
-              required: ["type"]
-            },
-            HolderSubject: {
-              type: "object",
-              properties: {
-                field_id: {
-                  type: "array",
-                  items: {
-                    type: "string"
-                  }
-                },
-                directive: {
-                  $ref: "#/components/schemas/Optionality"
-                }
-              },
-              required: ["field_id", "directive"]
-            },
-            GetOIDProviderMetadataResponse: {
-              $ref: "#/components/schemas/EbsiOpenIDMetadata"
-            },
-            EbsiOpenIDMetadata: {
-              anyOf: [
-                {
-                  type: "object",
-                  properties: {
-                    presentation_definition_endpoint: {
-                      type: "string"
-                    },
-                    authorization_endpoint: {
-                      anyOf: [
-                        {
-                          $ref: "#/components/schemas/Schema"
-                        },
-                        {
-                          type: "string"
-                        }
-                      ]
-                    },
-                    issuer: {
-                      anyOf: [
-                        {
-                          $ref: "#/components/schemas/ResponseIss"
-                        },
-                        {
-                          type: "string"
-                        }
-                      ]
-                    },
-                    response_types_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/ResponseType"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/ResponseType"
-                        }
-                      ]
-                    },
-                    scopes_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/Scope"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/Scope"
-                        }
-                      ]
-                    },
-                    subject_types_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SubjectType"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SubjectType"
-                        }
-                      ]
-                    },
-                    id_token_signing_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    request_object_signing_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    subject_syntax_types_supported: {
-                      type: "array",
-                      items: {
-                        type: "string"
-                      }
-                    },
-                    token_endpoint: {
-                      type: "string"
-                    },
-                    userinfo_endpoint: {
-                      type: "string"
-                    },
-                    jwks_uri: {
-                      type: "string"
-                    },
-                    registration_endpoint: {
-                      type: "string"
-                    },
-                    response_modes_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/ResponseMode"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/ResponseMode"
-                        }
-                      ]
-                    },
-                    grant_types_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/GrantType"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/GrantType"
-                        }
-                      ]
-                    },
-                    acr_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/AuthenticationContextReferences"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/AuthenticationContextReferences"
-                        }
-                      ]
-                    },
-                    id_token_encryption_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    id_token_encryption_enc_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ],
-                      description: "OPTIONAL. JSON array containing a list of the JWE encryption algorithms (enc values) supported by the OP for the ID Token to encode the Claims in a JWT [JWT]."
-                    },
-                    userinfo_signing_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    userinfo_encryption_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    userinfo_encryption_enc_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ],
-                      description: "OPTIONAL. JSON array containing a list of the JWE encryption algorithms (enc values) [JWA] supported by the UserInfo Endpoint to encode the Claims in a JWT [JWT]."
-                    },
-                    request_object_encryption_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    request_object_encryption_enc_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ],
-                      description: "OPTIONAL. JSON array containing a list of the JWE encryption algorithms (enc values) supported by the OP for Request Objects. These algorithms are used both when the Request Object is passed by value and when it is passed by reference."
-                    },
-                    token_endpoint_auth_methods_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/TokenEndpointAuthMethod"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/TokenEndpointAuthMethod"
-                        }
-                      ]
-                    },
-                    token_endpoint_auth_signing_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    display_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {}
-                        },
-                        {}
-                      ],
-                      description: "OPTIONAL. JSON array containing a list of the display parameter values that the OpenID Provider supports. These values are described in Section 3.1.2.1 of OpenID Connect Core 1.0 [OpenID.Core]."
-                    },
-                    claim_types_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/ClaimType"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/ClaimType"
-                        }
-                      ],
-                      description: "OPTIONAL. JSON array containing a list of the Claim Types that the OpenID Provider supports. These Claim Types are described in Section 5.6 of OpenID Connect Core 1.0 [OpenID.Core]. Values defined by this specification are normal, aggregated, and distributed. If omitted, the implementation supports only normal Claims."
-                    },
-                    claims_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ],
-                      description: "RECOMMENDED. JSON array containing a list of the Claim Names of the Claims that the OpenID Provider MAY be able to supply values for. Note that for privacy or other reasons, this might not be an exhaustive list."
-                    },
-                    service_documentation: {
-                      type: "string"
-                    },
-                    claims_locales_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ]
-                    },
-                    ui_locales_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ]
-                    },
-                    claims_parameter_supported: {
-                      type: "boolean"
-                    },
-                    request_parameter_supported: {
-                      type: "boolean"
-                    },
-                    request_uri_parameter_supported: {
-                      type: "boolean"
-                    },
-                    require_request_uri_registration: {
-                      type: "boolean"
-                    },
-                    op_policy_uri: {
-                      type: "string"
-                    },
-                    op_tos_uri: {
-                      type: "string"
-                    },
-                    client_id: {
-                      type: "string"
-                    },
-                    redirect_uris: {
-                      type: "array",
-                      items: {
-                        type: "string"
-                      }
-                    },
-                    client_name: {
-                      type: "string"
-                    },
-                    token_endpoint_auth_method: {
-                      type: "string"
-                    },
-                    application_type: {
-                      type: "string"
-                    },
-                    response_types: {
-                      type: "string"
-                    },
-                    grant_types: {
-                      type: "string"
-                    },
-                    vp_formats: {
-                      $ref: "#/components/schemas/Format"
-                    }
-                  }
-                },
-                {
-                  type: "object",
-                  properties: {
-                    presentation_definition_endpoint: {
-                      type: "string"
-                    },
-                    authorization_endpoint: {
-                      anyOf: [
-                        {
-                          $ref: "#/components/schemas/Schema"
-                        },
-                        {
-                          type: "string"
-                        }
-                      ]
-                    },
-                    issuer: {
-                      anyOf: [
-                        {
-                          $ref: "#/components/schemas/ResponseIss"
-                        },
-                        {
-                          type: "string"
-                        }
-                      ]
-                    },
-                    response_types_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/ResponseType"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/ResponseType"
-                        }
-                      ]
-                    },
-                    scopes_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/Scope"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/Scope"
-                        }
-                      ]
-                    },
-                    subject_types_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SubjectType"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SubjectType"
-                        }
-                      ]
-                    },
-                    id_token_signing_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    request_object_signing_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    subject_syntax_types_supported: {
-                      type: "array",
-                      items: {
-                        type: "string"
-                      }
-                    },
-                    token_endpoint: {
-                      type: "string"
-                    },
-                    userinfo_endpoint: {
-                      type: "string"
-                    },
-                    jwks_uri: {
-                      type: "string"
-                    },
-                    registration_endpoint: {
-                      type: "string"
-                    },
-                    response_modes_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/ResponseMode"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/ResponseMode"
-                        }
-                      ]
-                    },
-                    grant_types_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/GrantType"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/GrantType"
-                        }
-                      ]
-                    },
-                    acr_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/AuthenticationContextReferences"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/AuthenticationContextReferences"
-                        }
-                      ]
-                    },
-                    id_token_encryption_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    id_token_encryption_enc_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ],
-                      description: "OPTIONAL. JSON array containing a list of the JWE encryption algorithms (enc values) supported by the OP for the ID Token to encode the Claims in a JWT [JWT]."
-                    },
-                    userinfo_signing_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    userinfo_encryption_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    userinfo_encryption_enc_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ],
-                      description: "OPTIONAL. JSON array containing a list of the JWE encryption algorithms (enc values) [JWA] supported by the UserInfo Endpoint to encode the Claims in a JWT [JWT]."
-                    },
-                    request_object_encryption_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    request_object_encryption_enc_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ],
-                      description: "OPTIONAL. JSON array containing a list of the JWE encryption algorithms (enc values) supported by the OP for Request Objects. These algorithms are used both when the Request Object is passed by value and when it is passed by reference."
-                    },
-                    token_endpoint_auth_methods_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/TokenEndpointAuthMethod"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/TokenEndpointAuthMethod"
-                        }
-                      ]
-                    },
-                    token_endpoint_auth_signing_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    display_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {}
-                        },
-                        {}
-                      ],
-                      description: "OPTIONAL. JSON array containing a list of the display parameter values that the OpenID Provider supports. These values are described in Section 3.1.2.1 of OpenID Connect Core 1.0 [OpenID.Core]."
-                    },
-                    claim_types_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/ClaimType"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/ClaimType"
-                        }
-                      ],
-                      description: "OPTIONAL. JSON array containing a list of the Claim Types that the OpenID Provider supports. These Claim Types are described in Section 5.6 of OpenID Connect Core 1.0 [OpenID.Core]. Values defined by this specification are normal, aggregated, and distributed. If omitted, the implementation supports only normal Claims."
-                    },
-                    claims_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ],
-                      description: "RECOMMENDED. JSON array containing a list of the Claim Names of the Claims that the OpenID Provider MAY be able to supply values for. Note that for privacy or other reasons, this might not be an exhaustive list."
-                    },
-                    service_documentation: {
-                      type: "string"
-                    },
-                    claims_locales_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ]
-                    },
-                    ui_locales_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ]
-                    },
-                    claims_parameter_supported: {
-                      type: "boolean"
-                    },
-                    request_parameter_supported: {
-                      type: "boolean"
-                    },
-                    request_uri_parameter_supported: {
-                      type: "boolean"
-                    },
-                    require_request_uri_registration: {
-                      type: "boolean"
-                    },
-                    op_policy_uri: {
-                      type: "string"
-                    },
-                    op_tos_uri: {
-                      type: "string"
-                    },
-                    client_id: {
-                      type: "string"
-                    },
-                    redirect_uris: {
-                      type: "array",
-                      items: {
-                        type: "string"
-                      }
-                    },
-                    client_name: {
-                      type: "string"
-                    },
-                    token_endpoint_auth_method: {
-                      type: "string"
-                    },
-                    application_type: {
-                      type: "string"
-                    },
-                    response_types: {
-                      type: "string"
-                    },
-                    grant_types: {
-                      type: "string"
-                    },
-                    vp_formats: {
-                      $ref: "#/components/schemas/Format"
-                    },
-                    logo_uri: {
-                      type: "string"
-                    },
-                    client_purpose: {
-                      type: "string"
-                    }
-                  }
-                },
-                {
-                  type: "object",
-                  properties: {
-                    presentation_definition_endpoint: {
-                      type: "string"
-                    },
-                    authorization_endpoint: {
-                      anyOf: [
-                        {
-                          $ref: "#/components/schemas/Schema"
-                        },
-                        {
-                          type: "string"
-                        }
-                      ]
-                    },
-                    issuer: {
-                      anyOf: [
-                        {
-                          $ref: "#/components/schemas/ResponseIss"
-                        },
-                        {
-                          type: "string"
-                        }
-                      ]
-                    },
-                    response_types_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/ResponseType"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/ResponseType"
-                        }
-                      ]
-                    },
-                    scopes_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/Scope"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/Scope"
-                        }
-                      ]
-                    },
-                    subject_types_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SubjectType"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SubjectType"
-                        }
-                      ]
-                    },
-                    id_token_signing_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    request_object_signing_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    subject_syntax_types_supported: {
-                      type: "array",
-                      items: {
-                        type: "string"
-                      }
-                    },
-                    token_endpoint: {
-                      type: "string"
-                    },
-                    userinfo_endpoint: {
-                      type: "string"
-                    },
-                    jwks_uri: {
-                      type: "string"
-                    },
-                    registration_endpoint: {
-                      type: "string"
-                    },
-                    response_modes_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/ResponseMode"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/ResponseMode"
-                        }
-                      ]
-                    },
-                    grant_types_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/GrantType"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/GrantType"
-                        }
-                      ]
-                    },
-                    acr_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/AuthenticationContextReferences"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/AuthenticationContextReferences"
-                        }
-                      ]
-                    },
-                    id_token_encryption_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    id_token_encryption_enc_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ],
-                      description: "OPTIONAL. JSON array containing a list of the JWE encryption algorithms (enc values) supported by the OP for the ID Token to encode the Claims in a JWT [JWT]."
-                    },
-                    userinfo_signing_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    userinfo_encryption_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    userinfo_encryption_enc_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ],
-                      description: "OPTIONAL. JSON array containing a list of the JWE encryption algorithms (enc values) [JWA] supported by the UserInfo Endpoint to encode the Claims in a JWT [JWT]."
-                    },
-                    request_object_encryption_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    request_object_encryption_enc_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ],
-                      description: "OPTIONAL. JSON array containing a list of the JWE encryption algorithms (enc values) supported by the OP for Request Objects. These algorithms are used both when the Request Object is passed by value and when it is passed by reference."
-                    },
-                    token_endpoint_auth_methods_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/TokenEndpointAuthMethod"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/TokenEndpointAuthMethod"
-                        }
-                      ]
-                    },
-                    token_endpoint_auth_signing_alg_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/SigningAlgo"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/SigningAlgo"
-                        }
-                      ]
-                    },
-                    display_values_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {}
-                        },
-                        {}
-                      ],
-                      description: "OPTIONAL. JSON array containing a list of the display parameter values that the OpenID Provider supports. These values are described in Section 3.1.2.1 of OpenID Connect Core 1.0 [OpenID.Core]."
-                    },
-                    claim_types_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/ClaimType"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/ClaimType"
-                        }
-                      ],
-                      description: "OPTIONAL. JSON array containing a list of the Claim Types that the OpenID Provider supports. These Claim Types are described in Section 5.6 of OpenID Connect Core 1.0 [OpenID.Core]. Values defined by this specification are normal, aggregated, and distributed. If omitted, the implementation supports only normal Claims."
-                    },
-                    claims_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ],
-                      description: "RECOMMENDED. JSON array containing a list of the Claim Names of the Claims that the OpenID Provider MAY be able to supply values for. Note that for privacy or other reasons, this might not be an exhaustive list."
-                    },
-                    service_documentation: {
-                      type: "string"
-                    },
-                    claims_locales_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ]
-                    },
-                    ui_locales_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            type: "string"
-                          }
-                        },
-                        {
-                          type: "string"
-                        }
-                      ]
-                    },
-                    claims_parameter_supported: {
-                      type: "boolean"
-                    },
-                    request_parameter_supported: {
-                      type: "boolean"
-                    },
-                    request_uri_parameter_supported: {
-                      type: "boolean"
-                    },
-                    require_request_uri_registration: {
-                      type: "boolean"
-                    },
-                    op_policy_uri: {
-                      type: "string"
-                    },
-                    op_tos_uri: {
-                      type: "string"
-                    },
-                    id_token_types_supported: {
-                      anyOf: [
-                        {
-                          type: "array",
-                          items: {
-                            $ref: "#/components/schemas/IdTokenType"
-                          }
-                        },
-                        {
-                          $ref: "#/components/schemas/IdTokenType"
-                        }
-                      ]
-                    },
-                    vp_formats_supported: {
-                      $ref: "#/components/schemas/Format"
-                    }
-                  }
-                }
-              ]
-            },
-            Schema: {
-              type: "string",
-              enum: ["openid:", "openid-vc:"]
-            },
-            ResponseIss: {
-              type: "string",
-              enum: ["https://self-issued.me", "https://self-issued.me/v2", "https://self-issued.me/v2/openid-vc"]
-            },
-            ResponseType: {
-              type: "string",
-              enum: ["id_token", "vp_token"]
-            },
-            Scope: {
-              type: "string",
-              enum: ["openid", "openid did_authn", "profile", "email", "address", "phone"]
-            },
-            SubjectType: {
-              type: "string",
-              enum: ["public", "pairwise"]
-            },
-            SigningAlgo: {
-              type: "string",
-              enum: ["EdDSA", "RS256", "PS256", "ES256", "ES256K"]
-            },
-            ResponseMode: {
-              type: "string",
-              enum: ["fragment", "form_post", "post", "direct_post", "query"]
-            },
-            GrantType: {
-              type: "string",
-              enum: ["authorization_code", "implicit"]
-            },
-            AuthenticationContextReferences: {
-              type: "string",
-              enum: ["phr", "phrh"]
-            },
-            TokenEndpointAuthMethod: {
-              type: "string",
-              enum: ["client_secret_post", "client_secret_basic", "client_secret_jwt", "private_key_jwt"]
-            },
-            ClaimType: {
-              type: "string",
-              enum: ["normal", "aggregated", "distributed"]
-            },
-            IdTokenType: {
-              type: "string",
-              enum: ["subject_signed", "attester_signed"]
-            }
-          },
-          methods: {
-            ebsiAccessTokenGet: {
-              description: "",
-              arguments: {
-                $ref: "#/components/schemas/EBSIAuthAccessTokenGetArgs"
-              },
-              returnType: {
-                $ref: "#/components/schemas/GetAccessTokenResponse"
-              }
-            },
-            ebsiAuthorizationServerJwks: {
-              description: "",
-              arguments: {
-                $ref: "#/components/schemas/ApiOpts"
-              },
-              returnType: {
-                $ref: "#/components/schemas/GetOIDProviderJwksResponse"
-              }
-            },
-            ebsiPresentationDefinitionGet: {
-              description: "",
-              arguments: {
-                $ref: "#/components/schemas/GetPresentationDefinitionArgs"
-              },
-              returnType: {
-                $ref: "#/components/schemas/GetPresentationDefinitionResponse"
-              }
-            },
-            ebsiWellknownMetadata: {
-              description: "",
-              arguments: {
-                $ref: "#/components/schemas/ApiOpts"
-              },
-              returnType: {
-                $ref: "#/components/schemas/GetOIDProviderMetadataResponse"
-              }
-            }
-          }
-        }
-      }
-    };
-  }
-});
-
-// src/index.ts
-import { Loggers } from "@sphereon/ssi-types";
-
-// src/agent/mDLMdoc.ts
-import { com as com3 } from "@sphereon/kmp-mdoc-core";
-import { calculateJwkThumbprint as calculateJwkThumbprint2 } from "@sphereon/ssi-sdk-ext.key-utils";
-import { getCertificateInfo as getCertificateInfo2, pemOrDerToX509Certificate as pemOrDerToX509Certificate2 } from "@sphereon/ssi-sdk-ext.x509-utils";
-
-// src/functions/index.ts
-import { com } from "@sphereon/kmp-mdoc-core";
-import { calculateJwkThumbprint, globalCrypto, verifyRawSignature } from "@sphereon/ssi-sdk-ext.key-utils";
-import { derToPEM, getCertificateInfo, getSubjectDN, pemOrDerToX509Certificate, validateX509CertificateChain } from "@sphereon/ssi-sdk-ext.x509-utils";
-import * as crypto from "crypto";
-import { CryptoEngine, setEngine } from "pkijs";
-import { fromString } from "uint8arrays/from-string";
-var CoseJoseKeyMappingService = com.sphereon.crypto.CoseJoseKeyMappingService;
-var KeyInfo = com.sphereon.crypto.KeyInfo;
-var DateTimeUtils = com.sphereon.kmp.DateTimeUtils;
-var decodeFrom = com.sphereon.kmp.decodeFrom;
-var encodeTo = com.sphereon.kmp.encodeTo;
-var Encoding = com.sphereon.kmp.Encoding;
-var SignatureAlgorithm = com.sphereon.crypto.generic.SignatureAlgorithm;
-var DefaultCallbacks = com.sphereon.crypto.DefaultCallbacks;
-var CoseCryptoService = class {
-  static {
-    __name(this, "CoseCryptoService");
-  }
-  context;
-  constructor(context) {
-    this.context = context;
-  }
-  setContext(context) {
-    this.context = context;
-  }
-  async signAsync(input, requireX5Chain) {
-    if (!this.context) {
-      throw Error("No context provided. Please provide a context with the setContext method or constructor");
-    }
-    const { keyInfo, alg, value } = input;
-    let kmsKeyRef = keyInfo.kmsKeyRef ?? void 0;
-    if (!kmsKeyRef) {
-      const key = keyInfo.key;
-      if (key == null) {
-        return Promise.reject(Error("No key present in keyInfo. This implementation cannot sign without a key!"));
-      }
-      const resolvedKeyInfo = com.sphereon.crypto.ResolvedKeyInfo.Static.fromKeyInfo(keyInfo, key);
-      const jwkKeyInfo = CoseJoseKeyMappingService.toResolvedJwkKeyInfo(resolvedKeyInfo);
-      const kid = jwkKeyInfo.kid ?? calculateJwkThumbprint({
-        jwk: jwkKeyInfo.key.toJsonDTO()
-      }) ?? jwkKeyInfo.key.getKidAsString(true);
-      if (!kid) {
-        return Promise.reject(Error("No kid present and not kmsKeyRef provided"));
-      }
-      kmsKeyRef = kid;
-    }
-    const result = await this.context.agent.keyManagerSign({
-      algorithm: alg.jose.value,
-      data: encodeTo(value, Encoding.UTF8),
-      encoding: "utf-8",
-      keyRef: kmsKeyRef
-    });
-    return decodeFrom(result, Encoding.UTF8);
-  }
-  async verify1Async(input, keyInfo, requireX5Chain) {
-    const getCertAndKey = /* @__PURE__ */ __name(async (x5c2) => {
-      if (requireX5Chain && (!x5c2 || x5c2.length === 0)) {
-        return Promise.reject(new Error(`No x5chain was present in the CoseSign headers!`));
-      }
-      issuerCert = x5c2 ? pemOrDerToX509Certificate(x5c2[0]) : void 0;
-      let issuerJwk;
-      if (issuerCert) {
-        const info = await getCertificateInfo(issuerCert);
-        issuerJwk = info.publicKeyJWK;
-      }
-      return {
-        issuerCert,
-        issuerJwk
-      };
-    }, "getCertAndKey");
-    const coseKeyInfo = CoseJoseKeyMappingService.toCoseKeyInfo(keyInfo);
-    if (coseKeyInfo?.key?.d) {
-      throw Error("Do not use private keys to verify!");
-    } else if (!input.payload?.value) {
-      return Promise.reject(Error("Signature validation without payload not supported"));
-    }
-    const sign1Json = input.toJson();
-    const coseAlg = sign1Json.protectedHeader.alg;
-    if (!coseAlg) {
-      return Promise.reject(Error("No alg protected header present"));
-    }
-    let issuerCert;
-    let issuerCoseKey;
-    let kid = coseKeyInfo?.kid ?? sign1Json.protectedHeader.kid ?? sign1Json.unprotectedHeader?.kid;
-    const x5c = coseKeyInfo?.key?.getX509CertificateChain() ?? sign1Json.protectedHeader?.x5chain ?? sign1Json.unprotectedHeader?.x5chain;
-    if (!coseKeyInfo || !coseKeyInfo?.key || coseKeyInfo?.key?.x5chain) {
-      const certAndKey = await getCertAndKey(x5c);
-      issuerCoseKey = certAndKey.issuerJwk ? CoseJoseKeyMappingService.toCoseKey(certAndKey.issuerJwk) : void 0;
-      issuerCert = certAndKey.issuerCert;
-    }
-    if (!issuerCoseKey) {
-      if (!coseKeyInfo?.key) {
-        return Promise.reject(Error(`Either a x5c needs to be in the headers, or you need to provide a key for verification`));
-      }
-      if (kid === null) {
-        kid = coseKeyInfo.key.getKidAsString(false);
-      }
-      issuerCoseKey = com.sphereon.crypto.cose.CoseKeyCbor.Static.fromDTO(coseKeyInfo.key);
-    }
-    const issuerCoseKeyInfo = new KeyInfo(kid, issuerCoseKey, coseKeyInfo.opts, coseKeyInfo.keyVisibility, issuerCoseKey.getSignatureAlgorithm() ?? coseKeyInfo.signatureAlgorithm, x5c, coseKeyInfo.kmsKeyRef, coseKeyInfo.kms, coseKeyInfo.keyType ?? issuerCoseKey.getKty());
-    const recalculatedToBeSigned = input.toBeSignedJson(issuerCoseKeyInfo, SignatureAlgorithm.Static.fromCose(coseAlg));
-    const key = CoseJoseKeyMappingService.toJoseJwk(issuerCoseKeyInfo.key).toJsonDTO();
-    const valid = await verifyRawSignature({
-      data: fromString(recalculatedToBeSigned.base64UrlValue, "base64url"),
-      signature: fromString(sign1Json.signature, "base64url"),
-      key
-    });
-    return {
-      name: "mdoc",
-      critical: true,
-      error: !valid,
-      message: `Signature of '${issuerCert ? getSubjectDN(issuerCert).DN : kid}' was ${valid ? "" : "in"}valid`,
-      keyInfo: issuerCoseKeyInfo
-    };
-  }
-  resolvePublicKeyAsync(keyInfo) {
-    if (keyInfo.key) {
-      return Promise.resolve(CoseJoseKeyMappingService.toResolvedKeyInfo(keyInfo, keyInfo.key));
-    }
-    return Promise.reject(Error("No key present in keyInfo. This implementation cannot resolve public keys on its own currently!"));
-  }
-};
-var X509CallbackService = class {
-  static {
-    __name(this, "X509CallbackService");
-  }
-  _trustedCerts;
-  constructor(trustedCerts) {
-    this.setTrustedCerts(trustedCerts);
-  }
-  /**
-  * A more powerful version of the method below. Allows to verify at a specific time and returns more information
-  * @param chain
-  * @param trustAnchors
-  * @param verificationTime
-  */
-  async verifyCertificateChain({ chain, trustAnchors = this.getTrustedCerts(), verificationTime, opts }) {
-    return await validateX509CertificateChain({
-      chain,
-      trustAnchors,
-      verificationTime,
-      opts
-    });
-  }
-  /**
-  * This method is the implementation used within the mDL/Mdoc library
-  */
-  async verifyCertificateChainJS(chainDER, chainPEM, trustedCerts, verificationProfile, verificationTime) {
-    const verificationAt = verificationTime ?? DateTimeUtils.Static.DEFAULT.dateTimeLocal();
-    let chain = [];
-    if (chainDER && chainDER.length > 0) {
-      chain = chainDER.map((der) => Uint8Array.from(der));
-    }
-    if (chainPEM && chainPEM.length > 0) {
-      chain = (chain ?? []).concat(chainPEM);
-    }
-    const result = await validateX509CertificateChain({
-      chain,
-      trustAnchors: trustedCerts ?? this.getTrustedCerts(),
-      verificationTime: new Date(verificationAt.toEpochSeconds().toULong() * 1e3),
-      opts: {
-        trustRootWhenNoAnchors: true
-      }
-    });
-    const cert = result.certificateChain ? result.certificateChain[result.certificateChain.length - 1] : void 0;
-    return {
-      publicKey: cert?.publicKeyJWK,
-      publicKeyAlgorithm: cert?.publicKeyJWK?.alg,
-      name: "x.509",
-      critical: result.critical,
-      message: result.message,
-      error: result.error,
-      verificationTime: verificationAt
-    };
-  }
-  setTrustedCerts = /* @__PURE__ */ __name((trustedCertsInPEM) => {
-    this._trustedCerts = trustedCertsInPEM?.map((cert) => {
-      if (cert.includes("CERTIFICATE")) {
-        return cert;
-      }
-      return derToPEM(cert);
-    });
-  }, "setTrustedCerts");
-  getTrustedCerts = /* @__PURE__ */ __name(() => this._trustedCerts, "getTrustedCerts");
-};
-var defaultCryptoEngine = /* @__PURE__ */ __name(() => {
-  if (typeof self !== "undefined") {
-    if ("crypto" in self) {
-      let engineName = "webcrypto";
-      if ("webkitSubtle" in self.crypto) {
-        engineName = "safari";
-      }
-      setEngine(engineName, new CryptoEngine({
-        name: engineName,
-        crypto
-      }));
-    }
-  } else if (typeof crypto !== "undefined" && "webcrypto" in crypto) {
-    const name = "NodeJS ^15";
-    const nodeCrypto = crypto.webcrypto;
-    setEngine(name, new CryptoEngine({
-      name,
-      crypto: nodeCrypto
-    }));
-  } else {
-    const name = "crypto";
-    setEngine(name, new CryptoEngine({
-      name,
-      crypto: globalCrypto(false)
-    }));
-  }
-}, "defaultCryptoEngine");
-defaultCryptoEngine();
-DefaultCallbacks.setCoseCryptoDefault(new CoseCryptoService());
-DefaultCallbacks.setX509Default(new X509CallbackService());
-
-// src/types/ImDLMdoc.ts
-import { com as com2 } from "@sphereon/kmp-mdoc-core";
-var CborByteString = com2.sphereon.cbor.CborByteString;
-var CoseKeyCbor = com2.sphereon.crypto.cose.CoseKeyCbor;
-var CoseCryptoServiceJS = com2.sphereon.crypto.CoseCryptoServiceJS;
-var CoseJoseKeyMappingService2 = com2.sphereon.crypto.CoseJoseKeyMappingService;
-var KeyInfo2 = com2.sphereon.crypto.KeyInfo;
-var DateTimeUtils2 = com2.sphereon.kmp.DateTimeUtils;
-var decodeFrom2 = com2.sphereon.kmp.decodeFrom;
-var encodeTo2 = com2.sphereon.kmp.encodeTo;
-var Encoding2 = com2.sphereon.kmp.Encoding;
-var MdocValidations = com2.sphereon.mdoc.data.MdocValidations;
-var MdocOid4vpService = com2.sphereon.mdoc.oid4vp.MdocOid4vpServiceJs;
-var Jwk = com2.sphereon.crypto.jose.Jwk;
-var Oid4VPPresentationSubmission = com2.sphereon.mdoc.oid4vp.Oid4VPPresentationSubmission;
-
-// src/agent/mDLMdoc.ts
-var mdocSupportMethods = [
-  "x509VerifyCertificateChain",
-  "x509GetCertificateInfo",
-  "mdocVerifyIssuerSigned",
-  "mdocOid4vpHolderPresent",
-  "mdocOid4vpRPVerify"
-];
-var MDLMdoc = class {
-  static {
-    __name(this, "MDLMdoc");
-  }
-  schema = schema.IMDLMdoc;
-  methods = {
-    x509VerifyCertificateChain: this.x509VerifyCertificateChain.bind(this),
-    x509GetCertificateInfo: this.x509GetCertificateInfo.bind(this),
-    mdocVerifyIssuerSigned: this.mdocVerifyIssuerSigned.bind(this),
-    mdocOid4vpHolderPresent: this.mdocOid4vpHolderPresent.bind(this),
-    mdocOid4vpRPVerify: this.mdocOid4vpRPVerify.bind(this)
-  };
-  trustAnchors;
-  opts;
-  constructor(args) {
-    this.trustAnchors = args?.trustAnchors ?? [];
-    this.opts = args?.opts ?? {
-      trustRootWhenNoAnchors: true
-    };
-  }
-  /**
-  * Processes and verifies the provided mdoc, generates device response and presentation submission tokens.
-  *
-  * @param {MdocOid4vpPresentArgs} args - An object containing arguments for mdoc oid4vp holder presentation.
-  * @param {IRequiredContext} _context - Required context for the operation.
-  * @return {Promise<MdocOid4VPPresentationAuth>} A promise that resolves to an object containing vp_token and presentation_submission.
-  */
-  async mdocOid4vpHolderPresent(args, _context) {
-    const { mdocs, presentationDefinition, trustAnchors, verifications, mdocHolderNonce, authorizationRequestNonce, responseUri, clientId } = args;
-    const oid4vpService = new MdocOid4vpService();
-    const validate = /* @__PURE__ */ __name(async (mdoc) => {
-      try {
-        const result = await MdocValidations.fromDocumentAsync(mdoc, null, trustAnchors ?? this.trustAnchors, DateTimeUtils2.Static.DEFAULT.dateTimeLocal((verifications?.verificationTime?.getTime() ?? Date.now()) / 1e3), verifications?.allowExpiredDocuments);
-        if (result.error) {
-          console.log(JSON.stringify(result, null, 2));
-        }
-        return result;
-      } catch (e) {
-        console.log(e);
-        return {
-          error: true,
-          verifications: [
-            {
-              name: "mdoc",
-              error: true,
-              critical: true,
-              message: e.message
-            }
-          ]
-        };
-      }
-    }, "validate");
-    const allMatches = oid4vpService.matchDocumentsAndDescriptors(mdocHolderNonce, mdocs, presentationDefinition);
-    const docsAndDescriptors = [];
-    let lastError = void 0;
-    for (let match of allMatches) {
-      if (match.document) {
-        const result = await validate(match.document);
-        if (!result.error || responseUri.includes("openid.net")) {
-          try {
-            const cborKey = result.keyInfo?.key ? CoseKeyCbor.Static.fromDTO(result.keyInfo.key) : void 0;
-            if (!cborKey) {
-              throw Error("No key found in result");
-            }
-            let jwk = CoseJoseKeyMappingService2.toJoseJwk(cborKey).toJsonDTO();
-            if (!result.keyInfo?.kmsKeyRef) {
-              const keyInfo = result.keyInfo;
-              const kid = jwk.kid ?? calculateJwkThumbprint2({
-                jwk
-              });
-              const key = await _context.agent.keyManagerGet({
-                kid
-              });
-              const kms = key.kms;
-              const kmsKeyRef = key.meta?.kmsKeyRef;
-              const updateCborKey = cborKey.copy(false, cborKey.kty, cborKey.kid ?? new CborByteString(decodeFrom2(kid, Encoding2.UTF8)));
-              const deviceKeyInfo = KeyInfo2.Static.fromDTO(keyInfo).copy(kid, updateCborKey, keyInfo.opts, keyInfo.keyVisibility, keyInfo.signatureAlgorithm, keyInfo.x5c, kmsKeyRef, kms);
-              const updateMatch = match.copy(match.inputDescriptor, match.document, match.documentError, deviceKeyInfo);
-              match = updateMatch;
-            }
-          } catch (e) {
-            console.log(`We tied to ammend key info from the KMS, but failed. Potential trouble ahead ${e.message}`, e);
-          }
-          docsAndDescriptors.push(match);
-        } else if (result.error) {
-          lastError = result;
-        }
-      }
-    }
-    if (docsAndDescriptors.length === 0) {
-      if (lastError) {
-        return Promise.reject(Error(lastError.verifications[0].message ?? "No matching documents found"));
-      }
-      return Promise.reject(Error("No matching documents found"));
-    }
-    const deviceResponse = await oid4vpService.createDeviceResponse(docsAndDescriptors, presentationDefinition, clientId, responseUri, authorizationRequestNonce);
-    const vp_token = encodeTo2(deviceResponse.cborEncode(), Encoding2.BASE64URL);
-    const presentation_submission = Oid4VPPresentationSubmission.Static.fromPresentationDefinition(presentationDefinition);
-    return {
-      vp_token,
-      presentation_submission
-    };
-  }
-  /**
-  * Verifies on the Relying Party (RP) side for mdoc (mobile document) OIDC4VP (OpenID Connect for Verifiable Presentations).
-  *
-  * @param {MdocOid4vpRPVerifyArgs} args - The arguments required for verification, including the vp_token, presentation_submission, and trustAnchors.
-  * @param {IRequiredContext} _context - The required context for this method.
-  * @return {Promise<MdocOid4vpRPVerifyResult>} - A promise that resolves to an object containing error status,
-  * validated documents, and the original presentation submission.
-  */
-  async mdocOid4vpRPVerify(args, _context) {
-    const { vp_token, presentation_submission, trustAnchors } = args;
-    const deviceResponse = com3.sphereon.mdoc.data.device.DeviceResponseCbor.Static.cborDecode(decodeFrom2(vp_token, Encoding2.BASE64URL));
-    if (!deviceResponse.documents) {
-      return Promise.reject(Error(`No documents found in vp_token`));
-    }
-    let error = false;
-    const documents = await Promise.all(deviceResponse.documents.map(async (document) => {
-      try {
-        const validations = await MdocValidations.fromDocumentAsync(document, null, trustAnchors ?? this.trustAnchors);
-        if (!validations || validations.error) {
-          error = true;
-        }
-        if (presentation_submission.descriptor_map.find((m) => m.id === document.docType.value) === null) {
-          error = true;
-          validations.verifications.push({
-            name: "mdoc",
-            error,
-            critical: error,
-            message: `No descriptor map id with document type ${document.docType.value} present`
-          });
-        }
-        return {
-          document: document.toJson(),
-          validations
-        };
-      } catch (e) {
-        error = true;
-        return {
-          document: document.toJson(),
-          validations: {
-            error: true,
-            verifications: [
-              {
-                name: "mdoc",
-                error,
-                critical: true,
-                message: e.message
-              }
-            ]
-          }
-        };
-      }
-    }));
-    if (error) {
-      console.log(JSON.stringify(documents, null, 2));
-    }
-    return {
-      error,
-      documents,
-      presentation_submission
-    };
-  }
-  /**
-  * Verifies the issuer-signed Mobile Document (mDoc) using the provided arguments and context.
-  *
-  * @param {MdocVerifyIssuerSignedArgs} args - The arguments required for verification, including input and key information.
-  * @param {IRequiredContext} context - The context encompassing necessary dependencies and configurations.
-  * @return {Promise<IVerifySignatureResult<KeyType>>} A promise that resolves to the result of the signature verification, including key information if available.
-  */
-  async mdocVerifyIssuerSigned(args, context) {
-    const { input, keyInfo, requireX5Chain } = args;
-    const coseKeyInfo = keyInfo && CoseJoseKeyMappingService2.toCoseKeyInfo(keyInfo);
-    const verification = await new CoseCryptoServiceJS(new CoseCryptoService(context)).verify1(com3.sphereon.crypto.cose.CoseSign1Json.Static.fromDTO(input).toCbor(), coseKeyInfo, requireX5Chain);
-    return {
-      ...verification,
-      keyInfo
-    };
-  }
-  /**
-  * Verifies an X.509 certificate chain against a set of trust anchors.
-  *
-  * @param {VerifyCertificateChainArgs} args - The arguments required for verifying the certificate chain.
-  * This includes the certificate chain to be verified and any additional trust anchors to be used.
-  * @param {IRequiredContext} _context - The context required for verification, including necessary dependencies and settings.
-  * @return {Promise<X509ValidationResult>} A promise that resolves to the result of the validation process, indicating the success or failure of the certificate chain verification.
-  */
-  async x509VerifyCertificateChain(args, _context) {
-    const mergedAnchors = [
-      ...this.trustAnchors,
-      ...args.trustAnchors ?? []
-    ];
-    const trustAnchors = new Set(mergedAnchors);
-    const validationResult = await new X509CallbackService(Array.from(mergedAnchors)).verifyCertificateChain({
-      ...args,
-      trustAnchors: Array.from(trustAnchors),
-      opts: {
-        ...args?.opts,
-        ...this.opts
-      }
-    });
-    console.log(`x509 validation for ${validationResult.error ? "Error" : "Success"}. message: ${validationResult.message}, details: ${validationResult.detailMessage}`);
-    return validationResult;
-  }
-  /**
-  * Extracts information from a list of X509 certificates.
-  *
-  * @param {GetX509CertificateInfoArgs} args - Arguments required to retrieve certificate information,
-  * including the certificates and optional Subject Alternative Name (SAN) type filter.
-  * @param {IRequiredContext} context - The context required for the operation, which may include
-  * logging, configuration, and other operational details.
-  * @return {Promise<CertificateInfo[]>} A promise that resolves with an array of certificate
-  * information objects, each containing details extracted from individual certificates.
-  */
-  async x509GetCertificateInfo(args, context) {
-    const certificates = args.certificates.map((cert) => pemOrDerToX509Certificate2(cert));
-    return await Promise.all(certificates.map((cert) => getCertificateInfo2(cert, args.sanTypeFilter && {
-      sanTypeFilter: args.sanTypeFilter
-    })));
-  }
-};
-
-// src/index.ts
-var logger = Loggers.DEFAULT.get("sphereon:mdoc");
-var schema = require_plugin_schema();
-export {
-  CborByteString,
-  CoseCryptoService,
-  CoseCryptoServiceJS,
-  CoseJoseKeyMappingService2 as CoseJoseKeyMappingService,
-  CoseKeyCbor,
-  DateTimeUtils2 as DateTimeUtils,
-  Encoding2 as Encoding,
-  Jwk,
-  KeyInfo2 as KeyInfo,
-  MDLMdoc,
-  MdocOid4vpService,
-  MdocValidations,
-  Oid4VPPresentationSubmission,
-  X509CallbackService,
-  decodeFrom2 as decodeFrom,
-  encodeTo2 as encodeTo,
-  logger,
-  mdocSupportMethods,
-  schema
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mdocSupportMethods = exports.MDLMdoc = exports.schema = exports.logger = void 0;
+const ssi_types_1 = require("@sphereon/ssi-types");
+exports.logger = ssi_types_1.Loggers.DEFAULT.get('sphereon:mdoc');
+const schema = require('../plugin.schema.json');
+exports.schema = schema;
+var mDLMdoc_1 = require("./agent/mDLMdoc");
+Object.defineProperty(exports, "MDLMdoc", { enumerable: true, get: function () { return mDLMdoc_1.MDLMdoc; } });
+Object.defineProperty(exports, "mdocSupportMethods", { enumerable: true, get: function () { return mDLMdoc_1.mdocSupportMethods; } });
+__exportStar(require("./types/ImDLMdoc"), exports);
+__exportStar(require("./functions"), exports);
 //# sourceMappingURL=index.js.map