diff --git a/src/plugins/qmldesigner/designercore/include/projectstorageids.h b/src/plugins/qmldesigner/designercore/include/projectstorageids.h
index 5e39fcdd864..d3701c6a6b4 100644
--- a/src/plugins/qmldesigner/designercore/include/projectstorageids.h
+++ b/src/plugins/qmldesigner/designercore/include/projectstorageids.h
@@ -83,7 +83,7 @@ enum class BasicIdType {
     FunctionDeclaration,
     SignalDeclaration,
     EnumerationDeclaration,
-    Import,
+    Module,
     TypeName,
     ProjectPartId
 };
@@ -109,8 +109,8 @@ using SourceContextIds = std::vector<SourceContextId>;
 using SourceId = BasicId<BasicIdType::SourceId, int>;
 using SourceIds = std::vector<SourceId>;
 
-using ImportId = BasicId<BasicIdType::Import>;
-using ImportIds = std::vector<ImportId>;
+using ModuleId = BasicId<BasicIdType::Module>;
+using ModuleIds = std::vector<ModuleId>;
 
 using TypeNameId = BasicId<BasicIdType::TypeName>;
 using TypeNameIds = std::vector<TypeNameId>;
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
index e0f0b2cef9f..cdf02674658 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
@@ -55,7 +55,7 @@ public:
         , initializer{database, isInitialized}
     {}
 
-    void synchronize(Storage::ImportDependencies importDependencies,
+    void synchronize(Storage::ModuleDependencies moduleDependencies,
                      Storage::Documents documents,
                      Storage::Types types,
                      SourceIds sourceIds,
@@ -76,7 +76,7 @@ public:
         });
 
         synchronizeFileStatuses(fileStatuses, sourceIdValues);
-        synchronizeImports(importDependencies, deletedTypeIds, sourceIdValues);
+        synchronizeModules(moduleDependencies, deletedTypeIds, sourceIdValues);
         synchronizeDocuments(documents, sourceIdValues);
         synchronizeTypes(types,
                          updatedTypeIds,
@@ -90,26 +90,26 @@ public:
         transaction.commit();
     }
 
-    ImportIds fetchImportIds(const Storage::Imports &imports)
+    ModuleIds fetchModuleIds(const Storage::Modules &modules)
     {
         Sqlite::DeferredTransaction transaction{database};
 
-        ImportIds importIds = fetchImportIdsUnguarded(imports);
+        ModuleIds moduleIds = fetchModuleIdsUnguarded(modules);
 
         transaction.commit();
 
-        return importIds;
+        return moduleIds;
     }
 
-    ImportIds fetchImportIds(SourceId sourceId)
+    ModuleIds fetchModuleIds(SourceId sourceId)
     {
-        return selectImportIdsForSourceIdStatement.template valeWithTransaction(16, &sourceId);
+        return selectModuleIdsForSourceIdStatement.template valeWithTransaction(16, &sourceId);
     }
 
-    ImportIds fetchImportDependencyIds(ImportIds importIds) const
+    ModuleIds fetchModuleDependencyIds(ModuleIds moduleIds) const
     {
-        return fetchImportDependencyIdsStatement.template valuesWithTransaction<ImportId>(
-            16, static_cast<void *>(importIds.data()), static_cast<long long>(importIds.size()));
+        return fetchModuleDependencyIdsStatement.template valuesWithTransaction<ModuleId>(
+            16, static_cast<void *>(moduleIds.data()), static_cast<long long>(moduleIds.size()));
     }
 
     PropertyDeclarationId fetchPropertyDeclarationByTypeIdAndName(TypeId typeId,
@@ -124,15 +124,15 @@ public:
         return selectTypeIdByExportedNameStatement.template valueWithTransaction<TypeId>(name);
     }
 
-    TypeId fetchTypeIdByImportIdsAndExportedName(ImportIds importIds, Utils::SmallStringView name) const
+    TypeId fetchTypeIdByModuleIdsAndExportedName(ModuleIds moduleIds, Utils::SmallStringView name) const
     {
-        return selectTypeIdByImportIdsAndExportedNameStatement.template valueWithTransaction<TypeId>(
-            static_cast<void *>(importIds.data()), static_cast<long long>(importIds.size()), name);
+        return selectTypeIdByModuleIdsAndExportedNameStatement.template valueWithTransaction<TypeId>(
+            static_cast<void *>(moduleIds.data()), static_cast<long long>(moduleIds.size()), name);
     }
 
-    TypeId fetchTypeIdByName(ImportId importId, Utils::SmallStringView name)
+    TypeId fetchTypeIdByName(ModuleId moduleId, Utils::SmallStringView name)
     {
-        return selectTypeIdByImportIdAndNameStatement.template valueWithTransaction<TypeId>(&importId,
+        return selectTypeIdByModuleIdAndNameStatement.template valueWithTransaction<TypeId>(&moduleId,
                                                                                             name);
     }
 
@@ -271,25 +271,25 @@ public:
         return writeSourceId(sourceContextId, sourceName);
     }
 
