@twin.org/federated-catalogue-service 0.0.1-next.3

package/dist/cjs/index.cjs

@@ -0,0 +1,2149 @@
+'use strict';
+
+var core = require('@twin.org/core');
+var federatedCatalogueModels = require('@twin.org/federated-catalogue-models');
+var standardsGaiaX = require('@twin.org/standards-gaia-x');
+var standardsSchemaOrg = require('@twin.org/standards-schema-org');
+var web = require('@twin.org/web');
+var dataJsonLd = require('@twin.org/data-json-ld');
+var entity = require('@twin.org/entity');
+var entityStorageModels = require('@twin.org/entity-storage-models');
+var identityModels = require('@twin.org/identity-models');
+var loggingModels = require('@twin.org/logging-models');
+var crypto = require('@twin.org/crypto');
+var standardsW3cDid = require('@twin.org/standards-w3c-did');
+
+/**
+ * The source used when communicating about these routes.
+ */
+const ROUTES_SOURCE = "federatedCatalogueRoutes";
+/**
+ * Participants route.
+ */
+const PARTICIPANTS_ROUTE = "participants";
+/**
+ * Service offering route.
+ */
+const SERVICE_OFFERING_ROUTE = "service-offerings";
+/**
+ * Data Resource route.
+ */
+const DATA_RESOURCE_ROUTE = "data-resources";
+/**
+ * Data Space Connector route.
+ */
+const DATA_SPACE_CONNECTOR_ROUTE = "data-space-connectors";
+/**
+ * The tag to associate with the routes.
+ */
+const tagsFederatedCatalogue = [
+    {
+        name: "Federated Catalogue",
+        description: "Endpoints to access a Federated Catalogue."
+    }
+];
+/**
+ * The REST routes for Federated Catalogue.
+ * @param baseRouteName Prefix to prepend to the paths.
+ * @param factoryServiceName The name of the service to use in the routes store in the ServiceFactory.
+ * @returns The generated routes.
+ */
+function generateRestRoutesFederatedCatalogue(baseRouteName, factoryServiceName) {
+    const createParticipantRoute = {
+        operationId: "compliancePresentationRequest",
+        summary: "Present a Compliance Credential",
+        tag: tagsFederatedCatalogue[0].name,
+        method: "POST",
+        path: `${baseRouteName}/participant-credentials`,
+        handler: async (httpRequestContext, request) => complianceCredentialPresentation(baseRouteName, httpRequestContext, factoryServiceName, request),
+        requestType: {
+            mimeType: web.MimeTypes.Jwt,
+            type: "ICompliancePresentationRequest",
+            examples: [
+                {
+                    id: "compliancePresentationRequestExample",
+                    request: {
+                        body: "ey..."
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "ICreatedResponse"
+            },
+            { type: "IUnprocessableEntityResponse" }
+        ]
+    };
+    const createServiceOfferingRoute = {
+        operationId: "serviceOfferingPresentationRequest",
+        summary: "Present a Service Offering Credential",
+        tag: tagsFederatedCatalogue[0].name,
+        method: "POST",
+        path: `${baseRouteName}/service-offering-credentials`,
+        handler: async (httpRequestContext, request) => serviceOfferingCredentialPresentation(baseRouteName, httpRequestContext, factoryServiceName, request),
+        requestType: {
+            mimeType: web.MimeTypes.Jwt,
+            type: "ICompliancePresentationRequest",
+            examples: [
+                {
+                    id: "serviceOfferingPresentationRequestExample",
+                    request: {
+                        body: "ey..."
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "ICreatedResponse"
+            },
+            { type: "IUnprocessableEntityResponse" }
+        ]
+    };
+    const createDataSpaceConnectorRoute = {
+        operationId: "dataSpaceConnectorPresentationRequest",
+        summary: "Present a Data Space Connector Credential",
+        tag: tagsFederatedCatalogue[0].name,
+        method: "POST",
+        path: `${baseRouteName}/data-space-connector-credentials`,
+        handler: async (httpRequestContext, request) => dataSpaceConnectorCredentialPresentation(baseRouteName, httpRequestContext, factoryServiceName, request),
+        requestType: {
+            mimeType: web.MimeTypes.Jwt,
+            type: "ICompliancePresentationRequest",
+            examples: [
+                {
+                    id: "dataSpaceConnectorPresentationRequestExample",
+                    request: {
+                        body: "ey..."
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "ICreatedResponse"
+            },
+            { type: "IUnprocessableEntityResponse" }
+        ]
+    };
+    const createDataResourceRoute = {
+        operationId: "dataResourcePresentationRequest",
+        summary: "Present a Data Resource Credential",
+        tag: tagsFederatedCatalogue[0].name,
+        method: "POST",
+        path: `${baseRouteName}/data-resource-credentials`,
+        handler: async (httpRequestContext, request) => dataResourceCredentialPresentation(baseRouteName, httpRequestContext, factoryServiceName, request),
+        requestType: {
+            mimeType: web.MimeTypes.Jwt,
+            type: "ICompliancePresentationRequest",
+            examples: [
+                {
+                    id: "dataResourcePresentationRequestExample",
+                    request: {
+                        body: "ey..."
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "ICreatedResponse"
+            },
+            { type: "IUnprocessableEntityResponse" }
+        ]
+    };
+    const participantEntryExample = {
+        "@context": federatedCatalogueModels.FederatedCatalogueContextInstances.DEFAULT_LD_CONTEXT_ENTRY,
+        id: "did:iota:xxx",
+        type: standardsGaiaX.GaiaXTypes.Participant,
+        registrationNumber: {
+            type: standardsGaiaX.GaiaXTypes.LocalRegistrationNumber,
+            local: "P1234567"
+        },
+        legalName: "A Inc.",
+        issuer: "did:iota:zzz",
+        legalAddress: {
+            type: standardsGaiaX.GaiaXTypes.Address,
+            countryCode: "KE"
+        },
+        validFrom: "2024-08-01T12:00:00Z",
+        validUntil: "2025-08-01T12:00:00Z",
+        dateCreated: "2024-08-02T13:45:00Z",
+        evidence: ["https://credentials.example.org/1234567"]
+    };
+    const listParticipantsRoute = {
+        operationId: "federatedCatalogueListParticipants",
+        summary: "Get a list of the participant entries",
+        tag: tagsFederatedCatalogue[0].name,
+        method: "GET",
+        path: `${baseRouteName}/${PARTICIPANTS_ROUTE}`,
+        handler: async (httpRequestContext, request) => participantList(httpRequestContext, factoryServiceName, request),
+        requestType: {
+            type: "IParticipantListRequest",
+            examples: [
+                {
+                    id: "participantListRequestExample",
+                    request: {
+                        query: {
+                            registrationNumber: "abc"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IParticipantListResponse",
+                examples: [
+                    {
+                        id: "participantListResponseExample",
+                        response: {
+                            body: {
+                                "@context": federatedCatalogueModels.FederatedCatalogueContextInstances.DEFAULT_LD_CONTEXT_ENTRY_LIST,
+                                type: standardsSchemaOrg.SchemaOrgTypes.ItemList,
+                                itemListElement: [
+                                    {
+                                        ...participantEntryExample
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const getParticipantRoute = {
+        operationId: "federatedCatalogueGetParticipant",
+        summary: "Get a participant",
+        tag: tagsFederatedCatalogue[0].name,
+        method: "GET",
+        path: `${baseRouteName}/${PARTICIPANTS_ROUTE}/:id`,
+        handler: async (httpRequestContext, request) => participantGet(httpRequestContext, factoryServiceName, request),
+        requestType: {
+            type: "ICatalogueEntryGetRequest",
+            examples: [
+                {
+                    id: "participantGetRequestExample",
+                    request: {
+                        pathParams: {
+                            id: "did:iota:123456"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IParticipantGetResponse",
+                examples: [
+                    {
+                        id: "participantGetResponseExample",
+                        response: {
+                            body: { ...participantEntryExample }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const servicePolicyExample = {
+        "@context": [
+            "https://www.w3.org/ns/odrl.jsonld",
+            {
+                twin: "https://schema.twindev.org/odrl/",
+                jsonPathSelector: "twin:jsonPathSelector"
+            }
+        ],
+        "@type": "Agreement",
+        uid: "http://example.com/policy:1010",
+        assigner: "did:iota:testnet:0x1a7bded4d22dc54722435d624e4323e10fcbc570cd57462eabbf3a5ab2ced24f",
+        assignee: "did:iota:testnet:0x119adb64d01d3b0fa0d308c67db90ab1c6e0df6aebe5b7e0250783f57cd10c21",
+        permission: [
+            {
+                target: {
+                    type: "https://vocabulary.uncefact.org/Document",
+                    refinement: {
+                        leftOperand: {
+                            "@id": "https://w3id.org/twin/odrl/propertyValue",
+                            jsonPathSelector: ".documentTypeCode"
+                        },
+                        operator: "eq",
+                        rightOperand: "https://vocabulary.uncefact.org/DocumentCodeList#331"
+                    }
+                },
+                action: "extract"
+            }
+        ]
+    };
+    const serviceOfferingEntryExample = {
+        "@context": federatedCatalogueModels.FederatedCatalogueContextInstances.DEFAULT_LD_CONTEXT_ENTRY,
+        id: "http://example.org/is123456",
+        name: "Service 1",
+        type: standardsGaiaX.GaiaXTypes.ServiceOffering,
+        servicePolicy: [servicePolicyExample],
+        endpoint: {
+            type: standardsGaiaX.GaiaXTypes.Endpoint,
+            endpointURL: "https://endpoint.example.org/api"
+        },
+        issuer: "did:iota:7890",
+        providedBy: "did:iota:1234567",
+        validFrom: "2024-08-01T12:00:00Z",
+        validUntil: "2025-08-01T12:00:00Z",
+        dateCreated: "2024-08-02T13:45:00Z",
+        evidence: ["https://credentials.example.org/1234567"]
+    };
+    const listServicesRoute = {
+        operationId: "federatedCatalogueListServices",
+        summary: "Get a list of the service entries",
+        tag: tagsFederatedCatalogue[0].name,
+        method: "GET",
+        path: `${baseRouteName}/${SERVICE_OFFERING_ROUTE}`,
+        handler: async (httpRequestContext, request) => serviceOfferingList(httpRequestContext, factoryServiceName, request),
+        requestType: {
+            type: "IServiceOfferingListRequest",
+            examples: [
+                {
+                    id: "serviceOfferingListRequestExample",
+                    request: {
+                        query: {
+                            providedBy: "did:iota:1234"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IServiceOfferingListResponse",
+                examples: [
+                    {
+                        id: "serviceOfferingListResponseExample",
+                        response: {
+                            body: {
+                                "@context": federatedCatalogueModels.FederatedCatalogueContextInstances.DEFAULT_LD_CONTEXT_ENTRY_LIST,
+                                type: standardsSchemaOrg.SchemaOrgTypes.ItemList,
+                                itemListElement: [
+                                    {
+                                        ...serviceOfferingEntryExample
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const getServiceRoute = {
+        operationId: "federatedCatalogueGetService",
+        summary: "Get a Service Offering entry",
+        tag: tagsFederatedCatalogue[0].name,
+        method: "GET",
+        path: `${baseRouteName}/${SERVICE_OFFERING_ROUTE}/:id`,
+        handler: async (httpRequestContext, request) => serviceOfferingGet(httpRequestContext, factoryServiceName, request),
+        requestType: {
+            type: "ICatalogueEntryGetRequest",
+            examples: [
+                {
+                    id: "serviceOfferingGetRequestExample",
+                    request: {
+                        pathParams: {
+                            id: "https://my-services.example.org/service1"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IServiceOfferingGetResponse",
+                examples: [
+                    {
+                        id: "serviceOfferingGetResponseExample",
+                        response: {
+                            body: {
+                                ...serviceOfferingEntryExample
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const resourcePolicyExample = {
+        "@context": ["https://www.w3.org/ns/odrl.jsonld"],
+        "@type": "Offer",
+        uid: "http://example.com/policy:1010",
+        assigner: "did:iota:testnet:0x1a7bded4d22dc54722435d624e4323e10fcbc570cd57462eabbf3a5ab2ced24f",
+        permission: [
+            {
+                target: {
+                    type: "https://vocabulary.uncefact.org/Document"
+                },
+                action: "extract"
+            }
+        ]
+    };
+    const dataResourceEntryExample = {
+        "@context": federatedCatalogueModels.FederatedCatalogueContextInstances.DEFAULT_LD_CONTEXT_ENTRY,
+        id: "http://example.org/is123456",
+        name: "Data Resource 1",
+        type: "DataResource",
+        copyrightOwnedBy: "did:iota:1234",
+        license: "http://licenses.example.org/12345",
+        resourcePolicy: [resourcePolicyExample],
+        exposedThrough: "https://ds-connectors.example.org/ds1",
+        producedBy: "did:iota:1234567",
+        issuer: "did:iota:987654",
+        validFrom: "2024-08-01T12:00:00Z",
+        validUntil: "2025-08-01T12:00:00Z",
+        dateCreated: "2024-08-02T13:45:00Z",
+        evidence: ["https://credentials.example.org/1234567"]
+    };
+    const listDataResourcesRoute = {
+        operationId: "federatedCatalogueListResources",
+        summary: "Get a list of the data resource entries",
+        tag: tagsFederatedCatalogue[0].name,
+        method: "GET",
+        path: `${baseRouteName}/${DATA_RESOURCE_ROUTE}`,
+        handler: async (httpRequestContext, request) => dataResourceList(httpRequestContext, factoryServiceName, request),
+        requestType: {
+            type: "IDataResourceListRequest",
+            examples: [
+                {
+                    id: "dataResourceListRequestExample",
+                    request: {
+                        query: {
+                            producedBy: "did:iota:1234"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IDataResourceListResponse",
+                examples: [
+                    {
+                        id: "dataResourceListResponseExample",
+                        response: {
+                            body: {
+                                "@context": federatedCatalogueModels.FederatedCatalogueContextInstances.DEFAULT_LD_CONTEXT_ENTRY_LIST,
+                                type: standardsSchemaOrg.SchemaOrgTypes.ItemList,
+                                itemListElement: [
+                                    {
+                                        ...dataResourceEntryExample
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const getDataResourceRoute = {
+        operationId: "federatedCatalogueGetDataResource",
+        summary: "Get a Data Resource entry",
+        tag: tagsFederatedCatalogue[0].name,
+        method: "GET",
+        path: `${baseRouteName}/${DATA_RESOURCE_ROUTE}/:id`,
+        handler: async (httpRequestContext, request) => dataResourceGet(httpRequestContext, factoryServiceName, request),
+        requestType: {
+            type: "IDataResourceListRequest",
+            examples: [
+                {
+                    id: "dataResourceListRequestExample",
+                    request: {
+                        pathParams: {
+                            id: "https://data-resources.example.org/drs1"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IDataResourceGetResponse",
+                examples: [
+                    {
+                        id: "dataResourceGetResponseExample",
+                        response: {
+                            body: {
+                                ...dataResourceEntryExample
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const dataSpaceConnectorEntryExample = {
+        "@context": federatedCatalogueModels.FederatedCatalogueContextInstances.DEFAULT_LD_CONTEXT_ENTRY,
+        id: "https://my-ds-connectors.example.org/ds-connector-ABCD",
+        type: [standardsGaiaX.GaiaXTypes.DataExchangeComponent, federatedCatalogueModels.FederatedCatalogueTypes.DataSpaceConnector],
+        identity: "did:iota:testnet:123456",
+        defaultEndpoint: {
+            type: standardsGaiaX.GaiaXTypes.Endpoint,
+            endpointURL: "https://my-twin-node.example.org:9000/twin-ds-connector"
+        },
+        subscriptionActivityEndpoint: {
+            type: standardsGaiaX.GaiaXTypes.Endpoint,
+            endpointURL: "/subscriptions"
+        },
+        pushActivityEndpoint: {
+            type: standardsGaiaX.GaiaXTypes.Endpoint,
+            endpointURL: "/notify"
+        },
+        pullDataEndpoint: {
+            type: standardsGaiaX.GaiaXTypes.Endpoint,
+            endpointURL: "/data"
+        },
+        maintainer: "did:iota:99999",
+        offeredResource: ["https://my-data-resource.example.org"],
+        issuer: "did:iota:987654",
+        validFrom: "2024-08-01T12:00:00Z",
+        validUntil: "2025-08-01T12:00:00Z",
+        dateCreated: "2024-08-02T13:45:00Z",
+        evidence: ["https://credentials.example.org/1234567"]
+    };
+    const listDataSpaceConnectorsRoute = {
+        operationId: "federatedCatalogueListDataSpaceConnectors",
+        summary: "Get a list of the Data Space connectors entries",
+        tag: tagsFederatedCatalogue[0].name,
+        method: "GET",
+        path: `${baseRouteName}/${DATA_SPACE_CONNECTOR_ROUTE}`,
+        handler: async (httpRequestContext, request) => dataSpaceConnectorList(httpRequestContext, factoryServiceName, request),
+        requestType: {
+            type: "IDataSpaceConnectorListRequest",
+            examples: [
+                {
+                    id: "dataSpaceConnectorListRequestExample",
+                    request: {
+                        query: {
+                            maintainedBy: "did:iota:1234"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IDataSpaceConnectorListResponse",
+                examples: [
+                    {
+                        id: "dataSpaceConnectorListResponseExample",
+                        response: {
+                            body: {
+                                "@context": federatedCatalogueModels.FederatedCatalogueContextInstances.DEFAULT_LD_CONTEXT_ENTRY_LIST,
+                                type: standardsSchemaOrg.SchemaOrgTypes.ItemList,
+                                itemListElement: [
+                                    {
+                                        ...dataSpaceConnectorEntryExample
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const getDataSpaceConnectorRoute = {
+        operationId: "federatedCatalogueGetDataSpaceConnector",
+        summary: "Get a Data Space Connector entry",
+        tag: tagsFederatedCatalogue[0].name,
+        method: "GET",
+        path: `${baseRouteName}/${DATA_SPACE_CONNECTOR_ROUTE}/:id`,
+        handler: async (httpRequestContext, request) => dataSpaceConnectorGet(httpRequestContext, factoryServiceName, request),
+        requestType: {
+            type: "ICatalogueEntryGetRequest",
+            examples: [
+                {
+                    id: "dataSpaceConnectorGetRequestExample",
+                    request: {
+                        pathParams: {
+                            id: "https://ds-connectors.example.org/ds1"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IDataSpaceConnectorGetResponse",
+                examples: [
+                    {
+                        id: "dataSpaceConnectorGetResponseExample",
+                        response: {
+                            body: {
+                                ...dataSpaceConnectorEntryExample
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    return [
+        createParticipantRoute,
+        createServiceOfferingRoute,
+        createDataResourceRoute,
+        createDataSpaceConnectorRoute,
+        listParticipantsRoute,
+        getParticipantRoute,
+        listServicesRoute,
+        getServiceRoute,
+        listDataResourcesRoute,
+        getDataResourceRoute,
+        listDataSpaceConnectorsRoute,
+        getDataSpaceConnectorRoute
+    ];
+}
+/**
+ * Register a new participant.
+ * @param baseRouteName The base route name.
+ * @param httpRequestContext The request context for the API.
+ * @param factoryServiceName The name of the service to use in the routes.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function complianceCredentialPresentation(baseRouteName, httpRequestContext, factoryServiceName, request) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.body", request.body);
+    const service = core.ComponentFactory.get(factoryServiceName);
+    const participantId = await service.registerComplianceCredential(request.body);
+    const searchParams = new URLSearchParams();
+    searchParams.append(federatedCatalogueModels.FederatedCatalogueTypes.Id, participantId);
+    return {
+        headers: {
+            location: `${baseRouteName}/${PARTICIPANTS_ROUTE}?${searchParams.toString()}`
+        },
+        statusCode: web.HttpStatusCode.created
+    };
+}
+/**
+ * Get a list of the participant entries.
+ * @param httpRequestContext The request context for the API.
+ * @param factoryServiceName The name of the service to use in the routes.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function participantList(httpRequestContext, factoryServiceName, request) {
+    const service = core.ComponentFactory.get(factoryServiceName);
+    const itemsAndCursor = await service.queryParticipants(request?.query?.id, request?.query?.registrationNumber, request?.query?.lrnType, request?.query?.cursor, core.Coerce.number(request?.query?.pageSize));
+    return {
+        body: {
+            ...itemsAndCursor
+        }
+    };
+}
+/**
+ * Get a Participant entry.
+ * @param httpRequestContext The request context for the API.
+ * @param factoryServiceName The name of the service to use in the routes.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function participantGet(httpRequestContext, factoryServiceName, request) {
+    const service = core.ComponentFactory.get(factoryServiceName);
+    const id = request?.pathParams.id;
+    core.Guards.stringValue(ROUTES_SOURCE, "id", id);
+    return {
+        body: (await service.getEntry(standardsGaiaX.GaiaXTypes.Participant, id))
+    };
+}
+/**
+ * Register a new service offering.
+ * @param baseRouteName The base route used.
+ * @param httpRequestContext The request context for the API.
+ * @param factoryServiceName The name of the service to use in the routes.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function serviceOfferingCredentialPresentation(baseRouteName, httpRequestContext, factoryServiceName, request) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.body", request.body);
+    const service = core.ComponentFactory.get(factoryServiceName);
+    const serviceOfferingsCreated = await service.registerServiceOfferingCredential(request.body);
+    // Prepare the Ids to be returned
+    const searchParams = new URLSearchParams();
+    for (const serviceOffering of serviceOfferingsCreated) {
+        searchParams.append(federatedCatalogueModels.FederatedCatalogueTypes.Id, serviceOffering);
+    }
+    return {
+        headers: {
+            location: `${baseRouteName}/${SERVICE_OFFERING_ROUTE}?${searchParams.toString()}`
+        },
+        statusCode: web.HttpStatusCode.created
+    };
+}
+/**
+ * Get a list of the service offering entries.
+ * @param httpRequestContext The request context for the API.
+ * @param factoryServiceName The name of the service to use in the routes.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function serviceOfferingList(httpRequestContext, factoryServiceName, request) {
+    const service = core.ComponentFactory.get(factoryServiceName);
+    const itemsAndCursor = await service.queryServiceOfferings(request?.query.id, request?.query.providedBy, request?.query.cursor, core.Coerce.number(request?.query?.pageSize));
+    return {
+        body: {
+            ...itemsAndCursor
+        }
+    };
+}
+/**
+ * Get a Service Offering entry.
+ * @param httpRequestContext The request context for the API.
+ * @param factoryServiceName The name of the service to use in the routes.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function serviceOfferingGet(httpRequestContext, factoryServiceName, request) {
+    const service = core.ComponentFactory.get(factoryServiceName);
+    const id = request?.pathParams.id;
+    core.Guards.stringValue(ROUTES_SOURCE, "id", id);
+    return {
+        body: (await service.getEntry(standardsGaiaX.GaiaXTypes.ServiceOffering, id))
+    };
+}
+/**
+ * Register a new data resource.
+ * @param baseRouteName The base route name.
+ * @param httpRequestContext The request context for the API.
+ * @param factoryServiceName The name of the service to use in the routes.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function dataResourceCredentialPresentation(baseRouteName, httpRequestContext, factoryServiceName, request) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.body", request.body);
+    const service = core.ComponentFactory.get(factoryServiceName);
+    const dataResourcesCreated = await service.registerDataResourceCredential(request.body);
+    // Prepare the Ids to be returned
+    const searchParams = new URLSearchParams();
+    for (const dataResource of dataResourcesCreated) {
+        searchParams.append(federatedCatalogueModels.FederatedCatalogueTypes.Id, dataResource);
+    }
+    return {
+        headers: {
+            location: `${baseRouteName}/${DATA_RESOURCE_ROUTE}?${searchParams.toString()}`
+        },
+        statusCode: web.HttpStatusCode.created
+    };
+}
+/**
+ * Get a list of the data resource entries.
+ * @param httpRequestContext The request context for the API.
+ * @param factoryServiceName The name of the service to use in the routes.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function dataResourceList(httpRequestContext, factoryServiceName, request) {
+    const service = core.ComponentFactory.get(factoryServiceName);
+    const itemsAndCursor = await service.queryDataResources(request?.query.id, request?.query.producedBy, request?.query.cursor, core.Coerce.number(request?.query?.pageSize));
+    return {
+        body: {
+            ...itemsAndCursor
+        }
+    };
+}
+/**
+ * Get a Data Resource entry.
+ * @param httpRequestContext The request context for the API.
+ * @param factoryServiceName The name of the service to use in the routes.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function dataResourceGet(httpRequestContext, factoryServiceName, request) {
+    const service = core.ComponentFactory.get(factoryServiceName);
+    const id = request?.pathParams.id;
+    core.Guards.stringValue(ROUTES_SOURCE, "id", id);
+    return {
+        body: (await service.getEntry(standardsGaiaX.GaiaXTypes.DataResource, id))
+    };
+}
+/**
+ * Register a new data space connector.
+ * @param baseRouteName the base route name.
+ * @param httpRequestContext The request context for the API.
+ * @param factoryServiceName The name of the service to use in the routes.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function dataSpaceConnectorCredentialPresentation(baseRouteName, httpRequestContext, factoryServiceName, request) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.body", request.body);
+    const service = core.ComponentFactory.get(factoryServiceName);
+    const dataSpaceConnectorId = await service.registerDataSpaceConnectorCredential(request.body);
+    const searchParams = new URLSearchParams();
+    searchParams.append("id", dataSpaceConnectorId);
+    return {
+        headers: {
+            location: `${baseRouteName}/${DATA_SPACE_CONNECTOR_ROUTE}?${searchParams.toString()}`
+        },
+        statusCode: web.HttpStatusCode.created
+    };
+}
+/**
+ * Get a list of the data space connector entries.
+ * @param httpRequestContext The request context for the API.
+ * @param factoryServiceName The name of the service to use in the routes.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function dataSpaceConnectorList(httpRequestContext, factoryServiceName, request) {
+    const service = core.ComponentFactory.get(factoryServiceName);
+    const itemsAndCursor = await service.queryDataSpaceConnectors(request?.query.id, request?.query.maintainedBy, request?.query.cursor, core.Coerce.number(request?.query?.pageSize));
+    return {
+        body: {
+            ...itemsAndCursor
+        }
+    };
+}
+/**
+ * Get a Data Space Connector entry.
+ * @param httpRequestContext The request context for the API.
+ * @param factoryServiceName The name of the service to use in the routes.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function dataSpaceConnectorGet(httpRequestContext, factoryServiceName, request) {
+    const service = core.ComponentFactory.get(factoryServiceName);
+    const id = request?.pathParams.id;
+    core.Guards.stringValue(ROUTES_SOURCE, "id", id);
+    return {
+        body: (await service.getEntry(standardsGaiaX.GaiaXTypes.DataExchangeComponent, id))
+    };
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Compliance Credential Verification Service.
+ */
+class ComplianceCredentialVerificationService {
+    /**
+     * Class name
+     */
+    CLASS_NAME = "ComplianceCredentialVerificationService";
+    /**
+     * Resolver component.
+     * @internal
+     */
+    _resolver;
+    /**
+     * Resolver component.
+     * @internal
+     */
+    _subResourceCacheTtlMs;
+    /**
+     * Logging Component.
+     * @internal
+     */
+    _logger;
+    /**
+     * List of clearing houses tha are approvers.
+     * @internal
+     */
+    _clearingHouseApproverList;
+    /**
+     * Constructor.
+     * @param clearingHouseApproverList The list of clearing house identities approved.
+     * @param resolver The resolver used for DID.
+     * @param subResourceCacheTtlMs The time to live (in ms) of sub-resource objects in the cache. undefined means no cache. 0 means live in cache forever.
+     * @param logger The Logger Component.
+     */
+    constructor(clearingHouseApproverList, resolver, subResourceCacheTtlMs, logger) {
+        this._clearingHouseApproverList = clearingHouseApproverList;
+        this._resolver = resolver;
+        this._subResourceCacheTtlMs = subResourceCacheTtlMs;
+        this._logger = logger;
+    }
+    /**
+     * Verifies a Compliance Credential.
+     * @param credential The Credential to be verified
+     * @returns The Verification Result.
+     */
+    async verify(credential) {
+        if (!core.Is.arrayValue(credential.type) ||
+            !credential.type.includes(federatedCatalogueModels.FederatedCatalogueTypes.ComplianceCredential)) {
+            return {
+                verified: false,
+                verificationFailureReason: federatedCatalogueModels.VerificationFailureReasons.InvalidCredentialType,
+                credentials: []
+            };
+        }
+        const issuer = core.Is.string(credential.issuer)
+            ? credential.issuer
+            : core.Coerce.object(credential.issuer)?.id;
+        if (core.Is.undefined(issuer)) {
+            return {
+                verified: false,
+                verificationFailureReason: federatedCatalogueModels.VerificationFailureReasons.InvalidIssuer,
+                credentials: []
+            };
+        }
+        if (!this._clearingHouseApproverList.includes(issuer)) {
+            return {
+                verified: false,
+                verificationFailureReason: federatedCatalogueModels.VerificationFailureReasons.InvalidIssuer,
+                credentials: []
+            };
+        }
+        const validFrom = credential.validFrom;
+        const validFromDate = core.Coerce.dateTime(validFrom);
+        if (core.Is.undefined(validFromDate) || validFromDate.getTime() > Date.now()) {
+            return {
+                verified: false,
+                verificationFailureReason: federatedCatalogueModels.VerificationFailureReasons.NotValidYet,
+                credentials: []
+            };
+        }
+        const validUntilDate = core.Coerce.dateTime(credential.validUntil);
+        if (core.Is.undefined(validUntilDate)) {
+            return {
+                verified: false,
+                verificationFailureReason: federatedCatalogueModels.VerificationFailureReasons.NoValidityEndPeriod,
+                credentials: []
+            };
+        }
+        if (validUntilDate.getTime() <= Date.now()) {
+            return {
+                verified: false,
+                verificationFailureReason: federatedCatalogueModels.VerificationFailureReasons.Expired,
+                credentials: []
+            };
+        }
+        const subject = credential.credentialSubject;
+        if (!subject) {
+            return {
+                verified: false,
+                verificationFailureReason: federatedCatalogueModels.VerificationFailureReasons.MissingSubject,
+                credentials: []
+            };
+        }
+        const evidences = core.Is.array(credential.evidence) ? credential.evidence : [credential.evidence];
+        if (evidences.length === 0) {
+            return {
+                verified: false,
+                verificationFailureReason: federatedCatalogueModels.VerificationFailureReasons.MissingEvidences,
+                credentials: []
+            };
+        }
+        const finalResult = {
+            verified: true,
+            credentials: []
+        };
+        for (const evidence of evidences) {
+            const verResult = await this.verifyEvidence(evidence);
+            if (!verResult.verified) {
+                return {
+                    verified: false,
+                    verificationFailureReason: federatedCatalogueModels.VerificationFailureReasons.EvidenceCannotBeVerified,
+                    evidenceVerificationResult: verResult,
+                    credentials: [],
+                    evidenceFailedToVerify: [evidence.id]
+                };
+            }
+            finalResult.credentials.push(verResult.credential);
+        }
+        return finalResult;
+    }
+    /**
+     * Verifies the evidence supplied as part of a Compliance Credential.
+     * @param evidence The compliance evidence
+     * @returns The verification result with the original credentials that served as evidence
+     */
+    async verifyEvidence(evidence) {
+        // The credential associated to the evidence has to be retrieved, then verified
+        core.Guards.object(this.CLASS_NAME, "IComplianceEvidence", evidence);
+        const credentialUrl = evidence.id;
+        this._logger?.log({
+            source: this.CLASS_NAME,
+            level: "info",
+            message: "verifyingEvidenceCredential",
+            ts: Date.now(),
+            data: {
+                credentialUrl
+            }
+        });
+        const credentialResponse = await web.FetchHelper.fetch(this.CLASS_NAME, credentialUrl, "GET", undefined, { cacheTtlMs: this._subResourceCacheTtlMs });
+        if (!credentialResponse.ok) {
+            this._logger?.log({
+                source: this.CLASS_NAME,
+                level: "error",
+                message: "credentialCannotBeRetrieved",
+                ts: Date.now(),
+                data: {
+                    credentialUrl,
+                    statusCode: credentialResponse.status
+                }
+            });
+            return {
+                verified: false,
+                verificationFailureReason: federatedCatalogueModels.VerificationFailureReasons.EvidenceCannotBeRetrieved
+            };
+        }
+        const originalCredential = await credentialResponse.json();
+        const theCredential = core.ObjectHelper.clone(originalCredential);
+        const proof = theCredential.proof;
+        // The proof is not taken into account to calculate the hash
+        delete theCredential.proof;
+        // Checking the hash
+        const canonicalized = core.JsonHelper.canonicalize(theCredential);
+        const hashingDetails = evidence.digestSRI;
+        const [hashingAlg, hash] = hashingDetails.split("-");
+        let hashToCheck = "";
+        if (hashingAlg === "sha256") {
+            hashToCheck = core.Converter.bytesToBase64(crypto.Sha256.sum256(core.Converter.utf8ToBytes(canonicalized)));
+        }
+        else if (hashingAlg === "sha512") {
+            hashToCheck = core.Converter.bytesToBase64(crypto.Sha512.sum512(core.Converter.utf8ToBytes(canonicalized)));
+        }
+        else {
+            throw new core.UnprocessableError(this.CLASS_NAME, "unknownHashingAlgorithm", { hashingAlg });
+        }
+        if (hashToCheck !== hash) {
+            return {
+                verified: false,
+                verificationFailureReason: federatedCatalogueModels.VerificationFailureReasons.IntegrityCheckFailed
+            };
+        }
+        const { id } = identityModels.DocumentHelper.parseId(proof.verificationMethod);
+        const documentId = theCredential.issuer ?? id;
+        core.Guards.stringValue(this.CLASS_NAME, "documentId", documentId);
+        let verified = false;
+        try {
+            const document = await this._resolver.identityResolve(documentId);
+            const jwk = identityModels.DocumentHelper.getJwk(document, proof.verificationMethod);
+            verified = await standardsW3cDid.ProofHelper.verifyProof(theCredential, proof, jwk);
+        }
+        catch (error) {
+            this._logger?.log({
+                source: this.CLASS_NAME,
+                level: "error",
+                message: "credentialVerificationError",
+                ts: Date.now(),
+                error: error,
+                data: {
+                    credentialUrl
+                }
+            });
+            return {
+                verified,
+                verificationFailureReason: federatedCatalogueModels.VerificationFailureReasons.GeneralVerificationError
+            };
+        }
+        this._logger?.log({
+            source: this.CLASS_NAME,
+            level: "info",
+            message: "credentialEvidenceVerified",
+            ts: Date.now(),
+            data: {
+                credentialUrl
+            }
+        });
+        return {
+            verified: true,
+            credential: originalCredential
+        };
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Service for performing logging operations to a connector.
+ */
+class FederatedCatalogueService {
+    /**
+     * Fields to skip when persisting entries to the Catalogue
+     * @internal
+     */
+    static _FIELDS_TO_SKIP = ["@context", "type"];
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "FederatedCatalogueService";
+    /**
+     * The identity resolver used to dereference DIDs.
+     * @internal
+     */
+    _resolver;
+    /**
+     * Logging service.
+     * @internal
+     */
+    _loggingService;
+    /**
+     * Storage service for participants.
+     * @internal
+     */
+    _entityStorageParticipants;
+    /**
+     * Storage service for service offering.
+     * @internal
+     */
+    _entityStorageServiceOfferings;
+    /**
+     * Storage service for data resources.
+     * @internal
+     */
+    _entityStorageDataResources;
+    /**
+     * Storage service for data resources.
+     * @internal
+     */
+    _entityStorageDataSpaceConnectors;
+    /**
+     * Compliance Credential Verifier service.
+     * @internal
+     */
+    _complianceCredentialVerifier;
+    /**
+     * Create a new instance of FederatedCatalogue service.
+     * @param options The options for the connector.
+     */
+    constructor(options) {
+        this._loggingService = loggingModels.LoggingConnectorFactory.getIfExists(options?.loggingConnectorType ?? "logging");
+        this._entityStorageParticipants = entityStorageModels.EntityStorageConnectorFactory.get(options.participantEntityStorageType ?? core.StringHelper.kebabCase("ParticipantEntry"));
+        this._entityStorageServiceOfferings = entityStorageModels.EntityStorageConnectorFactory.get(options.serviceOfferingEntityStorageType ??
+            core.StringHelper.kebabCase("ServiceOfferingEntry"));
+        this._entityStorageDataResources = entityStorageModels.EntityStorageConnectorFactory.get(options.dataResourceEntityStorageType ?? core.StringHelper.kebabCase("DataResourceEntry"));
+        this._entityStorageDataSpaceConnectors = entityStorageModels.EntityStorageConnectorFactory.get(options.dataSpaceConnectorStorageType ??
+            core.StringHelper.kebabCase("DataSpaceConnectorEntry"));
+        this._resolver = core.ComponentFactory.get(options.identityResolverComponentType ?? "identity-resolver");
+        this._complianceCredentialVerifier = new ComplianceCredentialVerificationService(options.config.clearingHouseApproverList, this._resolver, options.config.subResourceCacheTtlMs, this._loggingService);
+        standardsSchemaOrg.SchemaOrgDataTypes.registerRedirects();
+    }
+    /**
+     * Registers a Participant's compliance Credential.
+     * @param credentialJwt The credential (wrapped into a presentation) as JWT.
+     * @returns The Id of the Participant (DID usually).
+     */
+    async registerComplianceCredential(credentialJwt) {
+        core.Guards.string(this.CLASS_NAME, "credentialJwt", credentialJwt);
+        // This will raise exceptions as it has been coded reusing code from Gaia-X
+        const complianceCredential = await this.decodeJwt(credentialJwt);
+        const result = await this._complianceCredentialVerifier.verify(complianceCredential);
+        if (!result.verified) {
+            this._loggingService?.log({
+                level: "error",
+                source: this.CLASS_NAME,
+                ts: Date.now(),
+                message: "complianceCredentialNotVerified",
+                data: { result }
+            });
+            throw new core.UnprocessableError(this.CLASS_NAME, "complianceCredentialNotVerified", {
+                reason: result.verificationFailureReason
+            });
+        }
+        const targetCredential = result.credentials.find(credential => credential.credentialSubject.type === standardsGaiaX.GaiaXTypes.Participant);
+        if (core.Is.undefined(targetCredential)) {
+            throw new core.UnprocessableError(this.CLASS_NAME, "noEvidence");
+        }
+        const participantEntry = this.extractParticipantEntry(complianceCredential, targetCredential);
+        const theEntry = core.ObjectHelper.omit(participantEntry, FederatedCatalogueService._FIELDS_TO_SKIP);
+        await this._entityStorageParticipants.set(theEntry);
+        await this._loggingService?.log({
+            level: "info",
+            source: this.CLASS_NAME,
+            ts: Date.now(),
+            message: "complianceCredentialVerified",
+            data: {
+                participantId: complianceCredential.credentialSubject?.id,
+                trustedIssuer: complianceCredential.issuer
+            }
+        });
+        return participantEntry.id;
+    }
+    /**
+     * Query the federated catalogue.
+     * @param id The identity of the participant.
+     * @param legalRegistrationNumber The legal registration number.
+     * @param lrnType The legal registration number type (EORI, VATID, GLEIF, KENYA_PIN, etc.)
+     * @param cursor The cursor to request the next page of entities.
+     * @param pageSize The maximum number of entities in a page.
+     * @returns All the entities for the storage matching the conditions,
+     * and a cursor which can be used to request more entities.
+     * @throws NotImplementedError if the implementation does not support retrieval.
+     */
+    async queryParticipants(id, legalRegistrationNumber, lrnType, cursor, pageSize) {
+        const conditions = [];
+        if (core.Is.stringValue(id)) {
+            const condition = {
+                property: "id",
+                value: id,
+                comparison: entity.ComparisonOperator.Equals
+            };
+            conditions.push(condition);
+        }
+        if (core.Is.stringValue(lrnType)) {
+            const condition = {
+                property: "lrnType",
+                value: lrnType,
+                comparison: entity.ComparisonOperator.Equals
+            };
+            conditions.push(condition);
+        }
+        if (core.Is.stringValue(legalRegistrationNumber)) {
+            const condition = {
+                property: "registrationNumber",
+                value: legalRegistrationNumber,
+                comparison: entity.ComparisonOperator.Equals
+            };
+            conditions.push(condition);
+        }
+        const entries = await this._entityStorageParticipants.query({ conditions }, undefined, undefined, cursor, pageSize);
+        const itemList = entries.entities.map(entry => {
+            entry.type = standardsGaiaX.GaiaXTypes.Participant;
+            return entry;
+        });
+        const result = {
+            "@context": federatedCatalogueModels.FederatedCatalogueContextInstances.DEFAULT_LD_CONTEXT_ENTRY_LIST,
+            type: standardsSchemaOrg.SchemaOrgTypes.ItemList,
+            itemListElement: itemList,
+            nextItem: entries.cursor
+        };
+        return dataJsonLd.JsonLdProcessor.compact(result, result["@context"]);
+    }
+    /**
+     * Returns a Federated Catalogue entry.
+     * @param entryType The type of entry.
+     * @param entryId The entry's id.
+     * @returns Catalogue Entry
+     * @throws NotFoundError if not found.
+     */
+    async getEntry(entryType, entryId) {
+        core.Guards.stringValue(this.CLASS_NAME, "entryId", entryId);
+        let itemsAndCursor;
+        switch (entryType) {
+            case standardsGaiaX.GaiaXTypes.Participant:
+                itemsAndCursor = await this.queryParticipants(entryId);
+                break;
+            case standardsGaiaX.GaiaXTypes.DataExchangeComponent:
+            case federatedCatalogueModels.FederatedCatalogueTypes.DataSpaceConnector:
+                itemsAndCursor = await this.queryDataSpaceConnectors(entryId);
+                break;
+            case standardsGaiaX.GaiaXTypes.ServiceOffering:
+                itemsAndCursor = await this.queryServiceOfferings(entryId);
+                break;
+            case standardsGaiaX.GaiaXTypes.DataResource:
+                itemsAndCursor = await this.queryDataResources(entryId);
+                break;
+            default:
+                throw new core.GeneralError(this.CLASS_NAME, "unknownEntryType", { entryType });
+        }
+        if (core.Is.arrayValue(itemsAndCursor?.itemListElement)) {
+            const entry = {
+                ...itemsAndCursor.itemListElement[0],
+                "@context": federatedCatalogueModels.FederatedCatalogueContextInstances.DEFAULT_LD_CONTEXT_ENTRY
+            };
+            const result = await dataJsonLd.JsonLdProcessor.compact(entry, entry["@context"]);
+            return result;
+        }
+        throw new core.NotFoundError(this.CLASS_NAME, "entryNotFound", entryId);
+    }
+    /**
+     * Registers a compliance Credential concerning a Data Space Connector.
+     * @param credentialJwt The credential (wrapped into a presentation) as JWT.
+     * @returns The identifier of the Data Space Connector registered.
+     */
+    async registerDataSpaceConnectorCredential(credentialJwt) {
+        core.Guards.string(this.CLASS_NAME, "credentialJwt", credentialJwt);
+        // This will raise exceptions as it has been coded reusing code from Gaia-X
+        const complianceCredential = await this.decodeJwt(credentialJwt);
+        const result = await this._complianceCredentialVerifier.verify(complianceCredential);
+        if (!result.verified) {
+            this._loggingService?.log({
+                level: "error",
+                source: this.CLASS_NAME,
+                ts: Date.now(),
+                message: "complianceCredentialNotVerified",
+                data: { result }
+            });
+            throw new core.UnprocessableError(this.CLASS_NAME, "complianceCredentialNotVerified", {
+                reason: result.verificationFailureReason
+            });
+        }
+        const targetCredential = result.credentials.find(credential => {
+            if (core.Is.array(credential.credentialSubject.type)) {
+                return credential.credentialSubject.type.includes(federatedCatalogueModels.FederatedCatalogueTypes.DataSpaceConnector);
+            }
+            return credential.credentialSubject.type === federatedCatalogueModels.FederatedCatalogueTypes.DataSpaceConnector;
+        });
+        const dataResourceCredentials = result.credentials.filter(credential => credential.credentialSubject.type === standardsGaiaX.GaiaXTypes.DataResource);
+        if (core.Is.undefined(targetCredential)) {
+            throw new core.UnprocessableError(this.CLASS_NAME, "noEvidence");
+        }
+        await this.checkParticipantExists(targetCredential.issuer);
+        const dataSpaceConnectorEntry = this.extractDataSpaceConnectorEntry(complianceCredential, result.credentials[0]);
+        const theEntry = core.ObjectHelper.omit(dataSpaceConnectorEntry, FederatedCatalogueService._FIELDS_TO_SKIP);
+        await this._entityStorageDataSpaceConnectors.set(theEntry);
+        for (const dataResourceCredential of dataResourceCredentials) {
+            await this.checkParticipantExists(dataResourceCredential.issuer);
+            const dataResourceEntry = this.extractDataResourceEntry(complianceCredential, dataResourceCredential);
+            const drEntry = core.ObjectHelper.omit(dataResourceEntry, FederatedCatalogueService._FIELDS_TO_SKIP);
+            await this._entityStorageDataResources.set(drEntry);
+        }
+        await this._loggingService?.log({
+            level: "info",
+            source: this.CLASS_NAME,
+            ts: Date.now(),
+            message: "complianceCredentialVerified",
+            data: {
+                dataSpaceConnectorId: complianceCredential.credentialSubject?.id,
+                trustedIssuer: complianceCredential.issuer
+            }
+        });
+        return dataSpaceConnectorEntry.id;
+    }
+    /**
+     * Registers a data resource Credential concerning a Data Space Connector.
+     * @param credentialJwt The credential (wrapped into a presentation) as JWT.
+     * @returns The list of Data Resources created.
+     */
+    async registerDataResourceCredential(credentialJwt) {
+        core.Guards.string(this.CLASS_NAME, "credentialJwt", credentialJwt);
+        // This will raise exceptions as it has been coded reusing code from Gaia-X
+        const complianceCredential = await this.decodeJwt(credentialJwt);
+        const result = await this._complianceCredentialVerifier.verify(complianceCredential);
+        if (!result.verified) {
+            this._loggingService?.log({
+                level: "error",
+                source: this.CLASS_NAME,
+                ts: Date.now(),
+                message: "complianceCredentialNotVerified",
+                data: { result }
+            });
+            throw new core.UnprocessableError(this.CLASS_NAME, "complianceCredentialNotVerified", {
+                reason: result.verificationFailureReason
+            });
+        }
+        const dataResourceCredentials = result.credentials.filter(credential => credential.credentialSubject.type === standardsGaiaX.GaiaXTypes.DataResource);
+        if (dataResourceCredentials.length === 0) {
+            throw new core.UnprocessableError(this.CLASS_NAME, "noEvidence");
+        }
+        const dataResourceIds = [];
+        for (const dataResourceCredential of dataResourceCredentials) {
+            await this.checkParticipantExists(dataResourceCredential.issuer);
+            const dataResourceEntry = this.extractDataResourceEntry(complianceCredential, dataResourceCredential);
+            const theEntry = core.ObjectHelper.omit(dataResourceEntry, FederatedCatalogueService._FIELDS_TO_SKIP);
+            await this._entityStorageDataResources.set(theEntry);
+            dataResourceIds.push(dataResourceEntry.id);
+        }
+        await this._loggingService?.log({
+            level: "info",
+            source: this.CLASS_NAME,
+            ts: Date.now(),
+            message: "complianceCredentialVerified",
+            data: {
+                dataResourceIds,
+                trustedIssuer: complianceCredential.issuer
+            }
+        });
+        return dataResourceIds;
+    }
+    /**
+     * Query the federated catalogue.
+     * @param id The identity of the participant.
+     * @param maintainer The DS Connector maintainer.
+     * @param cursor The cursor to request the next page of entities.
+     * @param pageSize The maximum number of entities in a page.
+     * @returns All the entities for the storage matching the conditions,
+     * and a cursor which can be used to request more entities.
+     * @throws NotImplementedError if the implementation does not support retrieval.
+     */
+    async queryDataSpaceConnectors(id, maintainer, cursor, pageSize) {
+        const conditions = [];
+        if (core.Is.stringValue(id)) {
+            const condition = {
+                property: "id",
+                value: id,
+                comparison: entity.ComparisonOperator.Equals
+            };
+            conditions.push(condition);
+        }
+        if (core.Is.stringValue(maintainer)) {
+            const condition = {
+                property: "maintainer",
+                value: maintainer,
+                comparison: entity.ComparisonOperator.Equals
+            };
+            conditions.push(condition);
+        }
+        const entries = await this._entityStorageDataSpaceConnectors.query({ conditions }, undefined, undefined, cursor, pageSize);
+        const itemList = entries.entities.map(entry => {
+            entry.type = [
+                standardsGaiaX.GaiaXTypes.DataExchangeComponent,
+                federatedCatalogueModels.FederatedCatalogueTypes.DataSpaceConnector
+            ];
+            return entry;
+        });
+        const result = {
+            "@context": federatedCatalogueModels.FederatedCatalogueContextInstances.DEFAULT_LD_CONTEXT_ENTRY_LIST,
+            type: standardsSchemaOrg.SchemaOrgTypes.ItemList,
+            itemListElement: itemList,
+            nextItem: entries.cursor
+        };
+        return dataJsonLd.JsonLdProcessor.compact(result, result["@context"]);
+    }
+    /**
+     * Registers a Service Offering Credential.
+     * @param credentialJwt The credential (wrapped into a presentation) as JWT.
+     * @returns Nothing.
+     */
+    async registerServiceOfferingCredential(credentialJwt) {
+        core.Guards.string(this.CLASS_NAME, "credentialJwt", credentialJwt);
+        // This will raise exceptions as it has been coded reusing code from Gaia-X
+        const sdComplianceCredential = await this.decodeJwt(credentialJwt);
+        const result = await this._complianceCredentialVerifier.verify(sdComplianceCredential);
+        if (!result.verified) {
+            this._loggingService?.log({
+                level: "error",
+                source: this.CLASS_NAME,
+                ts: Date.now(),
+                message: "complianceCredentialNotVerified",
+                data: { result }
+            });
+            throw new core.UnprocessableError(this.CLASS_NAME, "complianceCredentialNotVerified", {
+                reason: result.verificationFailureReason
+            });
+        }
+        const serviceOfferingCredentials = result.credentials.filter(credential => credential.credentialSubject.type === standardsGaiaX.GaiaXTypes.ServiceOffering);
+        const dataResourceCredentials = result.credentials.filter(credential => credential.credentialSubject.type === standardsGaiaX.GaiaXTypes.DataResource);
+        if (serviceOfferingCredentials.length === 0) {
+            throw new core.UnprocessableError(this.CLASS_NAME, "noEvidence");
+        }
+        const serviceOfferingIds = [];
+        for (const serviceOfferingCredential of serviceOfferingCredentials) {
+            const serviceIssuer = serviceOfferingCredential.issuer;
+            await this.checkParticipantExists(serviceIssuer);
+            const serviceOfferingEntry = this.extractServiceOfferingEntry(sdComplianceCredential, serviceOfferingCredential);
+            const theEntry = core.ObjectHelper.omit(serviceOfferingEntry, FederatedCatalogueService._FIELDS_TO_SKIP);
+            await this._entityStorageServiceOfferings.set(theEntry);
+            serviceOfferingIds.push(serviceOfferingEntry.id);
+        }
+        for (const dataResourceCredential of dataResourceCredentials) {
+            await this.checkParticipantExists(dataResourceCredential.issuer);
+            const dataResourceEntry = this.extractDataResourceEntry(sdComplianceCredential, dataResourceCredential);
+            await this._entityStorageDataResources.set(dataResourceEntry);
+        }
+        await this._loggingService?.log({
+            level: "info",
+            source: this.CLASS_NAME,
+            ts: Date.now(),
+            message: "complianceCredentialVerified",
+            data: {
+                serviceOfferingIds,
+                trustedIssuer: sdComplianceCredential.issuer
+            }
+        });
+        return serviceOfferingIds;
+    }
+    /**
+     * Query the federated catalogue.
+     * @param id Service Id.
+     * @param providedBy The identity of the participant.
+     * @param cursor The cursor to request the next page of entities.
+     * @param pageSize The maximum number of entities in a page.
+     * @returns All the entities for the storage matching the conditions,
+     * and a cursor which can be used to request more entities.
+     * @throws NotImplementedError if the implementation does not support retrieval.
+     */
+    async queryServiceOfferings(id, providedBy, cursor, pageSize) {
+        const conditions = [];
+        if (core.Is.stringValue(providedBy)) {
+            const condition = {
+                property: "providedBy",
+                value: providedBy,
+                comparison: entity.ComparisonOperator.Equals
+            };
+            conditions.push(condition);
+        }
+        if (core.Is.stringValue(id)) {
+            const condition = {
+                property: "id",
+                value: id,
+                comparison: entity.ComparisonOperator.Equals
+            };
+            conditions.push(condition);
+        }
+        const entries = await this._entityStorageServiceOfferings.query({ conditions }, undefined, undefined, cursor, pageSize);
+        const itemList = entries.entities.map(entry => {
+            entry.type = standardsGaiaX.GaiaXTypes.ServiceOffering;
+            return entry;
+        });
+        const result = {
+            "@context": federatedCatalogueModels.FederatedCatalogueContextInstances.DEFAULT_LD_CONTEXT_ENTRY_LIST,
+            type: standardsSchemaOrg.SchemaOrgTypes.ItemList,
+            itemListElement: itemList,
+            nextItem: entries.cursor
+        };
+        return dataJsonLd.JsonLdProcessor.compact(result, result["@context"]);
+    }
+    /**
+     * Query the federated catalogue.
+     * @param id The identity of the DataResource.
+     * @param producedBy The identity of the participant.
+     * @param cursor The cursor to request the next page of entities.
+     * @param pageSize The maximum number of entities in a page.
+     * @returns All the entities for the storage matching the conditions,
+     * and a cursor which can be used to request more entities.
+     * @throws NotImplementedError if the implementation does not support retrieval.
+     */
+    async queryDataResources(id, producedBy, cursor, pageSize) {
+        const conditions = [];
+        if (core.Is.stringValue(producedBy)) {
+            const condition = {
+                property: "producedBy",
+                value: producedBy,
+                comparison: entity.ComparisonOperator.Equals
+            };
+            conditions.push(condition);
+        }
+        if (core.Is.stringValue(id)) {
+            const condition = {
+                property: "id",
+                value: id,
+                comparison: entity.ComparisonOperator.Equals
+            };
+            conditions.push(condition);
+        }
+        const entries = await this._entityStorageDataResources.query({ conditions }, undefined, undefined, cursor, pageSize);
+        const itemList = entries.entities.map(entry => {
+            entry.type = standardsGaiaX.GaiaXTypes.DataResource;
+            return entry;
+        });
+        const result = {
+            "@context": federatedCatalogueModels.FederatedCatalogueContextInstances.DEFAULT_LD_CONTEXT_ENTRY_LIST,
+            type: standardsSchemaOrg.SchemaOrgTypes.ItemList,
+            itemListElement: itemList,
+            nextItem: entries.cursor
+        };
+        return dataJsonLd.JsonLdProcessor.compact(result, result["@context"]);
+    }
+    /**
+     * Decodes the JWT.
+     * @param jwt JWT.
+     * @returns Decoded.
+     */
+    async decodeJwt(jwt) {
+        const { payload } = await identityModels.VerificationHelper.verifyJwt(this._resolver, jwt);
+        return payload;
+    }
+    /**
+     * Returns the trusted Issuer id.
+     * @param complianceCredential The compliance credential.
+     * @returns The trusted issuer.
+     */
+    getTrustedIssuerId(complianceCredential) {
+        const trustedIssuerId = core.Is.object(complianceCredential.issuer)
+            ? complianceCredential.issuer.id
+            : complianceCredential.issuer;
+        return trustedIssuerId;
+    }
+    /**
+     * Extracts participant entry from the credentials.
+     * @param complianceCredential Compliance credential
+     * @param participantCredential The Participant credential extracted.
+     * @returns Participant Entry to be saved on the Database.
+     */
+    extractParticipantEntry(complianceCredential, participantCredential) {
+        const participantData = participantCredential.credentialSubject;
+        core.Guards.objectValue(this.CLASS_NAME, "participantData", participantData);
+        const evidences = [];
+        for (const evidence of complianceCredential.evidence) {
+            evidences.push(evidence.id);
+        }
+        const result = {
+            ...participantData,
+            "@context": federatedCatalogueModels.FederatedCatalogueContextInstances.DEFAULT_LD_CONTEXT_ENTRY,
+            issuer: this.getTrustedIssuerId(complianceCredential),
+            validFrom: complianceCredential.validFrom,
+            validUntil: complianceCredential.validUntil,
+            dateCreated: new Date().toISOString(),
+            evidence: evidences
+        };
+        return result;
+    }
+    /**
+     * Extracts Data Space Connector description entry from the credentials.
+     * @param complianceCredential Compliance Credential.
+     * @param dataSpaceConnectorCredential Evidence Credential.
+     * @returns Service Description Entry to be saved on the Database.
+     */
+    extractDataSpaceConnectorEntry(complianceCredential, dataSpaceConnectorCredential) {
+        const credentialData = dataSpaceConnectorCredential.credentialSubject;
+        core.Guards.objectValue(this.CLASS_NAME, "credentialData", credentialData);
+        const { offeredResource, ...deStructuredData } = credentialData;
+        const result = {
+            ...deStructuredData,
+            "@context": federatedCatalogueModels.FederatedCatalogueContextInstances.DEFAULT_LD_CONTEXT_ENTRY,
+            offeredResource: Object.keys(offeredResource),
+            issuer: this.getTrustedIssuerId(complianceCredential),
+            validFrom: complianceCredential.validFrom,
+            validUntil: complianceCredential.validUntil,
+            dateCreated: new Date().toISOString(),
+            evidence: [dataSpaceConnectorCredential.id]
+        };
+        return result;
+    }
+    /**
+     * Extracts service offering entry from the credentials.
+     * @param complianceCredential The Compliance Credential.
+     * @param serviceOfferingCredential Service Offering credential (evidence).
+     * @returns Service Offering Entry to be saved on the Database.
+     */
+    extractServiceOfferingEntry(complianceCredential, serviceOfferingCredential) {
+        const credentialData = serviceOfferingCredential.credentialSubject;
+        core.Guards.objectValue(this.CLASS_NAME, "credentialData", credentialData);
+        const { providedBy, aggregationOfResources, servicePolicy, ...deStructuredData } = credentialData;
+        const result = {
+            ...deStructuredData,
+            "@context": federatedCatalogueModels.FederatedCatalogueContextInstances.DEFAULT_LD_CONTEXT_ENTRY,
+            providedBy: core.Is.string(providedBy) ? providedBy : providedBy.id,
+            aggregationOfResources: aggregationOfResources,
+            issuer: this.getTrustedIssuerId(complianceCredential),
+            validFrom: complianceCredential.validFrom,
+            validUntil: complianceCredential.validUntil,
+            dateCreated: new Date().toISOString(),
+            evidence: [serviceOfferingCredential.id],
+            servicePolicy: core.ArrayHelper.fromObjectOrArray(servicePolicy)
+        };
+        return result;
+    }
+    /**
+     * Extracts data resource entry from the credentials.
+     * @param complianceCredential The Compliance Credential.
+     * @param dataResourceCredential Data Resource credential.
+     * @returns DataResource Entry to be saved on the Database.
+     */
+    extractDataResourceEntry(complianceCredential, dataResourceCredential) {
+        const credentialData = dataResourceCredential.credentialSubject;
+        core.Guards.objectValue(this.CLASS_NAME, "credentialData", credentialData);
+        const { producedBy, copyrightOwnedBy, exposedThrough, resourcePolicy, ...deStructuredData } = credentialData;
+        let producedByValue = producedBy;
+        if (core.Is.object(producedByValue)) {
+            producedByValue = producedByValue.id;
+        }
+        let copyrightOwnedByValue = copyrightOwnedBy;
+        if (core.Is.object(copyrightOwnedByValue)) {
+            copyrightOwnedByValue = copyrightOwnedByValue.id;
+        }
+        const result = {
+            ...deStructuredData,
+            "@context": federatedCatalogueModels.FederatedCatalogueContextInstances.DEFAULT_LD_CONTEXT_ENTRY,
+            issuer: this.getTrustedIssuerId(complianceCredential),
+            producedBy: producedByValue,
+            copyrightOwnedBy: copyrightOwnedByValue,
+            exposedThrough: exposedThrough,
+            validFrom: complianceCredential.validFrom,
+            validUntil: complianceCredential.validUntil,
+            dateCreated: new Date().toISOString(),
+            evidence: [dataResourceCredential.id],
+            resourcePolicy: core.ArrayHelper.fromObjectOrArray(resourcePolicy)
+        };
+        return result;
+    }
+    /**
+     * Checks whether the Participant exists.
+     * @param participantId The Participant identifier
+     */
+    async checkParticipantExists(participantId) {
+        const participantData = await this._entityStorageParticipants.get(participantId);
+        if (!participantData) {
+            this._loggingService?.log({
+                level: "error",
+                source: this.CLASS_NAME,
+                ts: Date.now(),
+                message: "providerIsNotParticipant",
+                data: { providedBy: participantId }
+            });
+            throw new core.UnprocessableError(this.CLASS_NAME, "providerIsNotParticipant", {
+                providedBy: participantId
+            });
+        }
+    }
+}
+
+const restEntryPoints = [
+    {
+        name: "federated-catalogue",
+        defaultBaseRoute: "federated-catalogue",
+        tags: tagsFederatedCatalogue,
+        generateRoutes: generateRestRoutesFederatedCatalogue
+    }
+];
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Data Resource Entry.
+ */
+exports.DataResourceEntry = class DataResourceEntry {
+    /**
+     * The Id.
+     */
+    id;
+    /**
+     * The trusted issuer of the compliance credential
+     */
+    issuer;
+    /**
+     * The name.
+     */
+    name;
+    /**
+     * The description.
+     */
+    description;
+    /**
+     * The Id of the producer of the data described by this Data Resource.
+     */
+    producedBy;
+    /**
+     * The copyright owner
+     */
+    copyrightOwnedBy;
+    /**
+     * The license
+     */
+    license;
+    /**
+     * The data exchange component used to expose the Data Resource.
+     * Only a URL pointing to the resource is stored
+     */
+    exposedThrough;
+    /**
+     * The Data Resource policy
+     */
+    resourcePolicy;
+    /**
+     * Valid from
+     */
+    validFrom;
+    /**
+     * Valid to
+     */
+    validUntil;
+    /**
+     * Date created
+     */
+    dateCreated;
+    /**
+     * Evidences
+     */
+    evidence;
+};
+__decorate([
+    entity.property({ type: "string", isPrimary: true }),
+    __metadata("design:type", String)
+], exports.DataResourceEntry.prototype, "id", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.DataResourceEntry.prototype, "issuer", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.DataResourceEntry.prototype, "name", void 0);
+__decorate([
+    entity.property({ type: "string", optional: true }),
+    __metadata("design:type", String)
+], exports.DataResourceEntry.prototype, "description", void 0);
+__decorate([
+    entity.property({ type: "string", isSecondary: true }),
+    __metadata("design:type", String)
+], exports.DataResourceEntry.prototype, "producedBy", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.DataResourceEntry.prototype, "copyrightOwnedBy", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.DataResourceEntry.prototype, "license", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.DataResourceEntry.prototype, "exposedThrough", void 0);
+__decorate([
+    entity.property({ type: "array" }),
+    __metadata("design:type", Array)
+], exports.DataResourceEntry.prototype, "resourcePolicy", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time" }),
+    __metadata("design:type", String)
+], exports.DataResourceEntry.prototype, "validFrom", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time" }),
+    __metadata("design:type", String)
+], exports.DataResourceEntry.prototype, "validUntil", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time", sortDirection: entity.SortDirection.Descending }),
+    __metadata("design:type", String)
+], exports.DataResourceEntry.prototype, "dateCreated", void 0);
+__decorate([
+    entity.property({ type: "array" }),
+    __metadata("design:type", Array)
+], exports.DataResourceEntry.prototype, "evidence", void 0);
+exports.DataResourceEntry = __decorate([
+    entity.entity()
+], exports.DataResourceEntry);
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Data Space Connector Entry.
+ */
+exports.DataSpaceConnectorEntry = class DataSpaceConnectorEntry {
+    /**
+     * The Id.
+     */
+    id;
+    /**
+     * The trusted issuer of the compliance credential.
+     */
+    issuer;
+    /**
+     * The name.
+     */
+    name;
+    /**
+     * The description.
+     */
+    description;
+    /**
+     * The identity of the Data Space Connector
+     */
+    identity;
+    /**
+     * Who maintains the Data Space Connector
+     */
+    maintainer;
+    /**
+     * The default endpoint
+     */
+    defaultEndpoint;
+    /**
+     * The activity push endpoint
+     */
+    pushActivityEndpoint;
+    /**
+     * The activity subscribe endpoint
+     */
+    subscriptionActivityEndpoint;
+    /**
+     * The pull data endpoint
+     */
+    pullDataEndpoint;
+    /**
+     * The pull data endpoint
+     */
+    offeredResource;
+    /**
+     * Valid from
+     */
+    validFrom;
+    /**
+     * Valid to
+     */
+    validUntil;
+    /**
+     * Date created
+     */
+    dateCreated;
+    /**
+     * Evidences
+     */
+    evidence;
+};
+__decorate([
+    entity.property({ type: "string", isPrimary: true }),
+    __metadata("design:type", String)
+], exports.DataSpaceConnectorEntry.prototype, "id", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.DataSpaceConnectorEntry.prototype, "issuer", void 0);
+__decorate([
+    entity.property({ type: "string", optional: true }),
+    __metadata("design:type", String)
+], exports.DataSpaceConnectorEntry.prototype, "name", void 0);
+__decorate([
+    entity.property({ type: "string", optional: true }),
+    __metadata("design:type", String)
+], exports.DataSpaceConnectorEntry.prototype, "description", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.DataSpaceConnectorEntry.prototype, "identity", void 0);
+__decorate([
+    entity.property({ type: "string", isSecondary: true }),
+    __metadata("design:type", String)
+], exports.DataSpaceConnectorEntry.prototype, "maintainer", void 0);
+__decorate([
+    entity.property({ type: "object" }),
+    __metadata("design:type", Object)
+], exports.DataSpaceConnectorEntry.prototype, "defaultEndpoint", void 0);
+__decorate([
+    entity.property({ type: "object" }),
+    __metadata("design:type", Object)
+], exports.DataSpaceConnectorEntry.prototype, "pushActivityEndpoint", void 0);
+__decorate([
+    entity.property({ type: "object", optional: true }),
+    __metadata("design:type", Object)
+], exports.DataSpaceConnectorEntry.prototype, "subscriptionActivityEndpoint", void 0);
+__decorate([
+    entity.property({ type: "object" }),
+    __metadata("design:type", Object)
+], exports.DataSpaceConnectorEntry.prototype, "pullDataEndpoint", void 0);
+__decorate([
+    entity.property({ type: "array" }),
+    __metadata("design:type", Array)
+], exports.DataSpaceConnectorEntry.prototype, "offeredResource", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time" }),
+    __metadata("design:type", String)
+], exports.DataSpaceConnectorEntry.prototype, "validFrom", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time" }),
+    __metadata("design:type", String)
+], exports.DataSpaceConnectorEntry.prototype, "validUntil", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time", sortDirection: entity.SortDirection.Descending }),
+    __metadata("design:type", String)
+], exports.DataSpaceConnectorEntry.prototype, "dateCreated", void 0);
+__decorate([
+    entity.property({ type: "array" }),
+    __metadata("design:type", Array)
+], exports.DataSpaceConnectorEntry.prototype, "evidence", void 0);
+exports.DataSpaceConnectorEntry = __decorate([
+    entity.entity()
+], exports.DataSpaceConnectorEntry);
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Participant entry.
+ */
+exports.ParticipantEntry = class ParticipantEntry {
+    /**
+     * The participant Id.
+     */
+    id;
+    /**
+     * The trusted issuer of the compliance credential
+     */
+    issuer;
+    /**
+     * The legal registration number.
+     */
+    registrationNumber;
+    /**
+     * The legal name.
+     */
+    legalName;
+    /**
+     * Address
+     */
+    legalAddress;
+    /**
+     * Valid from
+     */
+    validFrom;
+    /**
+     * Valid to
+     */
+    validUntil;
+    /**
+     * Date created
+     */
+    dateCreated;
+    /**
+     * Evidences
+     */
+    evidence;
+};
+__decorate([
+    entity.property({ type: "string", isPrimary: true }),
+    __metadata("design:type", String)
+], exports.ParticipantEntry.prototype, "id", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.ParticipantEntry.prototype, "issuer", void 0);
+__decorate([
+    entity.property({ type: "object", isSecondary: true }),
+    __metadata("design:type", Object)
+], exports.ParticipantEntry.prototype, "registrationNumber", void 0);
+__decorate([
+    entity.property({ type: "string", isSecondary: true }),
+    __metadata("design:type", String)
+], exports.ParticipantEntry.prototype, "legalName", void 0);
+__decorate([
+    entity.property({ type: "object" }),
+    __metadata("design:type", Object)
+], exports.ParticipantEntry.prototype, "legalAddress", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time" }),
+    __metadata("design:type", String)
+], exports.ParticipantEntry.prototype, "validFrom", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time" }),
+    __metadata("design:type", String)
+], exports.ParticipantEntry.prototype, "validUntil", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time", sortDirection: entity.SortDirection.Descending }),
+    __metadata("design:type", String)
+], exports.ParticipantEntry.prototype, "dateCreated", void 0);
+__decorate([
+    entity.property({ type: "array" }),
+    __metadata("design:type", Array)
+], exports.ParticipantEntry.prototype, "evidence", void 0);
+exports.ParticipantEntry = __decorate([
+    entity.entity()
+], exports.ParticipantEntry);
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Service Offering Entry.
+ */
+exports.ServiceOfferingEntry = class ServiceOfferingEntry {
+    /**
+     * The service Id.
+     */
+    id;
+    /**
+     * The trusted issuer of the compliance credential associated with
+     */
+    issuer;
+    /**
+     * The service name.
+     */
+    name;
+    /**
+     * The service description.
+     */
+    description;
+    /**
+     * The provider Id
+     */
+    providedBy;
+    /**
+     * The REST endpoint
+     */
+    endpoint;
+    /**
+     * The policy
+     */
+    servicePolicy;
+    /**
+     * Resources aggregated
+     */
+    aggregationOfResources;
+    /**
+     * Valid from
+     */
+    validFrom;
+    /**
+     * Valid to
+     */
+    validUntil;
+    /**
+     * Date created
+     */
+    dateCreated;
+    /**
+     * Evidences
+     */
+    evidence;
+};
+__decorate([
+    entity.property({ type: "string", isPrimary: true }),
+    __metadata("design:type", String)
+], exports.ServiceOfferingEntry.prototype, "id", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.ServiceOfferingEntry.prototype, "issuer", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.ServiceOfferingEntry.prototype, "name", void 0);
+__decorate([
+    entity.property({ type: "string", optional: true }),
+    __metadata("design:type", String)
+], exports.ServiceOfferingEntry.prototype, "description", void 0);
+__decorate([
+    entity.property({ type: "string", isSecondary: true }),
+    __metadata("design:type", String)
+], exports.ServiceOfferingEntry.prototype, "providedBy", void 0);
+__decorate([
+    entity.property({ type: "object" }),
+    __metadata("design:type", Object)
+], exports.ServiceOfferingEntry.prototype, "endpoint", void 0);
+__decorate([
+    entity.property({ type: "array" }),
+    __metadata("design:type", Array)
+], exports.ServiceOfferingEntry.prototype, "servicePolicy", void 0);
+__decorate([
+    entity.property({ type: "array", optional: true }),
+    __metadata("design:type", Array)
+], exports.ServiceOfferingEntry.prototype, "aggregationOfResources", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time" }),
+    __metadata("design:type", String)
+], exports.ServiceOfferingEntry.prototype, "validFrom", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time" }),
+    __metadata("design:type", String)
+], exports.ServiceOfferingEntry.prototype, "validUntil", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time", sortDirection: entity.SortDirection.Descending }),
+    __metadata("design:type", String)
+], exports.ServiceOfferingEntry.prototype, "dateCreated", void 0);
+__decorate([
+    entity.property({ type: "array" }),
+    __metadata("design:type", Array)
+], exports.ServiceOfferingEntry.prototype, "evidence", void 0);
+exports.ServiceOfferingEntry = __decorate([
+    entity.entity()
+], exports.ServiceOfferingEntry);
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Inits schemas.
+ */
+function initSchema() {
+    entity.EntitySchemaFactory.register("ParticipantEntry", () => entity.EntitySchemaHelper.getSchema(exports.ParticipantEntry));
+    entity.EntitySchemaFactory.register("DataResourceEntry", () => entity.EntitySchemaHelper.getSchema(exports.DataResourceEntry));
+    entity.EntitySchemaFactory.register("ServiceOfferingEntry", () => entity.EntitySchemaHelper.getSchema(exports.ServiceOfferingEntry));
+    entity.EntitySchemaFactory.register("DataSpaceConnectorEntry", () => entity.EntitySchemaHelper.getSchema(exports.DataSpaceConnectorEntry));
+}
+
+exports.FederatedCatalogueService = FederatedCatalogueService;
+exports.complianceCredentialPresentation = complianceCredentialPresentation;
+exports.dataResourceCredentialPresentation = dataResourceCredentialPresentation;
+exports.dataResourceGet = dataResourceGet;
+exports.dataResourceList = dataResourceList;
+exports.dataSpaceConnectorCredentialPresentation = dataSpaceConnectorCredentialPresentation;
+exports.dataSpaceConnectorGet = dataSpaceConnectorGet;
+exports.dataSpaceConnectorList = dataSpaceConnectorList;
+exports.generateRestRoutesFederatedCatalogue = generateRestRoutesFederatedCatalogue;
+exports.initSchema = initSchema;
+exports.participantGet = participantGet;
+exports.participantList = participantList;
+exports.restEntryPoints = restEntryPoints;
+exports.serviceOfferingCredentialPresentation = serviceOfferingCredentialPresentation;
+exports.serviceOfferingGet = serviceOfferingGet;
+exports.serviceOfferingList = serviceOfferingList;
+exports.tagsFederatedCatalogue = tagsFederatedCatalogue;