@twin.org/engine-types 0.0.1 → 0.0.2-next.10

package/dist/cjs/index.cjs

@@ -2,8 +2,10 @@
 
 var attestationConnectorNft = require('@twin.org/attestation-connector-nft');
 var attestationModels = require('@twin.org/attestation-models');
+var attestationRestClient = require('@twin.org/attestation-rest-client');
 var attestationService = require('@twin.org/attestation-service');
 var core = require('@twin.org/core');
+var auditableItemGraphRestClient = require('@twin.org/auditable-item-graph-rest-client');
 var auditableItemGraphService = require('@twin.org/auditable-item-graph-service');
 var path = require('node:path');
 var entityStorageConnectorCosmosdb = require('@twin.org/entity-storage-connector-cosmosdb');
@@ -15,8 +17,11 @@ var entityStorageConnectorMongodb = require('@twin.org/entity-storage-connector-
 var entityStorageConnectorMysql = require('@twin.org/entity-storage-connector-mysql');
 var entityStorageConnectorPostgresql = require('@twin.org/entity-storage-connector-postgresql');
 var entityStorageConnectorScylladb = require('@twin.org/entity-storage-connector-scylladb');
+var entityStorageConnectorSynchronised = require('@twin.org/entity-storage-connector-synchronised');
 var entityStorageModels = require('@twin.org/entity-storage-models');
+var entityStorageRestClient = require('@twin.org/entity-storage-rest-client');
 var entityStorageService = require('@twin.org/entity-storage-service');
+var auditableItemStreamRestClient = require('@twin.org/auditable-item-stream-rest-client');
 var auditableItemStreamService = require('@twin.org/auditable-item-stream-service');
 var backgroundTaskConnectorEntityStorage = require('@twin.org/background-task-connector-entity-storage');
 var backgroundTaskModels = require('@twin.org/background-task-models');
@@ -27,28 +32,39 @@ var blobStorageConnectorGcp = require('@twin.org/blob-storage-connector-gcp');
 var blobStorageConnectorIpfs = require('@twin.org/blob-storage-connector-ipfs');
 var blobStorageConnectorMemory = require('@twin.org/blob-storage-connector-memory');
 var blobStorageModels = require('@twin.org/blob-storage-models');
+var blobStorageRestClient = require('@twin.org/blob-storage-rest-client');
 var blobStorageService = require('@twin.org/blob-storage-service');
 var dataProcessingConverters = require('@twin.org/data-processing-converters');
 var dataProcessingExtractors = require('@twin.org/data-processing-extractors');
 var dataProcessingModels = require('@twin.org/data-processing-models');
+var dataProcessingRestClient = require('@twin.org/data-processing-rest-client');
 var dataProcessingService = require('@twin.org/data-processing-service');
+var dataSpaceConnectorRestClient = require('@twin.org/data-space-connector-rest-client');
+var dataSpaceConnectorService = require('@twin.org/data-space-connector-service');
+var dataSpaceConnectorSocketClient = require('@twin.org/data-space-connector-socket-client');
+var documentManagementRestClient = require('@twin.org/document-management-rest-client');
 var documentManagementService = require('@twin.org/document-management-service');
 var eventBusConnectorLocal = require('@twin.org/event-bus-connector-local');
 var eventBusModels = require('@twin.org/event-bus-models');
 var eventBusService = require('@twin.org/event-bus-service');
+var eventBusSocketClient = require('@twin.org/event-bus-socket-client');
 var walletConnectorEntityStorage = require('@twin.org/wallet-connector-entity-storage');
 var walletConnectorIota = require('@twin.org/wallet-connector-iota');
 var walletModels = require('@twin.org/wallet-models');
+var federatedCatalogueRestClient = require('@twin.org/federated-catalogue-rest-client');
 var federatedCatalogueService = require('@twin.org/federated-catalogue-service');
 var identityConnectorEntityStorage = require('@twin.org/identity-connector-entity-storage');
 var identityConnectorIota = require('@twin.org/identity-connector-iota');
 var identityModels = require('@twin.org/identity-models');
+var identityRestClient = require('@twin.org/identity-rest-client');
 var identityService = require('@twin.org/identity-service');
 var identityConnectorUniversal = require('@twin.org/identity-connector-universal');
+var immutableProofRestClient = require('@twin.org/immutable-proof-rest-client');
 var immutableProofService = require('@twin.org/immutable-proof-service');
 var loggingConnectorConsole = require('@twin.org/logging-connector-console');
 var loggingConnectorEntityStorage = require('@twin.org/logging-connector-entity-storage');
 var loggingModels = require('@twin.org/logging-models');
+var loggingRestClient = require('@twin.org/logging-rest-client');
 var loggingService = require('@twin.org/logging-service');
 var messagingConnectorAws = require('@twin.org/messaging-connector-aws');
 var messagingConnectorEntityStorage = require('@twin.org/messaging-connector-entity-storage');
@@ -57,12 +73,22 @@ var messagingService = require('@twin.org/messaging-service');
 var nftConnectorEntityStorage = require('@twin.org/nft-connector-entity-storage');
 var nftConnectorIota = require('@twin.org/nft-connector-iota');
 var nftModels = require('@twin.org/nft-models');
+var nftRestClient = require('@twin.org/nft-rest-client');
 var nftService = require('@twin.org/nft-service');
+var rightsManagementRestClient = require('@twin.org/rights-management-rest-client');
 var rightsManagementService = require('@twin.org/rights-management-service');
 var rightsManagementPapService = require('@twin.org/rights-management-pap-service');
+var rightsManagementPdpService = require('@twin.org/rights-management-pdp-service');
+var rightsManagementPepService = require('@twin.org/rights-management-pep-service');
+var rightsManagementPipService = require('@twin.org/rights-management-pip-service');
+var rightsManagementPmpService = require('@twin.org/rights-management-pmp-service');
+var rightsManagementPxpService = require('@twin.org/rights-management-pxp-service');
+var synchronisedStorageRestClient = require('@twin.org/synchronised-storage-rest-client');
+var synchronisedStorageService = require('@twin.org/synchronised-storage-service');
 var backgroundTaskScheduler = require('@twin.org/background-task-scheduler');
 var telemetryConnectorEntityStorage = require('@twin.org/telemetry-connector-entity-storage');
 var telemetryModels = require('@twin.org/telemetry-models');
+var telemetryRestClient = require('@twin.org/telemetry-rest-client');
 var telemetryService = require('@twin.org/telemetry-service');
 var vaultConnectorEntityStorage = require('@twin.org/vault-connector-entity-storage');
 var vaultConnectorHashicorp = require('@twin.org/vault-connector-hashicorp');
@@ -70,6 +96,7 @@ var vaultModels = require('@twin.org/vault-models');
 var verifiableStorageConnectorEntityStorage = require('@twin.org/verifiable-storage-connector-entity-storage');
 var verifiableStorageConnectorIota = require('@twin.org/verifiable-storage-connector-iota');
 var verifiableStorageModels = require('@twin.org/verifiable-storage-models');
+var verifiableStorageRestClient = require('@twin.org/verifiable-storage-rest-client');
 var verifiableStorageService = require('@twin.org/verifiable-storage-service');
 
 // Copyright 2024 IOTA Stiftung.
@@ -82,7 +109,11 @@ const AttestationComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -118,8 +149,8 @@ function initialiseAttestationConnector(engineCore, context, instanceConfig, ove
     let instanceType;
     if (type === AttestationConnectorType.Nft) {
         connector = new attestationConnectorNft.NftAttestationConnector({
-            identityConnectorType: context.defaultTypes.identityConnector,
-            nftConnectorType: context.defaultTypes.nftConnector,
+            identityConnectorType: engineCore.getRegisteredInstanceType("identityConnector"),
+            nftConnectorType: engineCore.getRegisteredInstanceType("nftConnector"),
             ...instanceConfig.options
         });
         instanceType = attestationConnectorNft.NftAttestationConnector.NAMESPACE;
@@ -158,7 +189,11 @@ function initialiseAttestationComponent(engineCore, context, instanceConfig, ove
         component = new attestationService.AttestationService({
             ...instanceConfig.options
         });
-        instanceType = attestationService.AttestationService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("AttestationService");
+    }
+    else if (type === AttestationComponentType.RestClient) {
+        component = new attestationRestClient.AttestationClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("AttestationClient");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -185,7 +220,11 @@ const EntityStorageComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -230,7 +269,11 @@ const EntityStorageConnectorType = {
     /**
      * Postgre SQL.
      */
-    PostgreSql: "postgresql"
+    PostgreSql: "postgresql",
+    /**
+     * Synchronised.
+     */
+    Synchronised: "synchronised"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -241,6 +284,7 @@ const EntityStorageConnectorType = {
  * @param context The context for the engine.
  * @param typeCustom Override the type of connector to use instead of default configuration.
  * @param schema The schema for the entity storage.
+ * @returns The name of the instance type that was created.
  * @throws GeneralError if the connector type is unknown.
  */
 function initialiseEntityStorageConnector(engineCore, context, typeCustom, schema) {
@@ -361,6 +405,23 @@ function initialiseEntityStorageConnector(engineCore, context, typeCustom, schem
                 }
             });
         }
+        else if (type === EntityStorageConnectorType.Synchronised) {
+            // Create the entity storage that is wrapped by the synchronised connector
+            // by removing the custom type it will default to the standard storage
+            // mechanism for entity storage
+            const wrappedInstanceName = initialiseEntityStorageConnector(engineCore, context, undefined, schema);
+            // Use the wrapped instance name as the entity storage connector type
+            // for the synchronised connector
+            entityStorageConnector = new entityStorageConnectorSynchronised.SynchronisedEntityStorageConnector({
+                entitySchema: schema,
+                ...entityStorageConfig.options,
+                entityStorageConnectorType: wrappedInstanceName,
+                eventBusComponentType: engineCore.getRegisteredInstanceType("eventBusComponent"),
+                config: {
+                    ...entityStorageConfig.options.config
+                }
+            });
+        }
         else {
             throw new core.GeneralError("engineCore", "connectorUnknownType", {
                 type,
@@ -373,6 +434,7 @@ function initialiseEntityStorageConnector(engineCore, context, typeCustom, schem
         });
         entityStorageModels.EntityStorageConnectorFactory.register(instanceName, () => entityStorageConnector);
     }
+    return instanceName;
 }
 /**
  * Initialise the entity storage connector.
@@ -388,14 +450,14 @@ function initialiseEntityStorageComponent(engineCore, context, instanceConfig, o
         element: `Entity Storage Component: ${instanceConfig.type}`
     }));
     const type = instanceConfig.type;
-    let connector;
+    let component;
     let instanceType;
     if (type === EntityStorageComponentType.Service) {
         const kebabName = core.StringHelper.kebabCase(instanceConfig.options.entityStorageType);
         // See if there is a custom entity storage for this type, otherwise just use the default one.
         const hasCustom = context.config.types.entityStorageConnector?.some(c => c.type === kebabName || c.overrideInstanceType === kebabName);
         initialiseEntityStorageConnector(engineCore, context, hasCustom ? kebabName : undefined, instanceConfig.options.entityStorageType);
-        connector = new entityStorageService.EntityStorageService({
+        component = new entityStorageService.EntityStorageService({
             entityStorageType: kebabName,
             config: {
                 ...instanceConfig.options.config
@@ -403,6 +465,14 @@ function initialiseEntityStorageComponent(engineCore, context, instanceConfig, o
         });
         instanceType = core.StringHelper.kebabCase(instanceConfig.options.entityStorageType);
     }
+    else if (type === EntityStorageComponentType.RestClient) {
+        const kebabName = core.StringHelper.kebabCase(instanceConfig.options.entityStorageType);
+        component = new entityStorageRestClient.EntityStorageClient({
+            pathPrefix: kebabName,
+            ...instanceConfig.options
+        });
+        instanceType = `${core.StringHelper.kebabCase("EntityStorageClient")}-${kebabName}`;
+    }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
             type,
@@ -412,9 +482,9 @@ function initialiseEntityStorageComponent(engineCore, context, instanceConfig, o
     const finalInstanceType = overrideInstanceType ?? instanceType;
     context.componentInstances.push({
         instanceType: finalInstanceType,
-        component: connector
+        component
     });
-    core.ComponentFactory.register(finalInstanceType, () => connector);
+    core.ComponentFactory.register(finalInstanceType, () => component);
     return finalInstanceType;
 }
 
@@ -428,7 +498,11 @@ const AuditableItemGraphComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 /**
@@ -452,11 +526,15 @@ function initialiseAuditableItemGraphComponent(engineCore, context, instanceConf
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vertexEntityStorageType, "AuditableItemGraphVertex");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.changesetEntityStorageType, "AuditableItemGraphChangeset");
         component = new auditableItemGraphService.AuditableItemGraphService({
-            immutableProofComponentType: context.defaultTypes.immutableProofComponent,
-            eventBusComponentType: context.defaultTypes.eventBusComponent,
+            immutableProofComponentType: engineCore.getRegisteredInstanceType("immutableProofComponent"),
+            eventBusComponentType: engineCore.getRegisteredInstanceTypeOptional("eventBusComponent"),
             ...instanceConfig.options
         });
-        instanceType = auditableItemGraphService.AuditableItemGraphService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("AuditableItemGraphService");
+    }
+    else if (type === AuditableItemGraphComponentType.RestClient) {
+        component = new auditableItemGraphRestClient.AuditableItemGraphClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("AuditableItemGraphClient");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -483,7 +561,11 @@ const AuditableItemStreamComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 /**
@@ -507,11 +589,15 @@ function initialiseAuditableItemStreamComponent(engineCore, context, instanceCon
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.streamEntityStorageType, "AuditableItemStream");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.streamEntryEntityStorageType, "AuditableItemStreamEntry");
         component = new auditableItemStreamService.AuditableItemStreamService({
-            immutableProofComponentType: context.defaultTypes.immutableProofComponent,
-            eventBusComponentType: context.defaultTypes.eventBusComponent,
+            immutableProofComponentType: engineCore.getRegisteredInstanceType("immutableProofComponent"),
+            eventBusComponentType: engineCore.getRegisteredInstanceTypeOptional("eventBusComponent"),
             ...instanceConfig.options
         });
-        instanceType = auditableItemStreamService.AuditableItemStreamService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("AuditableItemStreamService");
+    }
+    else if (type === AuditableItemStreamComponentType.RestClient) {
+        component = new auditableItemStreamRestClient.AuditableItemStreamClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("AuditableItemStreamClient");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -563,7 +649,7 @@ function initialiseBackgroundTaskConnector(engineCore, context, instanceConfig,
         backgroundTaskConnectorEntityStorage.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.backgroundTaskEntityStorageType, "BackgroundTask");
         connector = new backgroundTaskConnectorEntityStorage.EntityStorageBackgroundTaskConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = backgroundTaskConnectorEntityStorage.EntityStorageBackgroundTaskConnector.NAMESPACE;
@@ -590,7 +676,11 @@ const BlobStorageComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -728,10 +818,14 @@ function initialiseBlobStorageComponent(engineCore, context, instanceConfig, ove
         blobStorageService.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.entryEntityStorageType, "BlobStorageEntry");
         component = new blobStorageService.BlobStorageService({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
             ...instanceConfig.options
         });
-        instanceType = blobStorageService.BlobStorageService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("BlobStorageService");
+    }
+    else if (type === BlobStorageComponentType.RestClient) {
+        component = new blobStorageRestClient.BlobStorageClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("BlobStorageClient");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -788,7 +882,11 @@ const DataProcessingComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -887,7 +985,11 @@ function initialiseDataProcessingComponent(engineCore, context, instanceConfig,
         component = new dataProcessingService.DataProcessingService({
             ...instanceConfig.options
         });
-        instanceType = dataProcessingService.DataProcessingService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("DataProcessingService");
+    }
+    else if (type === DataProcessingComponentType.RestClient) {
+        component = new dataProcessingRestClient.DataProcessingClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("DataProcessingClient");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -904,6 +1006,79 @@ function initialiseDataProcessingComponent(engineCore, context, instanceConfig,
     return finalInstanceType;
 }
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Data space connector component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const DataSpaceConnectorComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client",
+    /**
+     * Socket client.
+     */
+    SocketClient: "socket-client"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the data space connector component.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+function initialiseDataSpaceConnectorComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Data Space Connector Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === DataSpaceConnectorComponentType.Service) {
+        dataSpaceConnectorService.initSchema();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.activityLogEntityStorageType, "ActivityLogDetails");
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.activityTaskEntityStorageType, "ActivityTask");
+        component = new dataSpaceConnectorService.DataSpaceConnectorService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            backgroundTaskConnectorType: engineCore.getRegisteredInstanceType("backgroundTaskConnector"),
+            ...instanceConfig.options
+        });
+        instanceType = core.StringHelper.kebabCase("DataSpaceConnectorService");
+    }
+    else if (type === DataSpaceConnectorComponentType.RestClient) {
+        component = new dataSpaceConnectorRestClient.DataSpaceConnectorClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("DataSpaceConnectorClient");
+    }
+    else if (type === DataSpaceConnectorComponentType.SocketClient) {
+        component = new dataSpaceConnectorSocketClient.DataSpaceConnectorSocketClient({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            ...instanceConfig.options
+        });
+        instanceType = core.StringHelper.kebabCase("DataSpaceConnectorSocketClient");
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "DataSpaceConnectorComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
@@ -914,7 +1089,11 @@ const DocumentManagementComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -937,13 +1116,17 @@ function initialiseDocumentManagementComponent(engineCore, context, instanceConf
     let instanceType;
     if (type === DocumentManagementComponentType.Service) {
         component = new documentManagementService.DocumentManagementService({
-            auditableItemGraphComponentType: context.defaultTypes.auditableItemGraphComponent,
-            blobStorageComponentType: context.defaultTypes.blobStorageComponent,
-            attestationComponentType: context.defaultTypes.attestationComponent,
-            dataProcessingComponentType: context.defaultTypes.dataProcessingComponent,
+            auditableItemGraphComponentType: engineCore.getRegisteredInstanceType("auditableItemGraphComponent"),
+            blobStorageComponentType: engineCore.getRegisteredInstanceType("blobStorageComponent"),
+            attestationComponentType: engineCore.getRegisteredInstanceType("attestationComponent"),
+            dataProcessingComponentType: engineCore.getRegisteredInstanceType("dataProcessingComponent"),
             ...instanceConfig.options
         });
-        instanceType = documentManagementService.DocumentManagementService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("DocumentManagementService");
+    }
+    else if (type === DocumentManagementComponentType.RestClient) {
+        component = new documentManagementRestClient.DocumentManagementClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("DocumentManagementClient");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -970,7 +1153,11 @@ const EventBusComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * Socket client.
+     */
+    SocketClient: "socket-client"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -1006,7 +1193,7 @@ function initialiseEventBusConnector(engineCore, context, instanceConfig, overri
     let instanceType;
     if (type === EventBusConnectorType.Local) {
         connector = new eventBusConnectorLocal.LocalEventBusConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = eventBusConnectorLocal.LocalEventBusConnector.NAMESPACE;
@@ -1040,10 +1227,17 @@ function initialiseEventBusComponent(engineCore, context, instanceConfig, overri
     let instanceType;
     if (type === EventBusComponentType.Service) {
         component = new eventBusService.EventBusService({
-            eventBusConnectorType: context.defaultTypes.eventBusConnector,
+            eventBusConnectorType: engineCore.getRegisteredInstanceType("eventBusConnector"),
             ...instanceConfig.options
         });
-        instanceType = eventBusService.EventBusService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("EventBusService");
+    }
+    else if (type === EventBusComponentType.SocketClient) {
+        component = new eventBusSocketClient.EventBusSocketClient({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            ...instanceConfig.options
+        });
+        instanceType = core.StringHelper.kebabCase("EventBusSocketClient");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -1093,7 +1287,8 @@ function initialiseFaucetConnector(engineCore, context, instanceConfig, override
     let connector;
     let instanceType;
     if (type === FaucetConnectorType.Iota) {
-        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
+        const defaultConfigType = engineCore.getRegisteredInstanceType("dltConfig");
+        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === defaultConfigType);
         connector = new walletConnectorIota.IotaFaucetConnector({
             ...instanceConfig.options,
             config: {
@@ -1132,7 +1327,11 @@ const FederatedCatalogueComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -1160,11 +1359,15 @@ function initialiseFederatedCatalogueComponent(engineCore, context, instanceConf
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.serviceOfferingEntityStorageType, "ServiceOfferingEntry");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.dataSpaceConnectorStorageType, "DataSpaceConnectorEntry");
         component = new federatedCatalogueService.FederatedCatalogueService({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
-            identityResolverComponentType: context.defaultTypes.identityResolverComponent,
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            identityResolverComponentType: engineCore.getRegisteredInstanceType("identityResolverComponent"),
             ...instanceConfig.options
         });
-        instanceType = federatedCatalogueService.FederatedCatalogueService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("FederatedCatalogueService");
+    }
+    else if (type === FederatedCatalogueComponentType.RestClient) {
+        component = new federatedCatalogueRestClient.FederatedCatalogueClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("FederatedCatalogueClient");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -1191,7 +1394,11 @@ const IdentityComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -1230,9 +1437,10 @@ function initialiseIdentityConnector(engineCore, context, instanceConfig, overri
     let connector;
     let instanceType;
     if (type === IdentityConnectorType.Iota) {
-        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
+        const defaultConfigType = engineCore.getRegisteredInstanceType("dltConfig");
+        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === defaultConfigType);
         connector = new identityConnectorIota.IotaIdentityConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
             ...instanceConfig.options,
             config: {
                 ...dltConfig?.options?.config,
@@ -1245,7 +1453,7 @@ function initialiseIdentityConnector(engineCore, context, instanceConfig, overri
         identityConnectorEntityStorage.initSchema({ includeProfile: false });
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.didDocumentEntityStorageType, "IdentityDocument");
         connector = new identityConnectorEntityStorage.EntityStorageIdentityConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
             ...instanceConfig.options
         });
         instanceType = identityConnectorEntityStorage.EntityStorageIdentityConnector.NAMESPACE;
@@ -1279,7 +1487,11 @@ function initialiseIdentityComponent(engineCore, context, instanceConfig, overri
     let instanceType;
     if (type === IdentityComponentType.Service) {
         component = new identityService.IdentityService(instanceConfig.options);
-        instanceType = identityService.IdentityService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("IdentityService");
+    }
+    else if (type === IdentityComponentType.RestClient) {
+        component = new identityRestClient.IdentityClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("IdentityClient");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -1303,7 +1515,11 @@ const IdentityProfileComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -1375,10 +1591,14 @@ function initialiseIdentityProfileComponent(engineCore, context, instanceConfig,
     let instanceType;
     if (type === IdentityProfileComponentType.Service) {
         component = new identityService.IdentityProfileService({
-            profileEntityConnectorType: context.defaultTypes.identityProfileConnector,
+            profileEntityConnectorType: engineCore.getRegisteredInstanceType("identityProfileConnector"),
             ...instanceConfig.options
         });
-        instanceType = identityService.IdentityProfileService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("IdentityProfileService");
+    }
+    else if (type === IdentityProfileComponentType.RestClient) {
+        component = new identityRestClient.IdentityProfileClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("IdentityProfileClient");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -1405,7 +1625,11 @@ const IdentityResolverComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -1448,7 +1672,8 @@ function initialiseIdentityResolverConnector(engineCore, context, instanceConfig
     let connector;
     let instanceType;
     if (type === IdentityResolverConnectorType.Iota) {
-        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
+        const defaultConfigType = engineCore.getRegisteredInstanceType("dltConfig");
+        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === defaultConfigType);
         connector = new identityConnectorIota.IotaIdentityResolverConnector({
             ...instanceConfig.options,
             config: {
@@ -1462,7 +1687,7 @@ function initialiseIdentityResolverConnector(engineCore, context, instanceConfig
         identityConnectorEntityStorage.initSchema({ includeProfile: false });
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.didDocumentEntityStorageType, "IdentityDocument");
         connector = new identityConnectorEntityStorage.EntityStorageIdentityResolverConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
             ...instanceConfig.options
         });
         instanceType = identityConnectorEntityStorage.EntityStorageIdentityResolverConnector.NAMESPACE;
@@ -1501,13 +1726,18 @@ function initialiseIdentityResolverComponent(engineCore, context, instanceConfig
     let component;
     let instanceType;
     if (type === IdentityResolverComponentType.Service) {
+        const defaultIdentityResolverType = engineCore.getRegisteredInstanceType("identityResolverConnector");
         component = new identityService.IdentityResolverService({
-            fallbackResolverConnectorType: context.defaultTypes.identityResolverConnector !== IdentityResolverConnectorType.Universal
+            fallbackResolverConnectorType: defaultIdentityResolverType !== IdentityResolverConnectorType.Universal
                 ? IdentityResolverConnectorType.Universal
                 : undefined,
             ...instanceConfig.options
         });
-        instanceType = identityService.IdentityResolverService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("IdentityResolverService");
+    }
+    else if (type === IdentityResolverComponentType.RestClient) {
+        component = new identityRestClient.IdentityResolverClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("IdentityResolverClient");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -1531,7 +1761,11 @@ const ImmutableProofComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -1556,13 +1790,17 @@ function initialiseImmutableProofComponent(engineCore, context, instanceConfig,
         immutableProofService.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.immutableProofEntityStorageType, "ImmutableProof");
         component = new immutableProofService.ImmutableProofService({
-            verifiableStorageType: context.defaultTypes.verifiableStorageConnector,
-            identityConnectorType: context.defaultTypes.identityConnector,
-            backgroundTaskConnectorType: context.defaultTypes.backgroundTaskConnector,
-            eventBusComponentType: context.defaultTypes.eventBusComponent,
+            verifiableStorageType: engineCore.getRegisteredInstanceType("verifiableStorageConnector"),
+            identityConnectorType: engineCore.getRegisteredInstanceType("identityConnector"),
+            backgroundTaskConnectorType: engineCore.getRegisteredInstanceType("backgroundTaskConnector"),
+            eventBusComponentType: engineCore.getRegisteredInstanceTypeOptional("eventBusComponent"),
             ...instanceConfig.options
         });
-        instanceType = immutableProofService.ImmutableProofService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("ImmutableProofService");
+    }
+    else if (type === ImmutableProofComponentType.RestClient) {
+        component = new immutableProofRestClient.ImmutableProofClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("ImmutableProofClient");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -1589,7 +1827,11 @@ const LoggingComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -1674,10 +1916,14 @@ function initialiseLoggingComponent(engineCore, context, instanceConfig, overrid
     let instanceType;
     if (type === LoggingComponentType.Service) {
         component = new loggingService.LoggingService({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+            loggingConnectorType: engineCore.getRegisteredInstanceType("loggingConnector"),
             ...instanceConfig.options
         });
-        instanceType = loggingService.LoggingService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("LoggingService");
+    }
+    else if (type === LoggingComponentType.RestClient) {
+        component = new loggingRestClient.LoggingClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("LoggingClient");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -1777,14 +2023,14 @@ function initialiseMessagingEmailConnector(engineCore, context, instanceConfig,
         messagingConnectorEntityStorage.initSchema({ email: true, sms: false, pushNotification: false });
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.messagingEmailEntryStorageConnectorType, "EmailEntry");
         connector = new messagingConnectorEntityStorage.EntityStorageMessagingEmailConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = messagingConnectorEntityStorage.EntityStorageMessagingEmailConnector.NAMESPACE;
     }
     else if (type === MessagingEmailConnectorType.Aws) {
         connector = new messagingConnectorAws.AwsMessagingEmailConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = messagingConnectorAws.AwsMessagingEmailConnector.NAMESPACE;
@@ -1820,14 +2066,14 @@ function initialiseMessagingSmsConnector(engineCore, context, instanceConfig, ov
         messagingConnectorEntityStorage.initSchema({ email: false, sms: true, pushNotification: false });
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.messagingSmsEntryStorageConnectorType, "SmsEntry");
         connector = new messagingConnectorEntityStorage.EntityStorageMessagingSmsConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = messagingConnectorEntityStorage.EntityStorageMessagingSmsConnector.NAMESPACE;
     }
     else if (type === MessagingSmsConnectorType.Aws) {
         connector = new messagingConnectorAws.AwsMessagingSmsConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = messagingConnectorAws.AwsMessagingSmsConnector.NAMESPACE;
@@ -1864,14 +2110,14 @@ function initialiseMessagingPushNotificationConnector(engineCore, context, insta
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.messagingDeviceEntryStorageConnectorType, "PushNotificationDeviceEntry");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.messagingMessageEntryStorageConnectorType, "PushNotificationMessageEntry");
         connector = new messagingConnectorEntityStorage.EntityStorageMessagingPushNotificationConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = messagingConnectorEntityStorage.EntityStorageMessagingPushNotificationConnector.NAMESPACE;
     }
     else if (type === MessagingPushNotificationConnectorType.Aws) {
         connector = new messagingConnectorAws.AwsMessagingPushNotificationConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = messagingConnectorAws.AwsMessagingPushNotificationConnector.NAMESPACE;
@@ -1907,12 +2153,12 @@ function initialiseMessagingComponent(engineCore, context, instanceConfig, overr
         messagingService.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.templateEntryStorageConnectorType, "TemplateEntry");
         component = new messagingService.MessagingService({
-            messagingEmailConnectorType: context.defaultTypes.messagingEmailConnector,
-            messagingSmsConnectorType: context.defaultTypes.messagingSmsConnector,
-            messagingPushNotificationConnectorType: context.defaultTypes.messagingNotificationConnector,
+            messagingEmailConnectorType: engineCore.getRegisteredInstanceTypeOptional("messagingEmailConnector"),
+            messagingSmsConnectorType: engineCore.getRegisteredInstanceTypeOptional("messagingSmsConnector"),
+            messagingPushNotificationConnectorType: engineCore.getRegisteredInstanceTypeOptional("messagingNotificationConnector"),
             ...instanceConfig.options
         });
-        instanceType = messagingService.MessagingService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("MessagingService");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -1936,7 +2182,11 @@ const NftComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -1982,8 +2232,8 @@ function initialiseNftConnector(engineCore, context, instanceConfig, overrideIns
     }
     else if (type === NftConnectorType.Iota) {
         connector = new nftConnectorIota.IotaNftConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
-            walletConnectorType: context.defaultTypes.walletConnector,
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
+            walletConnectorType: engineCore.getRegisteredInstanceType("walletConnector"),
             ...instanceConfig.options
         });
         instanceType = nftConnectorIota.IotaNftConnector.NAMESPACE;
@@ -2020,7 +2270,11 @@ function initialiseNftComponent(engineCore, context, instanceConfig, overrideIns
     let instanceType;
     if (type === NftComponentType.Service) {
         component = new nftService.NftService(instanceConfig.options);
-        instanceType = nftService.NftService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("NftService");
+    }
+    else if (type === NftComponentType.RestClient) {
+        component = new nftRestClient.NftClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("NftClient");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -2047,7 +2301,11 @@ const RightsManagementComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -2070,10 +2328,15 @@ function initialiseRightsManagementComponent(engineCore, context, instanceConfig
     let instanceType;
     if (type === RightsManagementComponentType.Service) {
         component = new rightsManagementService.RightsManagementService({
-            papComponentType: context.defaultTypes.rightsManagementPapComponent,
+            policyAdministrationPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPapComponent"),
+            policyEnforcementPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPepComponent"),
             ...instanceConfig.options
         });
-        instanceType = rightsManagementService.RightsManagementService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("RightsManagementService");
+    }
+    else if (type === RightsManagementComponentType.RestClient) {
+        component = new rightsManagementRestClient.RightsManagementClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("RightsManagementClient");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -2124,8 +2387,11 @@ function initialiseRightsManagementPapComponent(engineCore, context, instanceCon
     if (type === RightsManagementPapComponentType.Service) {
         rightsManagementPapService.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.odrlPolicyEntityStorageType, "OdrlPolicy");
-        component = new rightsManagementPapService.PolicyAdministrationPointService(instanceConfig.options);
-        instanceType = rightsManagementPapService.PolicyAdministrationPointService.NAMESPACE;
+        component = new rightsManagementPapService.PolicyAdministrationPointService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            ...instanceConfig.options
+        });
+        instanceType = core.StringHelper.kebabCase("PolicyAdministrationPointService");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -2142,6 +2408,348 @@ function initialiseRightsManagementPapComponent(engineCore, context, instanceCon
     return finalInstanceType;
 }
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Rights management PDP component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const RightsManagementPdpComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the rights management PDP component.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+function initialiseRightsManagementPdpComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Rights Management PDP Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === RightsManagementPdpComponentType.Service) {
+        component = new rightsManagementPdpService.PolicyDecisionPointService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            policyInformationPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPipComponent"),
+            policyManagementPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPmpComponent"),
+            policyExecutionPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPxpComponent"),
+            ...instanceConfig.options
+        });
+        instanceType = core.StringHelper.kebabCase("PolicyDecisionPointService");
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "RightsManagementPdpComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Rights management PEP component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const RightsManagementPepComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the rights management PEP component.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+function initialiseRightsManagementPepComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Rights Management PEP Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === RightsManagementPepComponentType.Service) {
+        component = new rightsManagementPepService.PolicyEnforcementPointService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            policyDecisionPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPdpComponent"),
+            ...instanceConfig.options
+        });
+        instanceType = core.StringHelper.kebabCase("PolicyEnforcementPointService");
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "RightsManagementPepComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Rights management PIP component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const RightsManagementPipComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the rights management PIP component.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+function initialiseRightsManagementPipComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Rights Management PIP Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === RightsManagementPipComponentType.Service) {
+        component = new rightsManagementPipService.PolicyInformationPointService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            ...instanceConfig.options
+        });
+        instanceType = core.StringHelper.kebabCase("PolicyInformationPointService");
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "RightsManagementPipComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Rights management PMP component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const RightsManagementPmpComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the rights management PMP component.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+function initialiseRightsManagementPmpComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Rights Management PMP Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === RightsManagementPmpComponentType.Service) {
+        component = new rightsManagementPmpService.PolicyManagementPointService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            policyAdministrationPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPapComponent"),
+            ...instanceConfig.options
+        });
+        instanceType = core.StringHelper.kebabCase("PolicyManagementPointService");
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "RightsManagementPmpComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Rights management PXP component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const RightsManagementPxpComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the rights management PXP component.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+function initialiseRightsManagementPxpComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Rights Management PXP Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === RightsManagementPxpComponentType.Service) {
+        component = new rightsManagementPxpService.PolicyExecutionPointService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            ...instanceConfig.options
+        });
+        instanceType = core.StringHelper.kebabCase("PolicyExecutionPointService");
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "RightsManagementPxpComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Synchronised storage component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const SynchronisedStorageComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the synchronised storage component.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+function initialiseSynchronisedStorageComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Synchronised Storage Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === SynchronisedStorageComponentType.Service) {
+        synchronisedStorageService.initSchema();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.syncSnapshotStorageConnectorType, "SyncSnapshotEntry");
+        component = new synchronisedStorageService.SynchronisedStorageService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            eventBusComponentType: engineCore.getRegisteredInstanceType("eventBusComponent"),
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
+            verifiableStorageConnectorType: engineCore.getRegisteredInstanceType("verifiableStorageConnector"),
+            identityConnectorType: engineCore.getRegisteredInstanceType("identityConnector"),
+            taskSchedulerComponentType: engineCore.getRegisteredInstanceType("taskSchedulerComponent"),
+            trustedSynchronisedStorageComponentType: engineCore.getRegisteredInstanceTypeOptional("synchronisedStorageComponent", ["trusted"]),
+            blobStorageConnectorType: engineCore.getRegisteredInstanceType("blobStorageConnector", [
+                "public"
+            ]),
+            ...instanceConfig.options
+        });
+        instanceType = core.StringHelper.kebabCase("SynchronisedStorageService");
+    }
+    else if (type === SynchronisedStorageComponentType.RestClient) {
+        component = new synchronisedStorageRestClient.SynchronisedStorageClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("SynchronisedStorageClient");
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "SynchronisedStorageComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
@@ -2152,7 +2760,7 @@ const TaskSchedulerComponentType = {
     /**
      * Task scheduler.
      */
-    Default: "default"
+    Service: "service"
 };
 
 /**
@@ -2171,12 +2779,12 @@ function initialiseTaskSchedulerComponent(engineCore, context, instanceConfig, o
     const type = instanceConfig.type;
     let component;
     let instanceType;
-    if (type === TaskSchedulerComponentType.Default) {
-        component = new backgroundTaskScheduler.TaskSchedulerComponent({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+    if (type === TaskSchedulerComponentType.Service) {
+        component = new backgroundTaskScheduler.TaskSchedulerService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
-        instanceType = backgroundTaskScheduler.TaskSchedulerComponent.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("TaskSchedulerService");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -2203,7 +2811,11 @@ const TelemetryComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -2242,7 +2854,7 @@ function initialiseTelemetryConnector(engineCore, context, instanceConfig, overr
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.telemetryMetricStorageConnectorType, "TelemetryMetric");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.telemetryMetricValueStorageConnectorType, "TelemetryMetricValue");
         connector = new telemetryConnectorEntityStorage.EntityStorageTelemetryConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = telemetryConnectorEntityStorage.EntityStorageTelemetryConnector.NAMESPACE;
@@ -2276,10 +2888,14 @@ function initialiseTelemetryComponent(engineCore, context, instanceConfig, overr
     let instanceType;
     if (type === TelemetryComponentType.Service) {
         component = new telemetryService.TelemetryService({
-            telemetryConnectorType: context.defaultTypes.telemetryConnector,
+            telemetryConnectorType: engineCore.getRegisteredInstanceType("telemetryConnector"),
             ...instanceConfig.options
         });
-        instanceType = telemetryService.TelemetryService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("TelemetryService");
+    }
+    else if (type === TelemetryComponentType.RestClient) {
+        component = new telemetryRestClient.TelemetryClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("TelemetryClient");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -2361,7 +2977,11 @@ const VerifiableStorageComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -2400,9 +3020,10 @@ function initialiseVerifiableStorageConnector(engineCore, context, instanceConfi
     let connector;
     let instanceType;
     if (type === VerifiableStorageConnectorType.Iota) {
-        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
+        const defaultConfigType = engineCore.getRegisteredInstanceType("dltConfig");
+        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === defaultConfigType);
         connector = new verifiableStorageConnectorIota.IotaVerifiableStorageConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
             ...instanceConfig.options,
             config: {
                 ...dltConfig?.options?.config,
@@ -2451,7 +3072,11 @@ function initialiseVerifiableStorageComponent(engineCore, context, instanceConfi
         component = new verifiableStorageService.VerifiableStorageService({
             ...instanceConfig.options
         });
-        instanceType = verifiableStorageService.VerifiableStorageService.NAMESPACE;
+        instanceType = core.StringHelper.kebabCase("VerifiableStorageService");
+    }
+    else if (type === VerifiableStorageComponentType.RestClient) {
+        component = new verifiableStorageRestClient.VerifiableStorageClient(instanceConfig.options);
+        instanceType = core.StringHelper.kebabCase("VerifiableStorageClient");
     }
     else {
         throw new core.GeneralError("engineCore", "componentUnknownType", {
@@ -2504,10 +3129,11 @@ function initialiseWalletConnector(engineCore, context, instanceConfig, override
     let connector;
     let instanceType;
     if (type === WalletConnectorType.Iota) {
-        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
+        const defaultConfigType = engineCore.getRegisteredInstanceType("dltConfig");
+        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === defaultConfigType);
         connector = new walletConnectorIota.IotaWalletConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
-            faucetConnectorType: context.defaultTypes.faucetConnector,
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
+            faucetConnectorType: engineCore.getRegisteredInstanceType("faucetConnector"),
             ...instanceConfig.options,
             config: {
                 ...dltConfig?.options?.config,
@@ -2518,8 +3144,8 @@ function initialiseWalletConnector(engineCore, context, instanceConfig, override
     }
     else if (type === WalletConnectorType.EntityStorage) {
         connector = new walletConnectorEntityStorage.EntityStorageWalletConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
-            faucetConnectorType: context.defaultTypes.faucetConnector,
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
+            faucetConnectorType: engineCore.getRegisteredInstanceType("faucetConnector"),
             ...instanceConfig.options
         });
         instanceType = walletConnectorEntityStorage.EntityStorageWalletConnector.NAMESPACE;
@@ -2586,6 +3212,7 @@ exports.BlobStorageConnectorType = BlobStorageConnectorType;
 exports.DataConverterConnectorType = DataConverterConnectorType;
 exports.DataExtractorConnectorType = DataExtractorConnectorType;
 exports.DataProcessingComponentType = DataProcessingComponentType;
+exports.DataSpaceConnectorComponentType = DataSpaceConnectorComponentType;
 exports.DltConfigType = DltConfigType;
 exports.DocumentManagementComponentType = DocumentManagementComponentType;
 exports.EntityStorageComponentType = EntityStorageComponentType;
@@ -2611,6 +3238,12 @@ exports.NftComponentType = NftComponentType;
 exports.NftConnectorType = NftConnectorType;
 exports.RightsManagementComponentType = RightsManagementComponentType;
 exports.RightsManagementPapComponentType = RightsManagementPapComponentType;
+exports.RightsManagementPdpComponentType = RightsManagementPdpComponentType;
+exports.RightsManagementPepComponentType = RightsManagementPepComponentType;
+exports.RightsManagementPipComponentType = RightsManagementPipComponentType;
+exports.RightsManagementPmpComponentType = RightsManagementPmpComponentType;
+exports.RightsManagementPxpComponentType = RightsManagementPxpComponentType;
+exports.SynchronisedStorageComponentType = SynchronisedStorageComponentType;
 exports.TaskSchedulerComponentType = TaskSchedulerComponentType;
 exports.TelemetryComponentType = TelemetryComponentType;
 exports.TelemetryConnectorType = TelemetryConnectorType;
@@ -2628,6 +3261,7 @@ exports.initialiseBlobStorageConnector = initialiseBlobStorageConnector;
 exports.initialiseDataConverterConnector = initialiseDataConverterConnector;
 exports.initialiseDataExtractorConnector = initialiseDataExtractorConnector;
 exports.initialiseDataProcessingComponent = initialiseDataProcessingComponent;
+exports.initialiseDataSpaceConnectorComponent = initialiseDataSpaceConnectorComponent;
 exports.initialiseDocumentManagementComponent = initialiseDocumentManagementComponent;
 exports.initialiseEntityStorageComponent = initialiseEntityStorageComponent;
 exports.initialiseEntityStorageConnector = initialiseEntityStorageConnector;
@@ -2652,6 +3286,12 @@ exports.initialiseNftComponent = initialiseNftComponent;
 exports.initialiseNftConnector = initialiseNftConnector;
 exports.initialiseRightsManagementComponent = initialiseRightsManagementComponent;
 exports.initialiseRightsManagementPapComponent = initialiseRightsManagementPapComponent;
+exports.initialiseRightsManagementPdpComponent = initialiseRightsManagementPdpComponent;
+exports.initialiseRightsManagementPepComponent = initialiseRightsManagementPepComponent;
+exports.initialiseRightsManagementPipComponent = initialiseRightsManagementPipComponent;
+exports.initialiseRightsManagementPmpComponent = initialiseRightsManagementPmpComponent;
+exports.initialiseRightsManagementPxpComponent = initialiseRightsManagementPxpComponent;
+exports.initialiseSynchronisedStorageComponent = initialiseSynchronisedStorageComponent;
 exports.initialiseTaskSchedulerComponent = initialiseTaskSchedulerComponent;
 exports.initialiseTelemetryComponent = initialiseTelemetryComponent;
 exports.initialiseTelemetryConnector = initialiseTelemetryConnector;