@twin.org/engine-types 0.0.2-next.2 → 0.0.2-next.20

package/dist/esm/index.mjs

@@ -2,7 +2,7 @@ import { NftAttestationConnector } from '@twin.org/attestation-connector-nft';
 import { AttestationConnectorFactory } from '@twin.org/attestation-models';
 import { AttestationClient } from '@twin.org/attestation-rest-client';
 import { AttestationService } from '@twin.org/attestation-service';
-import { I18n, GeneralError, StringHelper, ComponentFactory, Is } from '@twin.org/core';
+import { ComponentFactory, StringHelper, Is, GeneralError, I18n } from '@twin.org/core';
 import { AuditableItemGraphClient } from '@twin.org/auditable-item-graph-rest-client';
 import { initSchema, AuditableItemGraphService } from '@twin.org/auditable-item-graph-service';
 import path from 'node:path';
@@ -15,11 +15,14 @@ import { MongoDbEntityStorageConnector } from '@twin.org/entity-storage-connecto
 import { MySqlEntityStorageConnector } from '@twin.org/entity-storage-connector-mysql';
 import { PostgreSqlEntityStorageConnector } from '@twin.org/entity-storage-connector-postgresql';
 import { ScyllaDBTableConnector } from '@twin.org/entity-storage-connector-scylladb';
+import { SynchronisedEntityStorageConnector } from '@twin.org/entity-storage-connector-synchronised';
 import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
 import { EntityStorageClient } from '@twin.org/entity-storage-rest-client';
 import { EntityStorageService } from '@twin.org/entity-storage-service';
 import { AuditableItemStreamClient } from '@twin.org/auditable-item-stream-rest-client';
 import { initSchema as initSchema$1, AuditableItemStreamService } from '@twin.org/auditable-item-stream-service';
+import { AuthenticationGeneratorFactory } from '@twin.org/api-models';
+import { VerifiableCredentialAuthenticationGenerator } from '@twin.org/identity-authentication';
 import { initSchema as initSchema$2, EntityStorageBackgroundTaskConnector } from '@twin.org/background-task-connector-entity-storage';
 import { BackgroundTaskConnectorFactory } from '@twin.org/background-task-models';
 import { S3BlobStorageConnector } from '@twin.org/blob-storage-connector-aws-s3';
@@ -36,51 +39,63 @@ import { JsonPathExtractorConnector } from '@twin.org/data-processing-extractors
 import { DataConverterConnectorFactory, DataExtractorConnectorFactory } from '@twin.org/data-processing-models';
 import { DataProcessingClient } from '@twin.org/data-processing-rest-client';
 import { initSchema as initSchema$4, DataProcessingService } from '@twin.org/data-processing-service';
+import { DataSpaceConnectorClient } from '@twin.org/data-space-connector-rest-client';
+import { initSchema as initSchema$5, DataSpaceConnectorService } from '@twin.org/data-space-connector-service';
+import { DataSpaceConnectorSocketClient } from '@twin.org/data-space-connector-socket-client';
 import { DocumentManagementClient } from '@twin.org/document-management-rest-client';
 import { DocumentManagementService } from '@twin.org/document-management-service';
 import { LocalEventBusConnector } from '@twin.org/event-bus-connector-local';
 import { EventBusConnectorFactory } from '@twin.org/event-bus-models';
 import { EventBusService } from '@twin.org/event-bus-service';
 import { EventBusSocketClient } from '@twin.org/event-bus-socket-client';
-import { EntityStorageFaucetConnector, EntityStorageWalletConnector, initSchema as initSchema$g } from '@twin.org/wallet-connector-entity-storage';
+import { initSchema as initSchema$6, EntityStorageFaucetConnector, EntityStorageWalletConnector } from '@twin.org/wallet-connector-entity-storage';
 import { IotaFaucetConnector, IotaWalletConnector } from '@twin.org/wallet-connector-iota';
 import { FaucetConnectorFactory, WalletConnectorFactory } from '@twin.org/wallet-models';
 import { FederatedCatalogueClient } from '@twin.org/federated-catalogue-rest-client';
-import { initSchema as initSchema$5, FederatedCatalogueService } from '@twin.org/federated-catalogue-service';
-import { initSchema as initSchema$6, EntityStorageIdentityConnector, EntityStorageIdentityProfileConnector, EntityStorageIdentityResolverConnector } from '@twin.org/identity-connector-entity-storage';
+import { initSchema as initSchema$7, FederatedCatalogueService } from '@twin.org/federated-catalogue-service';
+import { initSchema as initSchema$8, EntityStorageIdentityConnector, EntityStorageIdentityProfileConnector, EntityStorageIdentityResolverConnector } from '@twin.org/identity-connector-entity-storage';
 import { IotaIdentityConnector, IotaIdentityResolverConnector } from '@twin.org/identity-connector-iota';
 import { IdentityConnectorFactory, IdentityProfileConnectorFactory, IdentityResolverConnectorFactory } from '@twin.org/identity-models';
 import { IdentityClient, IdentityProfileClient, IdentityResolverClient } from '@twin.org/identity-rest-client';
 import { IdentityService, IdentityProfileService, IdentityResolverService } from '@twin.org/identity-service';
 import { UniversalResolverConnector } from '@twin.org/identity-connector-universal';
 import { ImmutableProofClient } from '@twin.org/immutable-proof-rest-client';
-import { initSchema as initSchema$7, ImmutableProofService } from '@twin.org/immutable-proof-service';
+import { initSchema as initSchema$9, ImmutableProofService } from '@twin.org/immutable-proof-service';
 import { ConsoleLoggingConnector } from '@twin.org/logging-connector-console';
-import { initSchema as initSchema$8, EntityStorageLoggingConnector } from '@twin.org/logging-connector-entity-storage';
+import { initSchema as initSchema$a, EntityStorageLoggingConnector } from '@twin.org/logging-connector-entity-storage';
 import { MultiLoggingConnector, LoggingConnectorFactory } from '@twin.org/logging-models';
 import { LoggingClient } from '@twin.org/logging-rest-client';
 import { LoggingService } from '@twin.org/logging-service';
 import { AwsMessagingEmailConnector, AwsMessagingSmsConnector, AwsMessagingPushNotificationConnector } from '@twin.org/messaging-connector-aws';
-import { initSchema as initSchema$9, EntityStorageMessagingEmailConnector, EntityStorageMessagingSmsConnector, EntityStorageMessagingPushNotificationConnector } from '@twin.org/messaging-connector-entity-storage';
+import { initSchema as initSchema$b, EntityStorageMessagingEmailConnector, EntityStorageMessagingSmsConnector, EntityStorageMessagingPushNotificationConnector } from '@twin.org/messaging-connector-entity-storage';
 import { MessagingEmailConnectorFactory, MessagingSmsConnectorFactory, MessagingPushNotificationsConnectorFactory } from '@twin.org/messaging-models';
-import { initSchema as initSchema$a, MessagingService } from '@twin.org/messaging-service';
-import { initSchema as initSchema$b, EntityStorageNftConnector } from '@twin.org/nft-connector-entity-storage';
+import { MessagingService, initSchema as initSchema$c, MessagingAdminService } from '@twin.org/messaging-service';
+import { initSchema as initSchema$d, EntityStorageNftConnector } from '@twin.org/nft-connector-entity-storage';
 import { IotaNftConnector } from '@twin.org/nft-connector-iota';
 import { NftConnectorFactory } from '@twin.org/nft-models';
 import { NftClient } from '@twin.org/nft-rest-client';
 import { NftService } from '@twin.org/nft-service';
-import { RightsManagementClient } from '@twin.org/rights-management-rest-client';
-import { RightsManagementService } from '@twin.org/rights-management-service';
-import { initSchema as initSchema$c, PolicyAdministrationPointService } from '@twin.org/rights-management-pap-service';
+import { DataAccessPointService, DataAccessRequestPointService } from '@twin.org/rights-management-dap-service';
+import { DataAccessPointClient, PolicyAdministrationPointClient, PolicyNegotiationAdminPointClient, PolicyNegotiationPointClient } from '@twin.org/rights-management-rest-client';
+import { initSchema as initSchema$e, PolicyAdministrationPointService } from '@twin.org/rights-management-pap-service';
+import { EngineModuleHelper } from '@twin.org/engine-core';
+import { PolicyDecisionPointService } from '@twin.org/rights-management-pdp-service';
+import { PolicyEnforcementPointService } from '@twin.org/rights-management-pep-service';
+import { PolicyInformationPointService } from '@twin.org/rights-management-pip-service';
+import { PolicyManagementPointService } from '@twin.org/rights-management-pmp-service';
+import { initSchema as initSchema$f, PolicyNegotiationAdminPointService, PolicyNegotiationPointService } from '@twin.org/rights-management-pnp-service';
+import { PolicyExecutionPointService } from '@twin.org/rights-management-pxp-service';
+import { SynchronisedStorageClient } from '@twin.org/synchronised-storage-rest-client';
+import { initSchema as initSchema$g, SynchronisedStorageService } from '@twin.org/synchronised-storage-service';
 import { TaskSchedulerService } from '@twin.org/background-task-scheduler';
