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

package/dist/esm/index.mjs

@@ -0,0 +1,1589 @@
+import { EntityStorageAttestationConnector } from '@twin.org/attestation-connector-entity-storage';
+import { IotaAttestationConnector } from '@twin.org/attestation-connector-iota';
+import { AttestationConnectorFactory } from '@twin.org/attestation-models';
+import { AttestationService } from '@twin.org/attestation-service';
+import { I18n, GeneralError, ComponentFactory, StringHelper, Is } from '@twin.org/core';
+import { initSchema, AuditableItemGraphService } from '@twin.org/auditable-item-graph-service';
+import path from 'node:path';
+import { CosmosDbEntityStorageConnector } from '@twin.org/entity-storage-connector-cosmosdb';
+import { DynamoDbEntityStorageConnector } from '@twin.org/entity-storage-connector-dynamodb';
+import { FileEntityStorageConnector } from '@twin.org/entity-storage-connector-file';
+import { FirestoreEntityStorageConnector } from '@twin.org/entity-storage-connector-gcp-firestore';
+import { MemoryEntityStorageConnector } from '@twin.org/entity-storage-connector-memory';
+import { ScyllaDBTableConnector } from '@twin.org/entity-storage-connector-scylladb';
+import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
+import { EntityStorageService } from '@twin.org/entity-storage-service';
+import { initSchema as initSchema$1, AuditableItemStreamService } from '@twin.org/auditable-item-stream-service';
+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';
+import { AzureBlobStorageConnector } from '@twin.org/blob-storage-connector-azure';
+import { FileBlobStorageConnector } from '@twin.org/blob-storage-connector-file';
+import { GcpBlobStorageConnector } from '@twin.org/blob-storage-connector-gcp';
+import { IpfsBlobStorageConnector } from '@twin.org/blob-storage-connector-ipfs';
+import { MemoryBlobStorageConnector } from '@twin.org/blob-storage-connector-memory';
+import { BlobStorageConnectorFactory } from '@twin.org/blob-storage-models';
+import { initSchema as initSchema$3, BlobStorageService } from '@twin.org/blob-storage-service';
+import { EntityStorageFaucetConnector, EntityStorageWalletConnector, initSchema as initSchema$b } 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 { initSchema as initSchema$4, EntityStorageIdentityConnector, EntityStorageIdentityProfileConnector } from '@twin.org/identity-connector-entity-storage';
+import { IotaIdentityConnector } from '@twin.org/identity-connector-iota';
+import { IdentityConnectorFactory, IdentityProfileConnectorFactory } from '@twin.org/identity-models';
+import { IdentityService, IdentityProfileService } from '@twin.org/identity-service';
+import { initSchema as initSchema$5, ImmutableProofService } from '@twin.org/immutable-proof-service';
+import { initSchema as initSchema$6, EntityStorageImmutableStorageConnector } from '@twin.org/immutable-storage-connector-entity-storage';
+import { IotaImmutableStorageConnector } from '@twin.org/immutable-storage-connector-iota';
+import { ImmutableStorageConnectorFactory } from '@twin.org/immutable-storage-models';
+import { ConsoleLoggingConnector } from '@twin.org/logging-connector-console';
+import { initSchema as initSchema$7, EntityStorageLoggingConnector } from '@twin.org/logging-connector-entity-storage';
+import { MultiLoggingConnector, LoggingConnectorFactory } from '@twin.org/logging-models';
+import { LoggingService } from '@twin.org/logging-service';
+import { initSchema as initSchema$8, EntityStorageNftConnector } from '@twin.org/nft-connector-entity-storage';
+import { IotaNftConnector } from '@twin.org/nft-connector-iota';
+import { NftConnectorFactory } from '@twin.org/nft-models';
+import { NftService } from '@twin.org/nft-service';
+import { initSchema as initSchema$9, EntityStorageTelemetryConnector } from '@twin.org/telemetry-connector-entity-storage';
+import { TelemetryConnectorFactory } from '@twin.org/telemetry-models';
+import { TelemetryService } from '@twin.org/telemetry-service';
+import { initSchema as initSchema$a, EntityStorageVaultConnector } from '@twin.org/vault-connector-entity-storage';
+import { HashicorpVaultConnector } from '@twin.org/vault-connector-hashicorp';
+import { VaultConnectorFactory } from '@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(I18n.formatMessage("engineCore.configuring", {
+        element: `Attestation Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === AttestationConnectorType.Iota) {
+        connector = new IotaAttestationConnector({
+            identityConnectorType: context.defaultTypes.identityConnector,
+            nftConnectorType: context.defaultTypes.nftConnector,
+            ...instanceConfig.options
+        });
+        instanceType = IotaAttestationConnector.NAMESPACE;
+    }
+    else if (type === AttestationConnectorType.EntityStorage) {
+        connector = new EntityStorageAttestationConnector({
+            identityConnectorType: context.defaultTypes.identityConnector,
+            nftConnectorType: context.defaultTypes.nftConnector,
+            ...instanceConfig.options
+        });
+        instanceType = EntityStorageAttestationConnector.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;
+}
+/**
+ * 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;
+    let component;
+    let instanceType;
+    if (type === AttestationComponentType.Service) {
+        component = new AttestationService({
+            walletConnectorType: context.defaultTypes.walletConnector,
+            ...instanceConfig.options
+        });
+        instanceType = AttestationService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "attestationComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    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 = StringHelper.kebabCase(schema);
+    let entityStorageConfig;
+    if (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 (Is.empty(entityStorageConfig)) {
+            throw new 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 (Is.empty(entityStorageConfig)) {
+            throw new GeneralError("engineCore", "entityStorageMissing", {
+                storageName: instanceName
+            });
+        }
+    }
+    const type = entityStorageConfig.type;
+    let entityStorageConnector;
+    engineCore.logInfo(I18n.formatMessage("engineCore.configuringEntityStorage", {
+        element: "Entity Storage",
+        storageName: instanceName,
+        storageType: type
+    }));
+    if (type === EntityStorageConnectorType.Memory) {
+        entityStorageConnector = new MemoryEntityStorageConnector({
+            entitySchema: schema
+        });
+    }
+    else if (type === EntityStorageConnectorType.File) {
+        entityStorageConnector = new 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 DynamoDbEntityStorageConnector({
+            entitySchema: schema,
+            ...entityStorageConfig.options,
+            config: {
+                ...entityStorageConfig.options.config,
+                tableName: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
+            }
+        });
+    }
+    else if (type === EntityStorageConnectorType.AzureCosmosDb) {
+        entityStorageConnector = new CosmosDbEntityStorageConnector({
+            entitySchema: schema,
+            ...entityStorageConfig.options,
+            config: {
+                ...entityStorageConfig.options.config,
+                containerId: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
+            }
+        });
+    }
+    else if (type === EntityStorageConnectorType.GcpFirestoreDb) {
+        entityStorageConnector = new FirestoreEntityStorageConnector({
+            entitySchema: schema,
+            ...entityStorageConfig.options,
+            config: {
+                ...entityStorageConfig.options.config,
+                collectionName: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
+            }
+        });
+    }
+    else if (type === EntityStorageConnectorType.ScyllaDb) {
+        entityStorageConnector = new ScyllaDBTableConnector({
+            entitySchema: schema,
+            ...entityStorageConfig.options,
+            config: {
+                ...entityStorageConfig.options.config,
+                tableName: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
+            }
+        });
+    }
+    else {
+        throw new GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "entityStorageConnector"
+        });
+    }
+    context.componentInstances.push({
+        instanceType: instanceName,
+        component: entityStorageConnector
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Entity Storage Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (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);
+        initialiseEntityStorageConnector(engineCore, context, hasCustom ? kebabName : undefined, instanceConfig.options.entityStorageType);
+        connector = new EntityStorageService({
+            entityStorageType: kebabName,
+            config: {
+                ...instanceConfig.options.config
+            }
+        });
+        instanceType = StringHelper.kebabCase(instanceConfig.options.entityStorageType);
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            serviceType: "entityStorageComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Auditable Item Graph Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (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,
+            ...instanceConfig.options
+        });
+        instanceType = AuditableItemGraphService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "auditableItemGraphComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Auditable Item Stream Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (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,
+            ...instanceConfig.options
+        });
+        instanceType = AuditableItemStreamService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "auditableItemStreamComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Background Task Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === BackgroundTaskConnectorType.EntityStorage) {
+        initSchema$2();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.backgroundTaskEntityStorageType, "BackgroundTask");
+        connector = new EntityStorageBackgroundTaskConnector({
+            loggingConnectorType: context.defaultTypes.loggingConnector,
+            ...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;
+}
+
+// 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(I18n.formatMessage("engineCore.configuring", {
+        element: `Blob Storage Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === BlobStorageConnectorType.Ipfs) {
+        connector = new IpfsBlobStorageConnector(instanceConfig.options);
+        instanceType = IpfsBlobStorageConnector.NAMESPACE;
+    }
+    else if (type === BlobStorageConnectorType.File) {
+        connector = new FileBlobStorageConnector({
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options.config,
+                directory: Is.stringValue(instanceConfig.options.storagePrefix)
+                    ? path.join(instanceConfig.options.config.directory, instanceConfig.options.storagePrefix)
+                    : instanceConfig.options.config.directory
+            }
+        });
+        instanceType = FileBlobStorageConnector.NAMESPACE;
+    }
+    else if (type === BlobStorageConnectorType.Memory) {
+        connector = new MemoryBlobStorageConnector();
+        instanceType = MemoryBlobStorageConnector.NAMESPACE;
+    }
+    else if (type === BlobStorageConnectorType.AwsS3) {
+        connector = new S3BlobStorageConnector({
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options.config,
+                bucketName: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.bucketName}`
+            }
+        });
+        instanceType = S3BlobStorageConnector.NAMESPACE;
+    }
+    else if (type === BlobStorageConnectorType.GcpStorage) {
+        connector = new GcpBlobStorageConnector({
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options.config,
+                bucketName: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.bucketName}`
+            }
+        });
+        instanceType = GcpBlobStorageConnector.NAMESPACE;
+    }
+    else if (type === BlobStorageConnectorType.AzureStorage) {
+        connector = new AzureBlobStorageConnector({
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options.config,
+                containerName: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.containerName}`
+            }
+        });
+        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;
+}
+/**
+ * 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;
+    let component;
+    let instanceType;
+    if (type === BlobStorageComponentType.Service) {
+        initSchema$3();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.entryEntityStorageType, "BlobStorageEntry");
+        component = new BlobStorageService({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            ...instanceConfig.options
+        });
+        instanceType = BlobStorageService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "blobStorageComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    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(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 IotaFaucetConnector({
+            ...instanceConfig.options,
+            config: {
+                ...dltConfig?.options?.config,
+                ...instanceConfig.options.config
+            }
+        });
+        instanceType = IotaFaucetConnector.NAMESPACE;
+    }
+    else if (type === FaucetConnectorType.EntityStorage) {
+        connector = 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;
+}
+
+// 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(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 IotaIdentityConnector({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            ...instanceConfig.options,
+            config: {
+                ...dltConfig?.options?.config,
+                ...instanceConfig.options.config
+            }
+        });
+        instanceType = IotaIdentityConnector.NAMESPACE;
+    }
+    else if (type === IdentityConnectorType.EntityStorage) {
+        initSchema$4({ includeProfile: false });
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.didDocumentEntityStorageType, "IdentityDocument");
+        connector = new EntityStorageIdentityConnector({
+            vaultConnectorType: context.defaultTypes.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;
+}
+/**
+ * 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;
+    let component;
+    let instanceType;
+    if (type === IdentityComponentType.Service) {
+        component = new IdentityService(instanceConfig.options);
+        instanceType = IdentityService.NAMESPACE;
+    }
+    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;
+}
+
+// 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(I18n.formatMessage("engineCore.configuring", {
+        element: `Identity Profile Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === IdentityProfileConnectorType.EntityStorage) {
+        initSchema$4({ 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;
+}
+/**
+ * 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;
+    let component;
+    let instanceType;
+    if (type === IdentityProfileComponentType.Service) {
+        component = new IdentityProfileService({
+            profileEntityConnectorType: context.defaultTypes.identityProfileConnector,
+            ...instanceConfig.options
+        });
+        instanceType = IdentityProfileService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "identityProfileComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Immutable Proof Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === ImmutableProofComponentType.Service) {
+        initSchema$5();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.immutableProofEntityStorageType, "ImmutableProof");
+        component = new ImmutableProofService({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            immutableStorageType: context.defaultTypes.immutableStorageConnector,
+            identityConnectorType: context.defaultTypes.identityConnector,
+            backgroundTaskConnectorType: context.defaultTypes.backgroundTaskConnector,
+            ...instanceConfig.options
+        });
+        instanceType = ImmutableProofService.NAMESPACE;
+    }
+    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;
+}
+
+// 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(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 IotaImmutableStorageConnector({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            ...instanceConfig.options,
+            config: {
+                ...dltConfig?.options?.config,
+                ...instanceConfig.options.config
+            }
+        });
+        instanceType = IotaImmutableStorageConnector.NAMESPACE;
+    }
+    else if (type === ImmutableStorageConnectorType.EntityStorage) {
+        initSchema$6();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.immutableStorageEntityStorageType, "ImmutableItem");
+        connector = new EntityStorageImmutableStorageConnector(instanceConfig.options);
+        instanceType = EntityStorageImmutableStorageConnector.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "immutableStorageConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Logging Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === LoggingConnectorType.Console) {
+        connector = new ConsoleLoggingConnector(instanceConfig.options);
+        instanceType = ConsoleLoggingConnector.NAMESPACE;
+    }
+    else if (type === LoggingConnectorType.EntityStorage) {
+        initSchema$7();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.logEntryStorageConnectorType, "LogEntry");
+        connector = new EntityStorageLoggingConnector(instanceConfig.options);
+        instanceType = EntityStorageLoggingConnector.NAMESPACE;
+    }
+    else if (type === LoggingConnectorType.Multi) {
+        connector = 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;
+}
+/**
+ * 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;
+    let component;
+    let instanceType;
+    if (type === LoggingComponentType.Service) {
+        component = new LoggingService({
+            loggingConnectorType: context.defaultTypes.loggingConnector,
+            ...instanceConfig.options
+        });
+        instanceType = LoggingService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "loggingComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `NFT Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === NftConnectorType.EntityStorage) {
+        initSchema$8();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.nftEntityStorageType, "Nft");
+        connector = new EntityStorageNftConnector(instanceConfig.options);
+        instanceType = EntityStorageNftConnector.NAMESPACE;
+    }
+    else if (type === NftConnectorType.Iota) {
+        connector = new IotaNftConnector({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            ...instanceConfig.options
+        });
+        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;
+}
+/**
+ * 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;
+    let component;
+    let instanceType;
+    if (type === NftComponentType.Service) {
+        component = new NftService(instanceConfig.options);
+        instanceType = NftService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "nftComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Telemetry Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === TelemetryConnectorType.EntityStorage) {
+        initSchema$9();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.telemetryMetricStorageConnectorType, "TelemetryMetric");
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.telemetryMetricValueStorageConnectorType, "TelemetryMetricValue");
+        connector = new EntityStorageTelemetryConnector({
+            loggingConnectorType: context.defaultTypes.loggingConnector,
+            ...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;
+}
+/**
+ * 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;
+    let component;
+    let instanceType;
+    if (type === TelemetryComponentType.Service) {
+        component = new TelemetryService({
+            telemetryConnectorType: context.defaultTypes.telemetryConnector,
+            ...instanceConfig.options
+        });
+        instanceType = TelemetryService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "telemetryComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Vault Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === VaultConnectorType.EntityStorage) {
+        initSchema$a();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vaultKeyEntityStorageType, "VaultKey");
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vaultSecretEntityStorageType, "VaultSecret");
+        connector = new EntityStorageVaultConnector(instanceConfig.options);
+        instanceType = EntityStorageVaultConnector.NAMESPACE;
+    }
+    else if (type === VaultConnectorType.Hashicorp) {
+        connector = 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;
+}
+
+// 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(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 IotaWalletConnector({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            faucetConnectorType: context.defaultTypes.faucetConnector,
+            ...instanceConfig.options,
+            config: {
+                ...dltConfig?.options?.config,
+                ...instanceConfig.options.config
+            }
+        });
+        instanceType = IotaWalletConnector.NAMESPACE;
+    }
+    else if (type === WalletConnectorType.EntityStorage) {
+        connector = new EntityStorageWalletConnector({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            faucetConnectorType: context.defaultTypes.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$b();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.walletAddressEntityStorageType, "WalletAddress");
+    }
+    else {
+        throw new 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"
+};
+
+export { AttestationComponentType, AttestationConnectorType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, BackgroundTaskConnectorType, BlobStorageComponentType, BlobStorageConnectorType, DltConfigType, EntityStorageComponentType, EntityStorageConnectorType, FaucetConnectorType, IdentityComponentType, IdentityConnectorType, IdentityProfileComponentType, IdentityProfileConnectorType, ImmutableProofComponentType, ImmutableStorageConnectorType, LoggingComponentType, LoggingConnectorType, NftComponentType, NftConnectorType, TelemetryComponentType, TelemetryConnectorType, VaultConnectorType, WalletConnectorType, initialiseAttestationComponent, initialiseAttestationConnector, initialiseAuditableItemGraphComponent, initialiseAuditableItemStreamComponent, initialiseBackgroundTaskConnector, initialiseBlobStorageComponent, initialiseBlobStorageConnector, initialiseEntityStorageComponent, initialiseEntityStorageConnector, initialiseFaucetConnector, initialiseIdentityComponent, initialiseIdentityConnector, initialiseIdentityProfileComponent, initialiseIdentityProfileConnector, initialiseImmutableProofComponent, initialiseImmutableStorageConnector, initialiseLoggingComponent, initialiseLoggingConnector, initialiseNftComponent, initialiseNftConnector, initialiseTelemetryComponent, initialiseTelemetryConnector, initialiseVaultConnector, initialiseWalletConnector, initialiseWalletStorage };