@twin.org/engine-types 0.0.1-next.14

package/dist/cjs/index.cjs

@@ -0,0 +1,1640 @@
+'use strict';
+
+var attestationConnectorEntityStorage = require('@twin.org/attestation-connector-entity-storage');
+var attestationConnectorIota = require('@twin.org/attestation-connector-iota');
+var attestationModels = require('@twin.org/attestation-models');
+var attestationService = require('@twin.org/attestation-service');
+var core = require('@twin.org/core');
+var auditableItemGraphService = require('@twin.org/auditable-item-graph-service');
+var path = require('node:path');
+var entityStorageConnectorCosmosdb = require('@twin.org/entity-storage-connector-cosmosdb');
+var entityStorageConnectorDynamodb = require('@twin.org/entity-storage-connector-dynamodb');
+var entityStorageConnectorFile = require('@twin.org/entity-storage-connector-file');
+var entityStorageConnectorGcpFirestore = require('@twin.org/entity-storage-connector-gcp-firestore');
+var entityStorageConnectorMemory = require('@twin.org/entity-storage-connector-memory');
+var entityStorageConnectorScylladb = require('@twin.org/entity-storage-connector-scylladb');
+var entityStorageModels = require('@twin.org/entity-storage-models');
+var entityStorageService = require('@twin.org/entity-storage-service');
+var auditableItemStreamService = require('@twin.org/auditable-item-stream-service');
+var backgroundTaskConnectorEntityStorage = require('@twin.org/background-task-connector-entity-storage');
+var backgroundTaskModels = require('@twin.org/background-task-models');
+var blobStorageConnectorAwsS3 = require('@twin.org/blob-storage-connector-aws-s3');
+var blobStorageConnectorAzure = require('@twin.org/blob-storage-connector-azure');
+var blobStorageConnectorFile = require('@twin.org/blob-storage-connector-file');
+var blobStorageConnectorGcp = require('@twin.org/blob-storage-connector-gcp');
+var blobStorageConnectorIpfs = require('@twin.org/blob-storage-connector-ipfs');
+var blobStorageConnectorMemory = require('@twin.org/blob-storage-connector-memory');
+var blobStorageModels = require('@twin.org/blob-storage-models');
+var blobStorageService = require('@twin.org/blob-storage-service');
+var walletConnectorEntityStorage = require('@twin.org/wallet-connector-entity-storage');
+var walletConnectorIota = require('@twin.org/wallet-connector-iota');
+var walletModels = require('@twin.org/wallet-models');
+var identityConnectorEntityStorage = require('@twin.org/identity-connector-entity-storage');
+var identityConnectorIota = require('@twin.org/identity-connector-iota');
+var identityModels = require('@twin.org/identity-models');
+var identityService = require('@twin.org/identity-service');
+var immutableProofService = require('@twin.org/immutable-proof-service');
+var immutableStorageConnectorEntityStorage = require('@twin.org/immutable-storage-connector-entity-storage');
+var immutableStorageConnectorIota = require('@twin.org/immutable-storage-connector-iota');
+var immutableStorageModels = require('@twin.org/immutable-storage-models');
+var loggingConnectorConsole = require('@twin.org/logging-connector-console');
+var loggingConnectorEntityStorage = require('@twin.org/logging-connector-entity-storage');
+var loggingModels = require('@twin.org/logging-models');
+var loggingService = require('@twin.org/logging-service');
+var nftConnectorEntityStorage = require('@twin.org/nft-connector-entity-storage');
+var nftConnectorIota = require('@twin.org/nft-connector-iota');
+var nftModels = require('@twin.org/nft-models');
+var nftService = require('@twin.org/nft-service');
+var telemetryConnectorEntityStorage = require('@twin.org/telemetry-connector-entity-storage');
+var telemetryModels = require('@twin.org/telemetry-models');
+var telemetryService = require('@twin.org/telemetry-service');
+var vaultConnectorEntityStorage = require('@twin.org/vault-connector-entity-storage');
+var vaultConnectorHashicorp = require('@twin.org/vault-connector-hashicorp');
+var vaultModels = require('@twin.org/vault-models');
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Attestation component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const AttestationComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Attestation connector types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const AttestationConnectorType = {
+    /**
+     * Entity storage.
+     */
+    EntityStorage: "entity-storage",
+    /**
+     * IOTA.
+     */
+    Iota: "iota"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the attestation 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 initialiseAttestationConnector(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Attestation Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === AttestationConnectorType.Iota) {
+        connector = new attestationConnectorIota.IotaAttestationConnector({
+            identityConnectorType: context.defaultTypes.identityConnector,
+            nftConnectorType: context.defaultTypes.nftConnector,
+            ...instanceConfig.options
+        });
+        instanceType = attestationConnectorIota.IotaAttestationConnector.NAMESPACE;
+    }
+    else if (type === AttestationConnectorType.EntityStorage) {
+        connector = new attestationConnectorEntityStorage.EntityStorageAttestationConnector({
+            identityConnectorType: context.defaultTypes.identityConnector,
+            nftConnectorType: context.defaultTypes.nftConnector,
+            ...instanceConfig.options
+        });
+        instanceType = attestationConnectorEntityStorage.EntityStorageAttestationConnector.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "attestationConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    attestationModels.AttestationConnectorFactory.register(finalInstanceType, () => connector);
+    return finalInstanceType;
+}
+/**
+ * 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(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Attestation Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === AttestationComponentType.Service) {
+        component = new attestationService.AttestationService({
+            walletConnectorType: context.defaultTypes.walletConnector,
+            ...instanceConfig.options
+        });
+        instanceType = attestationService.AttestationService.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "attestationComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Entity storage component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const EntityStorageComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Entity storage connector types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const EntityStorageConnectorType = {
+    /**
+     * Use storage.
+     */
+    File: "file",
+    /**
+     * Memory.
+     */
+    Memory: "memory",
+    /**
+     * ScyllaDb.
+     */
+    ScyllaDb: "scylladb",
+    /**
+     * AWS DynamoDB.
+     */
+    AwsDynamoDb: "aws-dynamodb",
+    /**
+     * Azure CosmosDB.
+     */
+    AzureCosmosDb: "azure-cosmosdb",
+    /**
+     * GCP Firestore.
+     */
+    GcpFirestoreDb: "gcp-firestoredb"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the entity storage connector.
+ * @param engineCore The engine core.
+ * @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.
+ */
+function initialiseEntityStorageConnector(engineCore, context, typeCustom, schema) {
+    const instanceName = core.StringHelper.kebabCase(schema);
+    let entityStorageConfig;
+    if (core.Is.stringValue(typeCustom)) {
+        // A custom type has been specified, so look it up
+        entityStorageConfig = context.config.types.entityStorageConnector?.find(c => c.type === typeCustom || c.overrideInstanceType === typeCustom);
+        if (core.Is.empty(entityStorageConfig)) {
+            throw new core.GeneralError("engineCore", "entityStorageCustomMissing", {
+                typeCustom,
+                storageName: instanceName
+            });
+        }
+    }
+    else {
+        // The default entity storage method is either the one with the isDefault flag set
+        // or pick the first one if no default is set.
+        entityStorageConfig =
+            context.config.types.entityStorageConnector?.find(c => c.isDefault ?? false) ??
+                context.config.types.entityStorageConnector?.[0];
+        if (core.Is.empty(entityStorageConfig)) {
+            throw new core.GeneralError("engineCore", "entityStorageMissing", {
+                storageName: instanceName
+            });
+        }
+    }
+    const type = entityStorageConfig.type;
+    let entityStorageConnector;
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuringEntityStorage", {
+        element: "Entity Storage",
+        storageName: instanceName,
+        storageType: type
+    }));
+    if (type === EntityStorageConnectorType.Memory) {
+        entityStorageConnector = new entityStorageConnectorMemory.MemoryEntityStorageConnector({
+            entitySchema: schema
+        });
+    }
+    else if (type === EntityStorageConnectorType.File) {
+        entityStorageConnector = new entityStorageConnectorFile.FileEntityStorageConnector({
+            entitySchema: schema,
+            ...entityStorageConfig.options,
+            config: {
+                ...entityStorageConfig.options.config,
+                directory: path.join(entityStorageConfig.options.config.directory, `${entityStorageConfig.options.folderPrefix ?? ""}${instanceName}`)
+            }
+        });
+    }
+    else if (type === EntityStorageConnectorType.AwsDynamoDb) {
+        entityStorageConnector = new entityStorageConnectorDynamodb.DynamoDbEntityStorageConnector({
+            entitySchema: schema,
+            ...entityStorageConfig.options,
+            config: {
+                ...entityStorageConfig.options.config,
+                tableName: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
+            }
+        });
+    }
+    else if (type === EntityStorageConnectorType.AzureCosmosDb) {
+        entityStorageConnector = new entityStorageConnectorCosmosdb.CosmosDbEntityStorageConnector({
+            entitySchema: schema,
+            ...entityStorageConfig.options,
+            config: {
+                ...entityStorageConfig.options.config,
+                containerId: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
+            }
+        });
+    }
+    else if (type === EntityStorageConnectorType.GcpFirestoreDb) {
+        entityStorageConnector = new entityStorageConnectorGcpFirestore.FirestoreEntityStorageConnector({
+            entitySchema: schema,
+            ...entityStorageConfig.options,
+            config: {
+                ...entityStorageConfig.options.config,
+                collectionName: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
+            }
+        });
+    }
+    else if (type === EntityStorageConnectorType.ScyllaDb) {
+        entityStorageConnector = new entityStorageConnectorScylladb.ScyllaDBTableConnector({
+            entitySchema: schema,
+            ...entityStorageConfig.options,
+            config: {
+                ...entityStorageConfig.options.config,
+                tableName: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
+            }
+        });
+    }
+    else {
+        throw new core.GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "entityStorageConnector"
+        });
+    }
+    context.componentInstances.push({
+        instanceType: instanceName,
+        component: entityStorageConnector
+    });
+    entityStorageModels.EntityStorageConnectorFactory.register(instanceName, () => entityStorageConnector);
+}
+/**
+ * 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(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Entity Storage Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === EntityStorageComponentType.Service) {
+        const kebabName = core.StringHelper.kebabCase(instanceConfig.options.entityStorageType);
+        // See if there is a custom entity storage for this type, otherwise just use the default one.
+        const hasCustom = context.config.types.entityStorageConnector?.some(c => c.type === kebabName || c.overrideInstanceType === kebabName);
+        initialiseEntityStorageConnector(engineCore, context, hasCustom ? kebabName : undefined, instanceConfig.options.entityStorageType);
+        connector = new entityStorageService.EntityStorageService({
+            entityStorageType: kebabName,
+            config: {
+                ...instanceConfig.options.config
+            }
+        });
+        instanceType = core.StringHelper.kebabCase(instanceConfig.options.entityStorageType);
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            serviceType: "entityStorageComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    core.ComponentFactory.register(finalInstanceType, () => connector);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Auditable item graph component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const AuditableItemGraphComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+/**
+ * Initialise the auditable item graph 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 initialiseAuditableItemGraphComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Auditable Item Graph Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === AuditableItemGraphComponentType.Service) {
+        auditableItemGraphService.initSchema();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vertexEntityStorageType, "AuditableItemGraphVertex");
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.changesetEntityStorageType, "AuditableItemGraphChangeset");
+        component = new auditableItemGraphService.AuditableItemGraphService({
+            immutableProofComponentType: context.defaultTypes.immutableProofComponent,
+            ...instanceConfig.options
+        });
+        instanceType = auditableItemGraphService.AuditableItemGraphService.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "auditableItemGraphComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Auditable item stream component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const AuditableItemStreamComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+/**
+ * Initialise the auditable item stream 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 initialiseAuditableItemStreamComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Auditable Item Stream Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === AuditableItemStreamComponentType.Service) {
+        auditableItemStreamService.initSchema();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.streamEntityStorageType, "AuditableItemStream");
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.streamEntryEntityStorageType, "AuditableItemStreamEntry");
+        component = new auditableItemStreamService.AuditableItemStreamService({
+            immutableProofComponentType: context.defaultTypes.immutableProofComponent,
+            ...instanceConfig.options
+        });
+        instanceType = auditableItemStreamService.AuditableItemStreamService.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "auditableItemStreamComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Background task connector types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const BackgroundTaskConnectorType = {
+    /**
+     * Entity storage.
+     */
+    EntityStorage: "entity-storage"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise a background task 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 initialiseBackgroundTaskConnector(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Background Task Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === BackgroundTaskConnectorType.EntityStorage) {
+        backgroundTaskConnectorEntityStorage.initSchema();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.backgroundTaskEntityStorageType, "BackgroundTask");
+        connector = new backgroundTaskConnectorEntityStorage.EntityStorageBackgroundTaskConnector({
+            loggingConnectorType: context.defaultTypes.loggingConnector,
+            ...instanceConfig.options
+        });
+        instanceType = backgroundTaskConnectorEntityStorage.EntityStorageBackgroundTaskConnector.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "backgroundTaskConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
+    backgroundTaskModels.BackgroundTaskConnectorFactory.register(finalInstanceType, () => connector);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Blob storage component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const BlobStorageComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Blob storage connector types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const BlobStorageConnectorType = {
+    /**
+     * File storage.
+     */
+    File: "file",
+    /**
+     * Memory.
+     */
+    Memory: "memory",
+    /**
+     * IPFS.
+     */
+    Ipfs: "ipfs",
+    /**
+     * AWS S3.
+     */
+    AwsS3: "aws-s3",
+    /**
+     * Azure Storage.
+     */
+    AzureStorage: "azure-storage",
+    /**
+     * GCP Storage.
+     */
+    GcpStorage: "gcp-storage"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the blob 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 initialiseBlobStorageConnector(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Blob Storage Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === BlobStorageConnectorType.Ipfs) {
+        connector = new blobStorageConnectorIpfs.IpfsBlobStorageConnector(instanceConfig.options);
+        instanceType = blobStorageConnectorIpfs.IpfsBlobStorageConnector.NAMESPACE;
+    }
+    else if (type === BlobStorageConnectorType.File) {
+        connector = new blobStorageConnectorFile.FileBlobStorageConnector({
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options.config,
+                directory: core.Is.stringValue(instanceConfig.options.storagePrefix)
+                    ? path.join(instanceConfig.options.config.directory, instanceConfig.options.storagePrefix)
+                    : instanceConfig.options.config.directory
+            }
+        });
+        instanceType = blobStorageConnectorFile.FileBlobStorageConnector.NAMESPACE;
+    }
+    else if (type === BlobStorageConnectorType.Memory) {
+        connector = new blobStorageConnectorMemory.MemoryBlobStorageConnector();
+        instanceType = blobStorageConnectorMemory.MemoryBlobStorageConnector.NAMESPACE;
+    }
+    else if (type === BlobStorageConnectorType.AwsS3) {
+        connector = new blobStorageConnectorAwsS3.S3BlobStorageConnector({
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options.config,
+                bucketName: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.bucketName}`
+            }
+        });
+        instanceType = blobStorageConnectorAwsS3.S3BlobStorageConnector.NAMESPACE;
+    }
+    else if (type === BlobStorageConnectorType.GcpStorage) {
+        connector = new blobStorageConnectorGcp.GcpBlobStorageConnector({
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options.config,
+                bucketName: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.bucketName}`
+            }
+        });
+        instanceType = blobStorageConnectorGcp.GcpBlobStorageConnector.NAMESPACE;
+    }
+    else if (type === BlobStorageConnectorType.AzureStorage) {
+        connector = new blobStorageConnectorAzure.AzureBlobStorageConnector({
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options.config,
+                containerName: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.containerName}`
+            }
+        });
+        instanceType = blobStorageConnectorAzure.AzureBlobStorageConnector.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "blobStorageConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    blobStorageModels.BlobStorageConnectorFactory.register(finalInstanceType, () => connector);
+    return finalInstanceType;
+}
+/**
+ * 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(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Blob Storage Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === BlobStorageComponentType.Service) {
+        blobStorageService.initSchema();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.entryEntityStorageType, "BlobStorageEntry");
+        component = new blobStorageService.BlobStorageService({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            ...instanceConfig.options
+        });
+        instanceType = blobStorageService.BlobStorageService.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "blobStorageComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Faucet connector types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const FaucetConnectorType = {
+    /**
+     * Entity storage.
+     */
+    EntityStorage: "entity-storage",
+    /**
+     * IOTA.
+     */
+    Iota: "iota"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * 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(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Faucet Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === FaucetConnectorType.Iota) {
+        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
+        connector = new walletConnectorIota.IotaFaucetConnector({
+            ...instanceConfig.options,
+            config: {
+                ...dltConfig?.options?.config,
+                ...instanceConfig.options.config
+            }
+        });
+        instanceType = walletConnectorIota.IotaFaucetConnector.NAMESPACE;
+    }
+    else if (type === FaucetConnectorType.EntityStorage) {
+        connector = new walletConnectorEntityStorage.EntityStorageFaucetConnector(instanceConfig.options);
+        instanceType = walletConnectorEntityStorage.EntityStorageFaucetConnector.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "faucetConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    walletModels.FaucetConnectorFactory.register(finalInstanceType, () => connector);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Identity component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const IdentityComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Identity connector types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const IdentityConnectorType = {
+    /**
+     * Entity storage.
+     */
+    EntityStorage: "entity-storage",
+    /**
+     * IOTA.
+     */
+    Iota: "iota"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the identity 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 initialiseIdentityConnector(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Identity Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === IdentityConnectorType.Iota) {
+        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
+        connector = new identityConnectorIota.IotaIdentityConnector({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            ...instanceConfig.options,
+            config: {
+                ...dltConfig?.options?.config,
+                ...instanceConfig.options.config
+            }
+        });
+        instanceType = identityConnectorIota.IotaIdentityConnector.NAMESPACE;
+    }
+    else if (type === IdentityConnectorType.EntityStorage) {
+        identityConnectorEntityStorage.initSchema({ includeProfile: false });
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.didDocumentEntityStorageType, "IdentityDocument");
+        connector = new identityConnectorEntityStorage.EntityStorageIdentityConnector({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            ...instanceConfig.options
+        });
+        instanceType = identityConnectorEntityStorage.EntityStorageIdentityConnector.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "identityConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
+    identityModels.IdentityConnectorFactory.register(finalInstanceType, () => connector);
+    return finalInstanceType;
+}
+/**
+ * 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(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Identity Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === IdentityComponentType.Service) {
+        component = new identityService.IdentityService(instanceConfig.options);
+        instanceType = identityService.IdentityService.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "identityComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Identity profile component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const IdentityProfileComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Identity profile connector types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const IdentityProfileConnectorType = {
+    /**
+     * Entity storage.
+     */
+    EntityStorage: "entity-storage"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the identity profile 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 initialiseIdentityProfileConnector(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Identity Profile Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === IdentityProfileConnectorType.EntityStorage) {
+        identityConnectorEntityStorage.initSchema({ includeDocument: false });
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.profileEntityStorageType, "IdentityProfile");
+        connector = new identityConnectorEntityStorage.EntityStorageIdentityProfileConnector(instanceConfig.options);
+        instanceType = identityConnectorEntityStorage.EntityStorageIdentityProfileConnector.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            serviceType: "identityProfile"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    identityModels.IdentityProfileConnectorFactory.register(finalInstanceType, () => connector);
+    return finalInstanceType;
+}
+/**
+ * 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(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Identity Profile Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === IdentityProfileComponentType.Service) {
+        component = new identityService.IdentityProfileService({
+            profileEntityConnectorType: context.defaultTypes.identityProfileConnector,
+            ...instanceConfig.options
+        });
+        instanceType = identityService.IdentityProfileService.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "identityProfileComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Immutable proof component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const ImmutableProofComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the immutable proof 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 initialiseImmutableProofComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Immutable Proof Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === ImmutableProofComponentType.Service) {
+        immutableProofService.initSchema();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.immutableProofEntityStorageType, "ImmutableProof");
+        component = new immutableProofService.ImmutableProofService({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            immutableStorageType: context.defaultTypes.immutableStorageConnector,
+            identityConnectorType: context.defaultTypes.identityConnector,
+            backgroundTaskConnectorType: context.defaultTypes.backgroundTaskConnector,
+            ...instanceConfig.options
+        });
+        instanceType = immutableProofService.ImmutableProofService.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "immutableProofComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Immutable storage connector types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const ImmutableStorageConnectorType = {
+    /**
+     * Entity storage.
+     */
+    EntityStorage: "entity-storage",
+    /**
+     * IOTA.
+     */
+    Iota: "iota"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the immutable 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 initialiseImmutableStorageConnector(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Immutable Storage Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === ImmutableStorageConnectorType.Iota) {
+        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
+        connector = new immutableStorageConnectorIota.IotaImmutableStorageConnector({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            ...instanceConfig.options,
+            config: {
+                ...dltConfig?.options?.config,
+                ...instanceConfig.options.config
+            }
+        });
+        instanceType = immutableStorageConnectorIota.IotaImmutableStorageConnector.NAMESPACE;
+    }
+    else if (type === ImmutableStorageConnectorType.EntityStorage) {
+        immutableStorageConnectorEntityStorage.initSchema();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.immutableStorageEntityStorageType, "ImmutableItem");
+        connector = new immutableStorageConnectorEntityStorage.EntityStorageImmutableStorageConnector(instanceConfig.options);
+        instanceType = immutableStorageConnectorEntityStorage.EntityStorageImmutableStorageConnector.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "immutableStorageConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    immutableStorageModels.ImmutableStorageConnectorFactory.register(finalInstanceType, () => connector);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Logging component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const LoggingComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Logging connector types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const LoggingConnectorType = {
+    /**
+     * Entity storage.
+     */
+    EntityStorage: "entity-storage",
+    /**
+     * Console.
+     */
+    Console: "console",
+    /**
+     * Multi combines other loggers.
+     */
+    Multi: "multi"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the logging connector.
+ * @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(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Logging Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === LoggingConnectorType.Console) {
+        connector = new loggingConnectorConsole.ConsoleLoggingConnector(instanceConfig.options);
+        instanceType = loggingConnectorConsole.ConsoleLoggingConnector.NAMESPACE;
+    }
+    else if (type === LoggingConnectorType.EntityStorage) {
+        loggingConnectorEntityStorage.initSchema();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.logEntryStorageConnectorType, "LogEntry");
+        connector = new loggingConnectorEntityStorage.EntityStorageLoggingConnector(instanceConfig.options);
+        instanceType = loggingConnectorEntityStorage.EntityStorageLoggingConnector.NAMESPACE;
+    }
+    else if (type === LoggingConnectorType.Multi) {
+        connector = new loggingModels.MultiLoggingConnector(instanceConfig.options);
+        instanceType = loggingModels.MultiLoggingConnector.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "loggingConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
+    loggingModels.LoggingConnectorFactory.register(finalInstanceType, () => connector);
+    return finalInstanceType;
+}
+/**
+ * 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(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Logging Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === LoggingComponentType.Service) {
+        component = new loggingService.LoggingService({
+            loggingConnectorType: context.defaultTypes.loggingConnector,
+            ...instanceConfig.options
+        });
+        instanceType = loggingService.LoggingService.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "loggingComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * NFT component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const NftComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * NFT connector types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const NftConnectorType = {
+    /**
+     * Entity storage.
+     */
+    EntityStorage: "entity-storage",
+    /**
+     * IOTA.
+     */
+    Iota: "iota"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the NFT 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 initialiseNftConnector(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `NFT Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === NftConnectorType.EntityStorage) {
+        nftConnectorEntityStorage.initSchema();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.nftEntityStorageType, "Nft");
+        connector = new nftConnectorEntityStorage.EntityStorageNftConnector(instanceConfig.options);
+        instanceType = nftConnectorEntityStorage.EntityStorageNftConnector.NAMESPACE;
+    }
+    else if (type === NftConnectorType.Iota) {
+        connector = new nftConnectorIota.IotaNftConnector({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            ...instanceConfig.options
+        });
+        instanceType = nftConnectorIota.IotaNftConnector.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "nftConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    nftModels.NftConnectorFactory.register(finalInstanceType, () => connector);
+    return finalInstanceType;
+}
+/**
+ * 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(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Nft Storage Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === NftComponentType.Service) {
+        component = new nftService.NftService(instanceConfig.options);
+        instanceType = nftService.NftService.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "nftComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Telemetry component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const TelemetryComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Telemetry connector types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const TelemetryConnectorType = {
+    /**
+     * Entity storage.
+     */
+    EntityStorage: "entity-storage"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise a telemetry 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 initialiseTelemetryConnector(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Telemetry Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === TelemetryConnectorType.EntityStorage) {
+        telemetryConnectorEntityStorage.initSchema();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.telemetryMetricStorageConnectorType, "TelemetryMetric");
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.telemetryMetricValueStorageConnectorType, "TelemetryMetricValue");
+        connector = new telemetryConnectorEntityStorage.EntityStorageTelemetryConnector({
+            loggingConnectorType: context.defaultTypes.loggingConnector,
+            ...instanceConfig.options
+        });
+        instanceType = telemetryConnectorEntityStorage.EntityStorageTelemetryConnector.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "telemetryConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
+    telemetryModels.TelemetryConnectorFactory.register(finalInstanceType, () => connector);
+    return finalInstanceType;
+}
+/**
+ * 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(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Telemetry Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === TelemetryComponentType.Service) {
+        component = new telemetryService.TelemetryService({
+            telemetryConnectorType: context.defaultTypes.telemetryConnector,
+            ...instanceConfig.options
+        });
+        instanceType = telemetryService.TelemetryService.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "telemetryComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Vault connector types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const VaultConnectorType = {
+    /**
+     * Entity storage.
+     */
+    EntityStorage: "entity-storage",
+    /**
+     * Hashicorp.
+     */
+    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(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Vault Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === VaultConnectorType.EntityStorage) {
+        vaultConnectorEntityStorage.initSchema();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vaultKeyEntityStorageType, "VaultKey");
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vaultSecretEntityStorageType, "VaultSecret");
+        connector = new vaultConnectorEntityStorage.EntityStorageVaultConnector(instanceConfig.options);
+        instanceType = vaultConnectorEntityStorage.EntityStorageVaultConnector.NAMESPACE;
+    }
+    else if (type === VaultConnectorType.Hashicorp) {
+        connector = new vaultConnectorHashicorp.HashicorpVaultConnector(instanceConfig.options);
+        instanceType = vaultConnectorHashicorp.HashicorpVaultConnector.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "vaultConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
+    vaultModels.VaultConnectorFactory.register(finalInstanceType, () => connector);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Wallet connector types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const WalletConnectorType = {
+    /**
+     * Entity storage.
+     */
+    EntityStorage: "entity-storage",
+    /**
+     * IOTA.
+     */
+    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(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Wallet Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === WalletConnectorType.Iota) {
+        const dltConfig = context.config.types.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
+        connector = new walletConnectorIota.IotaWalletConnector({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            faucetConnectorType: context.defaultTypes.faucetConnector,
+            ...instanceConfig.options,
+            config: {
+                ...dltConfig?.options?.config,
+                ...instanceConfig.options.config
+            }
+        });
+        instanceType = walletConnectorIota.IotaWalletConnector.NAMESPACE;
+    }
+    else if (type === WalletConnectorType.EntityStorage) {
+        connector = new walletConnectorEntityStorage.EntityStorageWalletConnector({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            faucetConnectorType: context.defaultTypes.faucetConnector,
+            ...instanceConfig.options
+        });
+        instanceType = walletConnectorEntityStorage.EntityStorageWalletConnector.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "walletConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    walletModels.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) {
+        walletConnectorEntityStorage.initSchema();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.walletAddressEntityStorageType, "WalletAddress");
+    }
+    else {
+        throw new core.GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "walletConnector"
+        });
+    }
+    return undefined;
+}
+
+// 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"
+};
+
+exports.AttestationComponentType = AttestationComponentType;
+exports.AttestationConnectorType = AttestationConnectorType;
+exports.AuditableItemGraphComponentType = AuditableItemGraphComponentType;
+exports.AuditableItemStreamComponentType = AuditableItemStreamComponentType;
+exports.BackgroundTaskConnectorType = BackgroundTaskConnectorType;
+exports.BlobStorageComponentType = BlobStorageComponentType;
+exports.BlobStorageConnectorType = BlobStorageConnectorType;
+exports.DltConfigType = DltConfigType;
+exports.EntityStorageComponentType = EntityStorageComponentType;
+exports.EntityStorageConnectorType = EntityStorageConnectorType;
+exports.FaucetConnectorType = FaucetConnectorType;
+exports.IdentityComponentType = IdentityComponentType;
+exports.IdentityConnectorType = IdentityConnectorType;
+exports.IdentityProfileComponentType = IdentityProfileComponentType;
+exports.IdentityProfileConnectorType = IdentityProfileConnectorType;
+exports.ImmutableProofComponentType = ImmutableProofComponentType;
+exports.ImmutableStorageConnectorType = ImmutableStorageConnectorType;
+exports.LoggingComponentType = LoggingComponentType;
+exports.LoggingConnectorType = LoggingConnectorType;
+exports.NftComponentType = NftComponentType;
+exports.NftConnectorType = NftConnectorType;
+exports.TelemetryComponentType = TelemetryComponentType;
+exports.TelemetryConnectorType = TelemetryConnectorType;
+exports.VaultConnectorType = VaultConnectorType;
+exports.WalletConnectorType = WalletConnectorType;
+exports.initialiseAttestationComponent = initialiseAttestationComponent;
+exports.initialiseAttestationConnector = initialiseAttestationConnector;
+exports.initialiseAuditableItemGraphComponent = initialiseAuditableItemGraphComponent;
+exports.initialiseAuditableItemStreamComponent = initialiseAuditableItemStreamComponent;
+exports.initialiseBackgroundTaskConnector = initialiseBackgroundTaskConnector;
+exports.initialiseBlobStorageComponent = initialiseBlobStorageComponent;
+exports.initialiseBlobStorageConnector = initialiseBlobStorageConnector;
+exports.initialiseEntityStorageComponent = initialiseEntityStorageComponent;
+exports.initialiseEntityStorageConnector = initialiseEntityStorageConnector;
+exports.initialiseFaucetConnector = initialiseFaucetConnector;
+exports.initialiseIdentityComponent = initialiseIdentityComponent;
+exports.initialiseIdentityConnector = initialiseIdentityConnector;
+exports.initialiseIdentityProfileComponent = initialiseIdentityProfileComponent;
+exports.initialiseIdentityProfileConnector = initialiseIdentityProfileConnector;
+exports.initialiseImmutableProofComponent = initialiseImmutableProofComponent;
+exports.initialiseImmutableStorageConnector = initialiseImmutableStorageConnector;
+exports.initialiseLoggingComponent = initialiseLoggingComponent;
+exports.initialiseLoggingConnector = initialiseLoggingConnector;
+exports.initialiseNftComponent = initialiseNftComponent;
+exports.initialiseNftConnector = initialiseNftConnector;
+exports.initialiseTelemetryComponent = initialiseTelemetryComponent;
+exports.initialiseTelemetryConnector = initialiseTelemetryConnector;
+exports.initialiseVaultConnector = initialiseVaultConnector;
+exports.initialiseWalletConnector = initialiseWalletConnector;
+exports.initialiseWalletStorage = initialiseWalletStorage;