-import { initSchema as initSchema$d, EntityStorageTelemetryConnector } from '@twin.org/telemetry-connector-entity-storage';
+import { initSchema as initSchema$h, EntityStorageTelemetryConnector } from '@twin.org/telemetry-connector-entity-storage';
 import { TelemetryConnectorFactory } from '@twin.org/telemetry-models';
 import { TelemetryClient } from '@twin.org/telemetry-rest-client';
 import { TelemetryService } from '@twin.org/telemetry-service';
-import { initSchema as initSchema$e, EntityStorageVaultConnector } from '@twin.org/vault-connector-entity-storage';
+import { initSchema as initSchema$i, EntityStorageVaultConnector } from '@twin.org/vault-connector-entity-storage';
 import { HashicorpVaultConnector } from '@twin.org/vault-connector-hashicorp';
 import { VaultConnectorFactory } from '@twin.org/vault-models';
-import { initSchema as initSchema$f, EntityStorageVerifiableStorageConnector } from '@twin.org/verifiable-storage-connector-entity-storage';
+import { initSchema as initSchema$j, EntityStorageVerifiableStorageConnector } from '@twin.org/verifiable-storage-connector-entity-storage';
 import { IotaVerifiableStorageConnector } from '@twin.org/verifiable-storage-connector-iota';
 import { VerifiableStorageConnectorFactory } from '@twin.org/verifiable-storage-models';
 import { VerifiableStorageClient } from '@twin.org/verifiable-storage-rest-client';
@@ -123,78 +138,50 @@ const AttestationConnectorType = {
  * @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 connector type is unknown.
- */
-function initialiseAttestationConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Attestation Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseAttestationConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === AttestationConnectorType.Nft) {
-        connector = new NftAttestationConnector({
-            identityConnectorType: context.defaultTypes.identityConnector,
-            nftConnectorType: context.defaultTypes.nftConnector,
+    if (instanceConfig.type === AttestationConnectorType.Nft) {
+        component = new NftAttestationConnector({
+            identityConnectorType: engineCore.getRegisteredInstanceType("identityConnector"),
+            nftConnectorType: engineCore.getRegisteredInstanceType("nftConnector"),
             ...instanceConfig.options
         });
         instanceType = NftAttestationConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "attestationConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    AttestationConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: AttestationConnectorFactory
+    };
 }
 /**
  * Initialise the attestation 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 initialiseAttestationComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Attestation Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseAttestationComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === AttestationComponentType.Service) {
+    if (instanceConfig.type === AttestationComponentType.Service) {
         component = new AttestationService({
             ...instanceConfig.options
         });
-        instanceType = StringHelper.kebabCase("AttestationService");
+        instanceType = "attestation-service";
     }
-    else if (type === AttestationComponentType.RestClient) {
+    else if (instanceConfig.type === AttestationComponentType.RestClient) {
         component = new AttestationClient(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("AttestationClient");
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "attestationComponent"
-        });
+        instanceType = "attestation-client";
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -256,7 +243,11 @@ const EntityStorageConnectorType = {
     /**
      * Postgre SQL.
      */
-    PostgreSql: "postgresql"
+    PostgreSql: "postgresql",
+    /**
+     * Synchronised.
+     */
+    Synchronised: "synchronised"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -267,7 +258,8 @@ 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.
- * @throws GeneralError if the connector type is unknown.
+ * @returns The name of the instance type that was created.
+ * @throws GeneralError when the configuration is invalid.
  */
 function initialiseEntityStorageConnector(engineCore, context, typeCustom, schema) {
     const instanceName = StringHelper.kebabCase(schema);
@@ -387,6 +379,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 SynchronisedEntityStorageConnector({
+                entitySchema: schema,
+                ...entityStorageConfig.options,
+                entityStorageConnectorType: wrappedInstanceName,
+                eventBusComponentType: engineCore.getRegisteredInstanceType("eventBusComponent"),
+                config: {
+                    ...entityStorageConfig.options.config
+                }
+            });
+        }
         else {
             throw new GeneralError("engineCore", "connectorUnknownType", {
                 type,
@@ -399,24 +408,19 @@ function initialiseEntityStorageConnector(engineCore, context, typeCustom, schem
         });
         EntityStorageConnectorFactory.register(instanceName, () => entityStorageConnector);
     }
+    return instanceName;
 }
 /**
  * Initialise the entity storage connector.
  * @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 connector type is unknown.
- */
-function initialiseEntityStorageComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Entity Storage Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseEntityStorageComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === EntityStorageComponentType.Service) {
+    if (instanceConfig.type === EntityStorageComponentType.Service) {
         const kebabName = 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);
@@ -429,27 +433,19 @@ function initialiseEntityStorageComponent(engineCore, context, instanceConfig, o
         });
         instanceType = StringHelper.kebabCase(instanceConfig.options.entityStorageType);
     }
-    else if (type === EntityStorageComponentType.RestClient) {
+    else if (instanceConfig.type === EntityStorageComponentType.RestClient) {
         const kebabName = StringHelper.kebabCase(instanceConfig.options.entityStorageType);
         component = new EntityStorageClient({
             pathPrefix: kebabName,
             ...instanceConfig.options
         });
-        instanceType = `${StringHelper.kebabCase("EntityStorageClient")}-${kebabName}`;
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            serviceType: "entityStorageComponent"
-        });
+        instanceType = `${"entity-storage-client"}-${kebabName}`;
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -474,45 +470,31 @@ const AuditableItemGraphComponentType = {
  * @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 initialiseAuditableItemGraphComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Auditable Item Graph Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseAuditableItemGraphComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === AuditableItemGraphComponentType.Service) {
+    if (instanceConfig.type === AuditableItemGraphComponentType.Service) {
         initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vertexEntityStorageType, "AuditableItemGraphVertex");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.changesetEntityStorageType, "AuditableItemGraphChangeset");
         component = new AuditableItemGraphService({
-            immutableProofComponentType: context.defaultTypes.immutableProofComponent,
-            eventBusComponentType: context.defaultTypes.eventBusComponent,
+            immutableProofComponentType: engineCore.getRegisteredInstanceType("immutableProofComponent"),
+            eventBusComponentType: engineCore.getRegisteredInstanceTypeOptional("eventBusComponent"),
             ...instanceConfig.options
         });
-        instanceType = StringHelper.kebabCase("AuditableItemGraphService");
+        instanceType = "auditable-item-graph-service";
     }
-    else if (type === AuditableItemGraphComponentType.RestClient) {
+    else if (instanceConfig.type === AuditableItemGraphComponentType.RestClient) {
         component = new AuditableItemGraphClient(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("AuditableItemGraphClient");
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "auditableItemGraphComponent"
-        });
+        instanceType = "auditable-item-graph-client";
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -537,45 +519,71 @@ const AuditableItemStreamComponentType = {
  * @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 initialiseAuditableItemStreamComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Auditable Item Stream Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseAuditableItemStreamComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === AuditableItemStreamComponentType.Service) {
+    if (instanceConfig.type === AuditableItemStreamComponentType.Service) {
         initSchema$1();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.streamEntityStorageType, "AuditableItemStream");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.streamEntryEntityStorageType, "AuditableItemStreamEntry");
         component = new AuditableItemStreamService({
-            immutableProofComponentType: context.defaultTypes.immutableProofComponent,
-            eventBusComponentType: context.defaultTypes.eventBusComponent,
+            immutableProofComponentType: engineCore.getRegisteredInstanceType("immutableProofComponent"),
+            eventBusComponentType: engineCore.getRegisteredInstanceTypeOptional("eventBusComponent"),
             ...instanceConfig.options
         });
-        instanceType = StringHelper.kebabCase("AuditableItemStreamService");
+        instanceType = "auditable-item-stream-service";
     }
