@twin.org/identity-service 0.0.1-next.8 → 0.0.1

package/dist/cjs/index.cjs

@@ -1,13 +1,17 @@
 'use strict';
 
+var apiModels = require('@twin.org/api-models');
 var core = require('@twin.org/core');
 var web = require('@twin.org/web');
 var identityModels = require('@twin.org/identity-models');
+var standardsW3cDid = require('@twin.org/standards-w3c-did');
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
 /**
  * The source used when communicating about these routes.
  */
-const ROUTES_SOURCE$1 = "identityProfileRoutes";
+const ROUTES_SOURCE$2 = "identityProfileRoutes";
 /**
  * The tag to associate with the routes.
  */
@@ -39,13 +43,13 @@ function generateRestRoutesIdentityProfile(baseRouteName, componentName) {
                     request: {
                         body: {
                             publicProfile: {
-                                "@context": "http://schema.org/",
+                                "@context": "https://schema.org",
                                 "@type": "Person",
                                 jobTitle: "Professor",
                                 name: "Jane Doe"
                             },
                             privateProfile: {
-                                "@context": "http://schema.org/",
+                                "@context": "https://schema.org",
                                 "@type": "Person",
                                 telephone: "(425) 123-4567",
                                 url: "http://www.janedoe.com"
@@ -94,7 +98,7 @@ function generateRestRoutesIdentityProfile(baseRouteName, componentName) {
                             body: {
                                 identity: "did:iota:tst:0xc57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
                                 publicProfile: {
-                                    "@context": "http://schema.org/",
+                                    "@context": "https://schema.org",
                                     "@type": "Person",
                                     jobTitle: "Professor",
                                     name: "Jane Doe"
@@ -144,7 +148,7 @@ function generateRestRoutesIdentityProfile(baseRouteName, componentName) {
                                 [web.HeaderTypes.ContentType]: web.MimeTypes.JsonLd
                             },
                             body: {
-                                "@context": "http://schema.org/",
+                                "@context": "https://schema.org",
                                 "@type": "Person",
                                 jobTitle: "Professor",
                                 name: "Jane Doe"
@@ -174,13 +178,13 @@ function generateRestRoutesIdentityProfile(baseRouteName, componentName) {
                     request: {
                         body: {
                             publicProfile: {
-                                "@context": "http://schema.org/",
+                                "@context": "https://schema.org",
                                 "@type": "Person",
                                 jobTitle: "Professor",
                                 name: "Jane Doe"
                             },
                             privateProfile: {
-                                "@context": "http://schema.org/",
+                                "@context": "https://schema.org",
                                 "@type": "Person",
                                 telephone: "(425) 123-4567",
                                 url: "http://www.janedoe.com"
@@ -253,7 +257,7 @@ function generateRestRoutesIdentityProfile(baseRouteName, componentName) {
                                     {
                                         identity: "did:iota:tst:0xc57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
                                         publicProfile: {
-                                            "@context": "http://schema.org/",
+                                            "@context": "https://schema.org",
                                             "@type": "Person",
                                             jobTitle: "Professor",
                                             name: "Jane Doe"
@@ -285,8 +289,8 @@ function generateRestRoutesIdentityProfile(baseRouteName, componentName) {
  * @returns The response object with additional http response properties.
  */
 async function identityProfileCreate(httpRequestContext, componentName, request) {
-    core.Guards.object(ROUTES_SOURCE$1, "request", request);
-    core.Guards.object(ROUTES_SOURCE$1, "request.body", request.body);
+    core.Guards.object(ROUTES_SOURCE$2, "request", request);
+    core.Guards.object(ROUTES_SOURCE$2, "request.body", request.body);
     const component = core.ComponentFactory.get(componentName);
     await component.create(request.body.publicProfile, request.body.privateProfile, httpRequestContext.userIdentity);
     return {
@@ -301,9 +305,9 @@ async function identityProfileCreate(httpRequestContext, componentName, request)
  * @returns The response object with additional http response properties.
  */
 async function identityGet(httpRequestContext, componentName, request) {
-    core.Guards.object(ROUTES_SOURCE$1, "request", request);
+    core.Guards.object(ROUTES_SOURCE$2, "request", request);
     const component = core.ComponentFactory.get(componentName);
-    const result = await component.get(request?.query?.publicPropertyNames?.split(","), request?.query?.privatePropertyNames?.split(","), httpRequestContext.userIdentity);
+    const result = await component.get(apiModels.HttpParameterHelper.arrayFromString(request?.query?.publicPropertyNames), apiModels.HttpParameterHelper.arrayFromString(request?.query?.privatePropertyNames), httpRequestContext.userIdentity);
     return {
         body: result
     };
@@ -316,10 +320,10 @@ async function identityGet(httpRequestContext, componentName, request) {
  * @returns The response object with additional http response properties.
  */
 async function identityGetPublic(httpRequestContext, componentName, request) {
-    core.Guards.object(ROUTES_SOURCE$1, "request", request);
-    core.Guards.stringValue(ROUTES_SOURCE$1, "request.pathParams.identity", request.pathParams?.identity);
+    core.Guards.object(ROUTES_SOURCE$2, "request", request);
+    core.Guards.stringValue(ROUTES_SOURCE$2, "request.pathParams.identity", request.pathParams?.identity);
     const component = core.ComponentFactory.get(componentName);
-    const result = await component.getPublic(request?.pathParams.identity, request?.query?.propertyNames?.split(","));
+    const result = await component.getPublic(request?.pathParams.identity, apiModels.HttpParameterHelper.arrayFromString(request?.query?.propertyNames));
     return {
         headers: {
             [web.HeaderTypes.ContentType]: web.MimeTypes.JsonLd
@@ -335,8 +339,8 @@ async function identityGetPublic(httpRequestContext, componentName, request) {
  * @returns The response object with additional http response properties.
  */
 async function identityProfileUpdate(httpRequestContext, componentName, request) {
-    core.Guards.object(ROUTES_SOURCE$1, "request", request);
-    core.Guards.object(ROUTES_SOURCE$1, "request.body", request.body);
+    core.Guards.object(ROUTES_SOURCE$2, "request", request);
+    core.Guards.object(ROUTES_SOURCE$2, "request.body", request.body);
     const component = core.ComponentFactory.get(componentName);
     await component.update(request.body.publicProfile, request.body.privateProfile, httpRequestContext.userIdentity);
     return {
@@ -366,8 +370,8 @@ async function identityProfileRemove(httpRequestContext, componentName, request)
  */
 async function identitiesList(httpRequestContext, componentName, request) {
     const component = core.ComponentFactory.get(componentName);
-    const publicFilterPairs = request?.query?.publicFilters?.split(",") ?? [];
-    const publicFilters = publicFilterPairs.map(pair => {
+    const publicFilterPairs = apiModels.HttpParameterHelper.arrayFromString(request?.query?.publicFilters);
+    const publicFilters = publicFilterPairs?.map(pair => {
         const parts = pair.split(":");
         return {
             propertyName: parts[0],
@@ -375,7 +379,7 @@ async function identitiesList(httpRequestContext, componentName, request) {
         };
     });
     return {
-        body: await component.list(publicFilters, request?.query?.publicPropertyNames?.split(","), request?.query?.cursor, core.Coerce.number(request.query?.pageSize))
+        body: await component.list(publicFilters, apiModels.HttpParameterHelper.arrayFromString(request?.query?.publicPropertyNames), request?.query?.cursor, core.Coerce.integer(request.query?.pageSize))
     };
 }
 
@@ -385,6 +389,10 @@ async function identitiesList(httpRequestContext, componentName, request) {
  * Class which implements the identity profile contract.
  */
 class IdentityProfileService {
+    /**
+     * The namespace supported by the identity profile service.
+     */
+    static NAMESPACE = "identity-profile";
     /**
      * Runtime name for the class.
      */
@@ -397,7 +405,6 @@ class IdentityProfileService {
     /**
      * Create a new instance of IdentityProfileService.
      * @param options The dependencies for the identity profile service.
-     * @param options.profileEntityConnectorType The storage connector for the profiles, default to "identity-profile".
      */
     constructor(options) {
         this._identityProfileConnector = identityModels.IdentityProfileConnectorFactory.get(options?.profileEntityConnectorType ?? "identity-profile");
@@ -537,11 +544,11 @@ class IdentityProfileService {
 /**
  * The source used when communicating about these routes.
  */
-const ROUTES_SOURCE = "identityRoutes";
+const ROUTES_SOURCE$1 = "identityResolverRoutes";
 /**
  * The tag to associate with the routes.
  */
-const tagsIdentity = [
+const tagsIdentityResolver = [
     {
         name: "Identity",
         description: "Service to provide all features related to digital identity."
@@ -553,13 +560,13 @@ const tagsIdentity = [
  * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
  * @returns The generated routes.
  */
-function generateRestRoutesIdentity(baseRouteName, componentName) {
+function generateRestRoutesIdentityResolver(baseRouteName, componentName) {
     const identityResolveRoute = {
         operationId: "identityResolve",
         summary: "Resolve an identity",
-        tag: tagsIdentity[0].name,
+        tag: tagsIdentityResolver[0].name,
         method: "GET",
-        path: `${baseRouteName}/:id`,
+        path: `${baseRouteName}/:identity`,
         handler: async (httpRequestContext, request) => identityResolve(httpRequestContext, componentName, request),
         requestType: {
             type: "IIdentityResolveRequest",
@@ -568,7 +575,7 @@ function generateRestRoutesIdentity(baseRouteName, componentName) {
                     id: "identityResolveRequestExample",
                     request: {
                         pathParams: {
-                            id: "did:iota:tst:0xe3088ba9aa8c28e1d139708a14e8c0fdff11ee8223baac4aa5bcf3321e4bfc6a"
+                            identity: "did:iota:tst:0xe3088ba9aa8c28e1d139708a14e8c0fdff11ee8223baac4aa5bcf3321e4bfc6a"
                         }
                     }
                 }
@@ -582,6 +589,7 @@ function generateRestRoutesIdentity(baseRouteName, componentName) {
                         id: "identityResolveResponseExample",
                         response: {
                             body: {
+                                "@context": standardsW3cDid.DidContexts.Context,
                                 id: "did:iota:tst:0xe3088ba9aa8c28e1d139708a14e8c0fdff11ee8223baac4aa5bcf3321e4bfc6a",
                                 service: [
                                     {
@@ -608,10 +616,11 @@ function generateRestRoutesIdentity(baseRouteName, componentName) {
  * @returns The response object with additional http response properties.
  */
 async function identityResolve(httpRequestContext, componentName, request) {
-    core.Guards.object(ROUTES_SOURCE, "request", request);
-    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    core.Guards.object(ROUTES_SOURCE$1, "request", request);
+    core.Guards.object(ROUTES_SOURCE$1, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE$1, "request.pathParams.identity", request.pathParams.identity);
     const component = core.ComponentFactory.get(componentName);
-    const result = await component.resolve(request.pathParams.id);
+    const result = await component.identityResolve(request.pathParams.identity);
     return {
         body: result
     };
@@ -620,43 +629,76 @@ async function identityResolve(httpRequestContext, componentName, request) {
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
- * Class which implements the identity contract.
+ * Class which implements the identity resolver contract.
  */
-class IdentityService {
+class IdentityResolverService {
     /**
      * The namespace supported by the identity service.
      */
-    static NAMESPACE = "did";
+    static NAMESPACE = "identity-resolver";
     /**
      * Runtime name for the class.
      */
-    CLASS_NAME = "IdentityService";
+    CLASS_NAME = "IdentityResolverService";
     /**
-     * Create a new instance of IdentityService.
+     * The default namespace for the connector to use.
+     * @internal
+     */
+    _defaultNamespace;
+    /**
+     * Fallback connector type to use if the namespace connector is not available.
+     * @internal
+     */
+    _fallbackResolverConnectorType;
+    /**
+     * Create a new instance of IdentityResolverService.
      * @param options The options for the service.
-     * @param options.config The configuration for the service.
      */
     constructor(options) {
-        const names = identityModels.IdentityConnectorFactory.names();
+        const names = identityModels.IdentityResolverConnectorFactory.names();
         if (names.length === 0) {
             throw new core.GeneralError(this.CLASS_NAME, "noConnectors");
         }
+        this._defaultNamespace = options?.config?.defaultNamespace ?? names[0];
+        this._fallbackResolverConnectorType = options?.fallbackResolverConnectorType ?? "universal";
     }
     /**
      * Resolve an identity.
-     * @param documentId The id of the document to resolve.
+     * @param identity The id of the document to resolve.
      * @returns The resolved document.
      */
-    async resolve(documentId) {
-        core.Urn.guard(this.CLASS_NAME, "documentId", documentId);
+    async identityResolve(identity) {
+        core.Urn.guard(this.CLASS_NAME, "identity", identity);
         try {
-            const identityConnector = this.getConnector(documentId);
-            const document = await identityConnector.resolveDocument(documentId);
+            const identityResolverConnector = this.getConnectorByUri(identity);
+            const document = await identityResolverConnector.resolveDocument(identity);
             return document;
         }
         catch (error) {
-            throw new core.GeneralError(this.CLASS_NAME, "resolveFailed", undefined, error);
+            throw new core.GeneralError(this.CLASS_NAME, "identityResolveFailed", {
+                identity
+            }, error);
+        }
+    }
+    /**
+     * Get the connector from the namespace.
+     * @param namespace The namespace for the identity.
+     * @returns The connector.
+     * @internal
+     */
+    getConnectorByNamespace(namespace) {
+        const namespaceMethod = namespace ?? this._defaultNamespace;
+        let connector = identityModels.IdentityResolverConnectorFactory.getIfExists(namespaceMethod);
+        if (core.Is.empty(connector)) {
+            // Let's see if a fallback 'universal' connector is registered
+            connector = identityModels.IdentityResolverConnectorFactory.getIfExists(this._fallbackResolverConnectorType);
+            if (core.Is.empty(connector)) {
+                throw new core.GeneralError(this.CLASS_NAME, "connectorNotFound", {
+                    namespace: namespaceMethod
+                });
+            }
         }
+        return connector;
     }
     /**
      * Get the connector from the uri.
@@ -664,19 +706,1329 @@ class IdentityService {
      * @returns The connector.
      * @internal
      */
-    getConnector(id) {
+    getConnectorByUri(id) {
         const idUri = core.Urn.fromValidString(id);
-        if (idUri.namespaceIdentifier() !== IdentityService.NAMESPACE) {
+        if (idUri.namespaceIdentifier() !== "did") {
             throw new core.GeneralError(this.CLASS_NAME, "namespaceMismatch", {
-                namespace: IdentityService.NAMESPACE,
+                namespace: "did",
                 id
             });
         }
-        return identityModels.IdentityConnectorFactory.get(idUri.namespaceMethod());
+        return this.getConnectorByNamespace(idUri.namespaceMethod());
     }
 }
 
-const restEntryPoints = [
+/**
+ * The source used when communicating about these routes.
+ */
+const ROUTES_SOURCE = "identityRoutes";
+/**
+ * The tag to associate with the routes.
+ */
+const tagsIdentity = [
+    {
+        name: "Identity",
+        description: "Service to provide all features related to digital identity."
+    }
+];
+/**
+ * The REST routes for identity.
+ * @param baseRouteName Prefix to prepend to the paths.
+ * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
+ * @returns The generated routes.
+ */
+function generateRestRoutesIdentity(baseRouteName, componentName) {
+    const identityCreateRoute = {
+        operationId: "identityCreate",
+        summary: "Create an identity",
+        tag: tagsIdentity[0].name,
+        method: "POST",
+        path: `${baseRouteName}/`,
+        handler: async (httpRequestContext, request) => identityCreate(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IIdentityCreateRequest",
+            examples: [
+                {
+                    id: "identityCreateRequestExample",
+                    request: {}
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IIdentityCreateResponse",
+                examples: [
+                    {
+                        id: "identityCreateResponseExample",
+                        response: {
+                            body: {
+                                "@context": standardsW3cDid.DidContexts.Context,
+                                id: "did:iota:tst:0xe3088ba9aa8c28e1d139708a14e8c0fdff11ee8223baac4aa5bcf3321e4bfc6a",
+                                service: [
+                                    {
+                                        id: "did:iota:tst:0xe3088ba9aa8c28e1d139708a14e8c0fdff11ee8223baac4aa5bcf3321e4bfc6a#revocation",
+                                        type: "RevocationBitmap2022",
+                                        serviceEndpoint: "data:application/octet-stream;base64,eJyzMmAAAwABr"
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const identityRemoveRoute = {
+        operationId: "identityRemove",
+        summary: "Remove an identity",
+        tag: tagsIdentity[0].name,
+        method: "DELETE",
+        path: `${baseRouteName}/:identity`,
+        handler: async (httpRequestContext, request) => identityRemove(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IIdentityRemoveRequest",
+            examples: [
+                {
+                    id: "identityRemoveRequestExample",
+                    request: {
+                        pathParams: {
+                            identity: "did:iota:tst:0xe3088ba9aa8c28e1d139708a14e8c0fdff11ee8223baac4aa5bcf3321e4bfc6a"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "INoContentResponse"
+            }
+        ]
+    };
+    const identityVerificationMethodCreateRoute = {
+        operationId: "identityVerificationMethodCreate",
+        summary: "Create an identity verification method",
+        tag: tagsIdentity[0].name,
+        method: "POST",
+        path: `${baseRouteName}/:identity/verification-method`,
+        handler: async (httpRequestContext, request) => identityVerificationMethodCreate(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IIdentityVerificationMethodCreateRequest",
+            examples: [
+                {
+                    id: "identityVerificationMethodCreateRequestExample",
+                    request: {
+                        pathParams: {
+                            identity: "did:iota:tst:0xe3088ba9aa8c28e1d139708a14e8c0fdff11ee8223baac4aa5bcf3321e4bfc6a"
+                        },
+                        body: {
+                            verificationMethodType: "assertionMethod",
+                            verificationMethodId: "my-assertion"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IIdentityVerificationMethodCreateResponse",
+                examples: [
+                    {
+                        id: "identityVerificationMethodCreateResponseExample",
+                        response: {
+                            body: {
+                                id: "did:iota:tst:0x70ce5abe69e7c56dd69684dd6da65812b9758b03a0081331ca560b34d73d5ff0#my-assertion",
+                                controller: "did:iota:tst:0x70ce5abe69e7c56dd69684dd6da65812b9758b03a0081331ca560b34d73d5ff0",
+                                type: "JsonWebKey2020",
+                                publicKeyJwk: {
+                                    kty: "OKP",
+                                    alg: "EdDSA",
+                                    kid: "f_fj3rGsZFSYvnS_xv5MgyIBlExq-lgDciu0YQ--S3s",
+                                    crv: "Ed25519",
+                                    x: "SFm32z7y9C17olpaTeocG25WV2CNTUl5MhM679Z4bok"
+                                }
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const identityVerificationMethodRemoveRoute = {
+        operationId: "identityVerificationMethodRemove",
+        summary: "Remove an identity verification method",
+        tag: tagsIdentity[0].name,
+        method: "DELETE",
+        path: `${baseRouteName}/:identity/verification-method/:verificationMethodId`,
+        handler: async (httpRequestContext, request) => identityVerificationMethodRemove(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IIdentityVerificationMethodRemoveRequest",
+            examples: [
+                {
+                    id: "identityVerificationMethodRemoveRequestExample",
+                    request: {
+                        pathParams: {
+                            identity: "did:iota:tst:0xe3088ba9aa8c28e1d139708a14e8c0fdff11ee8223baac4aa5bcf3321e4bfc6a",
+                            verificationMethodId: "my-assertion"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "INoContentResponse",
+                examples: [
+                    {
+                        id: "identityVerificationMethodCreateResponseExample",
+                        response: {
+                            statusCode: web.HttpStatusCode.noContent
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const identityServiceCreateRoute = {
+        operationId: "identityServiceCreate",
+        summary: "Create an identity service",
+        tag: tagsIdentity[0].name,
+        method: "POST",
+        path: `${baseRouteName}/:identity/service`,
+        handler: async (httpRequestContext, request) => identityServiceCreate(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IIdentityServiceCreateRequest",
+            examples: [
+                {
+                    id: "identityServiceCreateRequestExample",
+                    request: {
+                        pathParams: {
+                            identity: "did:iota:tst:0xe3088ba9aa8c28e1d139708a14e8c0fdff11ee8223baac4aa5bcf3321e4bfc6a"
+                        },
+                        body: {
+                            serviceId: "did:example:123#linked-domain",
+                            type: "LinkedDomains",
+                            endpoint: "https://bar.example.com"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IIdentityServiceCreateResponse",
+                examples: [
+                    {
+                        id: "identityServiceCreateResponseExample",
+                        response: {
+                            body: {
+                                id: "did:example:123#linked-domain",
+                                type: "LinkedDomains",
+                                serviceEndpoint: "https://bar.example.com"
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const identityServiceRemoveRoute = {
+        operationId: "identityServiceRemove",
+        summary: "Remove an identity service",
+        tag: tagsIdentity[0].name,
+        method: "DELETE",
+        path: `${baseRouteName}/:identity/service/:serviceId`,
+        handler: async (httpRequestContext, request) => identityServiceRemove(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IIdentityServiceRemoveRequest",
+            examples: [
+                {
+                    id: "identityServiceRemoveRequestExample",
+                    request: {
+                        pathParams: {
+                            identity: "did:iota:tst:0xe3088ba9aa8c28e1d139708a14e8c0fdff11ee8223baac4aa5bcf3321e4bfc6a",
+                            serviceId: "did:example:123#linked-domain"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "INoContentResponse",
+                examples: [
+                    {
+                        id: "identityServiceCreateResponseExample",
+                        response: {
+                            statusCode: web.HttpStatusCode.noContent
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const identityVerifiableCredentialCreateRoute = {
+        operationId: "identityVerifiableCredentialCreate",
+        summary: "Create an identity verifiable credential",
+        tag: tagsIdentity[0].name,
+        method: "POST",
+        path: `${baseRouteName}/:identity/verifiable-credential`,
+        handler: async (httpRequestContext, request) => identityVerifiableCredentialCreate(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IIdentityVerifiableCredentialCreateRequest",
+            examples: [
+                {
+                    id: "identityVerifiableCredentialCreateRequestExample",
+                    request: {
+                        pathParams: {
+                            identity: "did:entity-storage:0x879c31386f992cfa29b77fe31e37256d69f6a57653cee4eb60ad4c4613c5515a",
+                            verificationMethodId: "my-assertion"
+                        },
+                        body: {
+                            credentialId: "https://example.com/credentials/3732",
+                            subject: {
+                                "@context": "https://schema.org",
+                                "@type": "Person",
+                                id: "did:entity-storage:0x4757993355b921a8229bd780f30921b6a0216a72e6c3f37a09d13b8426a17def",
+                                name: "Jane Doe"
+                            },
+                            revocationIndex: 5
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IIdentityVerifiableCredentialCreateResponse",
+                examples: [
+                    {
+                        id: "identityVerifiableCredentialCreateResponseExample",
+                        response: {
+                            body: {
+                                verifiableCredential: {
+                                    "@context": ["https://www.w3.org/ns/credentials/v2", "https://schema.org"],
+                                    id: "https://example.com/credentials/3732",
+                                    type: ["VerifiableCredential", "Person"],
+                                    credentialSubject: {
+                                        id: "did:entity-storage:0x4757993355b921a8229bd780f30921b6a0216a72e6c3f37a09d13b8426a17def",
+                                        name: "Jane Doe"
+                                    },
+                                    issuer: "did:entity-storage:0x879c31386f992cfa29b77fe31e37256d69f6a57653cee4eb60ad4c4613c5515a",
+                                    issuanceDate: "2025-01-24T09:21:51.500Z",
+                                    credentialStatus: {
+                                        id: "did:entity-storage:0x879c31386f992cfa29b77fe31e37256d69f6a57653cee4eb60ad4c4613c5515a#revocation",
+                                        type: "BitstringStatusList",
+                                        revocationBitmapIndex: "5"
+                                    }
+                                },
+                                jwt: "eyJraWQiOi...D1Z3AQ"
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const identityVerifiableCredentialVerifyRoute = {
+        operationId: "identityVerifiableCredentialVerify",
+        summary: "Verify an identity verifiable credential",
+        tag: tagsIdentity[0].name,
+        method: "GET",
+        path: `${baseRouteName}/verifiable-credential/verify`,
+        handler: async (httpRequestContext, request) => identityVerifiableCredentialVerify(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IIdentityVerifiableCredentialVerifyRequest",
+            examples: [
+                {
+                    id: "identityVerifiableCredentialVerifyRequestExample",
+                    request: {
+                        query: {
+                            jwt: "eyJraWQiOi...D1Z3AQ"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IIdentityVerifiableCredentialVerifyResponse",
+                examples: [
+                    {
+                        id: "identityVerifiableCredentialVerifyResponseExample",
+                        response: {
+                            body: {
+                                revoked: false,
+                                verifiableCredential: {
+                                    "@context": ["https://www.w3.org/ns/credentials/v2", "https://schema.org"],
+                                    id: "https://example.com/credentials/3732",
+                                    type: ["VerifiableCredential", "Person"],
+                                    credentialSubject: {
+                                        id: "did:entity-storage:0x4757993355b921a8229bd780f30921b6a0216a72e6c3f37a09d13b8426a17def",
+                                        name: "Jane Doe"
+                                    },
+                                    issuer: "did:entity-storage:0x879c31386f992cfa29b77fe31e37256d69f6a57653cee4eb60ad4c4613c5515a",
+                                    issuanceDate: "2025-01-24T09:21:51.500Z",
+                                    credentialStatus: {
+                                        id: "did:entity-storage:0x879c31386f992cfa29b77fe31e37256d69f6a57653cee4eb60ad4c4613c5515a#revocation",
+                                        type: "BitstringStatusList",
+                                        revocationBitmapIndex: "5"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                ]
+            }
+        ],
+        skipAuth: true
+    };
+    const identityVerifiableCredentialRevokeRoute = {
+        operationId: "identityVerifiableCredentialRevoke",
+        summary: "Revoke an identity verifiable credential",
+        tag: tagsIdentity[0].name,
+        method: "GET",
+        path: `${baseRouteName}/:identity/verifiable-credential/revoke/:revocationIndex`,
+        handler: async (httpRequestContext, request) => identityVerifiableCredentialRevoke(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IIdentityVerifiableCredentialRevokeRequest",
+            examples: [
+                {
+                    id: "identityVerifiableCredentialRevokeRequestExample",
+                    request: {
+                        pathParams: {
+                            identity: "did:entity-storage:0x879c31386f992cfa29b77fe31e37256d69f6a57653cee4eb60ad4c4613c5515a",
+                            revocationIndex: 5
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "INoContentResponse",
+                examples: [
+                    {
+                        id: "identityServiceRevokeResponseExample",
+                        response: {
+                            statusCode: web.HttpStatusCode.noContent
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const identityVerifiableCredentialUnrevokeRoute = {
+        operationId: "identityVerifiableCredentialUnrevoke",
+        summary: "Unrevoke an identity verifiable credential",
+        tag: tagsIdentity[0].name,
+        method: "GET",
+        path: `${baseRouteName}/:identity/verifiable-credential/unrevoke/:revocationIndex`,
+        handler: async (httpRequestContext, request) => identityVerifiableCredentialUnrevoke(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IIdentityVerifiableCredentialUnrevokeRequest",
+            examples: [
+                {
+                    id: "identityVerifiableCredentialUnrevokeRequestExample",
+                    request: {
+                        pathParams: {
+                            identity: "did:entity-storage:0x879c31386f992cfa29b77fe31e37256d69f6a57653cee4eb60ad4c4613c5515a",
+                            revocationIndex: 5
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "INoContentResponse",
+                examples: [
+                    {
+                        id: "identityServiceUnrevokeResponseExample",
+                        response: {
+                            statusCode: web.HttpStatusCode.noContent
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const identityVerifiablePresentationCreateRoute = {
+        operationId: "identityVerifiablePresentationCreate",
+        summary: "Create an identity verifiable presentation",
+        tag: tagsIdentity[0].name,
+        method: "POST",
+        path: `${baseRouteName}/:identity/verifiable-presentation`,
+        handler: async (httpRequestContext, request) => identityVerifiablePresentationCreate(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IIdentityVerifiablePresentationCreateRequest",
+            examples: [
+                {
+                    id: "identityVerifiablePresentationCreateRequestExample",
+                    request: {
+                        pathParams: {
+                            identity: "did:entity-storage:0x879c31386f992cfa29b77fe31e37256d69f6a57653cee4eb60ad4c4613c5515a",
+                            verificationMethodId: "my-assertion"
+                        },
+                        body: {
+                            presentationId: "https://example.com/presentation/3732",
+                            verifiableCredentials: ["eyJraWQiOi...D1Z3AQ"]
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IIdentityVerifiablePresentationCreateResponse",
+                examples: [
+                    {
+                        id: "IIdentityVerifiablePresentationCreateResponseExample",
+                        response: {
+                            body: {
+                                verifiablePresentation: {
+                                    "@context": ["https://www.w3.org/ns/credentials/v2", "https://schema.org"],
+                                    id: "presentationId",
+                                    type: ["VerifiablePresentation", "Person"],
+                                    verifiableCredential: ["eyJraWQiOi...D1Z3AQ"],
+                                    holder: "did:entity-storage:0xcea318e06e89f3fb4048160770effd84d0cfa5801fee13dfa6f9413a00429cec"
+                                },
+                                jwt: "eyJraWQiOi...D1Z3AQ"
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const identityVerifiablePresentationVerifyRoute = {
+        operationId: "identityVerifiablePresentationVerify",
+        summary: "Verify an identity verifiable presentation",
+        tag: tagsIdentity[0].name,
+        method: "GET",
+        path: `${baseRouteName}/verifiable-presentation/verify`,
+        handler: async (httpRequestContext, request) => identityVerifiablePresentationVerify(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IIdentityVerifiablePresentationVerifyRequest",
+            examples: [
+                {
+                    id: "identityVerifiablePresentationVerifyRequestExample",
+                    request: {
+                        query: {
+                            jwt: "eyJraWQiOi...D1Z3AQ"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IIdentityVerifiablePresentationVerifyResponse",
+                examples: [
+                    {
+                        id: "identityVerifiablePresentationVerifyResponseExample",
+                        response: {
+                            body: {
+                                revoked: false,
+                                verifiablePresentation: {
+                                    "@context": ["https://www.w3.org/ns/credentials/v2", "https://schema.org"],
+                                    id: "presentationId",
+                                    type: ["VerifiablePresentation", "Person"],
+                                    verifiableCredential: ["eyJraWQiOi...D1Z3AQ"],
+                                    holder: "did:entity-storage:0xcea318e06e89f3fb4048160770effd84d0cfa5801fee13dfa6f9413a00429cec"
+                                }
+                            }
+                        }
+                    }
+                ]
+            }
+        ],
+        skipAuth: true
+    };
+    const identityProofCreateRoute = {
+        operationId: "identityProofCreate",
+        summary: "Create an identity proof",
+        tag: tagsIdentity[0].name,
+        method: "POST",
+        path: `${baseRouteName}/:identity/proof`,
+        handler: async (httpRequestContext, request) => identityProofCreate(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IIdentityProofCreateRequest",
+            examples: [
+                {
+                    id: "identityProofCreateRequestExample",
+                    request: {
+                        pathParams: {
+                            identity: "did:entity-storage:0xda2df3ebc91ee0d5229d6532ffd0f4426952a94f34988b0ca906694dfd366a6a",
+                            verificationMethodId: "my-verification-id"
+                        },
+                        body: {
+                            proofType: "DataIntegrityProof",
+                            document: {
+                                "@context": [
+                                    "https://www.w3.org/ns/credentials/v2",
+                                    "https://www.w3.org/ns/credentials/examples/v2"
+                                ],
+                                id: "urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33",
+                                type: ["VerifiableCredential", "AlumniCredential"],
+                                name: "Alumni Credential",
+                                description: "A minimum viable example of an Alumni Credential.",
+                                issuer: "https://vc.example/issuers/5678",
+                                validFrom: "2023-01-01T00:00:00Z",
+                                credentialSubject: {
+                                    id: "did:example:abcdefgh",
+                                    alumniOf: "The School of Examples"
+                                }
+                            }
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IIdentityProofCreateResponse",
+                examples: [
+                    {
+                        id: "identityProofCreateResponseExample",
+                        response: {
+                            body: {
+                                "@context": [
+                                    "https://www.w3.org/ns/credentials/v2",
+                                    "https://www.w3.org/ns/credentials/examples/v2"
+                                ],
+                                type: "DataIntegrityProof",
+                                cryptosuite: "eddsa-jcs-2022",
+                                created: "2024-01-31T16:00:45.490Z",
+                                verificationMethod: "did:entity-storage:0x0101010101010101010101010101010101010101010101010101010101010101#my-verification-id",
+                                proofPurpose: "assertionMethod",
+                                proofValue: "z2zGoejwpX6HH2T11BZaniEVZrqRKDpwbQSvPcL7eL9M7hV5P9zQQZxs85n6qyDzkkXCL8aFUWfwQD5bxVGqDK1fa"
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const identityProofVerifyRoute = {
+        operationId: "identityProofVerify",
+        summary: "Verify an identity proof",
+        tag: tagsIdentity[0].name,
+        method: "POST",
+        path: `${baseRouteName}/proof/verify`,
+        handler: async (httpRequestContext, request) => identityProofVerify(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IIdentityProofVerifyRequest",
+            examples: [
+                {
+                    id: "identityProofVerifyRequestExample",
+                    request: {
+                        body: {
+                            document: {
+                                "@context": [
+                                    "https://www.w3.org/ns/credentials/v2",
+                                    "https://www.w3.org/ns/credentials/examples/v2"
+                                ],
+                                id: "urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33",
+                                type: ["VerifiableCredential", "AlumniCredential"],
+                                name: "Alumni Credential",
+                                description: "A minimum viable example of an Alumni Credential.",
+                                issuer: "https://vc.example/issuers/5678",
+                                validFrom: "2023-01-01T00:00:00Z",
+                                credentialSubject: {
+                                    id: "did:example:abcdefgh",
+                                    alumniOf: "The School of Examples"
+                                }
+                            },
+                            proof: {
+                                "@context": "https://www.w3.org/ns/credentials/v2",
+                                type: "DataIntegrityProof",
+                                cryptosuite: "eddsa-jcs-2022",
+                                created: "2025-01-24T11:32:13.106Z",
+                                verificationMethod: "did:entity-storage:0xda2df3ebc91ee0d5229d6532ffd0f4426952a94f34988b0ca906694dfd366a6a#my-verification-id",
+                                proofPurpose: "assertionMethod",
+                                proofValue: "2fVLgANruCBoRPBCJavi54mZtkQdyMz6T2N4XVyB96asawiriKrVWoktcSQ7dMGrBTiemBBDpcLE2HfiTBCGuBmq"
+                            }
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IIdentityProofVerifyResponse",
+                examples: [
+                    {
+                        id: "identityProofVerifyResponseExample",
+                        response: {
+                            body: {
+                                verified: true
+                            }
+                        }
+                    }
+                ]
+            }
+        ],
+        skipAuth: true
+    };
+    return [
+        identityCreateRoute,
+        identityRemoveRoute,
+        identityVerificationMethodCreateRoute,
+        identityVerificationMethodRemoveRoute,
+        identityServiceCreateRoute,
+        identityServiceRemoveRoute,
+        identityVerifiableCredentialCreateRoute,
+        identityVerifiableCredentialVerifyRoute,
+        identityVerifiableCredentialRevokeRoute,
+        identityVerifiableCredentialUnrevokeRoute,
+        identityVerifiablePresentationCreateRoute,
+        identityVerifiablePresentationVerifyRoute,
+        identityProofCreateRoute,
+        identityProofVerifyRoute
+    ];
+}
+/**
+ * Create an identity.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function identityCreate(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.stringValue(ROUTES_SOURCE, "httpRequestContext.userIdentity", httpRequestContext.userIdentity);
+    const component = core.ComponentFactory.get(componentName);
+    const result = await component.identityCreate(request.body?.namespace, httpRequestContext.userIdentity);
+    return {
+        body: result
+    };
+}
+/**
+ * Remove an identity.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function identityRemove(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE, "httpRequestContext.userIdentity", httpRequestContext.userIdentity);
+    const component = core.ComponentFactory.get(componentName);
+    await component.identityRemove(request.pathParams.identity, httpRequestContext.userIdentity);
+    return {
+        statusCode: web.HttpStatusCode.noContent
+    };
+}
+/**
+ * Create an identity verification method.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function identityVerificationMethodCreate(httpRequestContext, componentName, request) {
+    core.Guards.stringValue(ROUTES_SOURCE, "httpRequestContext.userIdentity", httpRequestContext.userIdentity);
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.identity", request.pathParams.identity);
+    const component = core.ComponentFactory.get(componentName);
+    const result = await component.verificationMethodCreate(request.pathParams.identity, request.body.verificationMethodType, request.body.verificationMethodId, httpRequestContext.userIdentity);
+    return {
+        body: result
+    };
+}
+/**
+ * Remove an identity verification method.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function identityVerificationMethodRemove(httpRequestContext, componentName, request) {
+    core.Guards.stringValue(ROUTES_SOURCE, "httpRequestContext.userIdentity", httpRequestContext.userIdentity);
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.identity", request.pathParams.identity);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.verificationMethodId", request.pathParams.verificationMethodId);
+    const component = core.ComponentFactory.get(componentName);
+    await component.verificationMethodRemove(identityModels.DocumentHelper.joinId(request.pathParams.identity, request.pathParams.verificationMethodId), httpRequestContext.userIdentity);
+    return {
+        statusCode: web.HttpStatusCode.noContent
+    };
+}
+/**
+ * Create an identity service.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function identityServiceCreate(httpRequestContext, componentName, request) {
+    core.Guards.stringValue(ROUTES_SOURCE, "httpRequestContext.userIdentity", httpRequestContext.userIdentity);
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.identity", request.pathParams.identity);
+    const component = core.ComponentFactory.get(componentName);
+    const result = await component.serviceCreate(request.pathParams.identity, request.body.serviceId, request.body.type, request.body.endpoint, httpRequestContext.userIdentity);
+    return {
+        body: result
+    };
+}
+/**
+ * Remove an identity service.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function identityServiceRemove(httpRequestContext, componentName, request) {
+    core.Guards.stringValue(ROUTES_SOURCE, "httpRequestContext.userIdentity", httpRequestContext.userIdentity);
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.identity", request.pathParams.identity);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.serviceId", request.pathParams.serviceId);
+    const component = core.ComponentFactory.get(componentName);
+    await component.serviceRemove(identityModels.DocumentHelper.joinId(request.pathParams.identity, request.pathParams.serviceId), httpRequestContext.userIdentity);
+    return {
+        statusCode: web.HttpStatusCode.noContent
+    };
+}
+/**
+ * Create a verifiable credential.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function identityVerifiableCredentialCreate(httpRequestContext, componentName, request) {
+    core.Guards.stringValue(ROUTES_SOURCE, "httpRequestContext.userIdentity", httpRequestContext.userIdentity);
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.identity", request.pathParams.identity);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.verificationMethodId", request.pathParams.verificationMethodId);
+    const component = core.ComponentFactory.get(componentName);
+    const result = await component.verifiableCredentialCreate(identityModels.DocumentHelper.joinId(request.pathParams.identity, request.pathParams.verificationMethodId), request.body.credentialId, request.body.subject, request.body.revocationIndex, httpRequestContext.userIdentity);
+    return {
+        body: result
+    };
+}
+/**
+ * Verify a verifiable credential.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function identityVerifiableCredentialVerify(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.query", request.query);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.query.jwt", request.query.jwt);
+    const component = core.ComponentFactory.get(componentName);
+    const result = await component.verifiableCredentialVerify(request.query.jwt);
+    return {
+        body: result
+    };
+}
+/**
+ * Revoke a verifiable credential.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function identityVerifiableCredentialRevoke(httpRequestContext, componentName, request) {
+    core.Guards.stringValue(ROUTES_SOURCE, "httpRequestContext.userIdentity", httpRequestContext.userIdentity);
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.identity", request.pathParams.identity);
+    const revocationIndex = core.Coerce.number(request.pathParams.revocationIndex);
+    core.Guards.integer(ROUTES_SOURCE, "request.pathParams.revocationIndex", revocationIndex);
+    const component = core.ComponentFactory.get(componentName);
+    await component.verifiableCredentialRevoke(request.pathParams.identity, revocationIndex, httpRequestContext.userIdentity);
+    return {
+        statusCode: web.HttpStatusCode.noContent
+    };
+}
+/**
+ * Unrevoke a verifiable credential.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function identityVerifiableCredentialUnrevoke(httpRequestContext, componentName, request) {
+    core.Guards.stringValue(ROUTES_SOURCE, "httpRequestContext.userIdentity", httpRequestContext.userIdentity);
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.identity", request.pathParams.identity);
+    const revocationIndex = core.Coerce.number(request.pathParams.revocationIndex);
+    core.Guards.integer(ROUTES_SOURCE, "request.pathParams.revocationIndex", revocationIndex);
+    const component = core.ComponentFactory.get(componentName);
+    await component.verifiableCredentialUnrevoke(request.pathParams.identity, revocationIndex, httpRequestContext.userIdentity);
+    return {
+        statusCode: web.HttpStatusCode.noContent
+    };
+}
+/**
+ * Create a verifiable presentation.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function identityVerifiablePresentationCreate(httpRequestContext, componentName, request) {
+    core.Guards.stringValue(ROUTES_SOURCE, "httpRequestContext.userIdentity", httpRequestContext.userIdentity);
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.identity", request.pathParams.identity);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.verificationMethodId", request.pathParams.verificationMethodId);
+    const component = core.ComponentFactory.get(componentName);
+    const result = await component.verifiablePresentationCreate(identityModels.DocumentHelper.joinId(request.pathParams.identity, request.pathParams.verificationMethodId), request.body.presentationId, request.body.contexts, request.body.types, request.body.verifiableCredentials, request.body.expiresInMinutes, httpRequestContext.userIdentity);
+    return {
+        body: result
+    };
+}
+/**
+ * Verify a verifiable presentation.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function identityVerifiablePresentationVerify(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.query", request.query);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.query.jwt", request.query.jwt);
+    const component = core.ComponentFactory.get(componentName);
+    const result = await component.verifiablePresentationVerify(request.query.jwt);
+    return {
+        body: result
+    };
+}
+/**
+ * Create an identity proof.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function identityProofCreate(httpRequestContext, componentName, request) {
+    core.Guards.stringValue(ROUTES_SOURCE, "httpRequestContext.userIdentity", httpRequestContext.userIdentity);
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.identity", request.pathParams.identity);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.verificationMethodId", request.pathParams.verificationMethodId);
+    core.Guards.object(ROUTES_SOURCE, "request.body", request.body);
+    const component = core.ComponentFactory.get(componentName);
+    const result = await component.proofCreate(request.pathParams.identity, request.body.proofType, request.body.document, httpRequestContext.userIdentity);
+    return {
+        body: result
+    };
+}
+/**
+ * Verify an identity proof.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function identityProofVerify(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.body", request.body);
+    const component = core.ComponentFactory.get(componentName);
+    const result = await component.proofVerify(request.body.document, request.body.proof);
+    return {
+        body: {
+            verified: result
+        }
+    };
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class which implements the identity contract.
+ */
+class IdentityService {
+    /**
+     * The namespace supported by the identity service.
+     */
+    static NAMESPACE = "identity";
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "IdentityService";
+    /**
+     * The default namespace for the connector to use.
+     * @internal
+     */
+    _defaultNamespace;
+    /**
+     * Create a new instance of IdentityService.
+     * @param options The options for the service.
+     */
+    constructor(options) {
+        const names = identityModels.IdentityConnectorFactory.names();
+        if (names.length === 0) {
+            throw new core.GeneralError(this.CLASS_NAME, "noConnectors");
+        }
+        this._defaultNamespace = options?.config?.defaultNamespace ?? names[0];
+    }
+    /**
+     * Create a new identity.
+     * @param namespace The namespace of the connector to use for the identity, defaults to service configured namespace.
+     * @param controller The controller of the identity who can make changes.
+     * @returns The created identity document.
+     */
+    async identityCreate(namespace, controller) {
+        core.Guards.stringValue(this.CLASS_NAME, "controller", controller);
+        try {
+            const identityConnector = this.getConnectorByNamespace(namespace);
+            return identityConnector.createDocument(controller);
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "identityCreateFailed", undefined, error);
+        }
+    }
+    /**
+     * Remove an identity.
+     * @param identity The id of the document to remove.
+     * @param controller The controller of the identity who can make changes.
+     * @returns Nothing.
+     */
+    async identityRemove(identity, controller) {
+        core.Guards.stringValue(this.CLASS_NAME, "identity", identity);
+        core.Guards.stringValue(this.CLASS_NAME, "controller", controller);
+        try {
+            const identityConnector = this.getConnectorByUri(identity);
+            return identityConnector.removeDocument(controller, identity);
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "identityRemoveFailed", { identity }, error);
+        }
+    }
+    /**
+     * Add a verification method to the document in JSON Web key Format.
+     * @param identity The id of the document to add the verification method to.
+     * @param verificationMethodType The type of the verification method to add.
+     * @param verificationMethodId The id of the verification method, if undefined uses the kid of the generated JWK.
+     * @param controller The controller of the identity who can make changes.
+     * @returns The verification method.
+     * @throws NotFoundError if the id can not be resolved.
+     * @throws NotSupportedError if the platform does not support multiple keys.
+     */
+    async verificationMethodCreate(identity, verificationMethodType, verificationMethodId, controller) {
+        core.Guards.stringValue(this.CLASS_NAME, "controller", controller);
+        core.Urn.guard(this.CLASS_NAME, "identity", identity);
+        core.Guards.arrayOneOf(this.CLASS_NAME, "verificationMethodType", verificationMethodType, Object.values(standardsW3cDid.DidVerificationMethodType));
+        try {
+            const identityConnector = this.getConnectorByUri(identity);
+            const verificationMethod = await identityConnector.addVerificationMethod(controller, identity, verificationMethodType, verificationMethodId);
+            return verificationMethod;
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "verificationMethodCreateFailed", { identity }, error);
+        }
+    }
+    /**
+     * Remove a verification method from the document.
+     * @param verificationMethodId The id of the verification method.
+     * @param controller The controller of the identity who can make changes.
+     * @returns Nothing.
+     * @throws NotFoundError if the id can not be resolved.
+     * @throws NotSupportedError if the platform does not support multiple revocable keys.
+     */
+    async verificationMethodRemove(verificationMethodId, controller) {
+        core.Guards.stringValue(this.CLASS_NAME, "controller", controller);
+        core.Urn.guard(this.CLASS_NAME, "verificationMethodId", verificationMethodId);
+        try {
+            const idParts = identityModels.DocumentHelper.parseId(verificationMethodId);
+            const identityConnector = this.getConnectorByUri(idParts.id);
+            await identityConnector.removeVerificationMethod(controller, verificationMethodId);
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "verificationMethodRemoveFailed", { verificationMethodId }, error);
+        }
+    }
+    /**
+     * Add a service to the document.
+     * @param identity The id of the document to add the service to.
+     * @param serviceId The id of the service.
+     * @param serviceType The type of the service.
+     * @param serviceEndpoint The endpoint for the service.
+     * @param controller The controller of the identity who can make changes.
+     * @returns The service.
+     * @throws NotFoundError if the id can not be resolved.
+     */
+    async serviceCreate(identity, serviceId, serviceType, serviceEndpoint, controller) {
+        core.Guards.stringValue(this.CLASS_NAME, "controller", controller);
+        core.Urn.guard(this.CLASS_NAME, "identity", identity);
+        core.Guards.stringValue(this.CLASS_NAME, "serviceId", serviceId);
+        if (core.Is.array(serviceType)) {
+            core.Guards.arrayValue(this.CLASS_NAME, "serviceType", serviceType);
+        }
+        else {
+            core.Guards.stringValue(this.CLASS_NAME, "serviceType", serviceType);
+        }
+        if (core.Is.array(serviceEndpoint)) {
+            core.Guards.arrayValue(this.CLASS_NAME, "serviceEndpoint", serviceEndpoint);
+        }
+        else {
+            core.Guards.stringValue(this.CLASS_NAME, "serviceEndpoint", serviceEndpoint);
+        }
+        try {
+            const identityConnector = this.getConnectorByUri(identity);
+            const service = await identityConnector.addService(controller, identity, serviceId, serviceType, serviceEndpoint);
+            return service;
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "serviceCreateFailed", { identity, serviceId }, error);
+        }
+    }
+    /**
+     * Remove a service from the document.
+     * @param serviceId The id of the service.
+     * @param controller The controller of the identity who can make changes.
+     * @returns Nothing.
+     * @throws NotFoundError if the id can not be resolved.
+     */
+    async serviceRemove(serviceId, controller) {
+        core.Guards.stringValue(this.CLASS_NAME, "controller", controller);
+        core.Urn.guard(this.CLASS_NAME, "serviceId", serviceId);
+        try {
+            const idParts = identityModels.DocumentHelper.parseId(serviceId);
+            const identityConnector = this.getConnectorByUri(idParts.id);
+            await identityConnector.removeService(controller, serviceId);
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "serviceRemoveFailed", { serviceId }, error);
+        }
+    }
+    /**
+     * Create a verifiable credential for a verification method.
+     * @param verificationMethodId The verification method id to use.
+     * @param id The id of the credential.
+     * @param subject The credential subject to store in the verifiable credential.
+     * @param revocationIndex The bitmap revocation index of the credential, if undefined will not have revocation status.
+     * @param controller The controller of the identity who can make changes.
+     * @returns The created verifiable credential and its token.
+     * @throws NotFoundError if the id can not be resolved.
+     */
+    async verifiableCredentialCreate(verificationMethodId, id, subject, revocationIndex, controller) {
+        core.Guards.stringValue(this.CLASS_NAME, "controller", controller);
+        core.Urn.guard(this.CLASS_NAME, "verificationMethodId", verificationMethodId);
+        core.Guards.objectValue(this.CLASS_NAME, "subject", subject);
+        try {
+            const idParts = identityModels.DocumentHelper.parseId(verificationMethodId);
+            const identityConnector = this.getConnectorByUri(idParts.id);
+            const service = await identityConnector.createVerifiableCredential(controller, verificationMethodId, id, subject, revocationIndex);
+            return service;
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "verifiableCredentialCreateFailed", { verificationMethodId }, error);
+        }
+    }
+    /**
+     * Verify a verifiable credential is valid.
+     * @param credentialJwt The credential to verify.
+     * @returns The credential stored in the jwt and the revocation status.
+     */
+    async verifiableCredentialVerify(credentialJwt) {
+        core.Guards.stringValue(this.CLASS_NAME, "credentialJwt", credentialJwt);
+        const jwtDecoded = await web.Jwt.decode(credentialJwt);
+        const jwtHeader = jwtDecoded.header;
+        const jwtPayload = jwtDecoded.payload;
+        const jwtSignature = jwtDecoded.signature;
+        if (core.Is.undefined(jwtHeader) ||
+            core.Is.undefined(jwtPayload) ||
+            core.Is.undefined(jwtPayload.iss) ||
+            core.Is.undefined(jwtSignature)) {
+            throw new core.GeneralError(this.CLASS_NAME, "jwtDecodeFailed");
+        }
+        try {
+            const identityConnector = this.getConnectorByUri(jwtPayload.iss);
+            const service = await identityConnector.checkVerifiableCredential(credentialJwt);
+            return service;
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "verifiableCredentialVerifyFailed", undefined, error);
+        }
+    }
+    /**
+     * Revoke verifiable credential.
+     * @param issuerIdentity The id of the document to update the revocation list for.
+     * @param credentialIndex The revocation bitmap index revoke.
+     * @param controller The controller of the identity who can make changes.
+     * @returns Nothing.
+     */
+    async verifiableCredentialRevoke(issuerIdentity, credentialIndex, controller) {
+        core.Guards.stringValue(this.CLASS_NAME, "controller", controller);
+        core.Guards.stringValue(this.CLASS_NAME, "issuerIdentity", issuerIdentity);
+        core.Guards.number(this.CLASS_NAME, "credentialIndex", credentialIndex);
+        try {
+            const idParts = identityModels.DocumentHelper.parseId(issuerIdentity);
+            const identityConnector = this.getConnectorByUri(idParts.id);
+            return identityConnector.revokeVerifiableCredentials(controller, issuerIdentity, [
+                credentialIndex
+            ]);
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "verifiableCredentialRevokeFailed", { issuerIdentity, credentialIndex }, error);
+        }
+    }
+    /**
+     * Unrevoke verifiable credential.
+     * @param issuerIdentity The id of the document to update the revocation list for.
+     * @param credentialIndex The revocation bitmap index to un revoke.
+     * @param controller The controller of the identity who can make changes.
+     * @returns Nothing.
+     */
+    async verifiableCredentialUnrevoke(issuerIdentity, credentialIndex, controller) {
+        core.Guards.stringValue(this.CLASS_NAME, "controller", controller);
+        core.Guards.stringValue(this.CLASS_NAME, "issuerIdentity", issuerIdentity);
+        core.Guards.number(this.CLASS_NAME, "credentialIndex", credentialIndex);
+        try {
+            const idParts = identityModels.DocumentHelper.parseId(issuerIdentity);
+            const identityConnector = this.getConnectorByUri(idParts.id);
+            return identityConnector.unrevokeVerifiableCredentials(controller, issuerIdentity, [
+                credentialIndex
+            ]);
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "verifiableCredentialUnrevokeFailed", { issuerIdentity, credentialIndex }, error);
+        }
+    }
+    /**
+     * Create a verifiable presentation from the supplied verifiable credentials.
+     * @param verificationMethodId The method to associate with the presentation.
+     * @param presentationId The id of the presentation.
+     * @param contexts The contexts for the data stored in the verifiable credential.
+     * @param types The types for the data stored in the verifiable credential.
+     * @param verifiableCredentials The credentials to use for creating the presentation in jwt format.
+     * @param expiresInMinutes The time in minutes for the presentation to expire.
+     * @param controller The controller of the identity who can make changes.
+     * @returns The created verifiable presentation and its token.
+     * @throws NotFoundError if the id can not be resolved.
+     */
+    async verifiablePresentationCreate(verificationMethodId, presentationId, contexts, types, verifiableCredentials, expiresInMinutes, controller) {
+        core.Guards.stringValue(this.CLASS_NAME, "controller", controller);
+        core.Guards.stringValue(this.CLASS_NAME, "verificationMethodId", verificationMethodId);
+        try {
+            const idParts = identityModels.DocumentHelper.parseId(verificationMethodId);
+            const identityConnector = this.getConnectorByUri(idParts.id);
+            return identityConnector.createVerifiablePresentation(controller, verificationMethodId, presentationId, contexts, types, verifiableCredentials, expiresInMinutes);
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "verifiablePresentationCreateFailed", { verificationMethodId }, error);
+        }
+    }
+    /**
+     * Verify a verifiable presentation is valid.
+     * @param presentationJwt The presentation to verify.
+     * @returns The presentation stored in the jwt and the revocation status.
+     */
+    async verifiablePresentationVerify(presentationJwt) {
+        core.Guards.stringValue(this.CLASS_NAME, "presentationJwt", presentationJwt);
+        const jwtDecoded = await web.Jwt.decode(presentationJwt);
+        const jwtHeader = jwtDecoded.header;
+        const jwtPayload = jwtDecoded.payload;
+        const jwtSignature = jwtDecoded.signature;
+        if (core.Is.undefined(jwtHeader) ||
+            core.Is.undefined(jwtPayload) ||
+            core.Is.undefined(jwtPayload.iss) ||
+            core.Is.undefined(jwtSignature)) {
+            throw new core.GeneralError(this.CLASS_NAME, "jwtDecodeFailed");
+        }
+        try {
+            const identityConnector = this.getConnectorByUri(jwtPayload.iss);
+            const service = await identityConnector.checkVerifiablePresentation(presentationJwt);
+            return service;
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "verifiablePresentationVerifyFailed", undefined, error);
+        }
+    }
+    /**
+     * Create a proof for a document with the specified verification method.
+     * @param verificationMethodId The verification method id to use.
+     * @param proofType The type of proof to create.
+     * @param unsecureDocument The unsecure document to create the proof for.
+     * @param controller The controller of the identity who can make changes.
+     * @returns The proof.
+     */
+    async proofCreate(verificationMethodId, proofType, unsecureDocument, controller) {
+        core.Guards.stringValue(this.CLASS_NAME, "controller", controller);
+        core.Guards.stringValue(this.CLASS_NAME, "verificationMethodId", verificationMethodId);
+        core.Guards.arrayOneOf(this.CLASS_NAME, "proofType", proofType, Object.values(standardsW3cDid.ProofTypes));
+        core.Guards.object(this.CLASS_NAME, "unsecureDocument", unsecureDocument);
+        try {
+            const idParts = identityModels.DocumentHelper.parseId(verificationMethodId);
+            const identityConnector = this.getConnectorByUri(idParts.id);
+            return identityConnector.createProof(controller, verificationMethodId, proofType, unsecureDocument);
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "proofCreateFailed", { verificationMethodId }, error);
+        }
+    }
+    /**
+     * Verify proof for a document with the specified verification method.
+     * @param document The document to verify.
+     * @param proof The proof to verify.
+     * @returns True if the proof is verified.
+     */
+    async proofVerify(document, proof) {
+        core.Guards.object(this.CLASS_NAME, "document", document);
+        core.Guards.object(this.CLASS_NAME, "proof", proof);
+        core.Guards.stringValue(this.CLASS_NAME, "proof.verificationMethod", proof.verificationMethod);
+        try {
+            const idParts = identityModels.DocumentHelper.parseId(proof.verificationMethod);
+            const identityConnector = this.getConnectorByUri(idParts.id);
+            return identityConnector.verifyProof(document, proof);
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "proofVerifyFailed", undefined, error);
+        }
+    }
+    /**
+     * Get the connector from the namespace.
+     * @param namespace The namespace for the identity.
+     * @returns The connector.
+     * @internal
+     */
+    getConnectorByNamespace(namespace) {
+        const namespaceMethod = namespace ?? this._defaultNamespace;
+        const connector = identityModels.IdentityConnectorFactory.getIfExists(namespaceMethod);
+        if (core.Is.empty(connector)) {
+            throw new core.GeneralError(this.CLASS_NAME, "connectorNotFound", { namespace: namespaceMethod });
+        }
+        return connector;
+    }
+    /**
+     * Get the connector from the uri.
+     * @param id The id of the identity in urn format.
+     * @returns The connector.
+     * @internal
+     */
+    getConnectorByUri(id) {
+        const idUri = core.Urn.fromValidString(id);
+        if (idUri.namespaceIdentifier() !== "did") {
+            throw new core.GeneralError(this.CLASS_NAME, "namespaceMismatch", {
+                namespace: "did",
+                id
+            });
+        }
+        return this.getConnectorByNamespace(idUri.namespaceMethod());
+    }
+}
+
+const restEntryPoints = [
+    {
+        name: "identityResolver",
+        defaultBaseRoute: "identity",
+        tags: tagsIdentityResolver,
+        generateRoutes: generateRestRoutesIdentityResolver
+    },
     {
         name: "identity",
         defaultBaseRoute: "identity",
@@ -692,16 +2044,33 @@ const restEntryPoints = [
 ];
 
 exports.IdentityProfileService = IdentityProfileService;
+exports.IdentityResolverService = IdentityResolverService;
 exports.IdentityService = IdentityService;
 exports.generateRestRoutesIdentity = generateRestRoutesIdentity;
 exports.generateRestRoutesIdentityProfile = generateRestRoutesIdentityProfile;
+exports.generateRestRoutesIdentityResolver = generateRestRoutesIdentityResolver;
 exports.identitiesList = identitiesList;
+exports.identityCreate = identityCreate;
 exports.identityGet = identityGet;
 exports.identityGetPublic = identityGetPublic;
 exports.identityProfileCreate = identityProfileCreate;
 exports.identityProfileRemove = identityProfileRemove;
 exports.identityProfileUpdate = identityProfileUpdate;
+exports.identityProofCreate = identityProofCreate;
+exports.identityProofVerify = identityProofVerify;
+exports.identityRemove = identityRemove;
 exports.identityResolve = identityResolve;
+exports.identityServiceCreate = identityServiceCreate;
+exports.identityServiceRemove = identityServiceRemove;
+exports.identityVerifiableCredentialCreate = identityVerifiableCredentialCreate;
+exports.identityVerifiableCredentialRevoke = identityVerifiableCredentialRevoke;
+exports.identityVerifiableCredentialUnrevoke = identityVerifiableCredentialUnrevoke;
+exports.identityVerifiableCredentialVerify = identityVerifiableCredentialVerify;
+exports.identityVerifiablePresentationCreate = identityVerifiablePresentationCreate;
+exports.identityVerifiablePresentationVerify = identityVerifiablePresentationVerify;
+exports.identityVerificationMethodCreate = identityVerificationMethodCreate;
+exports.identityVerificationMethodRemove = identityVerificationMethodRemove;
 exports.restEntryPoints = restEntryPoints;
 exports.tagsIdentity = tagsIdentity;
 exports.tagsIdentityProfile = tagsIdentityProfile;
+exports.tagsIdentityResolver = tagsIdentityResolver;