-    auto fetchAllImports() const
+    auto fetchAllModules() const
     {
-        Storage::ImportDependencies imports;
-        imports.reserve(128);
+        Storage::ModuleDependencies modules;
+        modules.reserve(128);
 
-        auto callback = [&](Utils::SmallStringView name, int version, int importId) {
-            auto &lastImport = imports.emplace_back(name,
+        auto callback = [&](Utils::SmallStringView name, int version, int moduleId) {
+            auto &lastModule = modules.emplace_back(name,
                                                     Storage::VersionNumber{version},
-                                                    SourceId{importId});
+                                                    SourceId{moduleId});
 
-            lastImport.dependencies = selectImportsForThatDependentOnThisImportIdStatement
-                                          .template values<Storage::Import>(6, importId);
+            lastModule.dependencies = selectModulesForThatDependentOnThisModuleIdStatement
+                                          .template values<Storage::Module>(6, moduleId);
 
             return Sqlite::CallbackControl::Continue;
         };
 
-        selectAllImportsStatement.readCallbackWithTransaction(callback);
+        selectAllModulesStatement.readCallbackWithTransaction(callback);
 
-        return imports;
+        return modules;
     }
 
     auto fetchAllFileStatuses() const
@@ -369,8 +369,8 @@ private:
         bool isExplicitTypeName = typeNameIdValue < 0;
 
         if (isExplicitTypeName) {
-            auto callback = [&](Utils::SmallStringView type, Utils::SmallStringView import, int version) {
-                typeName = Storage::ExplicitExportedType{type, Storage::Import{import, version}};
+            auto callback = [&](Utils::SmallStringView type, Utils::SmallStringView module, int version) {
+                typeName = Storage::ExplicitExportedType{type, Storage::Module{module, version}};
                 return Sqlite::CallbackControl::Abort;
             };
 
@@ -386,27 +386,27 @@ private:
         return typeName;
     }
 
-    struct ImportDependency
+    struct ModuleDependency
     {
-        ImportDependency(ImportId id, ImportId dependencyId)
+        ModuleDependency(ModuleId id, ModuleId dependencyId)
             : id{id}
             , dependencyId{dependencyId}
         {}
 
-        ImportDependency(long long id, long long dependencyId)
+        ModuleDependency(long long id, long long dependencyId)
             : id{id}
             , dependencyId{dependencyId}
         {}
 
-        ImportId id;
-        ImportId dependencyId;
+        ModuleId id;
+        ModuleId dependencyId;
 
-        friend bool operator<(ImportDependency first, ImportDependency second)
+        friend bool operator<(ModuleDependency first, ModuleDependency second)
         {
             return std::tie(first.id, first.dependencyId) < std::tie(second.id, second.dependencyId);
         }
 
-        friend bool operator==(ImportDependency first, ImportDependency second)
+        friend bool operator==(ModuleDependency first, ModuleDependency second)
         {
             return first.id == second.id && first.dependencyId == second.dependencyId;
         }
@@ -470,23 +470,23 @@ private:
         Sqlite::insertUpdateDelete(range, fileStatuses, compareKey, insert, update, remove);
     }
 
-    void synchronizeImports(Storage::ImportDependencies &imports,
+    void synchronizeModules(Storage::ModuleDependencies &modules,
                             TypeIds &deletedTypeIds,
-                            const std::vector<int> &importIdValues)
+                            const std::vector<int> &moduleIdValues)
     {
-        synchronizeImportsAndUpdatesImportIds(imports, deletedTypeIds, importIdValues);
-        synchronizeImportDependencies(createSortedImportDependecies(imports), importIdValues);
+        synchronizeModulesAndUpdatesModuleIds(modules, deletedTypeIds, moduleIdValues);
+        synchronizeModuleDependencies(createSortedModuleDependecies(modules), moduleIdValues);
     }
 
     void synchronizeDocuments(Storage::Documents &documents, std::vector<int> &sourceIdValues)
     {
-        deleteDocumentImportsForDeletedDocuments(documents, sourceIdValues);
+        deleteDocumentModulesForDeletedDocuments(documents, sourceIdValues);
 
         for (auto &&document : documents)
-            synchronizeDocumentImports(document.sourceId, document.imports);
+            synchronizeDocumentModules(document.sourceId, document.modules);
     }
 
-    void deleteDocumentImportsForDeletedDocuments(Storage::Documents &documents,
+    void deleteDocumentModulesForDeletedDocuments(Storage::Documents &documents,
                                                   const std::vector<int> &sourceIdValues)
     {
         const std::vector<int> documentSourceIds = Utils::transform<std::vector<int>>(
@@ -500,70 +500,70 @@ private:
                             documentSourceIds.end(),
                             std::back_inserter(documentSourceIdsToBeDeleted));
 
-        deleteDocumentImportsWithSourceIdsStatement.write(Utils::span{documentSourceIdsToBeDeleted});
+        deleteDocumentModulesWithSourceIdsStatement.write(Utils::span{documentSourceIdsToBeDeleted});
     }
 
-    void synchronizeImportsAndUpdatesImportIds(Storage::ImportDependencies &imports,
+    void synchronizeModulesAndUpdatesModuleIds(Storage::ModuleDependencies &modules,
                                                TypeIds &deletedTypeIds,
-                                               const std::vector<int> &importIds)
+                                               const std::vector<int> &moduleIds)
     {
         auto compareKey = [](auto &&first, auto &&second) {
             return first.sourceId.id - second.sourceId.id;
         };
 
-        std::sort(imports.begin(), imports.end(), [&](auto &&first, auto &&second) {
+        std::sort(modules.begin(), modules.end(), [&](auto &&first, auto &&second) {
             return compareKey(first, second) < 0;
         });
 
-        auto range = selectImportsForIdsStatement.template range<Storage::ImportView>(
-            Utils::span(importIds));
+        auto range = selectModulesForIdsStatement.template range<Storage::ModuleView>(
+            Utils::span(moduleIds));
 
-        auto insert = [&](Storage::ImportDependency &import) {
-            insertImportStatement.write(import.name, import.version.version, &import.sourceId);
+        auto insert = [&](Storage::ModuleDependency &module) {
+            insertModuleStatement.write(module.name, module.version.version, &module.sourceId);
         };
 
-        auto update = [&](const Storage::ImportView &importView, Storage::ImportDependency &import) {
-            if (importView.name != import.name || importView.version != import.version)
-                updateImportStatement.write(&importView.sourceId, import.name, import.version.version);
+        auto update = [&](const Storage::ModuleView &moduleView, Storage::ModuleDependency &module) {
+            if (moduleView.name != module.name || moduleView.version != module.version)
+                updateModuleStatement.write(&moduleView.sourceId, module.name, module.version.version);
         };
 
-        auto remove = [&](const Storage::ImportView &importView) {
-            deleteImportStatement.write(&importView.sourceId);
-            selectTypeIdsForImportIdStatement.readTo(deletedTypeIds, &importView.sourceId);
+        auto remove = [&](const Storage::ModuleView &moduleView) {
+            deleteModuleStatement.write(&moduleView.sourceId);
+            selectTypeIdsForModuleIdStatement.readTo(deletedTypeIds, &moduleView.sourceId);
         };
 
-        Sqlite::insertUpdateDelete(range, imports, compareKey, insert, update, remove);
+        Sqlite::insertUpdateDelete(range, modules, compareKey, insert, update, remove);
     }
 
-    std::vector<ImportDependency> createSortedImportDependecies(
-        const Storage::ImportDependencies &importDependencies) const
+    std::vector<ModuleDependency> createSortedModuleDependecies(
+        const Storage::ModuleDependencies &moduleDependencies) const
     {
-        std::vector<ImportDependency> importDependecies;
-        importDependecies.reserve(importDependencies.size() * 5);
+        std::vector<ModuleDependency> moduleDependecies;
+        moduleDependecies.reserve(moduleDependencies.size() * 5);
 
-        for (const Storage::ImportDependency &importDependency : importDependencies) {
-            for (const Storage::Import &dependency : importDependency.dependencies) {
-                auto importIdForDependency = fetchImportId(dependency);
+        for (const Storage::ModuleDependency &moduleDependency : moduleDependencies) {
+            for (const Storage::Module &dependency : moduleDependency.dependencies) {
+                auto moduleIdForDependency = fetchModuleId(dependency);
 
-                if (!importIdForDependency)
-                    throw ImportDoesNotExists{};
+                if (!moduleIdForDependency)
+                    throw ModuleDoesNotExists{};
 
-                importDependecies.emplace_back(ImportId{&importDependency.sourceId},
-                                               importIdForDependency);
+                moduleDependecies.emplace_back(ModuleId{&moduleDependency.sourceId},
+                                               moduleIdForDependency);
             }
         }
 
-        std::sort(importDependecies.begin(), importDependecies.end());
-        importDependecies.erase(std::unique(importDependecies.begin(), importDependecies.end()),
-                                importDependecies.end());
+        std::sort(moduleDependecies.begin(), moduleDependecies.end());
+        moduleDependecies.erase(std::unique(moduleDependecies.begin(), moduleDependecies.end()),
+                                moduleDependecies.end());
 
-        return importDependecies;
+        return moduleDependecies;
     }
 
-    void synchronizeImportDependencies(const std::vector<ImportDependency> &importDependecies,
-                                       const std::vector<int> &importIds)
+    void synchronizeModuleDependencies(const std::vector<ModuleDependency> &moduleDependecies,
+                                       const std::vector<int> &moduleIds)
     {
-        auto compareKey = [](ImportDependency first, ImportDependency second) {
+        auto compareKey = [](ModuleDependency first, ModuleDependency second) {
             auto idCompare = first.id.id - second.id.id;
 
             if (idCompare != 0)
@@ -572,30 +572,30 @@ private:
             return first.dependencyId.id - second.dependencyId.id;
         };
 
-        auto range = selectImportDependenciesForIdsStatement.template range<ImportDependency>(
-            Utils::span(importIds));
+        auto range = selectModuleDependenciesForIdsStatement.template range<ModuleDependency>(
+            Utils::span(moduleIds));
 
-        auto insert = [&](ImportDependency dependency) {
-            insertImportDependencyStatement.write(&dependency.id, &dependency.dependencyId);
+        auto insert = [&](ModuleDependency dependency) {
+            insertModuleDependencyStatement.write(&dependency.id, &dependency.dependencyId);
         };
 
-        auto update = [](ImportDependency, ImportDependency) {};
+        auto update = [](ModuleDependency, ModuleDependency) {};
 
-        auto remove = [&](ImportDependency dependency) {
-            deleteImportDependencyStatement.write(&dependency.id, &dependency.dependencyId);
+        auto remove = [&](ModuleDependency dependency) {
+            deleteModuleDependencyStatement.write(&dependency.id, &dependency.dependencyId);
         };
 
-        Sqlite::insertUpdateDelete(range, importDependecies, compareKey, insert, update, remove);
+        Sqlite::insertUpdateDelete(range, moduleDependecies, compareKey, insert, update, remove);
     }
 
-    ImportId fetchImportId(const Storage::Import &import) const
+    ModuleId fetchModuleId(const Storage::Module &module) const
     {
-        if (import.version) {
-            return selectImportIdByNameAndVersionStatement
-                .template value<ImportId>(import.name, import.version.version);
+        if (module.version) {
+            return selectModuleIdByNameAndVersionStatement
+                .template value<ModuleId>(module.name, module.version.version);
         }
 
-        return selectImportIdByNameStatement.template value<ImportId>(import.name);
+        return selectModuleIdByNameStatement.template value<ModuleId>(module.name);
     }
 
     void handleAliasPropertyDeclarationsWithPropertyType(
@@ -845,20 +845,20 @@ private:
         updateAliasPropertyDeclarationValues(updatedAliasPropertyDeclarations);
     }
 
-    void upsertExportedType(ImportId importId, Utils::SmallStringView name, TypeId typeId)
+    void upsertExportedType(ModuleId moduleId, Utils::SmallStringView name, TypeId typeId)
     {
-        upsertTypeNamesStatement.write(&importId,
+        upsertTypeNamesStatement.write(&moduleId,
                                        name,
-                                       &typeId,
-                                       static_cast<long long>(Storage::TypeNameKind::Exported));
+                                       static_cast<long long>(Storage::TypeNameKind::Exported),
+                                       -1,
+                                       -1,
+                                       &typeId);
     }
 
-    void upsertNativeType(ImportId importId, Utils::SmallStringView name, TypeId typeId)
+    void upsertNativeType(ModuleId moduleId, Utils::SmallStringView name, TypeId typeId)
     {
-        upsertTypeNamesStatement.write(&importId,
-                                       name,
-                                       &typeId,
-                                       static_cast<long long>(Storage::TypeNameKind::Native));
+        upsertTypeNamesStatement.write(
+            &moduleId, name, static_cast<long long>(Storage::TypeNameKind::Native), -1, -1, &typeId);
     }
 
     void synchronizePropertyDeclarationsInsertAlias(
@@ -1040,38 +1040,38 @@ private:
         Sqlite::insertUpdateDelete(range, aliasDeclarations, compareKey, insert, update, remove);
     }
 
-    ImportIds fetchImportIdsUnguarded(const Storage::Imports &imports)
+    ModuleIds fetchModuleIdsUnguarded(const Storage::Modules &modules)
     {
-        ImportIds importIds;
-        importIds.reserve(importIds.size());
+        ModuleIds moduleIds;
+        moduleIds.reserve(moduleIds.size());
 
-        for (auto &&import : imports)
-            importIds.push_back(fetchImportId(import));
+        for (auto &&module : modules)
+            moduleIds.push_back(fetchModuleId(module));
 
-        return importIds;
+        return moduleIds;
     }
 
-    void synchronizeDocumentImports(SourceId sourceId, const Storage::Imports &imports)
+    void synchronizeDocumentModules(SourceId sourceId, const Storage::Modules &modules)
     {
-        ImportIds importIds = fetchImportIdsUnguarded(imports);
+        ModuleIds moduleIds = fetchModuleIdsUnguarded(modules);
 
-        std::sort(importIds.begin(), importIds.end());
+        std::sort(moduleIds.begin(), moduleIds.end());
 
-        auto range = selectImportIdsForSourceIdStatement.template range<ImportId>(&sourceId);
+        auto range = selectModuleIdsForSourceIdStatement.template range<ModuleId>(&sourceId);
 
-        auto compareKey = [](ImportId first, ImportId second) { return first.id - second.id; };
+        auto compareKey = [](ModuleId first, ModuleId second) { return first.id - second.id; };
 
-        auto insert = [&](ImportId importId) {
-            insertImportIdForSourceIdStatement.write(&sourceId, &importId);
+        auto insert = [&](ModuleId moduleId) {
+            insertModuleIdForSourceIdStatement.write(&sourceId, &moduleId);
         };
 
-        auto update = [](ImportId, ImportId) {};
+        auto update = [](ModuleId, ModuleId) {};
 
-        auto remove = [&](ImportId importId) {
-            deleteImportIdForSourceIdStatement.write(&sourceId, &importId);
+        auto remove = [&](ModuleId moduleId) {
+            deleteModuleIdForSourceIdStatement.write(&sourceId, &moduleId);
         };
 
-        Sqlite::insertUpdateDelete(range, importIds, compareKey, insert, update, remove);
+        Sqlite::insertUpdateDelete(range, moduleIds, compareKey, insert, update, remove);
     }
 
     Utils::PathString createJson(const Storage::ParameterDeclarations &parameters)
@@ -1246,28 +1246,28 @@ private:
 
     TypeId declareType(Storage::Type &type)
     {
-        if (type.import.name.isEmpty() && type.typeName.isEmpty()) {
+        if (type.module.name.isEmpty() && type.typeName.isEmpty()) {
             type.typeId = selectTypeIdBySourceIdStatement.template value<TypeId>(&type.sourceId);
             return type.typeId;
         }
 
-        ImportId importId = fetchImportId(type.import);
+        ModuleId moduleId = fetchModuleId(type.module);
 
-        if (!importId)
-            throw ImportDoesNotExists{};
+        if (!moduleId)
+            throw ModuleDoesNotExists{};
 
-        type.typeId = upsertTypeStatement.template value<TypeId>(&importId,
+        type.typeId = upsertTypeStatement.template value<TypeId>(&moduleId,
                                                                  type.typeName,
                                                                  static_cast<int>(type.accessSemantics),
                                                                  &type.sourceId);
 
         if (!type.typeId)
-            type.typeId = selectTypeIdByImportIdAndNameStatement.template value<TypeId>(&importId,
+            type.typeId = selectTypeIdByModuleIdAndNameStatement.template value<TypeId>(&moduleId,
                                                                                         type.typeName);
-        upsertNativeType(importId, type.typeName, type.typeId);
+        upsertNativeType(moduleId, type.typeName, type.typeId);
 
         for (const auto &exportedType : type.exportedTypes)
-            upsertExportedType(importId, exportedType.name, type.typeId);
+            upsertExportedType(moduleId, exportedType.name, type.typeId);
 
         return type.typeId;
     }
@@ -1367,27 +1367,27 @@ private:
         {
             auto operator()(const Storage::NativeType &nativeType)
             {
-                return storage.selectTypeIdByImportIdsFromSourceIdAndNameStatement
+                return storage.selectTypeIdByModuleIdsFromSourceIdAndNameStatement
                     .template value<TypeIdAndTypeNameId>(&sourceId, nativeType.name);
             }
 
             auto operator()(const Storage::ExportedType &exportedType)
             {
-                return storage.selectTypeIdByImportIdsFromSourceIdAndExportedNameStatement
+                return storage.selectTypeIdByModuleIdsFromSourceIdAndExportedNameStatement
                     .template value<TypeIdAndTypeNameId>(&sourceId, exportedType.name);
             }
 
             auto operator()(const Storage::ExplicitExportedType &exportedType)
             {
-                if (exportedType.import.version) {
-                    return storage.selectTypeIdByImportNameAndVersionAndExportedNameStatement
-                        .template value<TypeIdAndTypeNameId>(exportedType.import.name,
-                                                             exportedType.import.version.version,
+                if (exportedType.module.version) {
+                    return storage.selectTypeIdByModuleNameAndVersionAndExportedNameStatement
+                        .template value<TypeIdAndTypeNameId>(exportedType.module.name,
+                                                             exportedType.module.version.version,
                                                              exportedType.name);
                 }
 
-                return storage.selectTypeIdByImportNameAndExportedNameStatement
-                    .template value<TypeIdAndTypeNameId>(exportedType.import.name, exportedType.name);
+                return storage.selectTypeIdByModuleNameAndExportedNameStatement
+                    .template value<TypeIdAndTypeNameId>(exportedType.module.name, exportedType.name);
             }
 
             ProjectStorage &storage;
@@ -1542,8 +1542,8 @@ private:
             if (!isInitialized) {
                 Sqlite::ExclusiveTransaction transaction{database};
 
-                createImportsTable(database);
-                createImportDependeciesTable(database);
+                createModulesTable(database);
+                createModuleDependeciesTable(database);
                 createSourceContextsTable(database);
                 createSourcesTable(database);
                 createTypesAndePropertyDeclarationsTables(database);
@@ -1551,7 +1551,7 @@ private:
                 createEnumerationsTable(database);
                 createFunctionsTable(database);
                 createSignalsTable(database);
-                createSourceImportsTable(database);
+                createSourceModulesTable(database);
                 createFileStatusesTable(database);
 
                 transaction.commit();
@@ -1599,7 +1599,7 @@ private:
             typesTable.setUseIfNotExists(true);
             typesTable.setName("types");
             typesTable.addColumn("typeId", Sqlite::ColumnType::Integer, {Sqlite::PrimaryKey{}});
-            auto &importIdColumn = typesTable.addColumn("importId");
+            auto &moduleIdColumn = typesTable.addColumn("moduleId");
             auto &typesNameColumn = typesTable.addColumn("name");
             typesTable.addColumn("accessSemantics");
             typesTable.addColumn("sourceId");
@@ -1609,7 +1609,7 @@ private:
                                            Sqlite::ForeignKeyAction::Restrict);
             typesTable.addColumn("prototypeNameId");
 
-            typesTable.addUniqueIndex({importIdColumn, typesNameColumn});
+            typesTable.addUniqueIndex({moduleIdColumn, typesNameColumn});
 
             typesTable.initialize(database);
 
@@ -1648,12 +1648,14 @@ private:
             table.setUseIfNotExists(true);
             table.setName("typeNames");
             table.addColumn("typeNameId", Sqlite::ColumnType::Integer, {Sqlite::PrimaryKey{}});
-            auto &importIdColumn = table.addColumn("importId");
+            auto &moduleIdColumn = table.addColumn("moduleId");
             auto &nameColumn = table.addColumn("name");
             auto &kindColumn = table.addColumn("kind");
+            table.addColumn("majorVersion");
+            table.addColumn("minorVersion");
             table.addColumn("typeId");
 
-            table.addUniqueIndex({importIdColumn, nameColumn, kindColumn});
+            table.addUniqueIndex({moduleIdColumn, nameColumn, kindColumn});
 
             table.initialize(database);
         }
@@ -1708,12 +1710,12 @@ private:
             table.initialize(database);
         }
 
-        void createImportsTable(Database &database)
+        void createModulesTable(Database &database)
         {
             Sqlite::Table table;
             table.setUseIfNotExists(true);
-            table.setName("imports");
-            table.addColumn("importId", Sqlite::ColumnType::Integer, {Sqlite::PrimaryKey{}});
+            table.setName("modules");
+            table.addColumn("moduleId", Sqlite::ColumnType::Integer, {Sqlite::PrimaryKey{}});
             auto &nameColumn = table.addColumn("name");
             auto &versionColumn = table.addColumn("version");
 
@@ -1722,30 +1724,30 @@ private:
             table.initialize(database);
         }
 
-        void createImportDependeciesTable(Database &database)
+        void createModuleDependeciesTable(Database &database)
         {
             Sqlite::Table table;
             table.setUseIfNotExists(true);
             table.setUseWithoutRowId(true);
-            table.setName("importDependencies");
-            auto &importIdColumn = table.addColumn("importId");
-            auto &parentImportIdColumn = table.addColumn("parentImportId");
+            table.setName("moduleDependencies");
+            auto &moduleIdColumn = table.addColumn("moduleId");
+            auto &parentModuleIdColumn = table.addColumn("parentModuleId");
 
-            table.addPrimaryKeyContraint({importIdColumn, parentImportIdColumn});
+            table.addPrimaryKeyContraint({moduleIdColumn, parentModuleIdColumn});
 
             table.initialize(database);
         }
 
-        void createSourceImportsTable(Database &database)
+        void createSourceModulesTable(Database &database)
         {
             Sqlite::Table table;
             table.setUseIfNotExists(true);
             table.setUseWithoutRowId(true);
-            table.setName("documentImports");
+            table.setName("documentModules");
             auto &sourceIdColumn = table.addColumn("sourceId");
-            auto &importIdColumn = table.addColumn("importId");
+            auto &moduleIdColumn = table.addColumn("moduleId");
 
-            table.addPrimaryKeyContraint({sourceIdColumn, importIdColumn});
+            table.addPrimaryKeyContraint({sourceIdColumn, moduleIdColumn});
 
             table.initialize(database);
         }
@@ -1773,7 +1775,7 @@ public:
     Database &database;
     Initializer initializer;
     ReadWriteStatement<1> upsertTypeStatement{
-        "INSERT INTO types(importId, name,  accessSemantics, sourceId) VALUES(?1, ?2, "
+        "INSERT INTO types(moduleId, name,  accessSemantics, sourceId) VALUES(?1, ?2, "
         "?3, nullif(?4, -1)) ON CONFLICT DO UPDATE SET  accessSemantics=excluded.accessSemantics, "
         "sourceId=excluded.sourceId WHERE accessSemantics IS NOT excluded.accessSemantics OR "
         "sourceId IS NOT excluded.sourceId RETURNING typeId",
@@ -1814,8 +1816,11 @@ public:
         "  WHERE name=?2 ORDER BY level LIMIT 1",
         database};
     WriteStatement upsertTypeNamesStatement{
-        "INSERT INTO typeNames(importId, name, typeId, kind) VALUES(?1, ?2, ?3, ?4) ON CONFLICT DO "
-        "UPDATE SET typeId=excluded.typeId WHERE typeId IS NOT excluded.typeId",
+        "INSERT INTO typeNames(moduleId, name, kind, majorVersion, minorVersion, typeId) "
+        "VALUES(?1, ?2, ?3, ?4, ?5, ?6) ON CONFLICT DO UPDATE SET typeId=excluded.typeId, "
+        "majorVersion=excluded.majorVersion, minorVersion=excluded.minorVersion WHERE typeId IS "
+        "NOT excluded.typeId OR majorVersion IS NOT excluded.majorVersion OR minorVersion IS NOT "
+        "excluded.minorVersion",
         database};
     mutable ReadStatement<1> selectPrototypeIdsStatement{
         "WITH RECURSIVE "
@@ -1844,14 +1849,14 @@ public:
         "INSERT INTO sources(sourceContextId, sourceName) VALUES (?,?)", database};
     mutable ReadStatement<3> selectAllSourcesStatement{
         "SELECT sourceName, sourceContextId, sourceId  FROM sources", database};
-    mutable ReadStatement<1> selectTypeIdByImportIdsAndNameStatement{
-        "SELECT typeId FROM types WHERE importId IN carray(?1, ?2, 'int64') AND name=?3", database};
-    mutable ReadStatement<2> selectTypeIdByImportIdsFromSourceIdAndNameStatement{
-        "SELECT typeId, typeNameId FROM typeNames JOIN documentImports AS di USING(importId) WHERE "
+    mutable ReadStatement<1> selectTypeIdByModuleIdsAndNameStatement{
+        "SELECT typeId FROM types WHERE moduleId IN carray(?1, ?2, 'int64') AND name=?3", database};
+    mutable ReadStatement<2> selectTypeIdByModuleIdsFromSourceIdAndNameStatement{
+        "SELECT typeId, typeNameId FROM typeNames JOIN documentModules AS di USING(moduleId) WHERE "
         "  name=?2 AND kind=0 AND di.sourceId=?1 LIMIT 1",
         database};
     mutable ReadStatement<5> selectTypeByTypeIdStatement{
-        "SELECT importId, name, (SELECT name FROM types WHERE typeId=outerTypes.prototypeId), "
+        "SELECT moduleId, name, (SELECT name FROM types WHERE typeId=outerTypes.prototypeId), "
         "accessSemantics, ifnull(sourceId, -1) FROM types AS outerTypes WHERE typeId=?",
         database};
     mutable ReadStatement<1> selectExportedTypesByTypeIdStatement{
@@ -1859,7 +1864,7 @@ public:
     mutable ReadStatement<7> selectTypesStatement{
         "SELECT i.name, i.version, t.name, typeId, (SELECT name FROM types WHERE "
         "typeId=t.prototypeId), accessSemantics, ifnull(sourceId, -1) FROM types AS "
-        "t JOIN imports AS i USING (importId)",
+        "t JOIN modules AS i USING (moduleId)",
         database};
     ReadStatement<1> selectNotUpdatedTypesInSourcesStatement{
         "SELECT typeId FROM types WHERE (sourceId IN carray(?1) AND typeId NOT IN carray(?2))",
@@ -2005,76 +2010,76 @@ public:
         database};
     WriteStatement deleteEnumerationDeclarationStatement{
         "DELETE FROM enumerationDeclarations WHERE enumerationDeclarationId=?", database};
-    WriteStatement insertImportStatement{
-        "INSERT INTO imports(name, version, importId) VALUES(?1, ?2, ?3)", database};
-    WriteStatement updateImportStatement{"UPDATE imports SET name=?2, version=?3 WHERE importId=?1",
+    WriteStatement insertModuleStatement{
+        "INSERT INTO modules(name, version, moduleId) VALUES(?1, ?2, ?3)", database};
+    WriteStatement updateModuleStatement{"UPDATE modules SET name=?2, version=?3 WHERE moduleId=?1",
                                          database};
-    WriteStatement deleteImportStatement{"DELETE FROM imports WHERE importId=?", database};
-    mutable ReadStatement<1> selectImportIdByNameStatement{
-        "SELECT importId FROM imports WHERE name=? ORDER BY version DESC LIMIT 1", database};
-    mutable ReadStatement<1> selectImportIdByNameAndVersionStatement{
-        "SELECT importId FROM imports WHERE name=? AND version=?", database};
-    mutable ReadStatement<3> selectImportsForIdsStatement{
-        "SELECT name, version, importId FROM imports WHERE importId IN carray(?1) ORDER BY "
-        "importId",
+    WriteStatement deleteModuleStatement{"DELETE FROM modules WHERE moduleId=?", database};
+    mutable ReadStatement<1> selectModuleIdByNameStatement{
+        "SELECT moduleId FROM modules WHERE name=? ORDER BY version DESC LIMIT 1", database};
+    mutable ReadStatement<1> selectModuleIdByNameAndVersionStatement{
+        "SELECT moduleId FROM modules WHERE name=? AND version=?", database};
+    mutable ReadStatement<3> selectModulesForIdsStatement{
+        "SELECT name, version, moduleId FROM modules WHERE moduleId IN carray(?1) ORDER BY "
+        "moduleId",
         database};
-    mutable ReadStatement<3> selectAllImportsStatement{
-        "SELECT name, version, importId FROM imports ORDER BY importId", database};
-    WriteStatement insertImportDependencyStatement{
-        "INSERT INTO importDependencies(importId, parentImportId) VALUES(?1, ?2)", database};
-    WriteStatement deleteImportDependencyStatement{
-        "DELETE FROM importDependencies WHERE importId=?1 AND parentImportId=?2", database};
-    mutable ReadStatement<2> selectImportDependenciesForIdsStatement{
-        "SELECT importId, parentImportId FROM importDependencies WHERE importId IN carray(?1) "
-        "ORDER BY importId, parentImportId",
+    mutable ReadStatement<3> selectAllModulesStatement{
+        "SELECT name, version, moduleId FROM modules ORDER BY moduleId", database};
+    WriteStatement insertModuleDependencyStatement{
+        "INSERT INTO moduleDependencies(moduleId, parentModuleId) VALUES(?1, ?2)", database};
+    WriteStatement deleteModuleDependencyStatement{
+        "DELETE FROM moduleDependencies WHERE moduleId=?1 AND parentModuleId=?2", database};
+    mutable ReadStatement<2> selectModuleDependenciesForIdsStatement{
+        "SELECT moduleId, parentModuleId FROM moduleDependencies WHERE moduleId IN carray(?1) "
+        "ORDER BY moduleId, parentModuleId",
         database};
-    mutable ReadStatement<2> selectImportsForThatDependentOnThisImportIdStatement{
-        "SELECT name, version FROM importDependencies JOIN imports ON "
-        "importDependencies.parentImportId = imports.importId WHERE importDependencies.importId=?",
+    mutable ReadStatement<2> selectModulesForThatDependentOnThisModuleIdStatement{
+        "SELECT name, version FROM moduleDependencies JOIN modules ON "
+        "moduleDependencies.parentModuleId = modules.moduleId WHERE moduleDependencies.moduleId=?",
         database};
-    mutable ReadStatement<1> selectTypeIdsForImportIdStatement{
-        "SELECT typeId FROM types WHERE importId=?", database};
-    mutable ReadStatement<1> selectTypeIdByImportIdAndNameStatement{
-        "SELECT typeId FROM types WHERE importId=?1 and name=?2", database};
-    mutable ReadStatement<1> selectTypeIdByImportIdsAndExportedNameStatement{
-        "SELECT typeId FROM typeNames WHERE importId IN carray(?1, ?2, 'int64') AND name=?3 AND "
+    mutable ReadStatement<1> selectTypeIdsForModuleIdStatement{
+        "SELECT typeId FROM types WHERE moduleId=?", database};
+    mutable ReadStatement<1> selectTypeIdByModuleIdAndNameStatement{
+        "SELECT typeId FROM types WHERE moduleId=?1 and name=?2", database};
+    mutable ReadStatement<1> selectTypeIdByModuleIdsAndExportedNameStatement{
+        "SELECT typeId FROM typeNames WHERE moduleId IN carray(?1, ?2, 'int64') AND name=?3 AND "
         "kind=1",
         database};
-    mutable ReadStatement<2> selectTypeIdByImportIdsFromSourceIdAndExportedNameStatement{
-        "SELECT typeId, typeNameId FROM typeNames JOIN documentImports AS di USING(importId) WHERE "
+    mutable ReadStatement<2> selectTypeIdByModuleIdsFromSourceIdAndExportedNameStatement{
+        "SELECT typeId, typeNameId FROM typeNames JOIN documentModules AS di USING(moduleId) WHERE "
         "name=?2 AND kind=1 AND di.sourceId=?1 LIMIT 1",
         database};
-    mutable ReadStatement<2> selectTypeIdByImportNameAndExportedNameStatement{
+    mutable ReadStatement<2> selectTypeIdByModuleNameAndExportedNameStatement{
         "WITH RECURSIVE "
-        "  highestImport(importId) AS ( "
-        "    SELECT importId FROM imports WHERE name=?1 ORDER BY version DESC LIMIT 1) "
-        "SELECT typeId, -typeNameId FROM typeNames JOIN highestImport USING(importId) WHERE "
+        "  highestModule(moduleId) AS ( "
+        "    SELECT moduleId FROM modules WHERE name=?1 ORDER BY version DESC LIMIT 1) "
+        "SELECT typeId, -typeNameId FROM typeNames JOIN highestModule USING(moduleId) WHERE "
         "  name=?2 AND kind=1 LIMIT 1",
         database};
-    mutable ReadStatement<2> selectTypeIdByImportNameAndVersionAndExportedNameStatement{
+    mutable ReadStatement<2> selectTypeIdByModuleNameAndVersionAndExportedNameStatement{
         "WITH RECURSIVE "
-        "  highestImport(importId) AS ( "
-        "    SELECT importId FROM imports WHERE name=?1 AND version=?2 ORDER BY version DESC LIMIT "
+        "  highestModule(moduleId) AS ( "
+        "    SELECT moduleId FROM modules WHERE name=?1 AND version=?2 ORDER BY version DESC LIMIT "
         "      1) "
-        "SELECT typeId, -typeNameId FROM typeNames JOIN highestImport USING(importId) WHERE "
+        "SELECT typeId, -typeNameId FROM typeNames JOIN highestModule USING(moduleId) WHERE "
         "  name=?3 AND kind=1 LIMIT 1",
         database};
-    mutable ReadStatement<1> fetchImportDependencyIdsStatement{
+    mutable ReadStatement<1> fetchModuleDependencyIdsStatement{
         "WITH RECURSIVE "
-        "  importIds(importId) AS ("
+        "  moduleIds(moduleId) AS ("
         "      SELECT value FROM carray(?1, ?2, 'int64') "
         "    UNION "
-        "      SELECT parentImportId FROM importDependencies JOIN importIds USING(importId)) "
-        "SELECT importId FROM importIds",
+        "      SELECT parentModuleId FROM moduleDependencies JOIN moduleIds USING(moduleId)) "
+        "SELECT moduleId FROM moduleIds",
         database};
-    mutable ReadStatement<1> selectImportIdsForSourceIdStatement{
-        "SELECT importId FROM documentImports WHERE sourceId=? ORDER BY importId", database};
-    WriteStatement insertImportIdForSourceIdStatement{
-        "INSERT INTO documentImports(sourceId, importId) VALUES (?1, ?2)", database};
-    WriteStatement deleteImportIdForSourceIdStatement{
-        "DELETE FROM documentImports WHERE sourceId=?1 AND importId=?2", database};
-    WriteStatement deleteDocumentImportsWithSourceIdsStatement{
-        "DELETE FROM documentImports WHERE sourceId=?1 IN carray(?1)", database};
+    mutable ReadStatement<1> selectModuleIdsForSourceIdStatement{
+        "SELECT moduleId FROM documentModules WHERE sourceId=? ORDER BY moduleId", database};
+    WriteStatement insertModuleIdForSourceIdStatement{
+        "INSERT INTO documentModules(sourceId, moduleId) VALUES (?1, ?2)", database};
+    WriteStatement deleteModuleIdForSourceIdStatement{
+        "DELETE FROM documentModules WHERE sourceId=?1 AND moduleId=?2", database};
+    WriteStatement deleteDocumentModulesWithSourceIdsStatement{
+        "DELETE FROM documentModules WHERE sourceId=?1 IN carray(?1)", database};
     ReadStatement<1> selectPropertyDeclarationIdPrototypeChainDownStatement{
         "WITH RECURSIVE "
         "  typeSelection(typeId, level) AS ("
@@ -2130,7 +2135,7 @@ public:
     ReadStatement<2> selectTypeNameStatement{"SELECT name, kind FROM typeNames WHERE typeNameId=?",
                                              database};
     ReadStatement<3> selectExplicitTypeNameStatement{
-        "SELECT  tn.name, i.name, i.version FROM typeNames AS tn JOIN imports AS i USING(importId) "
+        "SELECT  tn.name, i.name, i.version FROM typeNames AS tn JOIN modules AS i USING(moduleId) "
         "WHERE typeNameId=? AND kind=1",
         database};
     ReadStatement<1> selectPropertyNameStatement{
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstorageexceptions.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstorageexceptions.h
index b71ca27122d..0d23e116050 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstorageexceptions.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstorageexceptions.h
@@ -71,10 +71,10 @@ public:
     const char *what() const noexcept override { return "The source id is invalid!"; }
 };
 
-class ImportDoesNotExists : std::exception
+class ModuleDoesNotExists : std::exception
 {
 public:
-    const char *what() const noexcept override { return "The import does not exist!"; }
+    const char *what() const noexcept override { return "The module does not exist!"; }
 };
 
 class TypeNameDoesNotExists : std::exception
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstorageinterface.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstorageinterface.h
index fc43d104ea5..713a1f727c6 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstorageinterface.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstorageinterface.h
@@ -33,7 +33,7 @@ namespace QmlDesigner {
 class ProjectStorageInterface
 {
 public:
-    virtual void synchronize(Storage::ImportDependencies importDependencies,
+    virtual void synchronize(Storage::ModuleDependencies moduleDependencies,
                              Storage::Documents documents,
                              Storage::Types types,
                              SourceIds sourceIds,
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h
index 1247820494c..1303af720c7 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h
@@ -110,22 +110,22 @@ public:
     VersionNumber minor;
 };
 
-class Import
+class Module
 {
 public:
-    explicit Import() = default;
+    explicit Module() = default;
 
-    explicit Import(Utils::SmallStringView name, VersionNumber version = VersionNumber{})
+    explicit Module(Utils::SmallStringView name, VersionNumber version = VersionNumber{})
         : name{name}
         , version{version}
     {}
 
-    explicit Import(Utils::SmallStringView name, int version)
+    explicit Module(Utils::SmallStringView name, int version)
         : name{name}
         , version{version}
     {}
 
-    friend bool operator==(const Import &first, const Import &second)
+    friend bool operator==(const Module &first, const Module &second)
     {
         return first.name == second.name && first.version == second.version;
     }
@@ -135,7 +135,7 @@ public:
     VersionNumber version;
 };
 
-using Imports = std::vector<Import>;
+using Modules = std::vector<Module>;
 
 class ExportedType
 {
@@ -158,19 +158,19 @@ class ExplicitExportedType
 {
 public:
     explicit ExplicitExportedType() = default;
-    explicit ExplicitExportedType(Utils::SmallStringView name, Import import)
+    explicit ExplicitExportedType(Utils::SmallStringView name, Module module)
         : name{name}
-        , import{std::move(import)}
+        , module{std::move(module)}
     {}
 
     friend bool operator==(const ExplicitExportedType &first, const ExplicitExportedType &second)
     {
-        return first.name == second.name && first.import == second.import;
+        return first.name == second.name && first.module == second.module;
     }
 
 public:
     Utils::SmallString name;
-    Import import;
+    Module module;
 };
 
 using ExportedTypes = std::vector<ExportedType>;
@@ -485,7 +485,7 @@ class Type
 {
 public:
     explicit Type() = default;
-    explicit Type(Import import,
+    explicit Type(Module module,
                   Utils::SmallStringView typeName,
                   TypeName prototype,
                   TypeAccessSemantics accessSemantics,
@@ -503,28 +503,28 @@ public:
         , functionDeclarations{std::move(functionDeclarations)}
         , signalDeclarations{std::move(signalDeclarations)}
         , enumerationDeclarations{std::move(enumerationDeclarations)}
-        , import{std::move(import)}
+        , module{std::move(module)}
         , accessSemantics{accessSemantics}
         , sourceId{sourceId}
         , typeId{typeId}
     {}
 
-    explicit Type(Utils::SmallStringView importName,
-                  int importVersion,
+    explicit Type(Utils::SmallStringView moduleName,
+                  int moduleVersion,
                   Utils::SmallStringView typeName,
                   Utils::SmallStringView prototype,
                   int accessSemantics,
                   int sourceId)
         : typeName{typeName}
         , prototype{NativeType{prototype}}
-        , import{importName, importVersion}
+        , module{moduleName, moduleVersion}
         , accessSemantics{static_cast<TypeAccessSemantics>(accessSemantics)}
         , sourceId{sourceId}
 
     {}
 
-    explicit Type(Utils::SmallStringView importName,
-                  int importVersion,
+    explicit Type(Utils::SmallStringView moduleName,
+                  int moduleVersion,
                   Utils::SmallStringView typeName,
                   long long typeId,
                   Utils::SmallStringView prototype,
@@ -532,7 +532,7 @@ public:
                   int sourceId)
         : typeName{typeName}
         , prototype{NativeType{prototype}}
-        , import{importName, importVersion}
+        , module{moduleName, moduleVersion}
         , accessSemantics{static_cast<TypeAccessSemantics>(accessSemantics)}
         , sourceId{sourceId}
         , typeId{typeId}
@@ -545,7 +545,7 @@ public:
                && first.propertyDeclarations == second.propertyDeclarations
                && first.functionDeclarations == second.functionDeclarations
                && first.signalDeclarations == second.signalDeclarations
-               && first.import == second.import && first.sourceId == second.sourceId
+               && first.module == second.module && first.sourceId == second.sourceId
                && first.sourceId == second.sourceId;
     }
 
@@ -557,7 +557,7 @@ public:
     FunctionDeclarations functionDeclarations;
     SignalDeclarations signalDeclarations;
     EnumerationDeclarations enumerationDeclarations;
-    Import import;
+    Module module;
     TypeAccessSemantics accessSemantics = TypeAccessSemantics::Invalid;
     SourceId sourceId;
     TypeId typeId;
@@ -569,58 +569,58 @@ class Document
 {
 public:
     explicit Document() = default;
-    explicit Document(SourceId sourceId, Imports imports)
-        : imports{std::move(imports)}
+    explicit Document(SourceId sourceId, Modules modules)
+        : modules{std::move(modules)}
         , sourceId{sourceId}
     {}
 
 public:
-    Imports imports;
+    Modules modules;
     SourceId sourceId;
 };
 
 using Documents = std::vector<Document>;
 
-class ImportDependency : public Import
+class ModuleDependency : public Module
 {
 public:
-    explicit ImportDependency(Utils::SmallStringView name,
+    explicit ModuleDependency(Utils::SmallStringView name,
                               VersionNumber version,
                               SourceId sourceId,
-                              Imports importDependencies = {})
-        : Import(name, version)
-        , dependencies{std::move(importDependencies)}
+                              Modules moduleDependencies = {})
+        : Module(name, version)
+        , dependencies{std::move(moduleDependencies)}
         , sourceId{sourceId}
     {}
 
-    explicit ImportDependency(Utils::SmallStringView name, int version, int sourceId)
-        : Import(name, version)
+    explicit ModuleDependency(Utils::SmallStringView name, int version, int sourceId)
+        : Module(name, version)
         , sourceId{sourceId}
     {}
 
-    friend bool operator==(const ImportDependency &first, const ImportDependency &second)
+    friend bool operator==(const ModuleDependency &first, const ModuleDependency &second)
     {
-        return static_cast<const Import &>(first) == static_cast<const Import &>(second)
+        return static_cast<const Module &>(first) == static_cast<const Module &>(second)
                && first.sourceId == second.sourceId && first.dependencies == second.dependencies;
     }
 
 public:
-    Imports dependencies;
+    Modules dependencies;
     SourceId sourceId;
 };
 
-using ImportDependencies = std::vector<ImportDependency>;
+using ModuleDependencies = std::vector<ModuleDependency>;
 
-class ImportView
+class ModuleView
 {
 public:
-    explicit ImportView(Utils::SmallStringView name, int version, int sourceId)
+    explicit ModuleView(Utils::SmallStringView name, int version, int sourceId)
         : name{name}
         , version{version}
         , sourceId{sourceId}
     {}
 
-    friend bool operator==(const ImportView &first, const ImportView &second)
+    friend bool operator==(const ModuleView &first, const ModuleView &second)
     {
         return first.name == second.name && first.version == second.version
                && first.sourceId == second.sourceId;
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.cpp b/src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.cpp
index 9eb05a0cbb4..da056777879 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.cpp
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.cpp
@@ -52,7 +52,7 @@ ComponentReferences createComponentReferences(const QMultiHash<QString, QmlDirPa
 
 void ProjectUpdater::update()
 {
-    Storage::ImportDependencies importDependencies;
+    Storage::ModuleDependencies moduleDependencies;
     Storage::Documents documents;
     Storage::Types types;
     SourceIds sourceIds;
@@ -72,18 +72,18 @@ void ProjectUpdater::update()
             Utils::SmallString moduleName{parser.typeNamespace()};
             SourceContextId directoryId = m_pathCache.sourceContextId(qmlDirSourceId);
 
-            parseTypeInfos(parser.typeInfos(), directoryId, importDependencies, types, sourceIds);
+            parseTypeInfos(parser.typeInfos(), directoryId, moduleDependencies, types, sourceIds);
             parseQmlComponents(createComponentReferences(parser.components()),
                                directoryId,
                                moduleName,
-                               importDependencies,
+                               moduleDependencies,
                                types,
                                sourceIds);
             break;
         }
         case FileState::NotChanged: {
             SourceIds qmltypesSourceIds = m_projectStorage.fetchSourceDependencieIds(qmlDirSourceId);
-            parseTypeInfos(qmltypesSourceIds, importDependencies, types, sourceIds);
+            parseTypeInfos(qmltypesSourceIds, moduleDependencies, types, sourceIds);
             break;
         }
         case FileState::NotExists: {
@@ -93,7 +93,7 @@ void ProjectUpdater::update()
         }
     }
 
-    m_projectStorage.synchronize(std::move(importDependencies),
+    m_projectStorage.synchronize(std::move(moduleDependencies),
                                  std::move(documents),
                                  std::move(types),
                                  std::move(sourceIds),
@@ -102,7 +102,7 @@ void ProjectUpdater::update()
 
 void ProjectUpdater::parseTypeInfos(const QStringList &typeInfos,
                                     SourceContextId directoryId,
-                                    Storage::ImportDependencies &importDependencies,
+                                    Storage::ModuleDependencies &moduleDependencies,
                                     Storage::Types &types,
                                     SourceIds &sourceIds)
 {
@@ -112,39 +112,39 @@ void ProjectUpdater::parseTypeInfos(const QStringList &typeInfos,
         SourceId sourceId = m_pathCache.sourceId(directoryId, Utils::SmallString{typeInfo});
         QString qmltypesPath = directory + "/" + typeInfo;
 
-        parseTypeInfo(sourceId, qmltypesPath, importDependencies, types, sourceIds);
+        parseTypeInfo(sourceId, qmltypesPath, moduleDependencies, types, sourceIds);
     }
 }
 
 void ProjectUpdater::parseTypeInfos(const SourceIds &qmltypesSourceIds,
-                                    Storage::ImportDependencies &importDependencies,
+                                    Storage::ModuleDependencies &moduleDependencies,
                                     Storage::Types &types,
                                     SourceIds &sourceIds)
 {
     for (SourceId sourceId : qmltypesSourceIds) {
         QString qmltypesPath = m_pathCache.sourcePath(sourceId).toQString();
 
-        parseTypeInfo(sourceId, qmltypesPath, importDependencies, types, sourceIds);
+        parseTypeInfo(sourceId, qmltypesPath, moduleDependencies, types, sourceIds);
     }
 }
 
 void ProjectUpdater::parseTypeInfo(SourceId sourceId,
                                    const QString &qmltypesPath,
-                                   Storage::ImportDependencies &importDependencies,
+                                   Storage::ModuleDependencies &moduleDependencies,
                                    Storage::Types &types,
                                    SourceIds &sourceIds)
 {
     if (fileState(sourceId) == FileState::Changed) {
         sourceIds.push_back(sourceId);
         const auto content = m_fileSystem.contentAsQString(qmltypesPath);
-        m_qmlTypesParser.parse(content, importDependencies, types, sourceIds);
+        m_qmlTypesParser.parse(content, moduleDependencies, types, sourceIds);
     }
 }
 
 void ProjectUpdater::parseQmlComponents(ComponentReferences components,
                                         SourceContextId directoryId,
                                         Utils::SmallStringView moduleName,
-                                        Storage::ImportDependencies &importDependencies,
+                                        Storage::ModuleDependencies &moduleDependencies,
                                         Storage::Types &types,
                                         SourceIds &sourceIds)
 {
@@ -172,8 +172,8 @@ void ProjectUpdater::parseQmlComponents(ComponentReferences components,
         auto type = m_qmlDocumentParser.parse(content);
 
         type.typeName = fileName;
-        type.import.name = moduleName;
-        type.import.version.version = component.majorVersion;
+        type.module.name = moduleName;
+        type.module.version.version = component.majorVersion;
         type.accessSemantics = Storage::TypeAccessSemantics::Reference;
         type.sourceId = sourceId;
         type.exportedTypes.push_back(Storage::ExportedType{Utils::SmallString{component.typeName}});
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.h
index ff8275377c7..cbfe1e45454 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.h
@@ -85,22 +85,22 @@ private:
 
     void parseTypeInfos(const QStringList &typeInfos,
                         SourceContextId directoryId,
-                        Storage::ImportDependencies &importDependencies,
+                        Storage::ModuleDependencies &moduleDependencies,
                         Storage::Types &types,
                         SourceIds &sourceIds);
     void parseTypeInfos(const SourceIds &qmltypesSourceIds,
-                        Storage::ImportDependencies &importDependencies,
+                        Storage::ModuleDependencies &moduleDependencies,
                         Storage::Types &types,
                         SourceIds &sourceIds);
     void parseTypeInfo(SourceId sourceId,
                        const QString &qmltypesPath,
-                       Storage::ImportDependencies &importDependencies,
+                       Storage::ModuleDependencies &moduleDependencies,
                        Storage::Types &types,
                        SourceIds &sourceIds);
     void parseQmlComponents(ComponentReferences components,
                             SourceContextId directoryId,
                             Utils::SmallStringView moduleName,
-                            Storage::ImportDependencies &importDependencies,
+                            Storage::ModuleDependencies &moduleDependencies,
                             Storage::Types &types,
                             SourceIds &sourceIds);
 
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/qmltypesparserinterface.h b/src/plugins/qmldesigner/designercore/projectstorage/qmltypesparserinterface.h
index 7f6239872ae..3c085766e48 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/qmltypesparserinterface.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/qmltypesparserinterface.h
@@ -35,7 +35,7 @@ class QmlTypesParserInterface
 {
 public:
     virtual void parse(const QString &sourceContent,
-                       Storage::ImportDependencies &importDependencies,
+                       Storage::ModuleDependencies &moduleDependencies,
                        Storage::Types &types,
                        SourceIds &sourceIds)
         = 0;
diff --git a/tests/unit/unittest/gtest-creator-printing.cpp b/tests/unit/unittest/gtest-creator-printing.cpp
index f158d4536b7..c1d26c388c8 100644
--- a/tests/unit/unittest/gtest-creator-printing.cpp
+++ b/tests/unit/unittest/gtest-creator-printing.cpp
@@ -1068,7 +1068,7 @@ std::ostream &operator<<(std::ostream &out, const ExportedType &exportedType)
 
 std::ostream &operator<<(std::ostream &out, const ExplicitExportedType &exportedType)
 {
-    return out << "(\"" << exportedType.name << "\", " << exportedType.import << ")";
+    return out << "(\"" << exportedType.name << "\", " << exportedType.module << ")";
 }
 
 std::ostream &operator<<(std::ostream &out, const NativeType &nativeType)
@@ -1079,7 +1079,7 @@ std::ostream &operator<<(std::ostream &out, const NativeType &nativeType)
 std::ostream &operator<<(std::ostream &out, const Type &type)
 {
     using Utils::operator<<;
-    return out << "(import: " << type.import << ", typename: \"" << type.typeName
+    return out << "(module: " << type.module << ", typename: \"" << type.typeName
                << "\", prototype: " << type.prototype << ", " << type.accessSemantics
                << ", source: " << type.sourceId << ", exports: " << type.exportedTypes
                << ", properties: " << type.propertyDeclarations
@@ -1149,15 +1149,15 @@ std::ostream &operator<<(std::ostream &out, const EnumerationDeclaration &enumer
                << enumerationDeclaration.enumeratorDeclarations << ")";
 }
 
-std::ostream &operator<<(std::ostream &out, const Import &import)
+std::ostream &operator<<(std::ostream &out, const Module &module)
 {
-    return out << "(" << import.name << ", " << import.version << ")";
+    return out << "(" << module.name << ", " << module.version << ")";
 }
 
-std::ostream &operator<<(std::ostream &out, const ImportDependency &import)
+std::ostream &operator<<(std::ostream &out, const ModuleDependency &module)
 {
-    return out << "(" << import.name << ", " << import.version << ", " << import.sourceId << ", "
-               << import.dependencies << ")";
+    return out << "(" << module.name << ", " << module.version << ", " << module.sourceId << ", "
+               << module.dependencies << ")";
 }
 
 } // namespace Storage
diff --git a/tests/unit/unittest/gtest-creator-printing.h b/tests/unit/unittest/gtest-creator-printing.h
index 26d27fd4239..26ff0ec8c75 100644
--- a/tests/unit/unittest/gtest-creator-printing.h
+++ b/tests/unit/unittest/gtest-creator-printing.h
@@ -259,8 +259,8 @@ class ParameterDeclaration;
 class SignalDeclaration;
 class EnumerationDeclaration;
 class EnumeratorDeclaration;
-class Import;
-class ImportDependency;
+class Module;
+class ModuleDependency;
 
 std::ostream &operator<<(std::ostream &out, TypeAccessSemantics accessSemantics);
 std::ostream &operator<<(std::ostream &out, VersionNumber versionNumber);
@@ -276,8 +276,8 @@ std::ostream &operator<<(std::ostream &out, const ParameterDeclaration &paramete
 std::ostream &operator<<(std::ostream &out, const SignalDeclaration &signalDeclaration);
 std::ostream &operator<<(std::ostream &out, const EnumerationDeclaration &enumerationDeclaration);
 std::ostream &operator<<(std::ostream &out, const EnumeratorDeclaration &enumeratorDeclaration);
-std::ostream &operator<<(std::ostream &out, const Import &import);
-std::ostream &operator<<(std::ostream &out, const ImportDependency &import);
+std::ostream &operator<<(std::ostream &out, const Module &module);
+std::ostream &operator<<(std::ostream &out, const ModuleDependency &module);
 
 } // namespace Storage
 
diff --git a/tests/unit/unittest/projectstorage-test.cpp b/tests/unit/unittest/projectstorage-test.cpp
index 2026e9d0e20..3a08fa4c3eb 100644
--- a/tests/unit/unittest/projectstorage-test.cpp
+++ b/tests/unit/unittest/projectstorage-test.cpp
@@ -38,7 +38,7 @@ namespace {
 
 using QmlDesigner::FileStatus;
 using QmlDesigner::FileStatuses;
-using QmlDesigner::ImportId;
+using QmlDesigner::ModuleId;
 using QmlDesigner::PropertyDeclarationId;
 using QmlDesigner::SourceContextId;
 using QmlDesigner::SourceId;
@@ -72,32 +72,32 @@ MATCHER_P2(IsSourceNameAndSourceContextId,
 }
 
 MATCHER_P5(IsStorageType,
-           import,
+           module,
            typeName,
            prototype,
            accessSemantics,
            sourceId,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::Type{import, typeName, prototype, accessSemantics, sourceId}))
+               + PrintToString(Storage::Type{module, typeName, prototype, accessSemantics, sourceId}))
 {
     const Storage::Type &type = arg;
 
-    return type.import == import && type.typeName == typeName
+    return type.module == module && type.typeName == typeName
            && type.accessSemantics == accessSemantics && type.sourceId == sourceId
            && Storage::TypeName{prototype} == type.prototype;
 }
 
 MATCHER_P4(IsStorageTypeWithInvalidSourceId,
-           import,
+           module,
            typeName,
            prototype,
            accessSemantics,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::Type{import, typeName, prototype, accessSemantics, SourceId{}}))
+               + PrintToString(Storage::Type{module, typeName, prototype, accessSemantics, SourceId{}}))
 {
     const Storage::Type &type = arg;
 
-    return type.import == import && type.typeName == typeName && type.prototype == prototype
+    return type.module == module && type.typeName == typeName && type.prototype == prototype
            && type.accessSemantics == accessSemantics && !type.sourceId.isValid();
 }
 
@@ -141,26 +141,26 @@ MATCHER_P4(IsPropertyDeclaration,
            && propertyDeclaration.traits == traits;
 }
 
-MATCHER_P2(IsImport,
+MATCHER_P2(IsModule,
            name,
            version,
-           std::string(negation ? "isn't " : "is ") + PrintToString(Storage::Import{name, version}))
+           std::string(negation ? "isn't " : "is ") + PrintToString(Storage::Module{name, version}))
 {
-    const Storage::Import &import = arg;
+    const Storage::Module &module = arg;
 
-    return import.name == name && import.version == version;
+    return module.name == name && module.version == version;
 }
 
-MATCHER_P3(IsImportDependency,
+MATCHER_P3(IsModuleDependency,
            name,
            version,
            sourceId,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::ImportDependency{name, version, sourceId}))
+               + PrintToString(Storage::ModuleDependency{name, version, sourceId}))
 {
-    const Storage::ImportDependency &import = arg;
+    const Storage::ModuleDependency &module = arg;
 
-    return import.name == name && import.version == version && &import.sourceId == &sourceId;
+    return module.name == name && module.version == version && &module.sourceId == &sourceId;
 }
 
 class ProjectStorage : public testing::Test
@@ -192,11 +192,11 @@ protected:
 
     auto createTypes()
     {
-        setUpImportDependenciesAndDocuments();
+        setUpModuleDependenciesAndDocuments();
 
         return Storage::Types{
             Storage::Type{
-                Storage::Import{"QtQuick"},
+                Storage::Module{"QtQuick"},
                 "QQuickItem",
                 Storage::NativeType{"QObject"},
                 TypeAccessSemantics::Reference,
@@ -232,7 +232,7 @@ protected:
                  Storage::EnumerationDeclaration{"Type",
                                                  {Storage::EnumeratorDeclaration{"Foo"},
                                                   Storage::EnumeratorDeclaration{"Poo", 12}}}}},
-            Storage::Type{Storage::Import{"Qml", 2},
+            Storage::Type{Storage::Module{"Qml", 2},
                           "QObject",
                           Storage::NativeType{},
                           TypeAccessSemantics::Reference,
@@ -259,7 +259,7 @@ protected:
                                          Storage::NativeType{"QObject"},
                                          Storage::PropertyDeclarationTraits::IsList});
 
-        types.push_back(Storage::Type{Storage::Import{"QtQuick"},
+        types.push_back(Storage::Type{Storage::Module{"QtQuick"},
                                       "QAliasItem",
                                       Storage::ExportedType{"Item"},
                                       TypeAccessSemantics::Reference,
@@ -275,7 +275,7 @@ protected:
             Storage::PropertyDeclaration{"objects", Storage::ExportedType{"Item"}, "objects"});
 
         types.push_back(
-            Storage::Type{Storage::Import{"/path/to"},
+            Storage::Type{Storage::Module{"/path/to"},
                           "QObject2",
                           Storage::NativeType{},
                           TypeAccessSemantics::Reference,
@@ -292,7 +292,7 @@ protected:
     auto createTypesWithRecursiveAliases()
     {
         auto types = createTypesWithAliases();
-        types.push_back(Storage::Type{Storage::Import{"QtQuick"},
+        types.push_back(Storage::Type{Storage::Module{"QtQuick"},
                                       "QAliasItem2",
                                       Storage::ExportedType{"Object"},
                                       TypeAccessSemantics::Reference,
@@ -314,42 +314,42 @@ protected:
         return types;
     }
 
-    auto createImportDependencies()
+    auto createModuleDependencies()
     {
-        importSourceId1 = sourcePathCache.sourceId(importPath1);
-        importSourceId2 = sourcePathCache.sourceId(importPath2);
-        importSourceId3 = sourcePathCache.sourceId(importPath3);
-        importSourceId5 = sourcePathCache.sourceId("/path/to/.");
+        moduleSourceId1 = sourcePathCache.sourceId(modulePath1);
+        moduleSourceId2 = sourcePathCache.sourceId(modulePath2);
+        moduleSourceId3 = sourcePathCache.sourceId(modulePath3);
+        moduleSourceId5 = sourcePathCache.sourceId("/path/to/.");
 
-        return Storage::ImportDependencies{
-            Storage::ImportDependency{"Qml", Storage::VersionNumber{2}, importSourceId1, {}},
-            Storage::ImportDependency{"QtQuick",
+        return Storage::ModuleDependencies{
+            Storage::ModuleDependency{"Qml", Storage::VersionNumber{2}, moduleSourceId1, {}},
+            Storage::ModuleDependency{"QtQuick",
                                       Storage::VersionNumber{},
-                                      importSourceId2,
-                                      {Storage::Import{"Qml", Storage::VersionNumber{2}}}},
-            Storage::ImportDependency{"/path/to",
+                                      moduleSourceId2,
+                                      {Storage::Module{"Qml", Storage::VersionNumber{2}}}},
+            Storage::ModuleDependency{"/path/to",
                                       Storage::VersionNumber{},
-                                      importSourceId5,
-                                      {Storage::Import{"QtQuick"},
-                                       Storage::Import{"Qml", Storage::VersionNumber{2}}}}};
+                                      moduleSourceId5,
+                                      {Storage::Module{"QtQuick"},
+                                       Storage::Module{"Qml", Storage::VersionNumber{2}}}}};
     }
 
-    Storage::Imports createImports()
+    Storage::Modules createModules()
     {
-        return Storage::Imports{Storage::Import{"Qml", Storage::VersionNumber{2}},
-                                Storage::Import{"QtQuick", Storage::VersionNumber{}},
-                                Storage::Import{"/path/to", Storage::VersionNumber{}}};
+        return Storage::Modules{Storage::Module{"Qml", Storage::VersionNumber{2}},
+                                Storage::Module{"QtQuick", Storage::VersionNumber{}},
+                                Storage::Module{"/path/to", Storage::VersionNumber{}}};
     }
 
-    auto createImportDependencies2()
+    auto createModuleDependencies2()
     {
-        importSourceId4 = sourcePathCache.sourceId(importPath4);
+        moduleSourceId4 = sourcePathCache.sourceId(modulePath4);
 
-        auto newImportDependencies = createImportDependencies();
-        newImportDependencies.push_back(
-            Storage::ImportDependency{"Qml2", Storage::VersionNumber{3}, importSourceId4, {}});
+        auto newModuleDependencies = createModuleDependencies();
+        newModuleDependencies.push_back(
+            Storage::ModuleDependency{"Qml2", Storage::VersionNumber{3}, moduleSourceId4, {}});
 
-        return newImportDependencies;
+        return newModuleDependencies;
     }
 
     void setUpSourceIds()
@@ -361,20 +361,20 @@ protected:
         sourceId5 = sourcePathCache.sourceId(path5);
     }
 
-    void setUpImportDependenciesAndDocuments()
+    void setUpModuleDependenciesAndDocuments()
     {
-        setUpImports();
+        setUpModules();
         setUpSourceIds();
 
-        importDependencies = createImportDependencies();
+        moduleDependencies = createModuleDependencies();
 
-        documents = {Storage::Document{sourceId1, imports},
-                     Storage::Document{sourceId2, imports},
-                     Storage::Document{sourceId3, imports},
-                     Storage::Document{sourceId4, imports},
-                     Storage::Document{sourceId5, imports}};
+        documents = {Storage::Document{sourceId1, modules},
+                     Storage::Document{sourceId2, modules},
+                     Storage::Document{sourceId3, modules},
+                     Storage::Document{sourceId4, modules},
+                     Storage::Document{sourceId5, modules}};
 
-        storage.synchronize(importDependencies,
+        storage.synchronize(moduleDependencies,
                             documents,
                             {},
                             {sourceId1,
@@ -382,17 +382,17 @@ protected:
                              sourceId3,
                              sourceId4,
                              sourceId5,
-                             importSourceId1,
-                             importSourceId2,
-                             importSourceId5},
+                             moduleSourceId1,
+                             moduleSourceId2,
+                             moduleSourceId5},
                             {});
-        importIds = storage.fetchImportIds(imports);
-        importId1 = importIds[0];
-        importId2 = importIds[1];
-        importId3 = importIds[2];
+        moduleIds = storage.fetchModuleIds(modules);
+        moduleId1 = moduleIds[0];
+        moduleId2 = moduleIds[1];
+        moduleId3 = moduleIds[2];
     }
 
-    void setUpImports() { imports = createImports(); }
+    void setUpModules() { modules = createModules(); }
 
     template<typename Range>
     static FileStatuses convert(const Range &range)
@@ -415,22 +415,22 @@ protected:
     SourceId sourceId3;
     SourceId sourceId4;
     SourceId sourceId5;
-    QmlDesigner::SourcePathView importPath1{"/import/path1/to"};
-    QmlDesigner::SourcePathView importPath2{"/import/path2/to"};
-    QmlDesigner::SourcePathView importPath3{"/import/aaaa/to"};
-    QmlDesigner::SourcePathView importPath4{"/import/ooo/to"};
-    SourceId importSourceId1;
-    SourceId importSourceId2;
-    SourceId importSourceId3;
-    SourceId importSourceId4;
-    SourceId importSourceId5;
-    Storage::Imports imports;
-    ImportId importId1;
-    ImportId importId2;
-    ImportId importId3;
-    Storage::ImportDependencies importDependencies;
+    QmlDesigner::SourcePathView modulePath1{"/module/path1/to"};
+    QmlDesigner::SourcePathView modulePath2{"/module/path2/to"};
+    QmlDesigner::SourcePathView modulePath3{"/module/aaaa/to"};
+    QmlDesigner::SourcePathView modulePath4{"/module/ooo/to"};
+    SourceId moduleSourceId1;
+    SourceId moduleSourceId2;
+    SourceId moduleSourceId3;
+    SourceId moduleSourceId4;
+    SourceId moduleSourceId5;
+    Storage::Modules modules;
+    ModuleId moduleId1;
+    ModuleId moduleId2;
+    ModuleId moduleId3;
+    Storage::ModuleDependencies moduleDependencies;
     Storage::Documents documents;
-    QmlDesigner::ImportIds importIds;
+    QmlDesigner::ModuleIds moduleIds;
 };
 
 TEST_F(ProjectStorage, FetchSourceContextIdReturnsAlwaysTheSameIdForTheSamePath)
@@ -638,7 +638,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypes)
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(Storage::Import{"Qml", 2},
+                UnorderedElementsAre(AllOf(IsStorageType(Storage::Module{"Qml", 2},
                                                          "QObject",
                                                          Storage::NativeType{},
                                                          TypeAccessSemantics::Reference,
@@ -646,7 +646,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypes)
                                            Field(&Storage::Type::exportedTypes,
                                                  UnorderedElementsAre(IsExportedType("Object"),
                                                                       IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                                     AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                                          "QQuickItem",
                                                          Storage::NativeType{"QObject"},
                                                          TypeAccessSemantics::Reference,
@@ -663,7 +663,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypesWithExportedPrototypeName)
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(Storage::Import{"Qml", 2},
+                UnorderedElementsAre(AllOf(IsStorageType(Storage::Module{"Qml", 2},
                                                          "QObject",
                                                          Storage::NativeType{},
                                                          TypeAccessSemantics::Reference,
@@ -671,7 +671,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypesWithExportedPrototypeName)
                                            Field(&Storage::Type::exportedTypes,
                                                  UnorderedElementsAre(IsExportedType("Object"),
                                                                       IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                                     AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                                          "QQuickItem",
                                                          Storage::NativeType{"QObject"},
                                                          TypeAccessSemantics::Reference,
@@ -689,26 +689,26 @@ TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypesThrowsWithWrongExportedProtot
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
-TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypesWithMissingImportAndExportedPrototypeName)
+TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypesWithMissingModuleAndExportedPrototypeName)
 {
     Storage::Types types{createTypes()};
-    types.push_back(Storage::Type{Storage::Import{"/path/to"},
+    types.push_back(Storage::Type{Storage::Module{"/path/to"},
                                   "QObject2",
                                   Storage::NativeType{},
                                   TypeAccessSemantics::Reference,
                                   sourceId4,
                                   {Storage::ExportedType{"Object2"}, Storage::ExportedType{"Obj2"}}});
-    storage.synchronize({}, {Storage::Document{sourceId1, {imports[0]}}}, {}, {sourceId1}, {});
+    storage.synchronize({}, {Storage::Document{sourceId1, {modules[0]}}}, {}, {sourceId1}, {});
     types[1].prototype = Storage::ExportedType{"Object2"};
 
     ASSERT_THROW(storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
-TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypesWithMissingImport)
+TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypesWithMissingModule)
 {
     Storage::Types types{createTypes()};
-    storage.synchronize({}, {Storage::Document{sourceId1, {imports[0]}}}, {}, {sourceId1}, {});
+    storage.synchronize({}, {Storage::Document{sourceId1, {modules[0]}}}, {}, {sourceId1}, {});
 
     ASSERT_THROW(storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
@@ -722,7 +722,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypesReverseOrder)
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(Storage::Import{"Qml", 2},
+                UnorderedElementsAre(AllOf(IsStorageType(Storage::Module{"Qml", 2},
                                                          "QObject",
                                                          Storage::NativeType{},
                                                          TypeAccessSemantics::Reference,
@@ -730,7 +730,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypesReverseOrder)
                                            Field(&Storage::Type::exportedTypes,
                                                  UnorderedElementsAre(IsExportedType("Object"),
                                                                       IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                                     AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                                          "QQuickItem",
                                                          Storage::NativeType{"QObject"},
                                                          TypeAccessSemantics::Reference,
@@ -749,7 +749,7 @@ TEST_F(ProjectStorage, SynchronizeTypesOverwritesTypeAccessSemantics)
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(Storage::Import{"Qml", 2},
+                UnorderedElementsAre(AllOf(IsStorageType(Storage::Module{"Qml", 2},
                                                          "QObject",
                                                          Storage::NativeType{},
                                                          TypeAccessSemantics::Value,
@@ -757,7 +757,7 @@ TEST_F(ProjectStorage, SynchronizeTypesOverwritesTypeAccessSemantics)
                                            Field(&Storage::Type::exportedTypes,
                                                  UnorderedElementsAre(IsExportedType("Object"),
                                                                       IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                                     AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                                          "QQuickItem",
                                                          Storage::NativeType{"QObject"},
                                                          TypeAccessSemantics::Value,
@@ -776,7 +776,7 @@ TEST_F(ProjectStorage, SynchronizeTypesOverwritesSources)
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(Storage::Import{"Qml", 2},
+                UnorderedElementsAre(AllOf(IsStorageType(Storage::Module{"Qml", 2},
                                                          "QObject",
                                                          Storage::NativeType{},
                                                          TypeAccessSemantics::Reference,
@@ -784,7 +784,7 @@ TEST_F(ProjectStorage, SynchronizeTypesOverwritesSources)
                                            Field(&Storage::Type::exportedTypes,
                                                  UnorderedElementsAre(IsExportedType("Object"),
                                                                       IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                                     AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                                          "QQuickItem",
                                                          Storage::NativeType{"QObject"},
                                                          TypeAccessSemantics::Reference,
@@ -798,7 +798,7 @@ TEST_F(ProjectStorage, SynchronizeTypesInsertTypeIntoPrototypeChain)
     Storage::Types types{createTypes()};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
     types[0].prototype = Storage::NativeType{"QQuickObject"};
-    types.push_back(Storage::Type{Storage::Import{"QtQuick"},
+    types.push_back(Storage::Type{Storage::Module{"QtQuick"},
                                   "QQuickObject",
                                   Storage::NativeType{"QObject"},
                                   TypeAccessSemantics::Reference,
@@ -808,7 +808,7 @@ TEST_F(ProjectStorage, SynchronizeTypesInsertTypeIntoPrototypeChain)
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(Storage::Import{"Qml", 2},
+                UnorderedElementsAre(AllOf(IsStorageType(Storage::Module{"Qml", 2},
                                                          "QObject",
                                                          Storage::NativeType{},
                                                          TypeAccessSemantics::Reference,
@@ -816,14 +816,14 @@ TEST_F(ProjectStorage, SynchronizeTypesInsertTypeIntoPrototypeChain)
                                            Field(&Storage::Type::exportedTypes,
                                                  UnorderedElementsAre(IsExportedType("Object"),
                                                                       IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                                     AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                                          "QQuickObject",
                                                          Storage::NativeType{"QObject"},
                                                          TypeAccessSemantics::Reference,
                                                          sourceId1),
                                            Field(&Storage::Type::exportedTypes,
                                                  UnorderedElementsAre(IsExportedType("Object")))),
-                                     AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                                     AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                                          "QQuickItem",
                                                          Storage::NativeType{"QQuickObject"},
                                                          TypeAccessSemantics::Reference,
@@ -835,8 +835,8 @@ TEST_F(ProjectStorage, SynchronizeTypesInsertTypeIntoPrototypeChain)
 TEST_F(ProjectStorage, SynchronizeTypesAddExplicitPrototype)
 {
     Storage::Types types{createTypes()};
-    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Import{"QtQuick"}};
-    types.push_back(Storage::Type{Storage::Import{"QtQuick"},
+    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Module{"QtQuick"}};
+    types.push_back(Storage::Type{Storage::Module{"QtQuick"},
                                   "QQuickObject",
                                   Storage::NativeType{"QObject"},
                                   TypeAccessSemantics::Reference,
@@ -846,7 +846,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddExplicitPrototype)
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(Storage::Import{"Qml", 2},
+                UnorderedElementsAre(AllOf(IsStorageType(Storage::Module{"Qml", 2},
                                                          "QObject",
                                                          Storage::NativeType{},
                                                          TypeAccessSemantics::Reference,
@@ -854,14 +854,14 @@ TEST_F(ProjectStorage, SynchronizeTypesAddExplicitPrototype)
                                            Field(&Storage::Type::exportedTypes,
                                                  UnorderedElementsAre(IsExportedType("Object"),
                                                                       IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                                     AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                                          "QQuickObject",
                                                          Storage::NativeType{"QObject"},
                                                          TypeAccessSemantics::Reference,
                                                          sourceId1),
                                            Field(&Storage::Type::exportedTypes,
                                                  UnorderedElementsAre(IsExportedType("Object")))),
-                                     AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                                     AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                                          "QQuickItem",
                                                          Storage::NativeType{"QQuickObject"},
                                                          TypeAccessSemantics::Reference,
@@ -872,9 +872,9 @@ TEST_F(ProjectStorage, SynchronizeTypesAddExplicitPrototype)
 
 TEST_F(ProjectStorage, SynchronizeTypesThrowsForMissingPrototype)
 {
-    setUpImportDependenciesAndDocuments();
+    setUpModuleDependenciesAndDocuments();
     sourceId1 = sourcePathCache.sourceId(path1);
-    Storage::Types types{Storage::Type{Storage::Import{"QtQuick"},
+    Storage::Types types{Storage::Type{Storage::Module{"QtQuick"},
                                        "QQuickItem",
                                        Storage::NativeType{"QObject"},
                                        TypeAccessSemantics::Reference,
@@ -885,10 +885,10 @@ TEST_F(ProjectStorage, SynchronizeTypesThrowsForMissingPrototype)
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
-TEST_F(ProjectStorage, SynchronizeTypesThrowsForMissingImport)
+TEST_F(ProjectStorage, SynchronizeTypesThrowsForMissingModule)
 {
     sourceId1 = sourcePathCache.sourceId(path1);
-    Storage::Types types{Storage::Type{Storage::Import{"QtQuick"},
+    Storage::Types types{Storage::Type{Storage::Module{"QtQuick"},
                                        "QQuickItem",
                                        Storage::NativeType{"QObject"},
                                        TypeAccessSemantics::Reference,
@@ -896,12 +896,12 @@ TEST_F(ProjectStorage, SynchronizeTypesThrowsForMissingImport)
                                        {Storage::ExportedType{"Item"}}}};
 
     ASSERT_THROW(storage.synchronize({}, {}, types, {sourceId1}, {}),
-                 QmlDesigner::ImportDoesNotExists);
+                 QmlDesigner::ModuleDoesNotExists);
 }
 
 TEST_F(ProjectStorage, TypeWithInvalidSourceIdThrows)
 {
-    Storage::Types types{Storage::Type{Storage::Import{"QtQuick"},
+    Storage::Types types{Storage::Type{Storage::Module{"QtQuick"},
                                        "QQuickItem",
                                        Storage::NativeType{""},
                                        TypeAccessSemantics::Reference,
@@ -920,7 +920,7 @@ TEST_F(ProjectStorage, DeleteTypeIfSourceIdIsSynchronized)
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(Storage::Import{"Qml", 2},
+                UnorderedElementsAre(AllOf(IsStorageType(Storage::Module{"Qml", 2},
                                                          "QObject",
                                                          Storage::NativeType{},
                                                          TypeAccessSemantics::Reference,
@@ -939,7 +939,7 @@ TEST_F(ProjectStorage, DontDeleteTypeIfSourceIdIsNotSynchronized)
     storage.synchronize({}, {}, types, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(Storage::Import{"Qml", 2},
+                UnorderedElementsAre(AllOf(IsStorageType(Storage::Module{"Qml", 2},
                                                          "QObject",
                                                          Storage::NativeType{},
                                                          TypeAccessSemantics::Reference,
@@ -947,7 +947,7 @@ TEST_F(ProjectStorage, DontDeleteTypeIfSourceIdIsNotSynchronized)
                                            Field(&Storage::Type::exportedTypes,
                                                  UnorderedElementsAre(IsExportedType("Object"),
                                                                       IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                                     AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                                          "QQuickItem",
                                                          Storage::NativeType{"QObject"},
                                                          TypeAccessSemantics::Reference,
@@ -965,7 +965,7 @@ TEST_F(ProjectStorage, UpdateExportedTypesIfTypeNameChanges)
     storage.synchronize({}, {}, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(Storage::Import{"Qml", 2},
+                UnorderedElementsAre(AllOf(IsStorageType(Storage::Module{"Qml", 2},
                                                          "QObject",
                                                          Storage::NativeType{},
                                                          TypeAccessSemantics::Reference,
@@ -973,7 +973,7 @@ TEST_F(ProjectStorage, UpdateExportedTypesIfTypeNameChanges)
                                            Field(&Storage::Type::exportedTypes,
                                                  UnorderedElementsAre(IsExportedType("Object"),
                                                                       IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                                     AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                                          "QQuickItem2",
                                                          Storage::NativeType{"QObject"},
                                                          TypeAccessSemantics::Reference,
@@ -1000,7 +1000,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddPropertyDeclarations)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(
-                    AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                    AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                         "QQuickItem",
                                         Storage::NativeType{"QObject"},
                                         TypeAccessSemantics::Reference,
@@ -1017,7 +1017,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddPropertyDeclarations)
                                             | Storage::PropertyDeclarationTraits::IsReadOnly))))));
 }
 
-TEST_F(ProjectStorage, SynchronizeTypesAddPropertyDeclarationsWithMissingImportIdsForNativeTypes)
+TEST_F(ProjectStorage, SynchronizeTypesAddPropertyDeclarationsWithMissingModuleIdsForNativeTypes)
 {
     Storage::Types types{createTypes()};
     storage.synchronize({}, {Storage::Document{sourceId1, {}}}, {}, {sourceId1}, {});
@@ -1026,10 +1026,10 @@ TEST_F(ProjectStorage, SynchronizeTypesAddPropertyDeclarationsWithMissingImportI
     ASSERT_THROW(storage.synchronize({}, {}, types, {}, {}), QmlDesigner::TypeNameDoesNotExists);
 }
 
-TEST_F(ProjectStorage, SynchronizeTypesAddPropertyDeclarationsWithMissingImportIdsForExportedTypes)
+TEST_F(ProjectStorage, SynchronizeTypesAddPropertyDeclarationsWithMissingModuleIdsForExportedTypes)
 {
     Storage::Types types{createTypes()};
-    storage.synchronize({}, {Storage::Document{sourceId1, {imports[0]}}}, {}, {sourceId1}, {});
+    storage.synchronize({}, {Storage::Document{sourceId1, {modules[0]}}}, {}, {sourceId1}, {});
     types[0].propertyDeclarations[0].typeName = Storage::ExportedType{"Obj"};
 
     ASSERT_THROW(storage.synchronize({}, {}, types, {}, {}), QmlDesigner::TypeNameDoesNotExists);
@@ -1039,9 +1039,9 @@ TEST_F(ProjectStorage, SynchronizeTypesAddPropertyDeclarationExplicitType)
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::ExplicitExportedType{"Object",
-                                                                              Storage::Import{
+                                                                              Storage::Module{
                                                                                   "QtQuick"}};
-    types.push_back(Storage::Type{Storage::Import{"QtQuick"},
+    types.push_back(Storage::Type{Storage::Module{"QtQuick"},
                                   "QQuickObject",
                                   Storage::NativeType{"QObject"},
                                   TypeAccessSemantics::Reference,
@@ -1052,7 +1052,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddPropertyDeclarationExplicitType)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(
-                    AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                    AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                         "QQuickItem",
                                         Storage::NativeType{"QObject"},
                                         TypeAccessSemantics::Reference,
@@ -1079,7 +1079,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesPropertyDeclarationType)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(
-                    AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                    AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                         "QQuickItem",
                                         Storage::NativeType{"QObject"},
                                         TypeAccessSemantics::Reference,
@@ -1106,7 +1106,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesDeclarationTraits)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(
-                    AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                    AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                         "QQuickItem",
                                         Storage::NativeType{"QObject"},
                                         TypeAccessSemantics::Reference,
@@ -1134,7 +1134,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesDeclarationTraitsAndType)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(
-                    AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                    AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                         "QQuickItem",
                                         Storage::NativeType{"QObject"},
                                         TypeAccessSemantics::Reference,
@@ -1160,7 +1160,7 @@ TEST_F(ProjectStorage, SynchronizeTypesRemovesAPropertyDeclaration)
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1186,7 +1186,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddsAPropertyDeclaration)
     ASSERT_THAT(
         storage.fetchTypes(),
         Contains(AllOf(
-            IsStorageType(Storage::Import{"QtQuick"},
+            IsStorageType(Storage::Module{"QtQuick"},
                           "QQuickItem",
                           Storage::NativeType{"QObject"},
                           TypeAccessSemantics::Reference,
@@ -1215,7 +1215,7 @@ TEST_F(ProjectStorage, SynchronizeTypesRenameAPropertyDeclaration)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(
-                    AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                    AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                         "QQuickItem",
                                         Storage::NativeType{"QObject"},
                                         TypeAccessSemantics::Reference,
@@ -1256,7 +1256,7 @@ TEST_F(ProjectStorage, UsingNonExistingExplicitExportedPropertyTypeWithWrongName
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::ExplicitExportedType{"QObject2",
-                                                                              Storage::Import{
+                                                                              Storage::Module{
                                                                                   "Qml"}};
     types.pop_back();
 
@@ -1264,11 +1264,11 @@ TEST_F(ProjectStorage, UsingNonExistingExplicitExportedPropertyTypeWithWrongName
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
-TEST_F(ProjectStorage, UsingNonExistingExplicitExportedPropertyTypeWithWrongImportThrows)
+TEST_F(ProjectStorage, UsingNonExistingExplicitExportedPropertyTypeWithWrongModuleThrows)
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::ExplicitExportedType{"QObject",
-                                                                              Storage::Import{
+                                                                              Storage::Module{
                                                                                   "QtQuick"}};
     types.pop_back();
 
@@ -1294,7 +1294,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddFunctionDeclarations)
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1313,7 +1313,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesFunctionDeclarationReturnType)
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1332,7 +1332,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesFunctionDeclarationName)
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1351,7 +1351,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesFunctionDeclarationPopParameters)
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1370,7 +1370,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesFunctionDeclarationAppendParameter
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1389,7 +1389,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesFunctionDeclarationChangeParameter
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1408,7 +1408,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesFunctionDeclarationChangeParameter
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1427,7 +1427,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesFunctionDeclarationChangeParameter
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1446,7 +1446,7 @@ TEST_F(ProjectStorage, SynchronizeTypesRemovesFunctionDeclaration)
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1465,7 +1465,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddFunctionDeclaration)
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1483,7 +1483,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddSignalDeclarations)
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1502,7 +1502,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesSignalDeclarationName)
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1521,7 +1521,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesSignalDeclarationPopParameters)
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1540,7 +1540,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesSignalDeclarationAppendParameters)
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1559,7 +1559,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesSignalDeclarationChangeParameterNa
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1578,7 +1578,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesSignalDeclarationChangeParameterTy
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1597,7 +1597,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesSignalDeclarationChangeParameterTr
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1616,7 +1616,7 @@ TEST_F(ProjectStorage, SynchronizeTypesRemovesSignalDeclaration)
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1635,7 +1635,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddSignalDeclaration)
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1653,7 +1653,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddEnumerationDeclarations)
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1672,7 +1672,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesEnumerationDeclarationName)
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1691,7 +1691,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesEnumerationDeclarationPopEnumerato
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1711,7 +1711,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesEnumerationDeclarationAppendEnumer
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1730,7 +1730,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesEnumerationDeclarationChangeEnumer
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1749,7 +1749,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesEnumerationDeclarationChangeEnumer
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1770,7 +1770,7 @@ TEST_F(ProjectStorage,
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1790,7 +1790,7 @@ TEST_F(ProjectStorage,
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1809,7 +1809,7 @@ TEST_F(ProjectStorage, SynchronizeTypesRemovesEnumerationDeclaration)
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1828,7 +1828,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddEnumerationDeclaration)
     storage.synchronize({}, {}, types, {}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -1839,457 +1839,457 @@ TEST_F(ProjectStorage, SynchronizeTypesAddEnumerationDeclaration)
                                                           Eq(types[0].enumerationDeclarations[2]))))));
 }
 
-TEST_F(ProjectStorage, SynchronizeImportsAddImports)
+TEST_F(ProjectStorage, SynchronizeModulesAddModules)
 {
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
 
-    storage.synchronize(importDependencies,
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
 
-    ASSERT_THAT(storage.fetchAllImports(),
+    ASSERT_THAT(storage.fetchAllModules(),
                 UnorderedElementsAre(
-                    IsImportDependency("Qml", Storage::VersionNumber{2}, importSourceId1),
-                    IsImportDependency("QtQuick", Storage::VersionNumber{}, importSourceId2),
-                    IsImportDependency("/path/to", Storage::VersionNumber{}, importSourceId5)));
+                    IsModuleDependency("Qml", Storage::VersionNumber{2}, moduleSourceId1),
+                    IsModuleDependency("QtQuick", Storage::VersionNumber{}, moduleSourceId2),
+                    IsModuleDependency("/path/to", Storage::VersionNumber{}, moduleSourceId5)));
 }
 
-TEST_F(ProjectStorage, SynchronizeImportsAddImportsAgain)
+TEST_F(ProjectStorage, SynchronizeModulesAddModulesAgain)
 {
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
-    storage.synchronize(importDependencies,
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
 
-    storage.synchronize(importDependencies,
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
 
-    ASSERT_THAT(storage.fetchAllImports(),
+    ASSERT_THAT(storage.fetchAllModules(),
                 UnorderedElementsAre(
-                    IsImportDependency("Qml", Storage::VersionNumber{2}, importSourceId1),
-                    IsImportDependency("QtQuick", Storage::VersionNumber{}, importSourceId2),
-                    IsImportDependency("/path/to", Storage::VersionNumber{}, importSourceId5)));
+                    IsModuleDependency("Qml", Storage::VersionNumber{2}, moduleSourceId1),
+                    IsModuleDependency("QtQuick", Storage::VersionNumber{}, moduleSourceId2),
+                    IsModuleDependency("/path/to", Storage::VersionNumber{}, moduleSourceId5)));
 }
 
-TEST_F(ProjectStorage, SynchronizeImportsUpdateToMoreImports)
+TEST_F(ProjectStorage, SynchronizeModulesUpdateToMoreModules)
 {
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
-    storage.synchronize(importDependencies,
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
-    importDependencies.push_back(
-        Storage::ImportDependency{"QtQuick.Foo", Storage::VersionNumber{1}, importSourceId3});
+    moduleDependencies.push_back(
+        Storage::ModuleDependency{"QtQuick.Foo", Storage::VersionNumber{1}, moduleSourceId3});
 
-    storage.synchronize(importDependencies,
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId3, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId3, moduleSourceId5},
                         {});
 
-    ASSERT_THAT(storage.fetchAllImports(),
+    ASSERT_THAT(storage.fetchAllModules(),
                 UnorderedElementsAre(
-                    IsImportDependency("Qml", Storage::VersionNumber{2}, importSourceId1),
-                    IsImportDependency("QtQuick", Storage::VersionNumber{}, importSourceId2),
-                    IsImportDependency("/path/to", Storage::VersionNumber{}, importSourceId5),
-                    IsImportDependency("QtQuick.Foo", Storage::VersionNumber{1}, importSourceId3)));
+                    IsModuleDependency("Qml", Storage::VersionNumber{2}, moduleSourceId1),
+                    IsModuleDependency("QtQuick", Storage::VersionNumber{}, moduleSourceId2),
+                    IsModuleDependency("/path/to", Storage::VersionNumber{}, moduleSourceId5),
+                    IsModuleDependency("QtQuick.Foo", Storage::VersionNumber{1}, moduleSourceId3)));
 }
 
-TEST_F(ProjectStorage, SynchronizeImportsAddOneMoreImports)
+TEST_F(ProjectStorage, SynchronizeModulesAddOneMoreModules)
 {
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
-    storage.synchronize(importDependencies,
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
-    auto newImportDependency = Storage::ImportDependency{"QtQuick.Foo",
+    auto newModuleDependency = Storage::ModuleDependency{"QtQuick.Foo",
                                                          Storage::VersionNumber{1},
-                                                         importSourceId3};
+                                                         moduleSourceId3};
 
-    storage.synchronize({newImportDependency}, {}, {}, {importSourceId3}, {});
+    storage.synchronize({newModuleDependency}, {}, {}, {moduleSourceId3}, {});
 
-    ASSERT_THAT(storage.fetchAllImports(),
+    ASSERT_THAT(storage.fetchAllModules(),
                 UnorderedElementsAre(
-                    IsImportDependency("Qml", Storage::VersionNumber{2}, importSourceId1),
-                    IsImportDependency("QtQuick", Storage::VersionNumber{}, importSourceId2),
-                    IsImportDependency("/path/to", Storage::VersionNumber{}, importSourceId5),
-                    IsImportDependency("QtQuick.Foo", Storage::VersionNumber{1}, importSourceId3)));
+                    IsModuleDependency("Qml", Storage::VersionNumber{2}, moduleSourceId1),
+                    IsModuleDependency("QtQuick", Storage::VersionNumber{}, moduleSourceId2),
+                    IsModuleDependency("/path/to", Storage::VersionNumber{}, moduleSourceId5),
+                    IsModuleDependency("QtQuick.Foo", Storage::VersionNumber{1}, moduleSourceId3)));
 }
 
-TEST_F(ProjectStorage, SynchronizeImportsAddSameImportNameButDifferentVersion)
+TEST_F(ProjectStorage, SynchronizeModulesAddSameModuleNameButDifferentVersion)
 {
-    auto importSourceIdQml4 = sourcePathCache.sourceId("/path/Qml.4");
-    auto importSourceIdQml3 = sourcePathCache.sourceId("/path/Qml.3");
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
-    importDependencies.push_back(
-        Storage::ImportDependency{"Qml", Storage::VersionNumber{4}, importSourceIdQml4});
-    storage.synchronize(importDependencies,
+    auto moduleSourceIdQml4 = sourcePathCache.sourceId("/path/Qml.4");
+    auto moduleSourceIdQml3 = sourcePathCache.sourceId("/path/Qml.3");
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
+    moduleDependencies.push_back(
+        Storage::ModuleDependency{"Qml", Storage::VersionNumber{4}, moduleSourceIdQml4});
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
-    auto newImportDependency = Storage::ImportDependency{"Qml",
+    auto newModuleDependency = Storage::ModuleDependency{"Qml",
                                                          Storage::VersionNumber{3},
-                                                         importSourceIdQml3};
+                                                         moduleSourceIdQml3};
 
-    storage.synchronize({newImportDependency}, {}, {}, {importSourceIdQml4, importSourceIdQml3}, {});
+    storage.synchronize({newModuleDependency}, {}, {}, {moduleSourceIdQml4, moduleSourceIdQml3}, {});
 
-    ASSERT_THAT(storage.fetchAllImports(),
+    ASSERT_THAT(storage.fetchAllModules(),
                 UnorderedElementsAre(
-                    IsImportDependency("Qml", Storage::VersionNumber{2}, importSourceId1),
-                    IsImportDependency("Qml", Storage::VersionNumber{3}, importSourceIdQml3),
-                    IsImportDependency("QtQuick", Storage::VersionNumber{}, importSourceId2),
-                    IsImportDependency("/path/to", Storage::VersionNumber{}, importSourceId5)));
+                    IsModuleDependency("Qml", Storage::VersionNumber{2}, moduleSourceId1),
+                    IsModuleDependency("Qml", Storage::VersionNumber{3}, moduleSourceIdQml3),
+                    IsModuleDependency("QtQuick", Storage::VersionNumber{}, moduleSourceId2),
+                    IsModuleDependency("/path/to", Storage::VersionNumber{}, moduleSourceId5)));
 }
 
-TEST_F(ProjectStorage, SynchronizeImportsRemoveImport)
+TEST_F(ProjectStorage, SynchronizeModulesRemoveModule)
 {
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
-    storage.synchronize(importDependencies,
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
 
-    storage.synchronize({}, {}, {}, {importSourceId5}, {});
+    storage.synchronize({}, {}, {}, {moduleSourceId5}, {});
 
-    ASSERT_THAT(storage.fetchAllImports(),
+    ASSERT_THAT(storage.fetchAllModules(),
                 UnorderedElementsAre(
-                    IsImportDependency("Qml", Storage::VersionNumber{2}, importSourceId1),
-                    IsImportDependency("QtQuick", Storage::VersionNumber{}, importSourceId2)));
+                    IsModuleDependency("Qml", Storage::VersionNumber{2}, moduleSourceId1),
+                    IsModuleDependency("QtQuick", Storage::VersionNumber{}, moduleSourceId2)));
 }
 
-TEST_F(ProjectStorage, SynchronizeImportsChangeSourceId)
+TEST_F(ProjectStorage, SynchronizeModulesChangeSourceId)
 {
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
-    storage.synchronize(importDependencies,
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
-    importDependencies[1].sourceId = importSourceId3;
+    moduleDependencies[1].sourceId = moduleSourceId3;
 
-    storage.synchronize({importDependencies[1]}, {}, {}, {importSourceId2, importSourceId3}, {});
+    storage.synchronize({moduleDependencies[1]}, {}, {}, {moduleSourceId2, moduleSourceId3}, {});
 
-    ASSERT_THAT(storage.fetchAllImports(),
+    ASSERT_THAT(storage.fetchAllModules(),
                 UnorderedElementsAre(
-                    IsImportDependency("Qml", Storage::VersionNumber{2}, importSourceId1),
-                    IsImportDependency("QtQuick", Storage::VersionNumber{}, importSourceId3),
-                    IsImportDependency("/path/to", Storage::VersionNumber{}, importSourceId5)));
+                    IsModuleDependency("Qml", Storage::VersionNumber{2}, moduleSourceId1),
+                    IsModuleDependency("QtQuick", Storage::VersionNumber{}, moduleSourceId3),
+                    IsModuleDependency("/path/to", Storage::VersionNumber{}, moduleSourceId5)));
 }
 
-TEST_F(ProjectStorage, SynchronizeImportsChangeName)
+TEST_F(ProjectStorage, SynchronizeModulesChangeName)
 {
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
-    storage.synchronize(importDependencies,
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
-    importDependencies[0].name = "Qml2";
-    importDependencies[1].dependencies[0].name = "Qml2";
-    importDependencies[2].dependencies[1].name = "Qml2";
+    moduleDependencies[0].name = "Qml2";
+    moduleDependencies[1].dependencies[0].name = "Qml2";
+    moduleDependencies[2].dependencies[1].name = "Qml2";
 
-    storage.synchronize(importDependencies,
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
 
-    ASSERT_THAT(storage.fetchAllImports(),
+    ASSERT_THAT(storage.fetchAllModules(),
                 UnorderedElementsAre(
-                    IsImportDependency("Qml2", Storage::VersionNumber{2}, importSourceId1),
-                    IsImportDependency("QtQuick", Storage::VersionNumber{}, importSourceId2),
-                    IsImportDependency("/path/to", Storage::VersionNumber{}, importSourceId5)));
+                    IsModuleDependency("Qml2", Storage::VersionNumber{2}, moduleSourceId1),
+                    IsModuleDependency("QtQuick", Storage::VersionNumber{}, moduleSourceId2),
+                    IsModuleDependency("/path/to", Storage::VersionNumber{}, moduleSourceId5)));
 }
 
-TEST_F(ProjectStorage, SynchronizeImportsChangeVersion)
+TEST_F(ProjectStorage, SynchronizeModulesChangeVersion)
 {
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
-    storage.synchronize(importDependencies,
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
-    importDependencies[0].version = Storage::VersionNumber{3};
-    importDependencies[1].dependencies[0].version = Storage::VersionNumber{3};
-    importDependencies[2].dependencies[1].version = Storage::VersionNumber{3};
+    moduleDependencies[0].version = Storage::VersionNumber{3};
+    moduleDependencies[1].dependencies[0].version = Storage::VersionNumber{3};
+    moduleDependencies[2].dependencies[1].version = Storage::VersionNumber{3};
 
-    storage.synchronize(importDependencies,
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
 
-    ASSERT_THAT(storage.fetchAllImports(),
+    ASSERT_THAT(storage.fetchAllModules(),
                 UnorderedElementsAre(
-                    IsImportDependency("Qml", Storage::VersionNumber{3}, importSourceId1),
-                    IsImportDependency("QtQuick", Storage::VersionNumber{}, importSourceId2),
-                    IsImportDependency("/path/to", Storage::VersionNumber{}, importSourceId5)));
+                    IsModuleDependency("Qml", Storage::VersionNumber{3}, moduleSourceId1),
+                    IsModuleDependency("QtQuick", Storage::VersionNumber{}, moduleSourceId2),
+                    IsModuleDependency("/path/to", Storage::VersionNumber{}, moduleSourceId5)));
 }
 
-TEST_F(ProjectStorage, SynchronizeImportsAddImportDependecies)
+TEST_F(ProjectStorage, SynchronizeModulesAddModuleDependecies)
 {
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
 
-    storage.synchronize(importDependencies,
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
 
-    ASSERT_THAT(storage.fetchAllImports(),
+    ASSERT_THAT(storage.fetchAllModules(),
                 UnorderedElementsAre(
-                    AllOf(IsImportDependency("Qml", Storage::VersionNumber{2}, importSourceId1),
-                          Field(&Storage::ImportDependency::dependencies, IsEmpty())),
-                    AllOf(IsImportDependency("QtQuick", Storage::VersionNumber{}, importSourceId2),
-                          Field(&Storage::ImportDependency::dependencies,
-                                ElementsAre(IsImport("Qml", Storage::VersionNumber{2})))),
-                    AllOf(IsImportDependency("/path/to", Storage::VersionNumber{}, importSourceId5),
-                          Field(&Storage::ImportDependency::dependencies,
-                                UnorderedElementsAre(IsImport("Qml", Storage::VersionNumber{2}),
-                                                     IsImport("QtQuick", Storage::VersionNumber{}))))));
+                    AllOf(IsModuleDependency("Qml", Storage::VersionNumber{2}, moduleSourceId1),
+                          Field(&Storage::ModuleDependency::dependencies, IsEmpty())),
+                    AllOf(IsModuleDependency("QtQuick", Storage::VersionNumber{}, moduleSourceId2),
+                          Field(&Storage::ModuleDependency::dependencies,
+                                ElementsAre(IsModule("Qml", Storage::VersionNumber{2})))),
+                    AllOf(IsModuleDependency("/path/to", Storage::VersionNumber{}, moduleSourceId5),
+                          Field(&Storage::ModuleDependency::dependencies,
+                                UnorderedElementsAre(IsModule("Qml", Storage::VersionNumber{2}),
+                                                     IsModule("QtQuick", Storage::VersionNumber{}))))));
 }
 
-TEST_F(ProjectStorage, SynchronizeImportsAddImportDependeciesWhichDoesNotExitsThrows)
+TEST_F(ProjectStorage, SynchronizeModulesAddModuleDependeciesWhichDoesNotExitsThrows)
 {
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
-    importDependencies[1].dependencies.push_back(Storage::Import{"QmlBase", Storage::VersionNumber{2}});
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
+    moduleDependencies[1].dependencies.push_back(Storage::Module{"QmlBase", Storage::VersionNumber{2}});
 
-    ASSERT_THROW(storage.synchronize(importDependencies,
+    ASSERT_THROW(storage.synchronize(moduleDependencies,
                                      {},
                                      {},
-                                     {importSourceId1, importSourceId2, importSourceId5},
+                                     {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                                      {}),
-                 QmlDesigner::ImportDoesNotExists);
+                 QmlDesigner::ModuleDoesNotExists);
 }
 
-TEST_F(ProjectStorage, SynchronizeImportsRemovesDependeciesForRemovedImports)
+TEST_F(ProjectStorage, SynchronizeModulesRemovesDependeciesForRemovedModules)
 {
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
-    storage.synchronize(importDependencies,
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
-    auto last = importDependencies.back();
-    importDependencies.pop_back();
-    storage.synchronize({}, {}, {}, {importSourceId5}, {});
+    auto last = moduleDependencies.back();
+    moduleDependencies.pop_back();
+    storage.synchronize({}, {}, {}, {moduleSourceId5}, {});
     last.dependencies.pop_back();
-    importDependencies.push_back(last);
+    moduleDependencies.push_back(last);
 
-    storage.synchronize({importDependencies[2]}, {}, {}, {importSourceId5}, {});
+    storage.synchronize({moduleDependencies[2]}, {}, {}, {moduleSourceId5}, {});
 
-    ASSERT_THAT(storage.fetchAllImports(),
+    ASSERT_THAT(storage.fetchAllModules(),
                 UnorderedElementsAre(
-                    AllOf(IsImportDependency("Qml", Storage::VersionNumber{2}, importSourceId1),
-                          Field(&Storage::ImportDependency::dependencies, IsEmpty())),
-                    AllOf(IsImportDependency("QtQuick", Storage::VersionNumber{}, importSourceId2),
-                          Field(&Storage::ImportDependency::dependencies,
-                                ElementsAre(IsImport("Qml", Storage::VersionNumber{2})))),
-                    AllOf(IsImportDependency("/path/to", Storage::VersionNumber{}, importSourceId5),
-                          Field(&Storage::ImportDependency::dependencies,
-                                UnorderedElementsAre(IsImport("QtQuick", Storage::VersionNumber{}))))));
+                    AllOf(IsModuleDependency("Qml", Storage::VersionNumber{2}, moduleSourceId1),
+                          Field(&Storage::ModuleDependency::dependencies, IsEmpty())),
+                    AllOf(IsModuleDependency("QtQuick", Storage::VersionNumber{}, moduleSourceId2),
+                          Field(&Storage::ModuleDependency::dependencies,
+                                ElementsAre(IsModule("Qml", Storage::VersionNumber{2})))),
+                    AllOf(IsModuleDependency("/path/to", Storage::VersionNumber{}, moduleSourceId5),
+                          Field(&Storage::ModuleDependency::dependencies,
+                                UnorderedElementsAre(IsModule("QtQuick", Storage::VersionNumber{}))))));
 }
 
-TEST_F(ProjectStorage, SynchronizeImportsAddMoreImportDependecies)
+TEST_F(ProjectStorage, SynchronizeModulesAddMoreModuleDependecies)
 {
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
-    storage.synchronize(importDependencies,
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
-    auto importSourceIdQmlBase = sourcePathCache.sourceId("/path/QmlBase");
-    importDependencies.push_back(
-        Storage::ImportDependency{"QmlBase", Storage::VersionNumber{2}, importSourceIdQmlBase});
-    importDependencies[1].dependencies.push_back(Storage::Import{"QmlBase", Storage::VersionNumber{2}});
+    auto moduleSourceIdQmlBase = sourcePathCache.sourceId("/path/QmlBase");
+    moduleDependencies.push_back(
+        Storage::ModuleDependency{"QmlBase", Storage::VersionNumber{2}, moduleSourceIdQmlBase});
+    moduleDependencies[1].dependencies.push_back(Storage::Module{"QmlBase", Storage::VersionNumber{2}});
 
-    storage.synchronize({importDependencies[1], importDependencies[3]},
+    storage.synchronize({moduleDependencies[1], moduleDependencies[3]},
                         {},
                         {},
-                        {importSourceId2, importSourceIdQmlBase},
+                        {moduleSourceId2, moduleSourceIdQmlBase},
                         {});
 
     ASSERT_THAT(
-        storage.fetchAllImports(),
+        storage.fetchAllModules(),
         UnorderedElementsAre(
-            AllOf(IsImportDependency("Qml", Storage::VersionNumber{2}, importSourceId1),
-                  Field(&Storage::ImportDependency::dependencies, IsEmpty())),
-            AllOf(IsImportDependency("QmlBase", Storage::VersionNumber{2}, importSourceIdQmlBase),
-                  Field(&Storage::ImportDependency::dependencies, IsEmpty())),
-            AllOf(IsImportDependency("QtQuick", Storage::VersionNumber{}, importSourceId2),
-                  Field(&Storage::ImportDependency::dependencies,
-                        UnorderedElementsAre(IsImport("Qml", Storage::VersionNumber{2}),
-                                             IsImport("QmlBase", Storage::VersionNumber{2})))),
-            AllOf(IsImportDependency("/path/to", Storage::VersionNumber{}, importSourceId5),
-                  Field(&Storage::ImportDependency::dependencies,
-                        UnorderedElementsAre(IsImport("Qml", Storage::VersionNumber{2}),
-                                             IsImport("QtQuick", Storage::VersionNumber{}))))));
+            AllOf(IsModuleDependency("Qml", Storage::VersionNumber{2}, moduleSourceId1),
+                  Field(&Storage::ModuleDependency::dependencies, IsEmpty())),
+            AllOf(IsModuleDependency("QmlBase", Storage::VersionNumber{2}, moduleSourceIdQmlBase),
+                  Field(&Storage::ModuleDependency::dependencies, IsEmpty())),
+            AllOf(IsModuleDependency("QtQuick", Storage::VersionNumber{}, moduleSourceId2),
+                  Field(&Storage::ModuleDependency::dependencies,
+                        UnorderedElementsAre(IsModule("Qml", Storage::VersionNumber{2}),
+                                             IsModule("QmlBase", Storage::VersionNumber{2})))),
+            AllOf(IsModuleDependency("/path/to", Storage::VersionNumber{}, moduleSourceId5),
+                  Field(&Storage::ModuleDependency::dependencies,
+                        UnorderedElementsAre(IsModule("Qml", Storage::VersionNumber{2}),
+                                             IsModule("QtQuick", Storage::VersionNumber{}))))));
 }
 
-TEST_F(ProjectStorage, SynchronizeImportsAddMoreImportDependeciesWithDifferentVersionNumber)
+TEST_F(ProjectStorage, SynchronizeModulesAddMoreModuleDependeciesWithDifferentVersionNumber)
 {
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
-    storage.synchronize(importDependencies,
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
-    auto importSourceIdQml3 = sourcePathCache.sourceId("/path/Qml.3");
-    importDependencies.push_back(
-        Storage::ImportDependency{"Qml", Storage::VersionNumber{3}, importSourceIdQml3, {}});
-    importDependencies[1].dependencies.push_back(Storage::Import{"Qml", Storage::VersionNumber{3}});
+    auto moduleSourceIdQml3 = sourcePathCache.sourceId("/path/Qml.3");
+    moduleDependencies.push_back(
+        Storage::ModuleDependency{"Qml", Storage::VersionNumber{3}, moduleSourceIdQml3, {}});
+    moduleDependencies[1].dependencies.push_back(Storage::Module{"Qml", Storage::VersionNumber{3}});
 
-    storage.synchronize({importDependencies[1], importDependencies[3]},
+    storage.synchronize({moduleDependencies[1], moduleDependencies[3]},
                         {},
                         {},
-                        {importSourceId2, importSourceIdQml3},
+                        {moduleSourceId2, moduleSourceIdQml3},
                         {});
 
-    ASSERT_THAT(storage.fetchAllImports(),
+    ASSERT_THAT(storage.fetchAllModules(),
                 UnorderedElementsAre(
-                    AllOf(IsImportDependency("Qml", Storage::VersionNumber{2}, importSourceId1),
-                          Field(&Storage::ImportDependency::dependencies, IsEmpty())),
-                    AllOf(IsImportDependency("Qml", Storage::VersionNumber{3}, importSourceIdQml3),
-                          Field(&Storage::ImportDependency::dependencies, IsEmpty())),
-                    AllOf(IsImportDependency("QtQuick", Storage::VersionNumber{}, importSourceId2),
-                          Field(&Storage::ImportDependency::dependencies,
-                                UnorderedElementsAre(IsImport("Qml", Storage::VersionNumber{2}),
-                                                     IsImport("Qml", Storage::VersionNumber{3})))),
-                    AllOf(IsImportDependency("/path/to", Storage::VersionNumber{}, importSourceId5),
-                          Field(&Storage::ImportDependency::dependencies,
-                                UnorderedElementsAre(IsImport("Qml", Storage::VersionNumber{2}),
-                                                     IsImport("QtQuick", Storage::VersionNumber{}))))));
+                    AllOf(IsModuleDependency("Qml", Storage::VersionNumber{2}, moduleSourceId1),
+                          Field(&Storage::ModuleDependency::dependencies, IsEmpty())),
+                    AllOf(IsModuleDependency("Qml", Storage::VersionNumber{3}, moduleSourceIdQml3),
+                          Field(&Storage::ModuleDependency::dependencies, IsEmpty())),
+                    AllOf(IsModuleDependency("QtQuick", Storage::VersionNumber{}, moduleSourceId2),
+                          Field(&Storage::ModuleDependency::dependencies,
+                                UnorderedElementsAre(IsModule("Qml", Storage::VersionNumber{2}),
+                                                     IsModule("Qml", Storage::VersionNumber{3})))),
+                    AllOf(IsModuleDependency("/path/to", Storage::VersionNumber{}, moduleSourceId5),
+                          Field(&Storage::ModuleDependency::dependencies,
+                                UnorderedElementsAre(IsModule("Qml", Storage::VersionNumber{2}),
+                                                     IsModule("QtQuick", Storage::VersionNumber{}))))));
 }
 
-TEST_F(ProjectStorage, SynchronizeImportsDependencyGetsHighestVersionIfNoVersionIsSupplied)
+TEST_F(ProjectStorage, SynchronizeModulesDependencyGetsHighestVersionIfNoVersionIsSupplied)
 {
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
-    storage.synchronize(importDependencies,
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
-    auto importSourceIdQml3 = sourcePathCache.sourceId("/path/Qml.3");
-    importDependencies.push_back(
-        Storage::ImportDependency{"Qml", Storage::VersionNumber{3}, importSourceIdQml3, {}});
-    importDependencies[1].dependencies.push_back(Storage::Import{"Qml"});
+    auto moduleSourceIdQml3 = sourcePathCache.sourceId("/path/Qml.3");
+    moduleDependencies.push_back(
+        Storage::ModuleDependency{"Qml", Storage::VersionNumber{3}, moduleSourceIdQml3, {}});
+    moduleDependencies[1].dependencies.push_back(Storage::Module{"Qml"});
 
-    storage.synchronize({importDependencies[1], importDependencies[3]},
+    storage.synchronize({moduleDependencies[1], moduleDependencies[3]},
                         {},
                         {},
-                        {importSourceId2, importSourceIdQml3},
+                        {moduleSourceId2, moduleSourceIdQml3},
                         {});
 
-    ASSERT_THAT(storage.fetchAllImports(),
+    ASSERT_THAT(storage.fetchAllModules(),
                 UnorderedElementsAre(
-                    AllOf(IsImportDependency("Qml", Storage::VersionNumber{2}, importSourceId1),
-                          Field(&Storage::ImportDependency::dependencies, IsEmpty())),
-                    AllOf(IsImportDependency("Qml", Storage::VersionNumber{3}, importSourceIdQml3),
-                          Field(&Storage::ImportDependency::dependencies, IsEmpty())),
-                    AllOf(IsImportDependency("QtQuick", Storage::VersionNumber{}, importSourceId2),
-                          Field(&Storage::ImportDependency::dependencies,
-                                UnorderedElementsAre(IsImport("Qml", Storage::VersionNumber{2}),
-                                                     IsImport("Qml", Storage::VersionNumber{3})))),
-                    AllOf(IsImportDependency("/path/to", Storage::VersionNumber{}, importSourceId5),
-                          Field(&Storage::ImportDependency::dependencies,
-                                UnorderedElementsAre(IsImport("Qml", Storage::VersionNumber{2}),
-                                                     IsImport("QtQuick", Storage::VersionNumber{}))))));
+                    AllOf(IsModuleDependency("Qml", Storage::VersionNumber{2}, moduleSourceId1),
+                          Field(&Storage::ModuleDependency::dependencies, IsEmpty())),
+                    AllOf(IsModuleDependency("Qml", Storage::VersionNumber{3}, moduleSourceIdQml3),
+                          Field(&Storage::ModuleDependency::dependencies, IsEmpty())),
+                    AllOf(IsModuleDependency("QtQuick", Storage::VersionNumber{}, moduleSourceId2),
+                          Field(&Storage::ModuleDependency::dependencies,
+                                UnorderedElementsAre(IsModule("Qml", Storage::VersionNumber{2}),
+                                                     IsModule("Qml", Storage::VersionNumber{3})))),
+                    AllOf(IsModuleDependency("/path/to", Storage::VersionNumber{}, moduleSourceId5),
+                          Field(&Storage::ModuleDependency::dependencies,
+                                UnorderedElementsAre(IsModule("Qml", Storage::VersionNumber{2}),
+                                                     IsModule("QtQuick", Storage::VersionNumber{}))))));
 }
 
-TEST_F(ProjectStorage, SynchronizeImportsDependencyGetsOnlyTheHighestDependency)
+TEST_F(ProjectStorage, SynchronizeModulesDependencyGetsOnlyTheHighestDependency)
 {
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
-    storage.synchronize(importDependencies,
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
-    auto importSourceIdQml1 = sourcePathCache.sourceId("/path/Qml.1");
-    importDependencies.push_back(
-        Storage::ImportDependency{"Qml", Storage::VersionNumber{1}, importSourceIdQml1, {}});
-    importDependencies[1].dependencies.push_back(Storage::Import{"Qml"});
+    auto moduleSourceIdQml1 = sourcePathCache.sourceId("/path/Qml.1");
+    moduleDependencies.push_back(
+        Storage::ModuleDependency{"Qml", Storage::VersionNumber{1}, moduleSourceIdQml1, {}});
+    moduleDependencies[1].dependencies.push_back(Storage::Module{"Qml"});
 
-    storage.synchronize({importDependencies[1], importDependencies[3]},
+    storage.synchronize({moduleDependencies[1], moduleDependencies[3]},
                         {},
                         {},
-                        {importSourceId2, importSourceIdQml1},
+                        {moduleSourceId2, moduleSourceIdQml1},
                         {});
 
-    ASSERT_THAT(storage.fetchAllImports(),
+    ASSERT_THAT(storage.fetchAllModules(),
                 UnorderedElementsAre(
-                    AllOf(IsImportDependency("Qml", Storage::VersionNumber{2}, importSourceId1),
-                          Field(&Storage::ImportDependency::dependencies, IsEmpty())),
-                    AllOf(IsImportDependency("Qml", Storage::VersionNumber{1}, importSourceIdQml1),
-                          Field(&Storage::ImportDependency::dependencies, IsEmpty())),
-                    AllOf(IsImportDependency("QtQuick", Storage::VersionNumber{}, importSourceId2),
-                          Field(&Storage::ImportDependency::dependencies,
-                                UnorderedElementsAre(IsImport("Qml", Storage::VersionNumber{2})))),
-                    AllOf(IsImportDependency("/path/to", Storage::VersionNumber{}, importSourceId5),
-                          Field(&Storage::ImportDependency::dependencies,
-                                UnorderedElementsAre(IsImport("Qml", Storage::VersionNumber{2}),
-                                                     IsImport("QtQuick", Storage::VersionNumber{}))))));
+                    AllOf(IsModuleDependency("Qml", Storage::VersionNumber{2}, moduleSourceId1),
+                          Field(&Storage::ModuleDependency::dependencies, IsEmpty())),
+                    AllOf(IsModuleDependency("Qml", Storage::VersionNumber{1}, moduleSourceIdQml1),
+                          Field(&Storage::ModuleDependency::dependencies, IsEmpty())),
+                    AllOf(IsModuleDependency("QtQuick", Storage::VersionNumber{}, moduleSourceId2),
+                          Field(&Storage::ModuleDependency::dependencies,
+                                UnorderedElementsAre(IsModule("Qml", Storage::VersionNumber{2})))),
+                    AllOf(IsModuleDependency("/path/to", Storage::VersionNumber{}, moduleSourceId5),
+                          Field(&Storage::ModuleDependency::dependencies,
+                                UnorderedElementsAre(IsModule("Qml", Storage::VersionNumber{2}),
+                                                     IsModule("QtQuick", Storage::VersionNumber{}))))));
 }
 
-TEST_F(ProjectStorage, SynchronizeImportsDependencyRemoveDuplicateDependencies)
+TEST_F(ProjectStorage, SynchronizeModulesDependencyRemoveDuplicateDependencies)
 {
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
-    storage.synchronize(importDependencies,
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
+    storage.synchronize(moduleDependencies,
                         {},
                         {},
-                        {importSourceId1, importSourceId2, importSourceId5},
+                        {moduleSourceId1, moduleSourceId2, moduleSourceId5},
                         {});
-    auto importSourceIdQml3 = sourcePathCache.sourceId("/path/Qml.3");
-    importDependencies.push_back(
-        Storage::ImportDependency{"Qml", Storage::VersionNumber{3}, importSourceIdQml3});
-    importDependencies[2].dependencies.push_back(Storage::Import{"Qml", Storage::VersionNumber{3}});
-    importDependencies[2].dependencies.push_back(Storage::Import{"Qml", Storage::VersionNumber{2}});
-    importDependencies[2].dependencies.push_back(Storage::Import{"Qml", Storage::VersionNumber{3}});
-    importDependencies[2].dependencies.push_back(Storage::Import{"Qml", Storage::VersionNumber{2}});
+    auto moduleSourceIdQml3 = sourcePathCache.sourceId("/path/Qml.3");
+    moduleDependencies.push_back(
+        Storage::ModuleDependency{"Qml", Storage::VersionNumber{3}, moduleSourceIdQml3});
+    moduleDependencies[2].dependencies.push_back(Storage::Module{"Qml", Storage::VersionNumber{3}});
+    moduleDependencies[2].dependencies.push_back(Storage::Module{"Qml", Storage::VersionNumber{2}});
+    moduleDependencies[2].dependencies.push_back(Storage::Module{"Qml", Storage::VersionNumber{3}});
+    moduleDependencies[2].dependencies.push_back(Storage::Module{"Qml", Storage::VersionNumber{2}});
 
-    storage.synchronize({importDependencies[2], importDependencies[3]},
+    storage.synchronize({moduleDependencies[2], moduleDependencies[3]},
                         {},
                         {},
-                        {importSourceId5, importSourceIdQml3},
+                        {moduleSourceId5, moduleSourceIdQml3},
                         {});
 
-    ASSERT_THAT(storage.fetchAllImports(),
+    ASSERT_THAT(storage.fetchAllModules(),
                 UnorderedElementsAre(
-                    AllOf(IsImportDependency("Qml", Storage::VersionNumber{2}, importSourceId1),
-                          Field(&Storage::ImportDependency::dependencies, IsEmpty())),
-                    AllOf(IsImportDependency("Qml", Storage::VersionNumber{3}, importSourceIdQml3),
-                          Field(&Storage::ImportDependency::dependencies, IsEmpty())),
-                    AllOf(IsImportDependency("QtQuick", Storage::VersionNumber{}, importSourceId2),
-                          Field(&Storage::ImportDependency::dependencies,
-                                UnorderedElementsAre(IsImport("Qml", Storage::VersionNumber{2})))),
-                    AllOf(IsImportDependency("/path/to", Storage::VersionNumber{}, importSourceId5),
-                          Field(&Storage::ImportDependency::dependencies,
-                                UnorderedElementsAre(IsImport("Qml", Storage::VersionNumber{2}),
-                                                     IsImport("Qml", Storage::VersionNumber{3}),
-                                                     IsImport("QtQuick", Storage::VersionNumber{}))))));
+                    AllOf(IsModuleDependency("Qml", Storage::VersionNumber{2}, moduleSourceId1),
+                          Field(&Storage::ModuleDependency::dependencies, IsEmpty())),
+                    AllOf(IsModuleDependency("Qml", Storage::VersionNumber{3}, moduleSourceIdQml3),
+                          Field(&Storage::ModuleDependency::dependencies, IsEmpty())),
+                    AllOf(IsModuleDependency("QtQuick", Storage::VersionNumber{}, moduleSourceId2),
+                          Field(&Storage::ModuleDependency::dependencies,
+                                UnorderedElementsAre(IsModule("Qml", Storage::VersionNumber{2})))),
+                    AllOf(IsModuleDependency("/path/to", Storage::VersionNumber{}, moduleSourceId5),
+                          Field(&Storage::ModuleDependency::dependencies,
+                                UnorderedElementsAre(IsModule("Qml", Storage::VersionNumber{2}),
+                                                     IsModule("Qml", Storage::VersionNumber{3}),
+                                                     IsModule("QtQuick", Storage::VersionNumber{}))))));
 }
 
-TEST_F(ProjectStorage, RemovingImportRemovesDependentTypesToo)
+TEST_F(ProjectStorage, RemovingModuleRemovesDependentTypesToo)
 {
     Storage::Types types{createTypes()};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
-    Storage::ImportDependencies importDependencies{createImportDependencies()};
-    importDependencies.pop_back();
-    importDependencies.pop_back();
-    storage.synchronize({}, {}, {}, {importSourceId2, importSourceId5}, {});
+    Storage::ModuleDependencies moduleDependencies{createModuleDependencies()};
+    moduleDependencies.pop_back();
+    moduleDependencies.pop_back();
+    storage.synchronize({}, {}, {}, {moduleSourceId2, moduleSourceId5}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(Storage::Import{"Qml", 2},
+                UnorderedElementsAre(AllOf(IsStorageType(Storage::Module{"Qml", 2},
                                                          "QObject",
                                                          Storage::NativeType{},
                                                          TypeAccessSemantics::Reference,
@@ -2299,12 +2299,12 @@ TEST_F(ProjectStorage, RemovingImportRemovesDependentTypesToo)
                                                                       IsExportedType("Obj"))))));
 }
 
-TEST_F(ProjectStorage, FetchTypeIdByImportIdAndName)
+TEST_F(ProjectStorage, FetchTypeIdByModuleIdAndName)
 {
     Storage::Types types{createTypes()};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
 
-    auto typeId = storage.fetchTypeIdByName(importId1, "QObject");
+    auto typeId = storage.fetchTypeIdByName(moduleId1, "QObject");
 
     ASSERT_THAT(storage.fetchTypeIdByExportedName("Object"), Eq(typeId));
 }
@@ -2316,7 +2316,7 @@ TEST_F(ProjectStorage, FetchTypeIdByExportedName)
 
     auto typeId = storage.fetchTypeIdByExportedName("Object");
 
-    ASSERT_THAT(storage.fetchTypeIdByName(importId1, "QObject"), Eq(typeId));
+    ASSERT_THAT(storage.fetchTypeIdByName(moduleId1, "QObject"), Eq(typeId));
 }
 
 TEST_F(ProjectStorage, FetchTypeIdByImporIdsAndExportedName)
@@ -2324,59 +2324,59 @@ TEST_F(ProjectStorage, FetchTypeIdByImporIdsAndExportedName)
     Storage::Types types{createTypes()};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
 
-    auto typeId = storage.fetchTypeIdByImportIdsAndExportedName({importId1, importId2}, "Object");
+    auto typeId = storage.fetchTypeIdByModuleIdsAndExportedName({moduleId1, moduleId2}, "Object");
 
-    ASSERT_THAT(storage.fetchTypeIdByName(importId1, "QObject"), Eq(typeId));
+    ASSERT_THAT(storage.fetchTypeIdByName(moduleId1, "QObject"), Eq(typeId));
 }
 
-TEST_F(ProjectStorage, FetchInvalidTypeIdByImporIdsAndExportedNameIfImportIdsAreEmpty)
+TEST_F(ProjectStorage, FetchInvalidTypeIdByImporIdsAndExportedNameIfModuleIdsAreEmpty)
 {
     Storage::Types types{createTypes()};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
 
-    auto typeId = storage.fetchTypeIdByImportIdsAndExportedName({}, "Object");
+    auto typeId = storage.fetchTypeIdByModuleIdsAndExportedName({}, "Object");
 
     ASSERT_FALSE(typeId.isValid());
 }
 
-TEST_F(ProjectStorage, FetchInvalidTypeIdByImporIdsAndExportedNameIfImportIdsAreInvalid)
+TEST_F(ProjectStorage, FetchInvalidTypeIdByImporIdsAndExportedNameIfModuleIdsAreInvalid)
 {
     Storage::Types types{createTypes()};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
 
-    auto typeId = storage.fetchTypeIdByImportIdsAndExportedName({ImportId{}}, "Object");
+    auto typeId = storage.fetchTypeIdByModuleIdsAndExportedName({ModuleId{}}, "Object");
 
     ASSERT_FALSE(typeId.isValid());
 }
 
-TEST_F(ProjectStorage, FetchInvalidTypeIdByImporIdsAndExportedNameIfNotInImport)
+TEST_F(ProjectStorage, FetchInvalidTypeIdByImporIdsAndExportedNameIfNotInModule)
 {
     Storage::Types types{createTypes()};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
 
-    auto typeId = storage.fetchTypeIdByImportIdsAndExportedName({importId2, importId3}, "Object");
+    auto typeId = storage.fetchTypeIdByModuleIdsAndExportedName({moduleId2, moduleId3}, "Object");
 
     ASSERT_FALSE(typeId.isValid());
 }
 
-TEST_F(ProjectStorage, FetchImportDepencencyIds)
+TEST_F(ProjectStorage, FetchModuleDepencencyIds)
 {
     Storage::Types types{createTypes()};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
 
-    auto importIds = storage.fetchImportDependencyIds({importId3});
+    auto moduleIds = storage.fetchModuleDependencyIds({moduleId3});
 
-    ASSERT_THAT(importIds, UnorderedElementsAre(importId1, importId2, importId3));
+    ASSERT_THAT(moduleIds, UnorderedElementsAre(moduleId1, moduleId2, moduleId3));
 }
 
-TEST_F(ProjectStorage, FetchImportDepencencyIdsForRootDepencency)
+TEST_F(ProjectStorage, FetchModuleDepencencyIdsForRootDepencency)
 {
     Storage::Types types{createTypes()};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
 
-    auto importIds = storage.fetchImportDependencyIds({importId1});
+    auto moduleIds = storage.fetchModuleDependencyIds({moduleId1});
 
-    ASSERT_THAT(importIds, ElementsAre(importId1));
+    ASSERT_THAT(moduleIds, ElementsAre(moduleId1));
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesAddAliasDeclarations)
@@ -2387,7 +2387,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddAliasDeclarations)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(Storage::Import{"QtQuick"},
+                    IsStorageType(Storage::Module{"QtQuick"},
                                   "QAliasItem",
                                   Storage::NativeType{"QQuickItem"},
                                   TypeAccessSemantics::Reference,
@@ -2415,7 +2415,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddAliasDeclarationsAgain)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(Storage::Import{"QtQuick"},
+                    IsStorageType(Storage::Module{"QtQuick"},
                                   "QAliasItem",
                                   Storage::NativeType{"QQuickItem"},
                                   TypeAccessSemantics::Reference,
@@ -2444,7 +2444,7 @@ TEST_F(ProjectStorage, SynchronizeTypesRemoveAliasDeclarations)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(Storage::Import{"QtQuick"},
+                    IsStorageType(Storage::Module{"QtQuick"},
                                   "QAliasItem",
                                   Storage::NativeType{"QQuickItem"},
                                   TypeAccessSemantics::Reference,
@@ -2487,7 +2487,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangeAliasDeclarationsTypeName)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(Storage::Import{"QtQuick"},
+                    IsStorageType(Storage::Module{"QtQuick"},
                                   "QAliasItem",
                                   Storage::NativeType{"QQuickItem"},
                                   TypeAccessSemantics::Reference,
@@ -2517,7 +2517,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangeAliasDeclarationsPropertyName)
     ASSERT_THAT(
         storage.fetchTypes(),
         Contains(
-            AllOf(IsStorageType(Storage::Import{"QtQuick"},
+            AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                 "QAliasItem",
                                 Storage::NativeType{"QQuickItem"},
                                 TypeAccessSemantics::Reference,
@@ -2553,7 +2553,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangeAliasDeclarationsToPropertyDeclarat
     ASSERT_THAT(
         storage.fetchTypes(),
         Contains(
-            AllOf(IsStorageType(Storage::Import{"QtQuick"},
+            AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                 "QAliasItem",
                                 Storage::NativeType{"QQuickItem"},
                                 TypeAccessSemantics::Reference,
@@ -2589,7 +2589,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangePropertyDeclarationsToAliasDeclarat
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(Storage::Import{"QtQuick"},
+                    IsStorageType(Storage::Module{"QtQuick"},
                                   "QAliasItem",
                                   Storage::NativeType{"QQuickItem"},
                                   TypeAccessSemantics::Reference,
@@ -2620,7 +2620,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangeAliasTargetPropertyDeclarationTrait
     ASSERT_THAT(
         storage.fetchTypes(),
         Contains(
-            AllOf(IsStorageType(Storage::Import{"QtQuick"},
+            AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                 "QAliasItem",
                                 Storage::NativeType{"QQuickItem"},
                                 TypeAccessSemantics::Reference,
@@ -2650,7 +2650,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangeAliasTargetPropertyDeclarationTypeN
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(Storage::Import{"QtQuick"},
+                    IsStorageType(Storage::Module{"QtQuick"},
                                   "QAliasItem",
                                   Storage::NativeType{"QQuickItem"},
                                   TypeAccessSemantics::Reference,
@@ -2690,7 +2690,7 @@ TEST_F(ProjectStorage, SynchronizeTypesRemovePropertyDeclarationAndAlias)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(Storage::Import{"QtQuick"},
+                    IsStorageType(Storage::Module{"QtQuick"},
                                   "QAliasItem",
                                   Storage::NativeType{"QQuickItem"},
                                   TypeAccessSemantics::Reference,
@@ -2726,7 +2726,7 @@ TEST_F(ProjectStorage, SynchronizeTypesRemoveTypeAndAliasPropertyDeclaration)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(Storage::Import{"QtQuick"},
+                    IsStorageType(Storage::Module{"QtQuick"},
                                   "QAliasItem",
                                   Storage::NativeType{"QQuickItem"},
                                   TypeAccessSemantics::Reference,
@@ -2757,7 +2757,7 @@ TEST_F(ProjectStorage, UpdateAliasPropertyIfPropertyIsOverloaded)
     ASSERT_THAT(
         storage.fetchTypes(),
         Contains(
-            AllOf(IsStorageType(Storage::Import{"QtQuick"},
+            AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                 "QAliasItem",
                                 Storage::NativeType{"QQuickItem"},
                                 TypeAccessSemantics::Reference,
@@ -2791,7 +2791,7 @@ TEST_F(ProjectStorage, AliasPropertyIsOverloaded)
     ASSERT_THAT(
         storage.fetchTypes(),
         Contains(
-            AllOf(IsStorageType(Storage::Import{"QtQuick"},
+            AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                 "QAliasItem",
                                 Storage::NativeType{"QQuickItem"},
                                 TypeAccessSemantics::Reference,
@@ -2826,7 +2826,7 @@ TEST_F(ProjectStorage, UpdateAliasPropertyIfOverloadedPropertyIsRemoved)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(Storage::Import{"QtQuick"},
+                    IsStorageType(Storage::Module{"QtQuick"},
                                   "QAliasItem",
                                   Storage::NativeType{"QQuickItem"},
                                   TypeAccessSemantics::Reference,
@@ -2850,13 +2850,13 @@ TEST_F(ProjectStorage, RelinkAliasProperty)
     Storage::Types types{createTypesWithAliases()};
     types[1].propertyDeclarations[0].typeName = Storage::NativeType{"QObject2"};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2, sourceId3, sourceId4}, {});
-    types[3].import = Storage::Import{"QtQuick"};
+    types[3].module = Storage::Module{"QtQuick"};
 
     storage.synchronize({}, {}, {types[3]}, {sourceId4}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(Storage::Import{"QtQuick"},
+                    IsStorageType(Storage::Module{"QtQuick"},
                                   "QAliasItem",
                                   Storage::NativeType{"QQuickItem"},
                                   TypeAccessSemantics::Reference,
@@ -2879,10 +2879,10 @@ TEST_F(ProjectStorage, DoNotRelinkAliasPropertyForExplicitExportedTypeName)
 {
     Storage::Types types{createTypesWithAliases()};
     types[1].propertyDeclarations[0].typeName = Storage::ExplicitExportedType{"Object2",
-                                                                              Storage::Import{
+                                                                              Storage::Module{
                                                                                   "/path/to"}};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2, sourceId3, sourceId4}, {});
-    types[3].import = Storage::Import{"QtQuick"};
+    types[3].module = Storage::Module{"QtQuick"};
 
     ASSERT_THROW(storage.synchronize({}, {}, {types[3]}, {sourceId4}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
@@ -2893,9 +2893,9 @@ TEST_F(ProjectStorage,
 {
     Storage::Types types{createTypesWithAliases()};
     types[1].propertyDeclarations[0].typeName = Storage::ExplicitExportedType{"Object2",
-                                                                              Storage::Import{
+                                                                              Storage::Module{
                                                                                   "/path/to"}};
-    types.push_back(Storage::Type{Storage::Import{"QtQuick"},
+    types.push_back(Storage::Type{Storage::Module{"QtQuick"},
                                   "QObject2",
                                   Storage::NativeType{},
                                   TypeAccessSemantics::Reference,
@@ -2906,7 +2906,7 @@ TEST_F(ProjectStorage,
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(Storage::Import{"QtQuick"},
+                    IsStorageType(Storage::Module{"QtQuick"},
                                   "QAliasItem",
                                   Storage::NativeType{"QQuickItem"},
                                   TypeAccessSemantics::Reference,
@@ -2937,7 +2937,7 @@ TEST_F(ProjectStorage, RelinkAliasPropertyReactToTypeNameChange)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(Storage::Import{"QtQuick"},
+                    IsStorageType(Storage::Module{"QtQuick"},
                                   "QAliasItem",
                                   Storage::NativeType{"QObject"},
                                   TypeAccessSemantics::Reference,
@@ -2962,12 +2962,12 @@ TEST_F(ProjectStorage, DoNotRelinkAliasPropertyForDeletedType)
     types[1].propertyDeclarations[0].typeName = Storage::NativeType{"QObject2"};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2, sourceId3, sourceId4}, {});
     types.erase(std::next(types.begin(), 2));
-    types[2].import = Storage::Import{"QtQuick"};
+    types[2].module = Storage::Module{"QtQuick"};
 
     storage.synchronize({}, {}, {types[2]}, {sourceId3, sourceId4}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Not(Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Not(Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                                  "QAliasItem",
                                                  Storage::NativeType{"QQuickItem"},
                                                  TypeAccessSemantics::Reference,
@@ -2994,13 +2994,13 @@ TEST_F(ProjectStorage, DoNotRelinkAliasPropertyForDeletedTypeAndPropertyTypeName
     types[1].propertyDeclarations[0].typeName = Storage::NativeType{"QObject2"};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2, sourceId3, sourceId4}, {});
     types.erase(std::next(types.begin(), 2));
-    types[2].import = Storage::Import{"QtQuick"};
+    types[2].module = Storage::Module{"QtQuick"};
     types[1].propertyDeclarations[0].typeName = Storage::NativeType{"QObject"};
 
     storage.synchronize({}, {}, {types[2]}, {sourceId3, sourceId4}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Not(Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Not(Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                                  "QAliasItem",
                                                  Storage::NativeType{"QQuickItem"},
                                                  TypeAccessSemantics::Reference,
@@ -3036,69 +3036,69 @@ TEST_F(ProjectStorage, ChangePrototypeTypeName)
     storage.synchronize({}, {}, {types[1]}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(IsStorageType(Storage::Module{"QtQuick"},
                                        "QQuickItem",
                                        Storage::NativeType{"QObject3"},
                                        TypeAccessSemantics::Reference,
                                        sourceId1)));
 }
 
-TEST_F(ProjectStorage, ChangePrototypeTypeImportId)
+TEST_F(ProjectStorage, ChangePrototypeTypeModuleId)
 {
     Storage::Types types{createTypes()};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
-    types[1].import = Storage::Import{"QtQuick"};
+    types[1].module = Storage::Module{"QtQuick"};
 
     storage.synchronize({}, {}, {types[1]}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(IsStorageType(Storage::Module{"QtQuick"},
                                        "QQuickItem",
                                        Storage::NativeType{"QObject"},
                                        TypeAccessSemantics::Reference,
                                        sourceId1)));
 }
 
-TEST_F(ProjectStorage, ChangeExplicitPrototypeTypeImportIdThows)
+TEST_F(ProjectStorage, ChangeExplicitPrototypeTypeModuleIdThows)
 {
     Storage::Types types{createTypes()};
-    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Import{"Qml"}};
+    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Module{"Qml"}};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
-    types[1].import = Storage::Import{"QtQuick"};
+    types[1].module = Storage::Module{"QtQuick"};
 
     ASSERT_THROW(storage.synchronize({}, {}, {types[1]}, {sourceId2}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
-TEST_F(ProjectStorage, ChangeExplicitPrototypeTypeImportId)
+TEST_F(ProjectStorage, ChangeExplicitPrototypeTypeModuleId)
 {
     Storage::Types types{createTypes()};
-    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Import{"Qml"}};
+    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Module{"Qml"}};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
-    types[1].import = Storage::Import{"QtQuick"};
-    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Import{"QtQuick"}};
+    types[1].module = Storage::Module{"QtQuick"};
+    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Module{"QtQuick"}};
 
     storage.synchronize({}, {}, {types[0], types[1]}, {sourceId1, sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(IsStorageType(Storage::Module{"QtQuick"},
                                        "QQuickItem",
                                        Storage::NativeType{"QObject"},
                                        TypeAccessSemantics::Reference,
                                        sourceId1)));
 }
 
-TEST_F(ProjectStorage, ChangePrototypeTypeNameAndImportId)
+TEST_F(ProjectStorage, ChangePrototypeTypeNameAndModuleId)
 {
     Storage::Types types{createTypesWithExportedTypeNamesOnly()};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
-    types[1].import = Storage::Import{"QtQuick"};
+    types[1].module = Storage::Module{"QtQuick"};
     types[1].typeName = "QObject3";
 
     storage.synchronize({}, {}, {types[1]}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(IsStorageType(Storage::Module{"QtQuick"},
                                        "QQuickItem",
                                        Storage::NativeType{"QObject3"},
                                        TypeAccessSemantics::Reference,
@@ -3120,7 +3120,7 @@ TEST_F(ProjectStorage, ThrowForPrototypeChainCycles)
 {
     Storage::Types types{createTypes()};
     types[1].prototype = Storage::ExportedType{"Object2"};
-    types.push_back(Storage::Type{Storage::Import{"/path/to"},
+    types.push_back(Storage::Type{Storage::Module{"/path/to"},
                                   "QObject2",
                                   Storage::ExportedType{"Item"},
                                   TypeAccessSemantics::Reference,
@@ -3158,7 +3158,7 @@ TEST_F(ProjectStorage, RecursiveAliases)
     storage.synchronize({}, {}, types, {sourceId1, sourceId2, sourceId3, sourceId4, sourceId5}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QAliasItem2",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -3179,7 +3179,7 @@ TEST_F(ProjectStorage, RecursiveAliasesChangePropertyType)
     storage.synchronize({}, {}, {types[1]}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QAliasItem2",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -3204,7 +3204,7 @@ TEST_F(ProjectStorage, UpdateAliasesAfterInjectingProperty)
     storage.synchronize({}, {}, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QAliasItem2",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -3231,7 +3231,7 @@ TEST_F(ProjectStorage, UpdateAliasesAfterChangeAliasToProperty)
     storage.synchronize({}, {}, {types[2]}, {sourceId3}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                AllOf(Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                AllOf(Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                                    "QAliasItem2",
                                                    Storage::NativeType{"QObject"},
                                                    TypeAccessSemantics::Reference,
@@ -3243,7 +3243,7 @@ TEST_F(ProjectStorage, UpdateAliasesAfterChangeAliasToProperty)
                                                Storage::PropertyDeclarationTraits::IsList
                                                    | Storage::PropertyDeclarationTraits::IsReadOnly,
                                                "objects"))))),
-                      Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                      Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                                    "QAliasItem",
                                                    Storage::NativeType{"QQuickItem"},
                                                    TypeAccessSemantics::Reference,
@@ -3270,7 +3270,7 @@ TEST_F(ProjectStorage, UpdateAliasesAfterChangePropertyToAlias)
     storage.synchronize({}, {}, {types[1]}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QAliasItem2",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -3311,8 +3311,8 @@ TEST_F(ProjectStorage, CheckForProtoTypeCycleAfterUpdateThrows)
 TEST_F(ProjectStorage, ExplicitPrototype)
 {
     Storage::Types types{createTypes()};
-    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Import{"Qml"}};
-    types.push_back(Storage::Type{Storage::Import{"QtQuick"},
+    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Module{"Qml"}};
+    types.push_back(Storage::Type{Storage::Module{"QtQuick"},
                                   "QQuickObject",
                                   Storage::NativeType{},
                                   TypeAccessSemantics::Reference,
@@ -3322,27 +3322,27 @@ TEST_F(ProjectStorage, ExplicitPrototype)
     storage.synchronize({}, {}, types, {sourceId1, sourceId2, sourceId3}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(IsStorageType(Storage::Module{"QtQuick"},
                                        "QQuickItem",
                                        Storage::NativeType{"QObject"},
                                        TypeAccessSemantics::Reference,
                                        sourceId1)));
 }
 
-TEST_F(ProjectStorage, ExplicitPrototypeUpperDownTheImportChainThrows)
+TEST_F(ProjectStorage, ExplicitPrototypeUpperDownTheModuleChainThrows)
 {
     Storage::Types types{createTypes()};
-    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Import{"QtQuick"}};
+    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Module{"QtQuick"}};
 
     ASSERT_THROW(storage.synchronize({}, {}, types, {sourceId1, sourceId2, sourceId3}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
-TEST_F(ProjectStorage, ExplicitPrototypeUpperInTheImportChain)
+TEST_F(ProjectStorage, ExplicitPrototypeUpperInTheModuleChain)
 {
     Storage::Types types{createTypes()};
-    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Import{"QtQuick"}};
-    types.push_back(Storage::Type{Storage::Import{"QtQuick"},
+    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Module{"QtQuick"}};
+    types.push_back(Storage::Type{Storage::Module{"QtQuick"},
                                   "QQuickObject",
                                   Storage::NativeType{},
                                   TypeAccessSemantics::Reference,
@@ -3352,7 +3352,7 @@ TEST_F(ProjectStorage, ExplicitPrototypeUpperInTheImportChain)
     storage.synchronize({}, {}, types, {sourceId1, sourceId2, sourceId3}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(IsStorageType(Storage::Module{"QtQuick"},
                                        "QQuickItem",
                                        Storage::NativeType{"QQuickObject"},
                                        TypeAccessSemantics::Reference,
@@ -3362,8 +3362,8 @@ TEST_F(ProjectStorage, ExplicitPrototypeUpperInTheImportChain)
 TEST_F(ProjectStorage, ExplicitPrototypeWithWrongVersionThrows)
 {
     Storage::Types types{createTypes()};
-    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Import{"Qml", 4}};
-    types.push_back(Storage::Type{Storage::Import{"QtQuick"},
+    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Module{"Qml", 4}};
+    types.push_back(Storage::Type{Storage::Module{"QtQuick"},
                                   "QQuickObject",
                                   Storage::NativeType{},
                                   TypeAccessSemantics::Reference,
@@ -3377,8 +3377,8 @@ TEST_F(ProjectStorage, ExplicitPrototypeWithWrongVersionThrows)
 TEST_F(ProjectStorage, ExplicitPrototypeWithVersion)
 {
     Storage::Types types{createTypes()};
-    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Import{"Qml", 2}};
-    types.push_back(Storage::Type{Storage::Import{"QtQuick"},
+    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Module{"Qml", 2}};
+    types.push_back(Storage::Type{Storage::Module{"QtQuick"},
                                   "QQuickObject",
                                   Storage::NativeType{},
                                   TypeAccessSemantics::Reference,
@@ -3388,7 +3388,7 @@ TEST_F(ProjectStorage, ExplicitPrototypeWithVersion)
     storage.synchronize({}, {}, types, {sourceId1, sourceId2, sourceId3}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(IsStorageType(Storage::Module{"QtQuick"},
                                        "QQuickItem",
                                        Storage::NativeType{"QObject"},
                                        TypeAccessSemantics::Reference,
@@ -3398,27 +3398,27 @@ TEST_F(ProjectStorage, ExplicitPrototypeWithVersion)
 TEST_F(ProjectStorage, ExplicitPrototypeWithVersionInTheProtoTypeChain)
 {
     Storage::Types types{createTypes()};
-    auto importDependencyQtQuick2 = Storage::ImportDependency{
+    auto moduleDependencyQtQuick2 = Storage::ModuleDependency{
         "QtQuick",
         Storage::VersionNumber{2},
-        importSourceId2,
-        {Storage::Import{"Qml", Storage::VersionNumber{2}}}};
-    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Import{"QtQuick", 2}};
-    types.push_back(Storage::Type{Storage::Import{"QtQuick"},
+        moduleSourceId2,
+        {Storage::Module{"Qml", Storage::VersionNumber{2}}}};
+    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Module{"QtQuick", 2}};
+    types.push_back(Storage::Type{Storage::Module{"QtQuick"},
                                   "QQuickObject",
                                   Storage::NativeType{},
                                   TypeAccessSemantics::Reference,
                                   sourceId3,
                                   {Storage::ExportedType{"Object"}}});
 
-    storage.synchronize({importDependencyQtQuick2},
+    storage.synchronize({moduleDependencyQtQuick2},
                         {},
                         types,
-                        {sourceId1, sourceId2, sourceId3, importSourceId2},
+                        {sourceId1, sourceId2, sourceId3, moduleSourceId2},
                         {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(Storage::Import{"QtQuick", 2},
+                Contains(IsStorageType(Storage::Module{"QtQuick", 2},
                                        "QQuickItem",
                                        Storage::NativeType{"QQuickObject"},
                                        TypeAccessSemantics::Reference,
@@ -3428,17 +3428,17 @@ TEST_F(ProjectStorage, ExplicitPrototypeWithVersionInTheProtoTypeChain)
 TEST_F(ProjectStorage, ExplicitPrototypeWithVersionDownTheProtoTypeChainThrows)
 {
     Storage::Types types{createTypes()};
-    auto importDependencyQtQuick2 = Storage::ImportDependency{
+    auto moduleDependencyQtQuick2 = Storage::ModuleDependency{
         "QtQuick",
         Storage::VersionNumber{2},
-        importSourceId2,
-        {Storage::Import{"Qml", Storage::VersionNumber{2}}}};
-    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Import{"QtQuick", 2}};
+        moduleSourceId2,
+        {Storage::Module{"Qml", Storage::VersionNumber{2}}}};
+    types[0].prototype = Storage::ExplicitExportedType{"Object", Storage::Module{"QtQuick", 2}};
 
-    ASSERT_THROW(storage.synchronize({importDependencyQtQuick2},
+    ASSERT_THROW(storage.synchronize({moduleDependencyQtQuick2},
                                      {},
                                      types,
-                                     {sourceId1, sourceId2, sourceId3, importSourceId2},
+                                     {sourceId1, sourceId2, sourceId3, moduleSourceId2},
                                      {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
@@ -3447,9 +3447,9 @@ TEST_F(ProjectStorage, ExplicitPropertyDeclarationTypeName)
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::ExplicitExportedType{"Object",
-                                                                              Storage::Import{
+                                                                              Storage::Module{
                                                                                   "Qml"}};
-    types.push_back(Storage::Type{Storage::Import{"QtQuick"},
+    types.push_back(Storage::Type{Storage::Module{"QtQuick"},
                                   "QQuickObject",
                                   Storage::NativeType{},
                                   TypeAccessSemantics::Reference,
@@ -3466,24 +3466,24 @@ TEST_F(ProjectStorage, ExplicitPropertyDeclarationTypeName)
                                                          Storage::PropertyDeclarationTraits::IsList)))));
 }
 
-TEST_F(ProjectStorage, ExplicitPropertyDeclarationTypeNameDownTheImportChainThrows)
+TEST_F(ProjectStorage, ExplicitPropertyDeclarationTypeNameDownTheModuleChainThrows)
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::ExplicitExportedType{"Object",
-                                                                              Storage::Import{
+                                                                              Storage::Module{
                                                                                   "QtQuick"}};
 
     ASSERT_THROW(storage.synchronize({}, {}, types, {sourceId1, sourceId2, sourceId3}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
-TEST_F(ProjectStorage, ExplicitPropertyDeclarationTypeNameInTheImportChain)
+TEST_F(ProjectStorage, ExplicitPropertyDeclarationTypeNameInTheModuleChain)
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::ExplicitExportedType{"Object",
-                                                                              Storage::Import{
+                                                                              Storage::Module{
                                                                                   "QtQuick"}};
-    types.push_back(Storage::Type{Storage::Import{"QtQuick"},
+    types.push_back(Storage::Type{Storage::Module{"QtQuick"},
                                   "QQuickObject",
                                   Storage::NativeType{},
                                   TypeAccessSemantics::Reference,
@@ -3504,7 +3504,7 @@ TEST_F(ProjectStorage, ExplicitPropertyDeclarationTypeNameWithVersion)
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::ExplicitExportedType{"Object",
-                                                                              Storage::Import{"Qml",
+                                                                              Storage::Module{"Qml",
                                                                                               2}};
 
     storage.synchronize({}, {}, types, {sourceId1, sourceId2, sourceId3}, {});
@@ -3520,51 +3520,51 @@ TEST_F(ProjectStorage, ExplicitPropertyDeclarationTypeNameWithVersion)
 TEST_F(ProjectStorage, PrototypeWithVersionDownTheProtoTypeChainThrows)
 {
     Storage::Types types{createTypes()};
-    auto importDependencyQtQuick2 = Storage::ImportDependency{
+    auto moduleDependencyQtQuick2 = Storage::ModuleDependency{
         "QtQuick",
         Storage::VersionNumber{2},
-        importSourceId2,
-        {Storage::Import{"Qml", Storage::VersionNumber{2}}}};
+        moduleSourceId2,
+        {Storage::Module{"Qml", Storage::VersionNumber{2}}}};
     types[0].prototype = Storage::ExportedType{"Object"};
-    auto document = Storage::Document{sourceId1, {Storage::Import{"QtQuick"}}};
+    auto document = Storage::Document{sourceId1, {Storage::Module{"QtQuick"}}};
 
-    ASSERT_THROW(storage.synchronize({importDependencyQtQuick2},
+    ASSERT_THROW(storage.synchronize({moduleDependencyQtQuick2},
                                      {document},
                                      types,
-                                     {sourceId1, sourceId2, sourceId3, importSourceId2},
+                                     {sourceId1, sourceId2, sourceId3, moduleSourceId2},
                                      {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
-TEST_F(ProjectStorage, ChangePropertyTypeImportIdWithExplicitTypeThrows)
+TEST_F(ProjectStorage, ChangePropertyTypeModuleIdWithExplicitTypeThrows)
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::ExplicitExportedType{"Object",
-                                                                              Storage::Import{
+                                                                              Storage::Module{
                                                                                   "Qml"}};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
-    types[1].import = Storage::Import{"QtQuick"};
+    types[1].module = Storage::Module{"QtQuick"};
 
     ASSERT_THROW(storage.synchronize({}, {}, {types[1]}, {sourceId2}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
-TEST_F(ProjectStorage, ChangePropertyTypeImportIdWithExplicitType)
+TEST_F(ProjectStorage, ChangePropertyTypeModuleIdWithExplicitType)
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::ExplicitExportedType{"Object",
-                                                                              Storage::Import{
+                                                                              Storage::Module{
                                                                                   "Qml"}};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
     types[0].propertyDeclarations[0].typeName = Storage::ExplicitExportedType{"Object",
-                                                                              Storage::Import{
+                                                                              Storage::Module{
                                                                                   "QtQuick"}};
-    types[1].import = Storage::Import{"QtQuick"};
+    types[1].module = Storage::Module{"QtQuick"};
 
     storage.synchronize({}, {}, types, {sourceId1, sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"QtQuick"},
+                Contains(AllOf(IsStorageType(Storage::Module{"QtQuick"},
                                              "QQuickItem",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
@@ -3664,13 +3664,13 @@ TEST_F(ProjectStorage, SynchronizeTypesWithoutTypeName)
     Storage::Types types{createTypesWithAliases()};
     storage.synchronize({}, {}, types, {sourceId1, sourceId2, sourceId3, sourceId4}, {});
     types[3].typeName.clear();
-    types[3].import.name.clear();
+    types[3].module.name.clear();
     types[3].prototype = Storage::ExportedType{"Object"};
 
     storage.synchronize({}, {}, {types[3]}, {sourceId4}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(Storage::Import{"/path/to"},
+                Contains(AllOf(IsStorageType(Storage::Module{"/path/to"},
                                              "QObject2",
                                              Storage::NativeType{"QObject"},
                                              TypeAccessSemantics::Reference,
diff --git a/tests/unit/unittest/projectstoragemock.h b/tests/unit/unittest/projectstoragemock.h
index e3eb0e35de1..01fe3360f3c 100644
--- a/tests/unit/unittest/projectstoragemock.h
+++ b/tests/unit/unittest/projectstoragemock.h
@@ -38,7 +38,7 @@ class ProjectStorageMock : public QmlDesigner::ProjectStorageInterface
 public:
     MOCK_METHOD(void,
                 synchronize,
-                (QmlDesigner::Storage::ImportDependencies importDependencies,
+                (QmlDesigner::Storage::ModuleDependencies moduleDependencies,
                  QmlDesigner::Storage::Documents documents,
                  QmlDesigner::Storage::Types types,
                  QmlDesigner::SourceIds sourceIds,
diff --git a/tests/unit/unittest/projectstorageupdater-test.cpp b/tests/unit/unittest/projectstorageupdater-test.cpp
index 3b16f2e636e..0e1089bc466 100644
--- a/tests/unit/unittest/projectstorageupdater-test.cpp
+++ b/tests/unit/unittest/projectstorageupdater-test.cpp
@@ -44,19 +44,20 @@ namespace Storage = QmlDesigner::Storage;
 using QmlDesigner::FileStatus;
 using QmlDesigner::SourceId;
 using QmlDesigner::Storage::TypeAccessSemantics;
+namespace Storage = QmlDesigner::Storage;
 
 MATCHER_P5(IsStorageType,
-           import,
+           module,
            typeName,
            prototype,
            accessSemantics,
            sourceId,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::Type{import, typeName, prototype, accessSemantics, sourceId}))
+               + PrintToString(Storage::Type{module, typeName, prototype, accessSemantics, sourceId}))
 {
     const Storage::Type &type = arg;
 
-    return type.import == import && type.typeName == typeName
+    return type.module == module && type.typeName == typeName
            && type.accessSemantics == accessSemantics && type.sourceId == sourceId
            && Storage::TypeName{prototype} == type.prototype;
 }
@@ -132,7 +133,7 @@ protected:
                                         qmlDocumentParserMock,
                                         qmlTypesParserMock};
     SourceId objectTypeSourceId{sourcePathCache.sourceId("/path/Object")};
-    Storage::Type objectType{Storage::Import{"Qml", 2},
+    Storage::Type objectType{Storage::Module{"Qml", 2},
                              "QObject",
                              Storage::NativeType{},
                              Storage::TypeAccessSemantics::Reference,
@@ -246,7 +247,7 @@ TEST_F(ProjectStorageUpdater, SynchronizeQmlTypes)
     ON_CALL(fileSystemMock, contentAsQString(Eq(QString("/path/example.qmltypes"))))
         .WillByDefault(Return(qmltypes));
     ON_CALL(qmlTypesParserMock, parse(qmltypes, _, _, _))
-        .WillByDefault([&](auto, auto &importDependencies, auto &types, auto &sourceIds) {
+        .WillByDefault([&](auto, auto &moduleDependencies, auto &types, auto &sourceIds) {
             types.push_back(objectType);
         });
 
@@ -266,7 +267,7 @@ TEST_F(ProjectStorageUpdater, SynchronizeQmlTypesAreEmptyIfFileDoesNotChanged)
     ON_CALL(fileSystemMock, contentAsQString(Eq(QString("/path/example.qmltypes"))))
         .WillByDefault(Return(qmltypes));
     ON_CALL(qmlTypesParserMock, parse(qmltypes, _, _, _))
-        .WillByDefault([&](auto, auto &importDependencies, auto &types, auto &sourceIds) {
+        .WillByDefault([&](auto, auto &moduleDependencies, auto &types, auto &sourceIds) {
             types.push_back(objectType);
         });
     ON_CALL(fileSystemMock, fileStatus(Eq(qmltypesPathSourceId)))
@@ -349,7 +350,7 @@ TEST_F(ProjectStorageUpdater, SynchronizeQmlDocuments)
     EXPECT_CALL(projectStorageMock,
                 synchronize(_,
                             _,
-                            Contains(AllOf(IsStorageType(Storage::Import{"Example", 1},
+                            Contains(AllOf(IsStorageType(Storage::Module{"Example", 1},
                                                          "First.qml",
                                                          Storage::ExportedType{"Object"},
                                                          TypeAccessSemantics::Reference,
diff --git a/tests/unit/unittest/qmltypesparsermock.h b/tests/unit/unittest/qmltypesparsermock.h
index e88e0db8fd7..d321cb88377 100644
--- a/tests/unit/unittest/qmltypesparsermock.h
+++ b/tests/unit/unittest/qmltypesparsermock.h
@@ -35,7 +35,7 @@ public:
     MOCK_METHOD(void,
                 parse,
                 (const QString &sourceContent,
-                 QmlDesigner::Storage::ImportDependencies &importDependencies,
+                 QmlDesigner::Storage::ModuleDependencies &moduleDependencies,
                  QmlDesigner::Storage::Types &types,
                  QmlDesigner::SourceIds &sourceIds),
                 (override));