-    else if (type === AuditableItemStreamComponentType.RestClient) {
+    else if (instanceConfig.type === AuditableItemStreamComponentType.RestClient) {
         component = new AuditableItemStreamClient(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("AuditableItemStreamClient");
+        instanceType = "auditable-item-stream-client";
     }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "auditableItemStreamComponent"
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Authentication generator component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const AuthenticationGeneratorComponentType = {
+    /**
+     * Verifiable Credential.
+     */
+    VerifiableCredential: "verifiable-credential"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the authentication generator component.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseAuthenticationGeneratorComponent(engineCore, context, instanceConfig) {
+    let component;
+    let instanceType;
+    if (instanceConfig.type === AuthenticationGeneratorComponentType.VerifiableCredential) {
+        component = new VerifiableCredentialAuthenticationGenerator({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            identityConnectorType: engineCore.getRegisteredInstanceType("identityConnector"),
+            ...instanceConfig.options
         });
+        instanceType = "verifiable-credential-authentication-generator";
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: AuthenticationGeneratorFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -598,36 +606,25 @@ const BackgroundTaskConnectorType = {
  * @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 connector type is unknown.
- */
-function initialiseBackgroundTaskConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Background Task Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseBackgroundTaskConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === BackgroundTaskConnectorType.EntityStorage) {
+    if (instanceConfig.type === BackgroundTaskConnectorType.EntityStorage) {
         initSchema$2();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.backgroundTaskEntityStorageType, "BackgroundTask");
-        connector = new EntityStorageBackgroundTaskConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+        component = new EntityStorageBackgroundTaskConnector({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = EntityStorageBackgroundTaskConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "backgroundTaskConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    BackgroundTaskConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: BackgroundTaskConnectorFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -687,23 +684,17 @@ const BlobStorageConnectorType = {
  * @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 connector type is unknown.
- */
-function initialiseBlobStorageConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Blob Storage Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseBlobStorageConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === BlobStorageConnectorType.Ipfs) {
-        connector = new IpfsBlobStorageConnector(instanceConfig.options);
+    if (instanceConfig.type === BlobStorageConnectorType.Ipfs) {
+        component = new IpfsBlobStorageConnector(instanceConfig.options);
         instanceType = IpfsBlobStorageConnector.NAMESPACE;
     }
-    else if (type === BlobStorageConnectorType.File) {
-        connector = new FileBlobStorageConnector({
+    else if (instanceConfig.type === BlobStorageConnectorType.File) {
+        component = new FileBlobStorageConnector({
             ...instanceConfig.options,
             config: {
                 ...instanceConfig.options.config,
@@ -714,12 +705,12 @@ function initialiseBlobStorageConnector(engineCore, context, instanceConfig, ove
         });
         instanceType = FileBlobStorageConnector.NAMESPACE;
     }
-    else if (type === BlobStorageConnectorType.Memory) {
-        connector = new MemoryBlobStorageConnector();
+    else if (instanceConfig.type === BlobStorageConnectorType.Memory) {
+        component = new MemoryBlobStorageConnector();
         instanceType = MemoryBlobStorageConnector.NAMESPACE;
     }
-    else if (type === BlobStorageConnectorType.AwsS3) {
-        connector = new S3BlobStorageConnector({
+    else if (instanceConfig.type === BlobStorageConnectorType.AwsS3) {
+        component = new S3BlobStorageConnector({
             ...instanceConfig.options,
             config: {
                 ...instanceConfig.options.config,
@@ -728,8 +719,8 @@ function initialiseBlobStorageConnector(engineCore, context, instanceConfig, ove
         });
         instanceType = S3BlobStorageConnector.NAMESPACE;
     }
-    else if (type === BlobStorageConnectorType.GcpStorage) {
-        connector = new GcpBlobStorageConnector({
+    else if (instanceConfig.type === BlobStorageConnectorType.GcpStorage) {
+        component = new GcpBlobStorageConnector({
             ...instanceConfig.options,
             config: {
                 ...instanceConfig.options.config,
@@ -738,8 +729,8 @@ function initialiseBlobStorageConnector(engineCore, context, instanceConfig, ove
         });
         instanceType = GcpBlobStorageConnector.NAMESPACE;
     }
-    else if (type === BlobStorageConnectorType.AzureStorage) {
-        connector = new AzureBlobStorageConnector({
+    else if (instanceConfig.type === BlobStorageConnectorType.AzureStorage) {
+        component = new AzureBlobStorageConnector({
             ...instanceConfig.options,
             config: {
                 ...instanceConfig.options.config,
@@ -748,62 +739,40 @@ function initialiseBlobStorageConnector(engineCore, context, instanceConfig, ove
         });
         instanceType = AzureBlobStorageConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "blobStorageConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    BlobStorageConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: BlobStorageConnectorFactory
+    };
 }
 /**
  * Initialise the blob 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 initialiseBlobStorageComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Blob Storage Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseBlobStorageComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === BlobStorageComponentType.Service) {
+    if (instanceConfig.type === BlobStorageComponentType.Service) {
         initSchema$3();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.entryEntityStorageType, "BlobStorageEntry");
         component = new BlobStorageService({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
             ...instanceConfig.options
         });
-        instanceType = StringHelper.kebabCase("BlobStorageService");
+        instanceType = "blob-storage-service";
     }
-    else if (type === BlobStorageComponentType.RestClient) {
+    else if (instanceConfig.type === BlobStorageComponentType.RestClient) {
         component = new BlobStorageClient(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("BlobStorageClient");
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "blobStorageComponent"
-        });
+        instanceType = "blob-storage-client";
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -860,114 +829,135 @@ const DataProcessingComponentType = {
  * @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 connector type is unknown.
- */
-function initialiseDataConverterConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Data Converter Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseDataConverterConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === DataConverterConnectorType.Json) {
-        connector = new JsonConverterConnector();
+    if (instanceConfig.type === DataConverterConnectorType.Json) {
+        component = new JsonConverterConnector();
         instanceType = JsonConverterConnector.NAMESPACE;
     }
-    else if (type === DataConverterConnectorType.Xml) {
-        connector = new XmlConverterConnector();
+    else if (instanceConfig.type === DataConverterConnectorType.Xml) {
+        component = new XmlConverterConnector();
         instanceType = XmlConverterConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "dataConverterConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    DataConverterConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: DataConverterConnectorFactory
+    };
 }
 /**
  * Initialise the data extractor connector.
  * @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 connector type is unknown.
- */
-function initialiseDataExtractorConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Data Extractor Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseDataExtractorConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === DataExtractorConnectorType.JsonPath) {
-        connector = new JsonPathExtractorConnector();
+    if (instanceConfig.type === DataExtractorConnectorType.JsonPath) {
+        component = new JsonPathExtractorConnector();
         instanceType = JsonPathExtractorConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "dataExtractorConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    DataExtractorConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: DataExtractorConnectorFactory
+    };
 }
 /**
  * Initialise the data processing 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 initialiseDataProcessingComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Data Processing Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseDataProcessingComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === DataProcessingComponentType.Service) {
+    if (instanceConfig.type === DataProcessingComponentType.Service) {
         initSchema$4();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.extractionRuleGroupStorageConnectorType, "ExtractionRuleGroup");
         component = new DataProcessingService({
             ...instanceConfig.options
         });
-        instanceType = StringHelper.kebabCase("DataProcessingService");
+        instanceType = "data-processing-service";
     }
-    else if (type === DataProcessingComponentType.RestClient) {
+    else if (instanceConfig.type === DataProcessingComponentType.RestClient) {
         component = new DataProcessingClient(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("DataProcessingClient");
+        instanceType = "data-processing-client";
+    }
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
+}
+
+// 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.
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseDataSpaceConnectorComponent(engineCore, context, instanceConfig) {
+    let component;
+    let instanceType;
+    if (instanceConfig.type === DataSpaceConnectorComponentType.Service) {
+        initSchema$5();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.activityLogEntityStorageType, "ActivityLogDetails");
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.activityTaskEntityStorageType, "ActivityTask");
+        component = new DataSpaceConnectorService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            backgroundTaskConnectorType: engineCore.getRegisteredInstanceType("backgroundTaskConnector"),
+            taskSchedulerComponentType: engineCore.getRegisteredInstanceType("taskSchedulerComponent"),
+            ...instanceConfig.options
+        });
+        instanceType = "data-space-connector-service";
     }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "dataProcessingComponent"
+    else if (instanceConfig.type === DataSpaceConnectorComponentType.RestClient) {
+        component = new DataSpaceConnectorClient(instanceConfig.options);
+        instanceType = "data-space-connector-client";
+    }
+    else if (instanceConfig.type === DataSpaceConnectorComponentType.SocketClient) {
+        component = new DataSpaceConnectorSocketClient({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            ...instanceConfig.options
         });
+        instanceType = "data-space-connector-socket-client";
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -994,44 +984,30 @@ const DocumentManagementComponentType = {
  * @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 initialiseDocumentManagementComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Document Management Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseDocumentManagementComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === DocumentManagementComponentType.Service) {
+    if (instanceConfig.type === DocumentManagementComponentType.Service) {
         component = new 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 = StringHelper.kebabCase("DocumentManagementService");
+        instanceType = "document-management-service";
     }
-    else if (type === DocumentManagementComponentType.RestClient) {
+    else if (instanceConfig.type === DocumentManagementComponentType.RestClient) {
         component = new DocumentManagementClient(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("DocumentManagementClient");
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "documentManagementComponent"
-        });
+        instanceType = "document-management-client";
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1071,77 +1047,68 @@ const EventBusConnectorType = {
  * @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 connector type is unknown.
- */
-function initialiseEventBusConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Event Bus Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseEventBusConnector(engineCore, context, instanceConfig) {
     let connector;
     let instanceType;
-    if (type === EventBusConnectorType.Local) {
+    if (instanceConfig.type === EventBusConnectorType.Local) {
         connector = new LocalEventBusConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = LocalEventBusConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "eventBusConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    EventBusConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        instanceType,
+        factory: EventBusConnectorFactory,
+        component: connector
+    };
 }
 /**
  * Initialise the event bus 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 initialiseEventBusComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Event Bus Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseEventBusComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === EventBusComponentType.Service) {
+    if (instanceConfig.type === EventBusComponentType.Service) {
         component = new EventBusService({
-            eventBusConnectorType: context.defaultTypes.eventBusConnector,
+            eventBusConnectorType: engineCore.getRegisteredInstanceType("eventBusConnector"),
             ...instanceConfig.options
         });
-        instanceType = StringHelper.kebabCase("EventBusService");
+        instanceType = "event-bus-service";
     }
-    else if (type === EventBusComponentType.SocketClient) {
+    else if (instanceConfig.type === EventBusComponentType.SocketClient) {
         component = new EventBusSocketClient({
-            loggingComponentType: context.defaultTypes.loggingConnector,
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
-        instanceType = StringHelper.kebabCase("EventBusSocketClient");
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "EventBusComponent"
-        });
+        instanceType = "event-bus-socket-client";
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        instanceType,
+        factory: ComponentFactory,
+        component
+    };
 }
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * DLT config types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const DltConfigType = {
+    /**
+     * IOTA.
+     */
+    Iota: "iota"
+};
+
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
@@ -1161,25 +1128,48 @@ const FaucetConnectorType = {
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
+/**
+ * Helper methods for engine config types.
+ */
+class EngineTypeHelper {
+    /**
+     * Runtime name for the class.
+     */
+    static CLASS_NAME = "EngineTypeHelper";
+    /**
+     * Get the config for the specified component and type.
+     * @param engineConfig The engine configuration.
+     * @param component The component name.
+     * @param type The type name.
+     * @returns The config for the specified component and type or undefined if it does not exist.
+     */
+    static getConfigOfType(engineConfig, component, type) {
+        if (Is.empty(engineConfig.types[component])) {
+            return undefined;
+        }
+        // First look for any of the specific type marked as default
+        let foundConfig = engineConfig.types[component]?.find(config => config.type === type && config.isDefault);
+        // If we found a default config then return that otherwise return the first matching type
+        if (Is.empty(foundConfig)) {
+            foundConfig = engineConfig.types[component]?.find(config => config.type === type);
+        }
+        return foundConfig;
+    }
+}
+
 /**
  * Initialise a faucet connector.
  * @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 connector type is unknown.
- */
-function initialiseFaucetConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Faucet Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseFaucetConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === FaucetConnectorType.Iota) {
-        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
-        connector = new IotaFaucetConnector({
+    if (instanceConfig.type === FaucetConnectorType.Iota) {
+        const dltConfig = EngineTypeHelper.getConfigOfType(engineCore.getConfig(), "dltConfig", DltConfigType.Iota);
+        component = new IotaFaucetConnector({
             ...instanceConfig.options,
             config: {
                 ...dltConfig?.options?.config,
@@ -1188,23 +1178,17 @@ function initialiseFaucetConnector(engineCore, context, instanceConfig, override
         });
         instanceType = IotaFaucetConnector.NAMESPACE;
     }
-    else if (type === FaucetConnectorType.EntityStorage) {
-        connector = new EntityStorageFaucetConnector(instanceConfig.options);
+    else if (instanceConfig.type === FaucetConnectorType.EntityStorage) {
+        initSchema$6();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.walletAddressEntityStorageType, "WalletAddress");
+        component = new EntityStorageFaucetConnector(instanceConfig.options);
         instanceType = EntityStorageFaucetConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "faucetConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    FaucetConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: FaucetConnectorFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1231,47 +1215,33 @@ const FederatedCatalogueComponentType = {
  * @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 initialiseFederatedCatalogueComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Federated Catalogue Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseFederatedCatalogueComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === FederatedCatalogueComponentType.Service) {
-        initSchema$5();
+    if (instanceConfig.type === FederatedCatalogueComponentType.Service) {
+        initSchema$7();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.dataResourceEntityStorageType, "DataResourceEntry");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.participantEntityStorageType, "ParticipantEntry");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.serviceOfferingEntityStorageType, "ServiceOfferingEntry");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.dataSpaceConnectorStorageType, "DataSpaceConnectorEntry");
         component = new FederatedCatalogueService({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
-            identityResolverComponentType: context.defaultTypes.identityResolverComponent,
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            identityResolverComponentType: engineCore.getRegisteredInstanceType("identityResolverComponent"),
             ...instanceConfig.options
         });
-        instanceType = StringHelper.kebabCase("FederatedCatalogueService");
+        instanceType = "federated-catalogue-service";
     }
-    else if (type === FederatedCatalogueComponentType.RestClient) {
+    else if (instanceConfig.type === FederatedCatalogueComponentType.RestClient) {
         component = new FederatedCatalogueClient(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("FederatedCatalogueClient");
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "FederatedCatalogueComponent"
-        });
+        instanceType = "federated-catalogue-client";
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1315,21 +1285,15 @@ const IdentityConnectorType = {
  * @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 connector type is unknown.
- */
-function initialiseIdentityConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseIdentityConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === IdentityConnectorType.Iota) {
-        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
-        connector = new IotaIdentityConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
+    if (instanceConfig.type === IdentityConnectorType.Iota) {
+        const dltConfig = EngineTypeHelper.getConfigOfType(engineCore.getConfig(), "dltConfig", DltConfigType.Iota);
+        component = new IotaIdentityConnector({
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
             ...instanceConfig.options,
             config: {
                 ...dltConfig?.options?.config,
@@ -1338,60 +1302,44 @@ function initialiseIdentityConnector(engineCore, context, instanceConfig, overri
         });
         instanceType = IotaIdentityConnector.NAMESPACE;
     }
-    else if (type === IdentityConnectorType.EntityStorage) {
-        initSchema$6({ includeProfile: false });
+    else if (instanceConfig.type === IdentityConnectorType.EntityStorage) {
+        initSchema$8({ includeProfile: false });
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.didDocumentEntityStorageType, "IdentityDocument");
-        connector = new EntityStorageIdentityConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
+        component = new EntityStorageIdentityConnector({
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
             ...instanceConfig.options
         });
         instanceType = EntityStorageIdentityConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "identityConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    IdentityConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: IdentityConnectorFactory
+    };
 }
 /**
  * Initialise the identity 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 initialiseIdentityComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseIdentityComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === IdentityComponentType.Service) {
+    if (instanceConfig.type === IdentityComponentType.Service) {
         component = new IdentityService(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("IdentityService");
+        instanceType = "identity-service";
     }
-    else if (type === IdentityComponentType.RestClient) {
+    else if (instanceConfig.type === IdentityComponentType.RestClient) {
         component = new IdentityClient(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("IdentityClient");
+        instanceType = "identity-client";
     }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "identityComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1431,77 +1379,49 @@ const IdentityProfileConnectorType = {
  * @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 connector type is unknown.
- */
-function initialiseIdentityProfileConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Profile Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseIdentityProfileConnector(engineCore, context, instanceConfig) {
     let connector;
     let instanceType;
-    if (type === IdentityProfileConnectorType.EntityStorage) {
-        initSchema$6({ includeDocument: false });
+    if (instanceConfig.type === IdentityProfileConnectorType.EntityStorage) {
+        initSchema$8({ includeDocument: false });
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.profileEntityStorageType, "IdentityProfile");
         connector = new EntityStorageIdentityProfileConnector(instanceConfig.options);
         instanceType = EntityStorageIdentityProfileConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            serviceType: "identityProfile"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    IdentityProfileConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component: connector,
+        instanceType,
+        factory: IdentityProfileConnectorFactory
+    };
 }
 /**
  * Initialise the identity profile 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 initialiseIdentityProfileComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Profile Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseIdentityProfileComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === IdentityProfileComponentType.Service) {
+    if (instanceConfig.type === IdentityProfileComponentType.Service) {
         component = new IdentityProfileService({
-            profileEntityConnectorType: context.defaultTypes.identityProfileConnector,
+            profileEntityConnectorType: engineCore.getRegisteredInstanceType("identityProfileConnector"),
             ...instanceConfig.options
         });
-        instanceType = StringHelper.kebabCase("IdentityProfileService");
+        instanceType = "identity-profile-service";
     }
-    else if (type === IdentityProfileComponentType.RestClient) {
+    else if (instanceConfig.type === IdentityProfileComponentType.RestClient) {
         component = new IdentityProfileClient(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("IdentityProfileClient");
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "identityProfileComponent"
-        });
+        instanceType = "identity-profile-client";
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1549,20 +1469,14 @@ const IdentityResolverConnectorType = {
  * @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 connector type is unknown.
- */
-function initialiseIdentityResolverConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Resolver Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseIdentityResolverConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === IdentityResolverConnectorType.Iota) {
-        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
-        connector = new IotaIdentityResolverConnector({
+    if (instanceConfig.type === IdentityResolverConnectorType.Iota) {
+        const dltConfig = EngineTypeHelper.getConfigOfType(engineCore.getConfig(), "dltConfig", DltConfigType.Iota);
+        component = new IotaIdentityResolverConnector({
             ...instanceConfig.options,
             config: {
                 ...dltConfig?.options?.config,
@@ -1571,71 +1485,56 @@ function initialiseIdentityResolverConnector(engineCore, context, instanceConfig
         });
         instanceType = IotaIdentityResolverConnector.NAMESPACE;
     }
-    else if (type === IdentityResolverConnectorType.EntityStorage) {
-        initSchema$6({ includeProfile: false });
+    else if (instanceConfig.type === IdentityResolverConnectorType.EntityStorage) {
+        initSchema$8({ includeProfile: false });
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.didDocumentEntityStorageType, "IdentityDocument");
-        connector = new EntityStorageIdentityResolverConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
+        component = new EntityStorageIdentityResolverConnector({
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
             ...instanceConfig.options
         });
         instanceType = EntityStorageIdentityResolverConnector.NAMESPACE;
     }
-    else if (type === IdentityResolverConnectorType.Universal) {
-        connector = new UniversalResolverConnector({
+    else if (instanceConfig.type === IdentityResolverConnectorType.Universal) {
+        component = new UniversalResolverConnector({
             ...instanceConfig.options
         });
         instanceType = UniversalResolverConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "identityResolverConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    IdentityResolverConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: IdentityResolverConnectorFactory
+    };
 }
 /**
  * Initialise the identity resolver 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 initialiseIdentityResolverComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Resolver Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseIdentityResolverComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === IdentityResolverComponentType.Service) {
+    if (instanceConfig.type === IdentityResolverComponentType.Service) {
+        const defaultIdentityResolverType = engineCore.getRegisteredInstanceType("identityResolverConnector");
         component = new IdentityResolverService({
-            fallbackResolverConnectorType: context.defaultTypes.identityResolverConnector !== IdentityResolverConnectorType.Universal
+            fallbackResolverConnectorType: defaultIdentityResolverType !== IdentityResolverConnectorType.Universal
                 ? IdentityResolverConnectorType.Universal
                 : undefined,
             ...instanceConfig.options
         });
-        instanceType = StringHelper.kebabCase("IdentityResolverService");
+        instanceType = "identity-resolver-service";
     }
-    else if (type === IdentityResolverComponentType.RestClient) {
+    else if (instanceConfig.type === IdentityResolverComponentType.RestClient) {
         component = new IdentityResolverClient(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("IdentityResolverClient");
+        instanceType = "identity-resolver-client";
     }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "identityResolverComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1662,46 +1561,32 @@ const ImmutableProofComponentType = {
  * @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 initialiseImmutableProofComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Immutable Proof Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseImmutableProofComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === ImmutableProofComponentType.Service) {
-        initSchema$7();
+    if (instanceConfig.type === ImmutableProofComponentType.Service) {
+        initSchema$9();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.immutableProofEntityStorageType, "ImmutableProof");
         component = new 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 = StringHelper.kebabCase("ImmutableProofService");
+        instanceType = "immutable-proof-service";
     }
-    else if (type === ImmutableProofComponentType.RestClient) {
+    else if (instanceConfig.type === ImmutableProofComponentType.RestClient) {
         component = new ImmutableProofClient(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("ImmutableProofClient");
+        instanceType = "immutable-proof-client";
     }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "immutableProofComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1749,81 +1634,72 @@ const LoggingConnectorType = {
  * @param engineCore The engine core.
  * @param context The engine core context.
  * @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 connector type is unknown.
- */
-function initialiseLoggingConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Logging Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseLoggingConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === LoggingConnectorType.Console) {
-        connector = new ConsoleLoggingConnector(instanceConfig.options);
+    if (instanceConfig.type === LoggingConnectorType.Console) {
+        component = new ConsoleLoggingConnector(instanceConfig.options);
         instanceType = ConsoleLoggingConnector.NAMESPACE;
     }
-    else if (type === LoggingConnectorType.EntityStorage) {
-        initSchema$8();
+    else if (instanceConfig.type === LoggingConnectorType.EntityStorage) {
+        initSchema$a();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.logEntryStorageConnectorType, "LogEntry");
-        connector = new EntityStorageLoggingConnector(instanceConfig.options);
+        component = new EntityStorageLoggingConnector(instanceConfig.options);
         instanceType = EntityStorageLoggingConnector.NAMESPACE;
     }
-    else if (type === LoggingConnectorType.Multi) {
-        connector = new MultiLoggingConnector(instanceConfig.options);
+    else if (instanceConfig.type === LoggingConnectorType.Multi) {
+        component = new MultiLoggingConnector(instanceConfig.options);
         instanceType = MultiLoggingConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "loggingConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    LoggingConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: LoggingConnectorFactory
+    };
 }
 /**
  * Initialise the logging 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 initialiseLoggingComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Logging Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseLoggingComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === LoggingComponentType.Service) {
+    if (instanceConfig.type === LoggingComponentType.Service) {
         component = new LoggingService({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+            loggingConnectorType: engineCore.getRegisteredInstanceType("loggingConnector"),
             ...instanceConfig.options
         });
-        instanceType = StringHelper.kebabCase("LoggingService");
+        instanceType = "logging-service";
     }
-    else if (type === LoggingComponentType.RestClient) {
+    else if (instanceConfig.type === LoggingComponentType.RestClient) {
         component = new LoggingClient(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("LoggingClient");
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "loggingComponent"
-        });
+        instanceType = "logging-client";
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Messaging admin component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const MessagingAdminComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
@@ -1895,168 +1771,147 @@ const MessagingSmsConnectorType = {
  * @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 connector type is unknown.
- */
-function initialiseMessagingEmailConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Messaging Email Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseMessagingEmailConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === MessagingEmailConnectorType.EntityStorage) {
-        initSchema$9({ email: true, sms: false, pushNotification: false });
+    if (instanceConfig.type === MessagingEmailConnectorType.EntityStorage) {
+        initSchema$b({ email: true, sms: false, pushNotification: false });
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.messagingEmailEntryStorageConnectorType, "EmailEntry");
-        connector = new EntityStorageMessagingEmailConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+        component = new EntityStorageMessagingEmailConnector({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = EntityStorageMessagingEmailConnector.NAMESPACE;
     }
-    else if (type === MessagingEmailConnectorType.Aws) {
-        connector = new AwsMessagingEmailConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+    else if (instanceConfig.type === MessagingEmailConnectorType.Aws) {
+        component = new AwsMessagingEmailConnector({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = AwsMessagingEmailConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "messagingEmailConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    MessagingEmailConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: MessagingEmailConnectorFactory
+    };
 }
 /**
  * Initialise a messaging sms connector.
  * @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 connector type is unknown.
- */
-function initialiseMessagingSmsConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Messaging SMS Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseMessagingSmsConnector(engineCore, context, instanceConfig) {
     let connector;
     let instanceType;
-    if (type === MessagingSmsConnectorType.EntityStorage) {
-        initSchema$9({ email: false, sms: true, pushNotification: false });
+    if (instanceConfig.type === MessagingSmsConnectorType.EntityStorage) {
+        initSchema$b({ email: false, sms: true, pushNotification: false });
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.messagingSmsEntryStorageConnectorType, "SmsEntry");
         connector = new EntityStorageMessagingSmsConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = EntityStorageMessagingSmsConnector.NAMESPACE;
     }
-    else if (type === MessagingSmsConnectorType.Aws) {
+    else if (instanceConfig.type === MessagingSmsConnectorType.Aws) {
         connector = new AwsMessagingSmsConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = AwsMessagingSmsConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "messagingSmsConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    MessagingSmsConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        instanceType,
+        factory: MessagingSmsConnectorFactory,
+        component: connector
+    };
 }
 /**
  * Initialise a messaging push notification connector.
  * @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 connector type is unknown.
- */
-function initialiseMessagingPushNotificationConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Messaging Push Notification Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseMessagingPushNotificationConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === MessagingPushNotificationConnectorType.EntityStorage) {
-        initSchema$9({ email: false, sms: false, pushNotification: true });
+    if (instanceConfig.type === MessagingPushNotificationConnectorType.EntityStorage) {
+        initSchema$b({ email: false, sms: false, pushNotification: true });
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.messagingDeviceEntryStorageConnectorType, "PushNotificationDeviceEntry");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.messagingMessageEntryStorageConnectorType, "PushNotificationMessageEntry");
-        connector = new EntityStorageMessagingPushNotificationConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+        component = new EntityStorageMessagingPushNotificationConnector({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = EntityStorageMessagingPushNotificationConnector.NAMESPACE;
     }
-    else if (type === MessagingPushNotificationConnectorType.Aws) {
-        connector = new AwsMessagingPushNotificationConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+    else if (instanceConfig.type === MessagingPushNotificationConnectorType.Aws) {
+        component = new AwsMessagingPushNotificationConnector({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = AwsMessagingPushNotificationConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "messagingPushNotificationConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    MessagingPushNotificationsConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: MessagingPushNotificationsConnectorFactory
+    };
 }
 /**
  * Initialise the messaging 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 initialiseMessagingComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Messaging Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseMessagingComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === MessagingComponentType.Service) {
-        initSchema$a();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.templateEntryStorageConnectorType, "TemplateEntry");
+    if (instanceConfig.type === MessagingComponentType.Service) {
         component = new 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"),
+            messagingAdminComponentType: engineCore.getRegisteredInstanceTypeOptional("messagingAdminComponent"),
             ...instanceConfig.options
         });
-        instanceType = StringHelper.kebabCase("MessagingService");
+        instanceType = "messaging-service";
     }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "messagingComponent"
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
+}
+/**
+ * Initialise the messaging admin component.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseMessagingAdminComponent(engineCore, context, instanceConfig) {
+    let component;
+    let instanceType;
+    if (instanceConfig.type === MessagingAdminComponentType.Service) {
+        initSchema$c();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.templateEntryStorageConnectorType, "TemplateEntry");
+        component = new MessagingAdminService({
+            ...instanceConfig.options
         });
+        instanceType = "messaging-admin-service";
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2100,91 +1955,69 @@ const NftConnectorType = {
  * @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 connector type is unknown.
- */
-function initialiseNftConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `NFT Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseNftConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === NftConnectorType.EntityStorage) {
-        initSchema$b();
+    if (instanceConfig.type === NftConnectorType.EntityStorage) {
+        initSchema$d();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.nftEntityStorageType, "Nft");
-        connector = new EntityStorageNftConnector(instanceConfig.options);
+        component = new EntityStorageNftConnector(instanceConfig.options);
         instanceType = EntityStorageNftConnector.NAMESPACE;
     }
-    else if (type === NftConnectorType.Iota) {
-        connector = new IotaNftConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
-            walletConnectorType: context.defaultTypes.walletConnector,
-            ...instanceConfig.options
+    else if (instanceConfig.type === NftConnectorType.Iota) {
+        const dltConfig = EngineTypeHelper.getConfigOfType(engineCore.getConfig(), "dltConfig", DltConfigType.Iota);
+        component = new IotaNftConnector({
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
+            walletConnectorType: engineCore.getRegisteredInstanceType("walletConnector"),
+            loggingComponentType: engineCore.getRegisteredInstanceTypeOptional("loggingComponent"),
+            ...instanceConfig.options,
+            config: {
+                ...dltConfig?.options?.config,
+                ...instanceConfig.options.config
+            }
         });
         instanceType = IotaNftConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "nftConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    NftConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: NftConnectorFactory
+    };
 }
 /**
  * Initialise the NFT 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 initialiseNftComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Nft Storage Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseNftComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === NftComponentType.Service) {
+    if (instanceConfig.type === NftComponentType.Service) {
         component = new NftService(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("NftService");
+        instanceType = "nft-service";
     }
-    else if (type === NftComponentType.RestClient) {
+    else if (instanceConfig.type === NftComponentType.RestClient) {
         component = new NftClient(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("NftClient");
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "nftComponent"
-        });
+        instanceType = "nft-client";
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
- * Rights management component types.
+ * Rights management DAP component types.
  */
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const RightsManagementComponentType = {
+const RightsManagementDapComponentType = {
     /**
      * Service.
      */
@@ -2198,45 +2031,80 @@ const RightsManagementComponentType = {
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
- * Initialise the rights management component.
+ * Initialise the rights management DAP 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 initialiseRightsManagementComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Rights Management Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementDapComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === RightsManagementComponentType.Service) {
-        component = new RightsManagementService({
-            papComponentType: context.defaultTypes.rightsManagementPapComponent,
-            ...instanceConfig.options
+    if (instanceConfig.type === RightsManagementDapComponentType.Service) {
+        component = new DataAccessPointService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            policyEnforcementPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPepComponent"),
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options?.config
+            }
         });
-        instanceType = StringHelper.kebabCase("RightsManagementService");
-    }
-    else if (type === RightsManagementComponentType.RestClient) {
-        component = new RightsManagementClient(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("RightsManagementClient");
+        instanceType = "data-access-point-service";
     }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "RightsManagementComponent"
+    else if (instanceConfig.type === RightsManagementDapComponentType.RestClient) {
+        component = new DataAccessPointClient({
+            ...instanceConfig.options,
+            authenticationGeneratorType: instanceConfig.options?.authenticationGeneratorType ??
+                engineCore.getRegisteredInstanceType("authenticationGeneratorComponent", [
+                    "verifiable-credential"
+                ])
+        });
+        instanceType = "data-access-point-client";
+    }
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Rights management DARP component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const RightsManagementDarpComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the rights management DARP component.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementDarpComponent(engineCore, context, instanceConfig) {
+    let component;
+    let instanceType;
+    if (instanceConfig.type === RightsManagementDarpComponentType.Service) {
+        component = new DataAccessRequestPointService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            ...instanceConfig.options
         });
+        instanceType = "data-access-request-point-service";
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2249,7 +2117,11 @@ const RightsManagementPapComponentType = {
     /**
      * Service.
      */
-    Service: "service"
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -2259,36 +2131,479 @@ const RightsManagementPapComponentType = {
  * @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 initialiseRightsManagementPapComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Rights Management PAP Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementPapComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === RightsManagementPapComponentType.Service) {
-        initSchema$c();
+    if (instanceConfig.type === RightsManagementPapComponentType.Service) {
+        initSchema$e();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.odrlPolicyEntityStorageType, "OdrlPolicy");
-        component = new PolicyAdministrationPointService(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("PolicyAdministrationPointService");
+        component = new PolicyAdministrationPointService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            ...instanceConfig.options
+        });
+        instanceType = "policy-administration-point-service";
+    }
+    else if (instanceConfig.type === RightsManagementPapComponentType.RestClient) {
+        component = new PolicyAdministrationPointClient(instanceConfig.options);
+        instanceType = "policy-administration-point-client";
     }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "RightsManagementPapComponent"
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
+}
+
+// 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.
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementPdpComponent(engineCore, context, instanceConfig) {
+    let component;
+    let instanceType;
+    if (instanceConfig.type === RightsManagementPdpComponentType.Service) {
+        const arbiterModules = [];
+        if (Is.arrayValue(instanceConfig.options?.arbiterModulesConfig)) {
+            for (const moduleConfig of instanceConfig.options.arbiterModulesConfig) {
+                arbiterModules.push({
+                    arbiterId: moduleConfig.id,
+                    arbiter: await EngineModuleHelper.loadComponent(engineCore, moduleConfig)
+                });
+            }
+        }
+        component = new PolicyDecisionPointService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            policyInformationPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPipComponent"),
+            policyManagementPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPmpComponent"),
+            policyExecutionPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPxpComponent"),
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options?.config,
+                arbiters: instanceConfig.options?.config?.arbiters ?? arbiterModules
+            }
         });
+        instanceType = "policy-decision-point-service";
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
+}
+
+// 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",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
+};
+
+// 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.
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementPepComponent(engineCore, context, instanceConfig) {
+    let component;
+    let instanceType;
+    if (instanceConfig.type === RightsManagementPepComponentType.Service) {
+        const processorModules = [];
+        if (Is.arrayValue(instanceConfig.options?.processorModulesConfig)) {
+            for (const moduleConfig of instanceConfig.options.processorModulesConfig) {
+                processorModules.push({
+                    processorId: moduleConfig.id,
+                    processor: await EngineModuleHelper.loadComponent(engineCore, moduleConfig)
+                });
+            }
+        }
+        component = new PolicyEnforcementPointService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            policyDecisionPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPdpComponent"),
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options?.config,
+                processors: instanceConfig.options?.config?.processors ?? processorModules
+            }
+        });
+        instanceType = "policy-enforcement-point-service";
+    }
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
+}
+
+// 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.
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementPipComponent(engineCore, context, instanceConfig) {
+    let component;
+    let instanceType;
+    if (instanceConfig.type === RightsManagementPipComponentType.Service) {
+        const informationSourceModules = [];
+        if (Is.arrayValue(instanceConfig.options?.informationModulesConfig)) {
+            for (const moduleConfig of instanceConfig.options.informationModulesConfig) {
+                informationSourceModules.push({
+                    sourceId: moduleConfig.id,
+                    source: await EngineModuleHelper.loadComponent(engineCore, moduleConfig)
+                });
+            }
+        }
+        component = new PolicyInformationPointService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options?.config,
+                sources: instanceConfig.options?.config?.sources ?? informationSourceModules
+            }
+        });
+        instanceType = "policy-information-point-service";
+    }
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
+}
+
+// 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.
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementPmpComponent(engineCore, context, instanceConfig) {
+    let component;
+    let instanceType;
+    if (instanceConfig.type === RightsManagementPmpComponentType.Service) {
+        component = new PolicyManagementPointService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            policyAdministrationPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPapComponent"),
+            ...instanceConfig.options
+        });
+        instanceType = "policy-management-point-service";
+    }
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Rights management PNAP component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const RightsManagementPnapComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the rights management PNAP component.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementPnapComponent(engineCore, context, instanceConfig) {
+    let component;
+    let instanceType;
+    if (instanceConfig.type === RightsManagementPnapComponentType.Service) {
+        initSchema$f();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.policyNegotiationEntityStorageType, "PolicyNegotiation");
+        component = new PolicyNegotiationAdminPointService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            taskSchedulerComponentType: engineCore.getRegisteredInstanceType("taskSchedulerComponent"),
+            policyInformationPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPipComponent"),
+            ...instanceConfig.options
+        });
+        instanceType = "policy-negotiation-admin-point-service";
+    }
+    else if (instanceConfig.type === RightsManagementPnapComponentType.RestClient) {
+        component = new PolicyNegotiationAdminPointClient(instanceConfig.options);
+        instanceType = "policy-negotiation-admin-point-client";
+    }
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Rights management PNP component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const RightsManagementPnpComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service",
+    /**
+     * REST client.
+     */
+    RestClient: "rest-client"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the rights management PNP component.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementPnpComponent(engineCore, context, instanceConfig) {
+    let component;
+    let instanceType;
+    if (instanceConfig.type === RightsManagementPnpComponentType.Service) {
+        const negotiatorModules = [];
+        if (Is.arrayValue(instanceConfig.options?.negotiatorModulesConfig)) {
+            for (const moduleConfig of instanceConfig.options.negotiatorModulesConfig) {
+                negotiatorModules.push({
+                    negotiatorId: moduleConfig.id,
+                    negotiator: await EngineModuleHelper.loadComponent(engineCore, moduleConfig)
+                });
+            }
+        }
+        const requesterModules = [];
+        if (Is.arrayValue(instanceConfig.options?.requesterModulesConfig)) {
+            for (const moduleConfig of instanceConfig.options.requesterModulesConfig) {
+                requesterModules.push({
+                    requesterId: moduleConfig.id,
+                    requester: await EngineModuleHelper.loadComponent(engineCore, moduleConfig)
+                });
+            }
+        }
+        component = new PolicyNegotiationPointService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            policyNegotiationAdministrationPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPnapComponent"),
+            policyAdministrationPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPapComponent"),
+            policyInformationPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPipComponent"),
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options?.config,
+                negotiators: instanceConfig.options?.config?.negotiators ?? negotiatorModules,
+                requesters: instanceConfig.options?.config?.requesters ?? requesterModules
+            }
+        });
+        instanceType = "policy-negotiation-point-service";
+    }
+    else if (instanceConfig.type === RightsManagementPnpComponentType.RestClient) {
+        component = new PolicyNegotiationPointClient({
+            ...instanceConfig.options,
+            authenticationGeneratorType: instanceConfig.options?.authenticationGeneratorType ??
+                engineCore.getRegisteredInstanceType("authenticationGeneratorComponent", [
+                    "verifiable-credential"
+                ])
+        });
+        instanceType = "policy-negotiation-point-client";
+    }
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
+}
+
+// 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.
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementPxpComponent(engineCore, context, instanceConfig) {
+    let component;
+    let instanceType;
+    if (instanceConfig.type === RightsManagementPxpComponentType.Service) {
+        const modules = [];
+        if (Is.arrayValue(instanceConfig.options?.actionModulesConfig)) {
+            for (const moduleConfig of instanceConfig.options.actionModulesConfig) {
+                modules.push({
+                    actionId: moduleConfig.id,
+                    action: await EngineModuleHelper.loadComponent(engineCore, moduleConfig)
+                });
+            }
+        }
+        component = new PolicyExecutionPointService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options?.config,
+                actions: instanceConfig.options?.config?.actions ?? modules
+            }
+        });
+        instanceType = "policy-execution-point-service";
+    }
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
+}
+
+// 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.
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseSynchronisedStorageComponent(engineCore, context, instanceConfig) {
+    let component;
+    let instanceType;
+    if (instanceConfig.type === SynchronisedStorageComponentType.Service) {
+        initSchema$g();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.syncSnapshotStorageConnectorType, "SyncSnapshotEntry");
+        component = new SynchronisedStorageService({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
+            eventBusComponentType: engineCore.getRegisteredInstanceType("eventBusComponent"),
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
+            verifiableStorageConnectorType: engineCore.getRegisteredInstanceType("verifiableStorageConnector"),
+            taskSchedulerComponentType: engineCore.getRegisteredInstanceType("taskSchedulerComponent"),
+            policyEnforcementPointComponentType: engineCore.getRegisteredInstanceTypeOptional("rightsManagementPepComponent"),
+            trustedSynchronisedStorageComponentType: engineCore.getRegisteredInstanceTypeOptional("synchronisedStorageComponent", ["trusted"]),
+            blobStorageConnectorType: engineCore.getRegisteredInstanceType("blobStorageConnector", [
+                "public"
+            ]),
+            ...instanceConfig.options
+        });
+        instanceType = "synchronised-storage-service";
+    }
+    else if (instanceConfig.type === SynchronisedStorageComponentType.RestClient) {
+        component = new SynchronisedStorageClient({
+            ...instanceConfig.options,
+            authenticationGeneratorType: instanceConfig.options?.authenticationGeneratorType ??
+                engineCore.getRegisteredInstanceType("authenticationGeneratorComponent", [
+                    "verifiable-credential"
+                ])
+        });
+        instanceType = "synchronised-storage-client";
+    }
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2309,37 +2624,23 @@ const TaskSchedulerComponentType = {
  * @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 connector type is unknown.
- */
-function initialiseTaskSchedulerComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Task Scheduler: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseTaskSchedulerComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === TaskSchedulerComponentType.Service) {
+    if (instanceConfig.type === TaskSchedulerComponentType.Service) {
         component = new TaskSchedulerService({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
-        instanceType = StringHelper.kebabCase("TaskSchedulerService");
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "taskSchedulerComponent"
-        });
+        instanceType = "task-scheduler-service";
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2379,75 +2680,53 @@ const TelemetryConnectorType = {
  * @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 connector type is unknown.
- */
-function initialiseTelemetryConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Telemetry Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseTelemetryConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === TelemetryConnectorType.EntityStorage) {
-        initSchema$d();
+    if (instanceConfig.type === TelemetryConnectorType.EntityStorage) {
+        initSchema$h();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.telemetryMetricStorageConnectorType, "TelemetryMetric");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.telemetryMetricValueStorageConnectorType, "TelemetryMetricValue");
-        connector = new EntityStorageTelemetryConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
+        component = new EntityStorageTelemetryConnector({
+            loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = EntityStorageTelemetryConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "telemetryConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    TelemetryConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        instanceType,
+        factory: TelemetryConnectorFactory,
+        component
+    };
 }
 /**
  * Initialise the telemetry 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 initialiseTelemetryComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Telemetry Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseTelemetryComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === TelemetryComponentType.Service) {
+    if (instanceConfig.type === TelemetryComponentType.Service) {
         component = new TelemetryService({
-            telemetryConnectorType: context.defaultTypes.telemetryConnector,
+            telemetryConnectorType: engineCore.getRegisteredInstanceType("telemetryConnector"),
             ...instanceConfig.options
         });
-        instanceType = StringHelper.kebabCase("TelemetryService");
+        instanceType = "telemetry-service";
     }
-    else if (type === TelemetryComponentType.RestClient) {
+    else if (instanceConfig.type === TelemetryComponentType.RestClient) {
         component = new TelemetryClient(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("TelemetryClient");
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "telemetryComponent"
-        });
+        instanceType = "telemetry-client";
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2467,45 +2746,32 @@ const VaultConnectorType = {
     Hashicorp: "hashicorp"
 };
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
 /**
  * Initialise the vault connector.
  * @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 connector type is unknown.
- */
-function initialiseVaultConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Vault Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseVaultConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === VaultConnectorType.EntityStorage) {
-        initSchema$e();
+    if (instanceConfig.type === VaultConnectorType.EntityStorage) {
+        initSchema$i();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vaultKeyEntityStorageType, "VaultKey");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vaultSecretEntityStorageType, "VaultSecret");
-        connector = new EntityStorageVaultConnector(instanceConfig.options);
+        component = new EntityStorageVaultConnector(instanceConfig.options);
         instanceType = EntityStorageVaultConnector.NAMESPACE;
     }
-    else if (type === VaultConnectorType.Hashicorp) {
-        connector = new HashicorpVaultConnector(instanceConfig.options);
+    else if (instanceConfig.type === VaultConnectorType.Hashicorp) {
+        component = new HashicorpVaultConnector(instanceConfig.options);
         instanceType = HashicorpVaultConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "vaultConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    VaultConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: VaultConnectorFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2549,21 +2815,16 @@ const VerifiableStorageConnectorType = {
  * @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 connector type is unknown.
- */
-function initialiseVerifiableStorageConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Verifiable Storage Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseVerifiableStorageConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === VerifiableStorageConnectorType.Iota) {
-        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
-        connector = new IotaVerifiableStorageConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
+    if (instanceConfig.type === VerifiableStorageConnectorType.Iota) {
+        const dltConfig = EngineTypeHelper.getConfigOfType(engineCore.getConfig(), "dltConfig", DltConfigType.Iota);
+        component = new IotaVerifiableStorageConnector({
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
+            loggingComponentType: engineCore.getRegisteredInstanceTypeOptional("loggingComponent"),
             ...instanceConfig.options,
             config: {
                 ...dltConfig?.options?.config,
@@ -2572,65 +2833,43 @@ function initialiseVerifiableStorageConnector(engineCore, context, instanceConfi
         });
         instanceType = IotaVerifiableStorageConnector.NAMESPACE;
     }
-    else if (type === VerifiableStorageConnectorType.EntityStorage) {
-        initSchema$f();
+    else if (instanceConfig.type === VerifiableStorageConnectorType.EntityStorage) {
+        initSchema$j();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.verifiableStorageEntityStorageType, "VerifiableItem");
-        connector = new EntityStorageVerifiableStorageConnector(instanceConfig.options);
+        component = new EntityStorageVerifiableStorageConnector(instanceConfig.options);
         instanceType = EntityStorageVerifiableStorageConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "verifiableStorageConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    VerifiableStorageConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: VerifiableStorageConnectorFactory
+    };
 }
 /**
  * Initialise the verifiable 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 initialiseVerifiableStorageComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Verifiable Storage Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseVerifiableStorageComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === VerifiableStorageComponentType.Service) {
+    if (instanceConfig.type === VerifiableStorageComponentType.Service) {
         component = new VerifiableStorageService({
             ...instanceConfig.options
         });
-        instanceType = StringHelper.kebabCase("VerifiableStorageService");
+        instanceType = "verifiable-storage-service";
     }
-    else if (type === VerifiableStorageComponentType.RestClient) {
+    else if (instanceConfig.type === VerifiableStorageComponentType.RestClient) {
         component = new VerifiableStorageClient(instanceConfig.options);
-        instanceType = StringHelper.kebabCase("VerifiableStorageClient");
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "verifiableStorageComponent"
-        });
+        instanceType = "verifiable-storage-client";
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2650,29 +2889,21 @@ const WalletConnectorType = {
     Iota: "iota"
 };
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
 /**
  * Initialise a wallet connector.
  * @param engineCore The engine core.
  * @param context The context for the node.
  * @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 connector type is unknown.
- */
-function initialiseWalletConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Wallet Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseWalletConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === WalletConnectorType.Iota) {
-        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
-        connector = new IotaWalletConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
-            faucetConnectorType: context.defaultTypes.faucetConnector,
+    if (instanceConfig.type === WalletConnectorType.Iota) {
+        const dltConfig = EngineTypeHelper.getConfigOfType(engineCore.getConfig(), "dltConfig", DltConfigType.Iota);
+        component = new IotaWalletConnector({
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
+            faucetConnectorType: engineCore.getRegisteredInstanceType("faucetConnector"),
             ...instanceConfig.options,
             config: {
                 ...dltConfig?.options?.config,
@@ -2681,64 +2912,21 @@ function initialiseWalletConnector(engineCore, context, instanceConfig, override
         });
         instanceType = IotaWalletConnector.NAMESPACE;
     }
-    else if (type === WalletConnectorType.EntityStorage) {
-        connector = new EntityStorageWalletConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
-            faucetConnectorType: context.defaultTypes.faucetConnector,
+    else if (instanceConfig.type === WalletConnectorType.EntityStorage) {
+        initSchema$6();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.walletAddressEntityStorageType, "WalletAddress");
+        component = new EntityStorageWalletConnector({
+            vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
+            faucetConnectorType: engineCore.getRegisteredInstanceType("faucetConnector"),
             ...instanceConfig.options
         });
         instanceType = EntityStorageWalletConnector.NAMESPACE;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "walletConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    WalletConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-/**
- * Initialise the wallet storage.
- * @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 Nothing.
- * @throws GeneralError if the connector type is unknown.
- */
-function initialiseWalletStorage(engineCore, context, instanceConfig, overrideInstanceType) {
-    const type = instanceConfig.type;
-    if (type === WalletConnectorType.Iota) ;
-    else if (type === WalletConnectorType.EntityStorage) {
-        initSchema$g();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.walletAddressEntityStorageType, "WalletAddress");
-    }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "walletConnector"
-        });
-    }
-    return undefined;
+    return {
+        component,
+        instanceType,
+        factory: WalletConnectorFactory
+    };
 }
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * DLT config types.
- */
-// eslint-disable-next-line @typescript-eslint/naming-convention
-const DltConfigType = {
-    /**
-     * IOTA.
-     */
-    Iota: "iota"
-};
-
-export { AttestationComponentType, AttestationConnectorType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, BackgroundTaskConnectorType, BlobStorageComponentType, BlobStorageConnectorType, DataConverterConnectorType, DataExtractorConnectorType, DataProcessingComponentType, DltConfigType, DocumentManagementComponentType, EntityStorageComponentType, EntityStorageConnectorType, EventBusComponentType, EventBusConnectorType, FaucetConnectorType, FederatedCatalogueComponentType, IdentityComponentType, IdentityConnectorType, IdentityProfileComponentType, IdentityProfileConnectorType, IdentityResolverComponentType, IdentityResolverConnectorType, ImmutableProofComponentType, LoggingComponentType, LoggingConnectorType, MessagingComponentType, MessagingEmailConnectorType, MessagingPushNotificationConnectorType, MessagingSmsConnectorType, NftComponentType, NftConnectorType, RightsManagementComponentType, RightsManagementPapComponentType, TaskSchedulerComponentType, TelemetryComponentType, TelemetryConnectorType, VaultConnectorType, VerifiableStorageComponentType, VerifiableStorageConnectorType, WalletConnectorType, initialiseAttestationComponent, initialiseAttestationConnector, initialiseAuditableItemGraphComponent, initialiseAuditableItemStreamComponent, initialiseBackgroundTaskConnector, initialiseBlobStorageComponent, initialiseBlobStorageConnector, initialiseDataConverterConnector, initialiseDataExtractorConnector, initialiseDataProcessingComponent, initialiseDocumentManagementComponent, initialiseEntityStorageComponent, initialiseEntityStorageConnector, initialiseEventBusComponent, initialiseEventBusConnector, initialiseFaucetConnector, initialiseFederatedCatalogueComponent, initialiseIdentityComponent, initialiseIdentityConnector, initialiseIdentityProfileComponent, initialiseIdentityProfileConnector, initialiseIdentityResolverComponent, initialiseIdentityResolverConnector, initialiseImmutableProofComponent, initialiseLoggingComponent, initialiseLoggingConnector, initialiseMessagingComponent, initialiseMessagingEmailConnector, initialiseMessagingPushNotificationConnector, initialiseMessagingSmsConnector, initialiseNftComponent, initialiseNftConnector, initialiseRightsManagementComponent, initialiseRightsManagementPapComponent, initialiseTaskSchedulerComponent, initialiseTelemetryComponent, initialiseTelemetryConnector, initialiseVaultConnector, initialiseVerifiableStorageComponent, initialiseVerifiableStorageConnector, initialiseWalletConnector, initialiseWalletStorage };
+export { AttestationComponentType, AttestationConnectorType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, AuthenticationGeneratorComponentType, BackgroundTaskConnectorType, BlobStorageComponentType, BlobStorageConnectorType, DataConverterConnectorType, DataExtractorConnectorType, DataProcessingComponentType, DataSpaceConnectorComponentType, DltConfigType, DocumentManagementComponentType, EngineTypeHelper, EntityStorageComponentType, EntityStorageConnectorType, EventBusComponentType, EventBusConnectorType, FaucetConnectorType, FederatedCatalogueComponentType, IdentityComponentType, IdentityConnectorType, IdentityProfileComponentType, IdentityProfileConnectorType, IdentityResolverComponentType, IdentityResolverConnectorType, ImmutableProofComponentType, LoggingComponentType, LoggingConnectorType, MessagingAdminComponentType, MessagingComponentType, MessagingEmailConnectorType, MessagingPushNotificationConnectorType, MessagingSmsConnectorType, NftComponentType, NftConnectorType, RightsManagementDapComponentType, RightsManagementDarpComponentType, RightsManagementPapComponentType, RightsManagementPdpComponentType, RightsManagementPepComponentType, RightsManagementPipComponentType, RightsManagementPmpComponentType, RightsManagementPnapComponentType, RightsManagementPnpComponentType, RightsManagementPxpComponentType, SynchronisedStorageComponentType, TaskSchedulerComponentType, TelemetryComponentType, TelemetryConnectorType, VaultConnectorType, VerifiableStorageComponentType, VerifiableStorageConnectorType, WalletConnectorType, initialiseAttestationComponent, initialiseAttestationConnector, initialiseAuditableItemGraphComponent, initialiseAuditableItemStreamComponent, initialiseAuthenticationGeneratorComponent, initialiseBackgroundTaskConnector, initialiseBlobStorageComponent, initialiseBlobStorageConnector, initialiseDataConverterConnector, initialiseDataExtractorConnector, initialiseDataProcessingComponent, initialiseDataSpaceConnectorComponent, initialiseDocumentManagementComponent, initialiseEntityStorageComponent, initialiseEntityStorageConnector, initialiseEventBusComponent, initialiseEventBusConnector, initialiseFaucetConnector, initialiseFederatedCatalogueComponent, initialiseIdentityComponent, initialiseIdentityConnector, initialiseIdentityProfileComponent, initialiseIdentityProfileConnector, initialiseIdentityResolverComponent, initialiseIdentityResolverConnector, initialiseImmutableProofComponent, initialiseLoggingComponent, initialiseLoggingConnector, initialiseMessagingAdminComponent, initialiseMessagingComponent, initialiseMessagingEmailConnector, initialiseMessagingPushNotificationConnector, initialiseMessagingSmsConnector, initialiseNftComponent, initialiseNftConnector, initialiseRightsManagementDapComponent, initialiseRightsManagementDarpComponent, initialiseRightsManagementPapComponent, initialiseRightsManagementPdpComponent, initialiseRightsManagementPepComponent, initialiseRightsManagementPipComponent, initialiseRightsManagementPmpComponent, initialiseRightsManagementPnapComponent, initialiseRightsManagementPnpComponent, initialiseRightsManagementPxpComponent, initialiseSynchronisedStorageComponent, initialiseTaskSchedulerComponent, initialiseTelemetryComponent, initialiseTelemetryConnector, initialiseVaultConnector, initialiseVerifiableStorageComponent, initialiseVerifiableStorageConnector, initialiseWalletConnector };