@twin.org/identity-service 0.0.2-next.9 → 0.0.3-next.2

package/dist/cjs/index.cjs

@@ -1,2071 +0,0 @@
-'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$2 = "identityProfileRoutes";
-/**
- * The tag to associate with the routes.
- */
-const tagsIdentityProfile = [
-    {
-        name: "Identity Profile",
-        description: "Service to provide all features related to digital identity profiles."
-    }
-];
-/**
- * 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 generateRestRoutesIdentityProfile(baseRouteName, componentName) {
-    const identityProfileCreateRoute = {
-        operationId: "identityProfileCreate",
-        summary: "Create an identity profile",
-        tag: tagsIdentityProfile[0].name,
-        method: "POST",
-        path: `${baseRouteName}/`,
-        handler: async (httpRequestContext, request) => identityProfileCreate(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IIdentityProfileCreateRequest",
-            examples: [
-                {
-                    id: "identityProfileCreateRequestExample",
-                    request: {
-                        body: {
-                            publicProfile: {
-                                "@context": "https://schema.org",
-                                "@type": "Person",
-                                jobTitle: "Professor",
-                                name: "Jane Doe"
-                            },
-                            privateProfile: {
-                                "@context": "https://schema.org",
-                                "@type": "Person",
-                                telephone: "(425) 123-4567",
-                                url: "http://www.janedoe.com"
-                            }
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "INoContentResponse"
-            },
-            {
-                type: "IConflictResponse"
-            }
-        ]
-    };
-    const identityProfileGetRoute = {
-        operationId: "identityProfileGet",
-        summary: "Get the identity profile properties",
-        tag: tagsIdentityProfile[0].name,
-        method: "GET",
-        path: `${baseRouteName}/`,
-        handler: async (httpRequestContext, request) => identityGet(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IIdentityProfileGetRequest",
-            examples: [
-                {
-                    id: "identityGetProfileRequestExample",
-                    request: {
-                        query: {
-                            publicPropertyNames: "name,jobTitle"
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "IIdentityProfileGetResponse",
-                examples: [
-                    {
-                        id: "identityGetResponseExample",
-                        response: {
-                            body: {
-                                identity: "did:iota:tst:0xc57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
-                                publicProfile: {
-                                    "@context": "https://schema.org",
-                                    "@type": "Person",
-                                    jobTitle: "Professor",
-                                    name: "Jane Doe"
-                                }
-                            }
-                        }
-                    }
-                ]
-            },
-            {
-                type: "INotFoundResponse"
-            }
-        ]
-    };
-    const identityProfileGetPublicRoute = {
-        operationId: "identityProfileGetPublic",
-        summary: "Get the identity profile public properties",
-        tag: tagsIdentityProfile[0].name,
-        method: "GET",
-        path: `${baseRouteName}/:identity/public`,
-        handler: async (httpRequestContext, request) => identityGetPublic(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IIdentityProfileGetPublicRequest",
-            examples: [
-                {
-                    id: "identityGetPublicProfileRequestExample",
-                    request: {
-                        pathParams: {
-                            identity: "did:iota:tst:0xc57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
-                        },
-                        query: {
-                            propertyNames: "role,email,name"
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "IIdentityProfileGetPublicResponse",
-                mimeType: web.MimeTypes.JsonLd,
-                examples: [
-                    {
-                        id: "identityGetPublicResponseExample",
-                        response: {
-                            headers: {
-                                [web.HeaderTypes.ContentType]: web.MimeTypes.JsonLd
-                            },
-                            body: {
-                                "@context": "https://schema.org",
-                                "@type": "Person",
-                                jobTitle: "Professor",
-                                name: "Jane Doe"
-                            }
-                        }
-                    }
-                ]
-            },
-            {
-                type: "INotFoundResponse"
-            }
-        ],
-        skipAuth: true
-    };
-    const identityProfileUpdateRoute = {
-        operationId: "identityProfileUpdate",
-        summary: "Update an identity profile properties",
-        tag: tagsIdentityProfile[0].name,
-        method: "PUT",
-        path: `${baseRouteName}/`,
-        handler: async (httpRequestContext, request) => identityProfileUpdate(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IIdentityProfileUpdateRequest",
-            examples: [
-                {
-                    id: "identityProfileUpdateRequestExample",
-                    request: {
-                        body: {
-                            publicProfile: {
-                                "@context": "https://schema.org",
-                                "@type": "Person",
-                                jobTitle: "Professor",
-                                name: "Jane Doe"
-                            },
-                            privateProfile: {
-                                "@context": "https://schema.org",
-                                "@type": "Person",
-                                telephone: "(425) 123-4567",
-                                url: "http://www.janedoe.com"
-                            }
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "INoContentResponse"
-            },
-            {
-                type: "INotFoundResponse"
-            }
-        ]
-    };
-    const identityProfileRemoveRoute = {
-        operationId: "identityProfileRemove",
-        summary: "Remove an identity profile",
-        tag: tagsIdentityProfile[0].name,
-        method: "DELETE",
-        path: `${baseRouteName}/`,
-        handler: async (httpRequestContext, request) => identityProfileRemove(httpRequestContext, componentName),
-        responseType: [
-            {
-                type: "INoContentResponse"
-            },
-            {
-                type: "INotFoundResponse"
-            }
-        ]
-    };
-    const identityProfileListRoute = {
-        operationId: "identitiesProfileList",
-        summary: "Get the list of profile data for identities",
-        tag: tagsIdentityProfile[0].name,
-        method: "GET",
-        path: `${baseRouteName}/query/`,
-        handler: async (httpRequestContext, request) => identitiesList(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IIdentityProfileListRequest",
-            examples: [
-                {
-                    id: "identityProfileListRequestExample",
-                    request: {
-                        query: {}
-                    }
-                },
-                {
-                    id: "identityProfileListRequestFilteredExample",
-                    request: {
-                        query: {
-                            publicFilters: "jobTitle:Professor"
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "IIdentityProfileListResponse",
-                examples: [
-                    {
-                        id: "identitiesProfileListResponseExample",
-                        response: {
-                            body: {
-                                items: [
-                                    {
-                                        identity: "did:iota:tst:0xc57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
-                                        publicProfile: {
-                                            "@context": "https://schema.org",
-                                            "@type": "Person",
-                                            jobTitle: "Professor",
-                                            name: "Jane Doe"
-                                        }
-                                    }
-                                ],
-                                cursor: "1"
-                            }
-                        }
-                    }
-                ]
-            }
-        ]
-    };
-    return [
-        identityProfileCreateRoute,
-        identityProfileGetRoute,
-        identityProfileGetPublicRoute,
-        identityProfileUpdateRoute,
-        identityProfileRemoveRoute,
-        identityProfileListRoute
-    ];
-}
-/**
- * Create an identity profile.
- * @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 identityProfileCreate(httpRequestContext, componentName, request) {
-    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 {
-        statusCode: web.HttpStatusCode.noContent
-    };
-}
-/**
- * Get the identity profile.
- * @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 identityGet(httpRequestContext, componentName, request) {
-    core.Guards.object(ROUTES_SOURCE$2, "request", request);
-    const component = core.ComponentFactory.get(componentName);
-    const result = await component.get(apiModels.HttpParameterHelper.arrayFromString(request?.query?.publicPropertyNames), apiModels.HttpParameterHelper.arrayFromString(request?.query?.privatePropertyNames), httpRequestContext.userIdentity);
-    return {
-        body: result
-    };
-}
-/**
- * Get the identity public profile.
- * @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 identityGetPublic(httpRequestContext, componentName, request) {
-    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, apiModels.HttpParameterHelper.arrayFromString(request?.query?.propertyNames));
-    return {
-        headers: {
-            [web.HeaderTypes.ContentType]: web.MimeTypes.JsonLd
-        },
-        body: result
-    };
-}
-/**
- * Update an identity profile.
- * @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 identityProfileUpdate(httpRequestContext, componentName, request) {
-    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 {
-        statusCode: web.HttpStatusCode.noContent
-    };
-}
-/**
- * Remove an identity profile.
- * @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 identityProfileRemove(httpRequestContext, componentName, request) {
-    const component = core.ComponentFactory.get(componentName);
-    await component.remove(httpRequestContext.userIdentity);
-    return {
-        statusCode: web.HttpStatusCode.noContent
-    };
-}
-/**
- * Get the list of organizations.
- * @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 identitiesList(httpRequestContext, componentName, request) {
-    const component = core.ComponentFactory.get(componentName);
-    const publicFilterPairs = apiModels.HttpParameterHelper.arrayFromString(request?.query?.publicFilters);
-    const publicFilters = publicFilterPairs?.map(pair => {
-        const parts = pair.split(":");
-        return {
-            propertyName: parts[0],
-            propertyValue: parts[1]
-        };
-    });
-    return {
-        body: await component.list(publicFilters, apiModels.HttpParameterHelper.arrayFromString(request?.query?.publicPropertyNames), request?.query?.cursor, core.Coerce.integer(request.query?.limit))
-    };
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class which implements the identity profile contract.
- */
-class IdentityProfileService {
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "IdentityProfileService";
-    /**
-     * The identity profile connector.
-     * @internal
-     */
-    _identityProfileConnector;
-    /**
-     * Create a new instance of IdentityProfileService.
-     * @param options The dependencies for the identity profile service.
-     */
-    constructor(options) {
-        this._identityProfileConnector = identityModels.IdentityProfileConnectorFactory.get(options?.profileEntityConnectorType ?? "identity-profile");
-    }
-    /**
-     * Create the profile properties for an identity.
-     * @param publicProfile The public profile data as JSON-LD.
-     * @param privateProfile The private profile data as JSON-LD.
-     * @param identity The identity to perform the profile operation on.
-     * @returns Nothing.
-     */
-    async create(publicProfile, privateProfile, identity) {
-        core.Guards.stringValue(IdentityProfileService.CLASS_NAME, "identity", identity);
-        try {
-            await this._identityProfileConnector.create(identity, publicProfile, privateProfile);
-        }
-        catch (error) {
-            if (core.BaseError.someErrorClass(error, IdentityProfileService.CLASS_NAME)) {
-                throw error;
-            }
-            throw new core.GeneralError(IdentityProfileService.CLASS_NAME, "createFailed", { identity }, error);
-        }
-    }
-    /**
-     * Get the profile properties for an identity.
-     * @param publicPropertyNames The public properties to get for the profile, defaults to all.
-     * @param privatePropertyNames The private properties to get for the profile, defaults to all.
-     * @param identity The identity to perform the profile operation on.
-     * @returns The items identity and the properties.
-     */
-    async get(publicPropertyNames, privatePropertyNames, identity) {
-        core.Guards.stringValue(IdentityProfileService.CLASS_NAME, "identity", identity);
-        try {
-            const result = await this._identityProfileConnector.get(identity, publicPropertyNames, privatePropertyNames);
-            if (core.Is.undefined(result)) {
-                throw new core.NotFoundError(IdentityProfileService.CLASS_NAME, "notFound", identity);
-            }
-            return {
-                identity,
-                publicProfile: result.publicProfile,
-                privateProfile: result.privateProfile
-            };
-        }
-        catch (error) {
-            if (core.BaseError.someErrorClass(error, IdentityProfileService.CLASS_NAME)) {
-                throw error;
-            }
-            throw new core.GeneralError(IdentityProfileService.CLASS_NAME, "getFailed", undefined, error);
-        }
-    }
-    /**
-     * Get the public profile properties for an identity.
-     * @param identity The identity to perform the profile operation on.
-     * @param propertyNames The properties to get for the item, defaults to all.
-     * @returns The items properties.
-     */
-    async getPublic(identity, propertyNames) {
-        core.Guards.stringValue(IdentityProfileService.CLASS_NAME, "identity", identity);
-        try {
-            const result = await this._identityProfileConnector.get(identity, propertyNames);
-            if (core.Is.undefined(result)) {
-                throw new core.NotFoundError(IdentityProfileService.CLASS_NAME, "notFound", identity);
-            }
-            return result.publicProfile;
-        }
-        catch (error) {
-            if (core.BaseError.someErrorClass(error, IdentityProfileService.CLASS_NAME)) {
-                throw error;
-            }
-            throw new core.GeneralError(IdentityProfileService.CLASS_NAME, "getPublicFailed", undefined, error);
-        }
-    }
-    /**
-     * Update the profile properties of an identity.
-     * @param publicProfile The public profile data as JSON-LD.
-     * @param privateProfile The private profile data as JSON-LD.
-     * @param identity The identity to perform the profile operation on.
-     * @returns Nothing.
-     */
-    async update(publicProfile, privateProfile, identity) {
-        core.Guards.stringValue(IdentityProfileService.CLASS_NAME, "identity", identity);
-        try {
-            const result = await this._identityProfileConnector.get(identity);
-            if (core.Is.undefined(result)) {
-                throw new core.NotFoundError(IdentityProfileService.CLASS_NAME, "notFound", identity);
-            }
-            await this._identityProfileConnector.update(identity, publicProfile, privateProfile);
-        }
-        catch (error) {
-            if (core.BaseError.someErrorClass(error, IdentityProfileService.CLASS_NAME)) {
-                throw error;
-            }
-            throw new core.GeneralError(IdentityProfileService.CLASS_NAME, "updateFailed", { identity }, error);
-        }
-    }
-    /**
-     * Delete the profile for an identity.
-     * @param identity The identity to perform the profile operation on.
-     * @returns Nothing.
-     */
-    async remove(identity) {
-        core.Guards.stringValue(IdentityProfileService.CLASS_NAME, "identity", identity);
-        try {
-            const result = await this._identityProfileConnector.get(identity);
-            if (core.Is.undefined(result)) {
-                throw new core.NotFoundError(IdentityProfileService.CLASS_NAME, "notFound", identity);
-            }
-            await this._identityProfileConnector.remove(identity);
-        }
-        catch (error) {
-            if (core.BaseError.someErrorClass(error, IdentityProfileService.CLASS_NAME)) {
-                throw error;
-            }
-            throw new core.GeneralError(IdentityProfileService.CLASS_NAME, "removeFailed", { identity }, error);
-        }
-    }
-    /**
-     * Get a list of the requested types.
-     * @param publicFilters The filters to apply to the identities public profiles.
-     * @param publicPropertyNames The public properties to get for the profile, defaults to all.
-     * @param cursor The cursor for paged requests.
-     * @param limit The maximum number of items in a page.
-     * @returns The list of items and cursor for paging.
-     */
-    async list(publicFilters, publicPropertyNames, cursor, limit) {
-        try {
-            // We don't want to return private profile for this type of query
-            // as it would expose the values to the REST api
-            return this._identityProfileConnector.list(publicFilters, undefined, publicPropertyNames, undefined, cursor, limit);
-        }
-        catch (error) {
-            throw new core.GeneralError(IdentityProfileService.CLASS_NAME, "listFailed", undefined, error);
-        }
-    }
-}
-
-/**
- * The source used when communicating about these routes.
- */
-const ROUTES_SOURCE$1 = "identityResolverRoutes";
-/**
- * The tag to associate with the routes.
- */
-const tagsIdentityResolver = [
-    {
-        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 generateRestRoutesIdentityResolver(baseRouteName, componentName) {
-    const identityResolveRoute = {
-        operationId: "identityResolve",
-        summary: "Resolve an identity",
-        tag: tagsIdentityResolver[0].name,
-        method: "GET",
-        path: `${baseRouteName}/:identity`,
-        handler: async (httpRequestContext, request) => identityResolve(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IIdentityResolveRequest",
-            examples: [
-                {
-                    id: "identityResolveRequestExample",
-                    request: {
-                        pathParams: {
-                            identity: "did:iota:tst:0xe3088ba9aa8c28e1d139708a14e8c0fdff11ee8223baac4aa5bcf3321e4bfc6a"
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "IIdentityResolveResponse",
-                examples: [
-                    {
-                        id: "identityResolveResponseExample",
-                        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"
-                                    }
-                                ]
-                            }
-                        }
-                    }
-                ]
-            }
-        ],
-        skipAuth: true
-    };
-    return [identityResolveRoute];
-}
-/**
- * Resolve 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 identityResolve(httpRequestContext, componentName, request) {
-    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.identityResolve(request.pathParams.identity);
-    return {
-        body: result
-    };
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class which implements the identity resolver contract.
- */
-class IdentityResolverService {
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "IdentityResolverService";
-    /**
-     * 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.
-     */
-    constructor(options) {
-        const names = identityModels.IdentityResolverConnectorFactory.names();
-        if (names.length === 0) {
-            throw new core.GeneralError(IdentityResolverService.CLASS_NAME, "noConnectors");
-        }
-        this._defaultNamespace = options?.config?.defaultNamespace ?? names[0];
-        this._fallbackResolverConnectorType = options?.fallbackResolverConnectorType ?? "universal";
-    }
-    /**
-     * Resolve an identity.
-     * @param identity The id of the document to resolve.
-     * @returns The resolved document.
-     */
-    async identityResolve(identity) {
-        core.Urn.guard(IdentityResolverService.CLASS_NAME, "identity", identity);
-        try {
-            const identityResolverConnector = this.getConnectorByUri(identity);
-            const document = await identityResolverConnector.resolveDocument(identity);
-            return document;
-        }
-        catch (error) {
-            throw new core.GeneralError(IdentityResolverService.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(IdentityResolverService.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(IdentityResolverService.CLASS_NAME, "namespaceMismatch", {
-                namespace: "did",
-                id
-            });
-        }
-        return this.getConnectorByNamespace(idUri.namespaceMethod());
-    }
-}
-
-/**
- * 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/2018/credentials/v1", "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/2018/credentials/v1", "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/2018/credentials/v1", "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/2018/credentials/v1", "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/2018/credentials/v1",
-                                    "https://www.w3.org/2018/credentials/examples/v1"
-                                ],
-                                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/2018/credentials/v1",
-                                    "https://www.w3.org/2018/credentials/examples/v1"
-                                ],
-                                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, {
-        revocationIndex: request.body.revocationIndex,
-        expirationDate: core.Coerce.date(request.body.expirationDate)
-    }, 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 {
-    /**
-     * Runtime name for the class.
-     */
-    static 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(IdentityService.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(IdentityService.CLASS_NAME, "controller", controller);
-        try {
-            const identityConnector = this.getConnectorByNamespace(namespace);
-            return identityConnector.createDocument(controller);
-        }
-        catch (error) {
-            throw new core.GeneralError(IdentityService.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(IdentityService.CLASS_NAME, "identity", identity);
-        core.Guards.stringValue(IdentityService.CLASS_NAME, "controller", controller);
-        try {
-            const identityConnector = this.getConnectorByUri(identity);
-            return identityConnector.removeDocument(controller, identity);
-        }
-        catch (error) {
-            throw new core.GeneralError(IdentityService.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(IdentityService.CLASS_NAME, "controller", controller);
-        core.Urn.guard(IdentityService.CLASS_NAME, "identity", identity);
-        core.Guards.arrayOneOf(IdentityService.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(IdentityService.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(IdentityService.CLASS_NAME, "controller", controller);
-        core.Urn.guard(IdentityService.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(IdentityService.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(IdentityService.CLASS_NAME, "controller", controller);
-        core.Urn.guard(IdentityService.CLASS_NAME, "identity", identity);
-        core.Guards.stringValue(IdentityService.CLASS_NAME, "serviceId", serviceId);
-        if (core.Is.array(serviceType)) {
-            core.Guards.arrayValue(IdentityService.CLASS_NAME, "serviceType", serviceType);
-        }
-        else {
-            core.Guards.stringValue(IdentityService.CLASS_NAME, "serviceType", serviceType);
-        }
-        if (core.Is.array(serviceEndpoint)) {
-            core.Guards.arrayValue(IdentityService.CLASS_NAME, "serviceEndpoint", serviceEndpoint);
-        }
-        else {
-            core.Guards.stringValue(IdentityService.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(IdentityService.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(IdentityService.CLASS_NAME, "controller", controller);
-        core.Urn.guard(IdentityService.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(IdentityService.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 options Additional options for creating the verifiable credential.
-     * @param options.revocationIndex The bitmap revocation index of the credential, if undefined will not have revocation status.
-     * @param options.expirationDate The date the verifiable credential is valid until.
-     * @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, options, controller) {
-        core.Guards.stringValue(IdentityService.CLASS_NAME, "controller", controller);
-        core.Urn.guard(IdentityService.CLASS_NAME, "verificationMethodId", verificationMethodId);
-        core.Guards.objectValue(IdentityService.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, options);
-            return service;
-        }
-        catch (error) {
-            throw new core.GeneralError(IdentityService.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(IdentityService.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(IdentityService.CLASS_NAME, "jwtDecodeFailed");
-        }
-        try {
-            const identityConnector = this.getConnectorByUri(jwtPayload.iss);
-            const service = await identityConnector.checkVerifiableCredential(credentialJwt);
-            return service;
-        }
-        catch (error) {
-            throw new core.GeneralError(IdentityService.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(IdentityService.CLASS_NAME, "controller", controller);
-        core.Guards.stringValue(IdentityService.CLASS_NAME, "issuerIdentity", issuerIdentity);
-        core.Guards.number(IdentityService.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(IdentityService.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(IdentityService.CLASS_NAME, "controller", controller);
-        core.Guards.stringValue(IdentityService.CLASS_NAME, "issuerIdentity", issuerIdentity);
-        core.Guards.number(IdentityService.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(IdentityService.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(IdentityService.CLASS_NAME, "controller", controller);
-        core.Guards.stringValue(IdentityService.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(IdentityService.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(IdentityService.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(IdentityService.CLASS_NAME, "jwtDecodeFailed");
-        }
-        try {
-            const identityConnector = this.getConnectorByUri(jwtPayload.iss);
-            const service = await identityConnector.checkVerifiablePresentation(presentationJwt);
-            return service;
-        }
-        catch (error) {
-            throw new core.GeneralError(IdentityService.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(IdentityService.CLASS_NAME, "controller", controller);
-        core.Guards.stringValue(IdentityService.CLASS_NAME, "verificationMethodId", verificationMethodId);
-        core.Guards.arrayOneOf(IdentityService.CLASS_NAME, "proofType", proofType, Object.values(standardsW3cDid.ProofTypes));
-        core.Guards.object(IdentityService.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(IdentityService.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(IdentityService.CLASS_NAME, "document", document);
-        core.Guards.object(IdentityService.CLASS_NAME, "proof", proof);
-        core.Guards.stringValue(IdentityService.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(IdentityService.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(IdentityService.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(IdentityService.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",
-        tags: tagsIdentity,
-        generateRoutes: generateRestRoutesIdentity
-    },
-    {
-        name: "identityProfile",
-        defaultBaseRoute: "identity/profile",
-        tags: tagsIdentityProfile,
-        generateRoutes: generateRestRoutesIdentityProfile
-    }
-];
-
-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;