QmlDesigner: Support multiple module ids per type

The type will be use source id and name instead of module id and name as
key.

Task-number: QDS-5236
Task-number: QDS-5238
Change-Id: Ibc9c298dc0a6363b630173ec4981d574cecd02ff
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>

16 files changed, 1832 insertions, 2203 deletions

diff --git a/src/libs/utils/set_algorithm.h b/src/libs/utils/set_algorithm.h
index 42a21f3f2d..97e33a047f 100644
--- a/src/libs/utils/set_algorithm.h
+++ b/src/libs/utils/set_algorithm.h
@@ -99,6 +99,24 @@ bool set_intersection_compare(
     return false;
 }
 
+template<class InputIt1, class InputIt2, class Callable, class Compare>
+void set_greedy_difference(
+    InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, Callable call, Compare comp)
+{
+    while (first1 != last1 && first2 != last2) {
+        if (comp(*first1, *first2)) {
+            call(*first1++);
+        } else if (comp(*first2, *first1)) {
+            ++first2;
+        } else {
+            ++first1;
+        }
+    }
+
+    while (first1 != last1)
+        call(*first1++);
+}
+
 template<typename InputIt1, typename InputIt2, typename BinaryPredicate, typename Callable, typename Value>
 Value mismatch_collect(InputIt1 first1,
                        InputIt1 last1,
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
index 9bd49ef467..f6412d231b 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
@@ -28,6 +28,7 @@
 #include "projectstorageexceptions.h"
 #include "projectstorageinterface.h"
 #include "sourcepathcachetypes.h"
+#include "storagecache.h"
 
 #include <sqlitealgorithms.h>
 #include <sqlitetable.h>
@@ -35,7 +36,9 @@
 
 #include <utils/algorithm.h>
 #include <utils/optional.h>
+#include <utils/set_algorithm.h>
 
+#include <algorithm>
 #include <tuple>
 
 namespace QmlDesigner {
@@ -53,18 +56,24 @@ public:
     ProjectStorage(Database &database, bool isInitialized)
         : database{database}
         , initializer{database, isInitialized}
-    {}
+    {
+        moduleCache.populate();
+    }
 
-    void synchronize(Storage::Modules modules,
-                     Storage::Imports imports,
+    void synchronize(Storage::Imports imports,
                      Storage::Types types,
                      SourceIds sourceIds,
                      FileStatuses fileStatuses) override
     {
         Sqlite::ImmediateTransaction transaction{database};
 
-        std::vector<AliasPropertyDeclaration> insertedAliasPropertyDeclarations;
-        std::vector<AliasPropertyDeclaration> updatedAliasPropertyDeclarations;
+        AliasPropertyDeclarations insertedAliasPropertyDeclarations;
+        AliasPropertyDeclarations updatedAliasPropertyDeclarations;
+
+        AliasPropertyDeclarations relinkableAliasPropertyDeclarations;
+        PropertyDeclarations relinkablePropertyDeclarations;
+        Prototypes relinkablePrototypes;
+        TypeIds deletedTypeIds;
 
         TypeIds updatedTypeIds;
         updatedTypeIds.reserve(types.size());
@@ -78,40 +87,45 @@ public:
         std::sort(sourceIdValues.begin(), sourceIdValues.end());
 
         synchronizeFileStatuses(fileStatuses, sourceIdValues);
-        synchronizeModules(modules, typeIdsToBeDeleted, sourceIdValues);
         synchronizeImports(imports, sourceIdValues);
         synchronizeTypes(types,
                          updatedTypeIds,
                          insertedAliasPropertyDeclarations,
-                         updatedAliasPropertyDeclarations);
-
-        deleteNotUpdatedTypes(updatedTypeIds, sourceIdValues, typeIdsToBeDeleted);
+                         updatedAliasPropertyDeclarations,
+                         relinkableAliasPropertyDeclarations,
+                         relinkablePropertyDeclarations,
+                         relinkablePrototypes,
+                         sourceIdValues);
+
+        deleteNotUpdatedTypes(updatedTypeIds,
+                              sourceIdValues,
+                              typeIdsToBeDeleted,
+                              relinkableAliasPropertyDeclarations,
+                              relinkablePropertyDeclarations,
+                              relinkablePrototypes,
+                              deletedTypeIds);
+
+        relink(relinkableAliasPropertyDeclarations,
+               relinkablePropertyDeclarations,
+               relinkablePrototypes,
+               deletedTypeIds);
 
         linkAliases(insertedAliasPropertyDeclarations, updatedAliasPropertyDeclarations);
 
         transaction.commit();
     }
 
-    ModuleId fetchModuleId(Utils::SmallStringView moduleName)
+    ModuleId moduleId(Utils::SmallStringView moduleName) override
     {
-        Sqlite::DeferredTransaction transaction{database};
-
-        ModuleId moduleId = fetchModuleIdUnguarded(moduleName);
-
-        transaction.commit();
-
-        return moduleId;
+        return moduleCache.id(moduleName);
     }
 
-    ModuleIds fetchModuleIds(const Storage::Modules &modules)
+    Utils::SmallString moduleName(ModuleId moduleId)
     {
-        Sqlite::DeferredTransaction transaction{database};
-
-        ModuleIds moduleIds = fetchModuleIdsUnguarded(modules);
-
-        transaction.commit();
+        if (!moduleId)
+            throw ModuleDoesNotExists{};
 
-        return moduleIds;
+        return moduleCache.value(moduleId);
     }
 
     PropertyDeclarationId fetchPropertyDeclarationByTypeIdAndName(TypeId typeId,
@@ -132,9 +146,9 @@ public:
             static_cast<void *>(moduleIds.data()), static_cast<long long>(moduleIds.size()), name);
     }
 
-    TypeId fetchTypeIdByName(ModuleId moduleId, Utils::SmallStringView name)
+    TypeId fetchTypeIdByName(SourceId sourceId, Utils::SmallStringView name)
     {
-        return selectTypeIdByModuleIdAndNameStatement.template valueWithTransaction<TypeId>(&moduleId,
+        return selectTypeIdBySourceIdAndNameStatement.template valueWithTransaction<TypeId>(&sourceId,
                                                                                             name);
     }
 
@@ -283,11 +297,6 @@ public:
         return writeSourceId(sourceContextId, sourceName);
     }
 
-    auto fetchAllModules() const
-    {
-        return selectAllModulesStatement.template valuesWithTransaction<Storage::Module>(128);
-    }
-
     auto fetchAllFileStatuses() const
     {
         return selectAllFileStatusesStatement.template rangeWithTransaction<FileStatus>();
@@ -302,6 +311,73 @@ public:
     SourceIds fetchSourceDependencieIds(SourceId sourceId) const override { return {}; }
 
 private:
+    class ModuleStorageAdapter
+    {
+    public:
+        auto fetchId(const Utils::SmallStringView name) { return storage.fetchModuleId(name); }
+
+        auto fetchValue(ModuleId id) { return storage.fetchModuleName(id); }
+
+        auto fetchAll() { return storage.fetchAllModules(); }
+
+        ProjectStorage &storage;
+    };
+
+    class Module : public StorageCacheEntry<Utils::PathString, Utils::SmallStringView, ModuleId>
+    {
+        using Base = StorageCacheEntry<Utils::PathString, Utils::SmallStringView, ModuleId>;
+
+    public:
+        using Base::Base;
+
+        friend bool operator==(const Module &first, const Module &second)
+        {
+            return first.id == second.id && first.value == second.value;
+        }
+    };
+
+    friend ModuleStorageAdapter;
+
+    static bool moduleNameLess(Utils::SmallStringView first, Utils::SmallStringView second) noexcept
+    {
+        return Utils::reverseCompare(first, second) < 0;
+    }
+
+    using ModuleCache = StorageCache<Utils::PathString,
+                                     Utils::SmallStringView,
+                                     ModuleId,
+                                     ModuleStorageAdapter,
+                                     NonLockingMutex,
+                                     moduleNameLess,
+                                     Module>;
+
+    ModuleId fetchModuleId(Utils::SmallStringView moduleName)
+    {
+        Sqlite::DeferredTransaction transaction{database};
+
+        ModuleId moduleId = fetchModuleIdUnguarded(moduleName);
+
+        transaction.commit();
+
+        return moduleId;
+    }
+
+    auto fetchModuleName(ModuleId id)
+    {
+        Sqlite::DeferredTransaction transaction{database};
+
+        auto moduleName = fetchModuleNameUnguarded(id);
+
+        transaction.commit();
+
+        return moduleName;
+    }
+
+    auto fetchAllModules() const
+    {
+        return selectAllModulesStatement.template valuesWithTransaction<Module>(128);
+    }
+
     class AliasPropertyDeclaration
     {
     public:
@@ -318,6 +394,13 @@ private:
             , aliasPropertyDeclarationId{aliasPropertyDeclarationId}
         {}
 
+        friend bool operator<(const AliasPropertyDeclaration &first,
+                              const AliasPropertyDeclaration &second)
+        {
+            return std::tie(first.typeId, first.propertyDeclarationId)
+                   < std::tie(second.typeId, second.propertyDeclarationId);
+        }
+
     public:
         TypeId typeId;
         PropertyDeclarationId propertyDeclarationId;
@@ -326,6 +409,8 @@ private:
         PropertyDeclarationId aliasPropertyDeclarationId;
     };
 
+    using AliasPropertyDeclarations = std::vector<AliasPropertyDeclaration>;
+
     class PropertyDeclaration
     {
     public:
@@ -345,12 +430,20 @@ private:
             , importedTypeNameId{importedTypeNameId}
         {}
 
+        friend bool operator<(const PropertyDeclaration &first, const PropertyDeclaration &second)
+        {
+            return std::tie(first.typeId, first.propertyDeclarationId)
+                   < std::tie(second.typeId, second.propertyDeclarationId);
+        }
+
     public:
         TypeId typeId;
         PropertyDeclarationId propertyDeclarationId;
         ImportedTypeNameId importedTypeNameId;
     };
 
+    using PropertyDeclarations = std::vector<PropertyDeclaration>;
+
     class Prototype
     {
     public:
@@ -359,15 +452,58 @@ private:
             , prototypeNameId{std::move(prototypeNameId)}
         {}
 
+        friend bool operator<(Prototype first, Prototype second)
+        {
+            return first.typeId < second.typeId;
+        }
+
     public:
         TypeId typeId;
         ImportedTypeNameId prototypeNameId;
     };
 
+    using Prototypes = std::vector<Prototype>;
+
+    template<typename Type>
+    struct TypeCompare
+    {
+        bool operator()(const Type &type, TypeId typeId) { return type.typeId < typeId; };
+
+        bool operator()(TypeId typeId, const Type &type) { return typeId < type.typeId; };
+
+        bool operator()(const Type &first, const Type &second)
+        {
+            return first.typeId < second.typeId;
+        };
+    };
+
+    template<typename Property>
+    struct PropertyCompare
+    {
+        bool operator()(const Property &property, PropertyDeclarationId id)
+        {
+            return property.propertyDeclarationId < id;
+        };
+
+        bool operator()(PropertyDeclarationId id, const Property &property)
+        {
+            return id < property.propertyDeclarationId;
+        };
+
+        bool operator()(const Property &first, const Property &second)
+        {
+            return first.propertyDeclarationId < second.propertyDeclarationId;
+        };
+    };
+
     void synchronizeTypes(Storage::Types &types,
                           TypeIds &updatedTypeIds,
-                          std::vector<AliasPropertyDeclaration> &insertedAliasPropertyDeclarations,
-                          std::vector<AliasPropertyDeclaration> &updatedAliasPropertyDeclarations)
+                          AliasPropertyDeclarations &insertedAliasPropertyDeclarations,
+                          AliasPropertyDeclarations &updatedAliasPropertyDeclarations,
+                          AliasPropertyDeclarations &relinkableAliasPropertyDeclarations,
+                          PropertyDeclarations &relinkablePropertyDeclarations,
+                          Prototypes &relinkablePrototypes,
+                          const std::vector<int> &sourceIdValues)
     {
         Storage::ExportedTypes exportedTypes;
         exportedTypes.reserve(types.size() * 3);
@@ -381,16 +517,19 @@ private:
             extractExportedTypes(typeId, type, exportedTypes);
         }
 
-        synchronizeExportedTypes(updatedTypeIds, exportedTypes);
-
-        for (auto &&type : types)
-            syncPrototypes(type);
-
-        for (auto &&type : types)
-            resetRemovedAliasPropertyDeclarationsToNull(type.typeId, type.propertyDeclarations);
+        synchronizeExportedTypes(sourceIdValues,
+                                 updatedTypeIds,
+                                 exportedTypes,
+                                 relinkableAliasPropertyDeclarations,
+                                 relinkablePropertyDeclarations,
+                                 relinkablePrototypes);
 
-        for (auto &&type : types)
-            syncDeclarations(type, insertedAliasPropertyDeclarations, updatedAliasPropertyDeclarations);
+        syncPrototypes(types, relinkablePrototypes);
+        resetRemovedAliasPropertyDeclarationsToNull(types, relinkableAliasPropertyDeclarations);
+        syncDeclarations(types,
+                         insertedAliasPropertyDeclarations,
+                         updatedAliasPropertyDeclarations,
+                         relinkablePropertyDeclarations);
     }
 
     void synchronizeFileStatuses(FileStatuses &fileStatuses, const std::vector<int> &sourceIdValues)
@@ -428,43 +567,10 @@ private:
         Sqlite::insertUpdateDelete(range, fileStatuses, compareKey, insert, update, remove);
     }
 
-    void synchronizeModules(Storage::Modules &modules,
-                            TypeIds &typeIdsToBeDeleted,
-                            const std::vector<int> &moduleIdValues)
-    {
-        auto compareKey = [](auto &&first, auto &&second) {
-            return first.sourceId.id - second.sourceId.id;
-        };
-
-        std::sort(modules.begin(), modules.end(), [&](auto &&first, auto &&second) {
-            return compareKey(first, second) < 0;
-        });
-
-        auto range = selectModulesForIdsStatement.template range<Storage::ModuleView>(
-            Utils::span(moduleIdValues));
-
-        auto insert = [&](Storage::Module &module) {
-            insertModuleStatement.write(module.name, &module.sourceId);
-        };
-
-        auto update = [&](const Storage::ModuleView &moduleView, Storage::Module &module) {
-            if (moduleView.name != module.name)
-                updateModuleStatement.write(&moduleView.sourceId, module.name);
-        };
-
-        auto remove = [&](const Storage::ModuleView &moduleView) {
-            deleteModuleStatement.write(&moduleView.sourceId);
-            selectTypeIdsForModuleIdStatement.readTo(typeIdsToBeDeleted, &moduleView.sourceId);
-        };
-
-        Sqlite::insertUpdateDelete(range, modules, compareKey, insert, update, remove);
-    }
-
     void synchronizeImports(Storage::Imports &imports, std::vector<int> &sourceIdValues)
     {
         deleteDocumentImportsForDeletedDocuments(imports, sourceIdValues);
 
-        addModuleIdToImports(imports);
         synchronizeDocumentImports(imports, sourceIdValues);
     }
 
@@ -487,50 +593,28 @@ private:
         deleteDocumentImportsWithSourceIdsStatement.write(Utils::span{documentSourceIdsToBeDeleted});
     }
 
-    void synchronizeModulesAndUpdatesModuleIds(Storage::Modules &modules,
-                                               TypeIds &typeIdsToBeDeleted,
-                                               const std::vector<int> &moduleIds)
+    ModuleId fetchModuleIdUnguarded(Utils::SmallStringView name) const
     {
-        auto compareKey = [](auto &&first, auto &&second) {
-            return first.sourceId.id - second.sourceId.id;
-        };
+        auto moduleId = selectModuleIdByNameStatement.template value<ModuleId>(name);
 
-        std::sort(modules.begin(), modules.end(), [&](auto &&first, auto &&second) {
-            return compareKey(first, second) < 0;
-        });
+        if (moduleId)
+            return moduleId;
 
-        auto range = selectModulesForIdsStatement.template range<Storage::ModuleView>(
-            Utils::span(moduleIds));
-
-        auto insert = [&](Storage::Module &module) {
-            insertModuleStatement.write(module.name, &module.sourceId);
-        };
-
-        auto update = [&](const Storage::ModuleView &moduleView, Storage::Module &module) {
-            if (moduleView.name != module.name)
-                updateModuleStatement.write(&moduleView.sourceId, module.name);
-        };
-
-        auto remove = [&](const Storage::ModuleView &moduleView) {
-            deleteModuleStatement.write(&moduleView.sourceId);
-            selectTypeIdsForModuleIdStatement.readTo(typeIdsToBeDeleted, &moduleView.sourceId);
-        };
-
-        Sqlite::insertUpdateDelete(range, modules, compareKey, insert, update, remove);
+        return insertModuleNameStatement.template value<ModuleId>(name);
     }
 
-    ModuleId fetchModuleIdUnguarded(const Storage::Module &module) const
+    auto fetchModuleNameUnguarded(ModuleId id) const
     {
-        return fetchModuleIdUnguarded(module.name);
-    }
+        auto moduleName = selectModuleNameStatement.template value<Utils::PathString>(&id);
 
-    ModuleId fetchModuleIdUnguarded(Utils::SmallStringView name) const
-    {
-        return selectModuleIdByNameStatement.template value<ModuleId>(name);
+        if (moduleName.empty())
+            throw ModuleDoesNotExists{};
+
+        return moduleName;
     }
 
     void handleAliasPropertyDeclarationsWithPropertyType(
-        TypeId typeId, std::vector<AliasPropertyDeclaration> &relinkableAliasPropertyDeclarations)
+        TypeId typeId, AliasPropertyDeclarations &relinkableAliasPropertyDeclarations)
     {
         auto callback = [&](long long typeId,
                             long long propertyDeclarationId,
@@ -555,8 +639,7 @@ private:
     }
 
     void prepareLinkingOfAliasPropertiesDeclarationsWithAliasId(
-        PropertyDeclarationId aliasId,
-        std::vector<AliasPropertyDeclaration> &relinkableAliasPropertyDeclarations)
+        PropertyDeclarationId aliasId, AliasPropertyDeclarations &relinkableAliasPropertyDeclarations)
     {
         auto callback = [&](long long propertyDeclarationId,
                             long long propertyImportedTypeNameId,
@@ -578,14 +661,14 @@ private:
                                                                                        &aliasId);
     }
 
-    void handlePropertyDeclarationWithPropertyType(
-        TypeId typeId, std::vector<PropertyDeclaration> &relinkablePropertyDeclarations)
+    void handlePropertyDeclarationWithPropertyType(TypeId typeId,
+                                                   PropertyDeclarations &relinkablePropertyDeclarations)
     {
         updatesPropertyDeclarationPropertyTypeToNullStatement.readTo(relinkablePropertyDeclarations,
                                                                      &typeId);
     }
 
-    void handlePrototypes(TypeId prototypeId, std::vector<Prototype> &relinkablePrototypes)
+    void handlePrototypes(TypeId prototypeId, Prototypes &relinkablePrototypes)
     {
         auto callback = [&](long long typeId, long long prototypeNameId) {
             relinkablePrototypes.emplace_back(TypeId{typeId}, ImportedTypeNameId{prototypeNameId});
@@ -597,9 +680,9 @@ private:
     }
 
     void deleteType(TypeId typeId,
-                    std::vector<AliasPropertyDeclaration> &relinkableAliasPropertyDeclarations,
-                    std::vector<PropertyDeclaration> &relinkablePropertyDeclarations,
-                    std::vector<Prototype> &relinkablePrototypes)
+                    AliasPropertyDeclarations &relinkableAliasPropertyDeclarations,
+                    PropertyDeclarations &relinkablePropertyDeclarations,
+                    Prototypes &relinkablePrototypes)
     {
         handlePropertyDeclarationWithPropertyType(typeId, relinkablePropertyDeclarations);
         handleAliasPropertyDeclarationsWithPropertyType(typeId, relinkableAliasPropertyDeclarations);
@@ -612,72 +695,85 @@ private:
         deleteTypeStatement.write(&typeId);
     }
 
-    void relinkAliasPropertyDeclarations(
-        const std::vector<AliasPropertyDeclaration> &aliasPropertyDeclarations,
-        const TypeIds &deletedTypeIds)
+    void relinkAliasPropertyDeclarations(AliasPropertyDeclarations &aliasPropertyDeclarations,
+                                         const TypeIds &deletedTypeIds)
     {
-        for (const AliasPropertyDeclaration &alias : aliasPropertyDeclarations) {
-            if (std::binary_search(deletedTypeIds.begin(), deletedTypeIds.end(), alias.typeId))
-                continue;
+        std::sort(aliasPropertyDeclarations.begin(), aliasPropertyDeclarations.end());
 
-            auto typeId = fetchTypeId(alias.aliasImportedTypeNameId);
+        Utils::set_greedy_difference(
+            aliasPropertyDeclarations.cbegin(),
+            aliasPropertyDeclarations.cend(),
+            deletedTypeIds.begin(),
+            deletedTypeIds.end(),
+            [&](const AliasPropertyDeclaration &alias) {
+                auto typeId = fetchTypeId(alias.aliasImportedTypeNameId);
 
-            if (!typeId)
-                throw TypeNameDoesNotExists{};
+                if (!typeId)
+                    throw TypeNameDoesNotExists{};
 
-            auto [propertyTypeId, aliasId, propertyTraits] = fetchPropertyDeclarationByTypeIdAndNameUngarded(
-                typeId, alias.aliasPropertyName);
+                auto [propertyTypeId, aliasId, propertyTraits] = fetchPropertyDeclarationByTypeIdAndNameUngarded(
+                    typeId, alias.aliasPropertyName);
 
-            updatePropertyDeclarationWithAliasAndTypeStatement.write(&alias.propertyDeclarationId,
-                                                                     &propertyTypeId,
-                                                                     propertyTraits,
-                                                                     &alias.aliasImportedTypeNameId,
-                                                                     &aliasId);
-        }
+                updatePropertyDeclarationWithAliasAndTypeStatement.write(&alias.propertyDeclarationId,
+                                                                         &propertyTypeId,
+                                                                         propertyTraits,
+                                                                         &alias.aliasImportedTypeNameId,
+                                                                         &aliasId);
+            },
+            TypeCompare<AliasPropertyDeclaration>{});
     }
 
-    void relinkPropertyDeclarations(const std::vector<PropertyDeclaration> &relinkablePropertyDeclaration,
+    void relinkPropertyDeclarations(PropertyDeclarations &relinkablePropertyDeclaration,
                                     const TypeIds &deletedTypeIds)
     {
-        for (const PropertyDeclaration &property : relinkablePropertyDeclaration) {
-            if (std::binary_search(deletedTypeIds.begin(), deletedTypeIds.end(), property.typeId))
-                continue;
+        std::sort(relinkablePropertyDeclaration.begin(), relinkablePropertyDeclaration.end());
 
-            TypeId propertyTypeId = fetchTypeId(property.importedTypeNameId);
+        Utils::set_greedy_difference(
+            relinkablePropertyDeclaration.cbegin(),
+            relinkablePropertyDeclaration.cend(),
+            deletedTypeIds.begin(),
+            deletedTypeIds.end(),
+            [&](const PropertyDeclaration &property) {
+                TypeId propertyTypeId = fetchTypeId(property.importedTypeNameId);
 
-            if (!propertyTypeId)
-                throw TypeNameDoesNotExists{};
+                if (!propertyTypeId)
+                    throw TypeNameDoesNotExists{};
 
-            updatePropertyDeclarationTypeStatement.write(&property.propertyDeclarationId,
-                                                         &propertyTypeId);
-        }
+                updatePropertyDeclarationTypeStatement.write(&property.propertyDeclarationId,
+                                                             &propertyTypeId);
+            },
+            TypeCompare<PropertyDeclaration>{});
     }
 
-    void relinkPrototypes(std::vector<Prototype> relinkablePrototypes, const TypeIds &deletedTypeIds)
+    void relinkPrototypes(Prototypes &relinkablePrototypes, const TypeIds &deletedTypeIds)
     {
-        for (const Prototype &prototype : relinkablePrototypes) {
-            if (std::binary_search(deletedTypeIds.begin(), deletedTypeIds.end(), prototype.typeId))
-                continue;
+        std::sort(relinkablePrototypes.begin(), relinkablePrototypes.end());
 
-            TypeId prototypeId = fetchTypeId(prototype.prototypeNameId);
+        Utils::set_greedy_difference(
+            relinkablePrototypes.cbegin(),
+            relinkablePrototypes.cend(),
+            deletedTypeIds.begin(),
+            deletedTypeIds.end(),
+            [&](const Prototype &prototype) {
+                TypeId prototypeId = fetchTypeId(prototype.prototypeNameId);
 
-            if (!prototypeId)
-                throw TypeNameDoesNotExists{};
+                if (!prototypeId)
+                    throw TypeNameDoesNotExists{};
 
-            updateTypePrototypeStatement.write(&prototype.typeId, &prototypeId);
-            checkForPrototypeChainCycle(prototype.typeId);
-        }
+                updateTypePrototypeStatement.write(&prototype.typeId, &prototypeId);
+                checkForPrototypeChainCycle(prototype.typeId);
+            },
+            TypeCompare<Prototype>{});
     }
 
     void deleteNotUpdatedTypes(const TypeIds &updatedTypeIds,
                                const std::vector<int> &sourceIdValues,
-                               const TypeIds &typeIdsToBeDeleted)
+                               const TypeIds &typeIdsToBeDeleted,
+                               AliasPropertyDeclarations &relinkableAliasPropertyDeclarations,
+                               PropertyDeclarations &relinkablePropertyDeclarations,
+                               Prototypes &relinkablePrototypes,
+                               TypeIds &deletedTypeIds)
     {
-        std::vector<AliasPropertyDeclaration> relinkableAliasPropertyDeclarations;
-        std::vector<PropertyDeclaration> relinkablePropertyDeclarations;
-        std::vector<Prototype> relinkablePrototypes;
-        TypeIds deletedTypeIds;
-
         auto updatedTypeIdValues = Utils::transform<std::vector>(updatedTypeIds, [](TypeId typeId) {
             return &typeId;
         });
@@ -696,7 +792,13 @@ private:
                                                              Utils::span(updatedTypeIdValues));
         for (TypeId typeIdToBeDeleted : typeIdsToBeDeleted)
             callback(&typeIdToBeDeleted);
+    }
 
+    void relink(AliasPropertyDeclarations &relinkableAliasPropertyDeclarations,
+                PropertyDeclarations &relinkablePropertyDeclarations,
+                Prototypes &relinkablePrototypes,
+                TypeIds &deletedTypeIds)
+    {
         std::sort(deletedTypeIds.begin(), deletedTypeIds.end());
 
         relinkPrototypes(relinkablePrototypes, deletedTypeIds);
@@ -704,7 +806,7 @@ private:
         relinkAliasPropertyDeclarations(relinkableAliasPropertyDeclarations, deletedTypeIds);
     }
 
-    void linkAliasPropertyDeclarationAliasIds(const std::vector<AliasPropertyDeclaration> &aliasDeclarations)
+    void linkAliasPropertyDeclarationAliasIds(const AliasPropertyDeclarations &aliasDeclarations)
     {
         for (const auto &aliasDeclaration : aliasDeclarations) {
             auto aliasTypeId = fetchTypeId(aliasDeclaration.aliasImportedTypeNameId);
@@ -722,7 +824,7 @@ private:
         }
     }
 
-    void updateAliasPropertyDeclarationValues(const std::vector<AliasPropertyDeclaration> &aliasDeclarations)
+    void updateAliasPropertyDeclarationValues(const AliasPropertyDeclarations &aliasDeclarations)
     {
         for (const auto &aliasDeclaration : aliasDeclarations) {
             updatetPropertiesDeclarationValuesOfAliasStatement.write(
@@ -732,14 +834,14 @@ private:
         }
     }
 
-    void checkAliasPropertyDeclarationCycles(const std::vector<AliasPropertyDeclaration> &aliasDeclarations)
+    void checkAliasPropertyDeclarationCycles(const AliasPropertyDeclarations &aliasDeclarations)
     {
         for (const auto &aliasDeclaration : aliasDeclarations)
             checkForAliasChainCycle(aliasDeclaration.propertyDeclarationId);
     }
 
-    void linkAliases(const std::vector<AliasPropertyDeclaration> &insertedAliasPropertyDeclarations,
-                     const std::vector<AliasPropertyDeclaration> &updatedAliasPropertyDeclarations)
+    void linkAliases(const AliasPropertyDeclarations &insertedAliasPropertyDeclarations,
+                     const AliasPropertyDeclarations &updatedAliasPropertyDeclarations)
     {
         linkAliasPropertyDeclarationAliasIds(insertedAliasPropertyDeclarations);
         linkAliasPropertyDeclarationAliasIds(updatedAliasPropertyDeclarations);
@@ -751,16 +853,25 @@ private:
         updateAliasPropertyDeclarationValues(updatedAliasPropertyDeclarations);
     }
 
-    void synchronizeExportedTypes(const TypeIds &typeIds, Storage::ExportedTypes &exportedTypes)
+    void synchronizeExportedTypes(const std::vector<int> &sourceIdValues,
+                                  const TypeIds &updatedTypeIds,
+                                  Storage::ExportedTypes &exportedTypes,
+                                  AliasPropertyDeclarations &relinkableAliasPropertyDeclarations,
+                                  PropertyDeclarations &relinkablePropertyDeclarations,
+                                  Prototypes &relinkablePrototypes)
     {
         std::sort(exportedTypes.begin(), exportedTypes.end(), [](auto &&first, auto &&second) {
             return std::tie(first.moduleId, first.name, first.version)
                    < std::tie(second.moduleId, second.name, second.version);
         });
 
-        auto range = selectExportedTypesForTypeIdStatement.template range<Storage::ExportedTypeView>(
-            const_cast<void *>(static_cast<const void *>(typeIds.data())),
-            static_cast<long long>(typeIds.size()));
+        Utils::span typeIdValues{static_cast<const TypeIds::value_type::DatabaseType *>(
+                                     &updatedTypeIds.data()->id),
+                                 updatedTypeIds.size()};
+
+        auto range = selectExportedTypesForSourceIdsStatement
+                         .template range<Storage::ExportedTypeView>(Utils::span{sourceIdValues},
+                                                                    typeIdValues);
 
         auto compareKey = [](const Storage::ExportedTypeView &view,
                              const Storage::ExportedType &type) -> long long {
@@ -780,53 +891,51 @@ private:
         };
 
         auto insert = [&](const Storage::ExportedType &type) {
+            if (!type.moduleId)
+                throw QmlDesigner::ModuleDoesNotExists{};
+
             if (type.version) {
-                upsertExportedTypeNamesWithVersionStatement.write(&type.moduleId,
+                insertExportedTypeNamesWithVersionStatement.write(&type.moduleId,
                                                                   type.name,
-                                                                  static_cast<long long>(
-                                                                      Storage::TypeNameKind::Exported),
                                                                   type.version.major.value,
                                                                   type.version.minor.value,
                                                                   &type.typeId);
 
             } else if (type.version.major) {
-                upsertExportedTypeNamesWithMajorVersionStatement
-                    .write(&type.moduleId,
-                           type.name,
-                           static_cast<long long>(Storage::TypeNameKind::Exported),
-                           type.version.major.value,
-                           &type.typeId);
+                insertExportedTypeNamesWithMajorVersionStatement.write(&type.moduleId,
+                                                                       type.name,
+                                                                       type.version.major.value,
+                                                                       &type.typeId);
             } else {
-                upsertExportedTypeNamesWithoutVersionStatement
-                    .write(&type.moduleId,
-                           type.name,
-                           static_cast<long long>(Storage::TypeNameKind::Exported),
-                           &type.typeId);
+                insertExportedTypeNamesWithoutVersionStatement.write(&type.moduleId,
+                                                                     type.name,
+                                                                     &type.typeId);
             }
         };
 
         auto update = [&](const Storage::ExportedTypeView &view, const Storage::ExportedType &type) {
-            if (view.typeId != type.typeId)
+            if (view.typeId != type.typeId) {
+                handlePropertyDeclarationWithPropertyType(view.typeId, relinkablePropertyDeclarations);
+                handleAliasPropertyDeclarationsWithPropertyType(view.typeId,
+                                                                relinkableAliasPropertyDeclarations);
+                handlePrototypes(view.typeId, relinkablePrototypes);
                 updateExportedTypeNameTypeIdStatement.write(&view.exportedTypeNameId, &type.typeId);
+            }
         };
 
         auto remove = [&](const Storage::ExportedTypeView &view) {
+            handlePropertyDeclarationWithPropertyType(view.typeId, relinkablePropertyDeclarations);
+            handleAliasPropertyDeclarationsWithPropertyType(view.typeId,
+                                                            relinkableAliasPropertyDeclarations);
+            handlePrototypes(view.typeId, relinkablePrototypes);
             deleteExportedTypeNameStatement.write(&view.exportedTypeNameId);
         };
 
         Sqlite::insertUpdateDelete(range, exportedTypes, compareKey, insert, update, remove);
     }
 
-    void upsertNativeType(ModuleId moduleId, Utils::SmallStringView name, TypeId typeId)
-    {
-        upsertExportedTypeNameStatement.write(&moduleId,
-                                              name,
-                                              static_cast<long long>(Storage::TypeNameKind::Native),
-                                              &typeId);
-    }
-
     void synchronizePropertyDeclarationsInsertAlias(
-        std::vector<AliasPropertyDeclaration> &insertedAliasPropertyDeclarations,
+        AliasPropertyDeclarations &insertedAliasPropertyDeclarations,
         const Storage::PropertyDeclaration &value,
         SourceId sourceId,
         TypeId typeId)
@@ -872,7 +981,7 @@ private:
     }
 
     void synchronizePropertyDeclarationsUpdateAlias(
-        std::vector<AliasPropertyDeclaration> &updatedAliasPropertyDeclarations,
+        AliasPropertyDeclarations &updatedAliasPropertyDeclarations,
         const Storage::PropertyDeclarationView &view,
         const Storage::PropertyDeclaration &value,
         SourceId sourceId)
@@ -887,7 +996,8 @@ private:
 
     void synchronizePropertyDeclarationsUpdateProperty(const Storage::PropertyDeclarationView &view,
                                                        const Storage::PropertyDeclaration &value,
-                                                       SourceId sourceId)
+                                                       SourceId sourceId,
+                                                       PropertyDeclarationIds &propertyDeclarationIds)
     {
         auto propertyImportedTypeNameId = fetchImportedTypeNameId(value.typeName, sourceId);
 
@@ -906,14 +1016,15 @@ private:
                                                  &propertyImportedTypeNameId);
         updatePropertyAliasDeclarationRecursivelyWithTypeAndTraitsStatement
             .write(&view.id, &propertyTypeId, static_cast<int>(value.traits));
+        propertyDeclarationIds.push_back(view.id);
     }
 
-    void synchronizePropertyDeclarations(
-        TypeId typeId,
-        Storage::PropertyDeclarations &propertyDeclarations,
-        SourceId sourceId,
-        std::vector<AliasPropertyDeclaration> &insertedAliasPropertyDeclarations,
-        std::vector<AliasPropertyDeclaration> &updatedAliasPropertyDeclarations)
+    void synchronizePropertyDeclarations(TypeId typeId,
+                                         Storage::PropertyDeclarations &propertyDeclarations,
+                                         SourceId sourceId,
+                                         AliasPropertyDeclarations &insertedAliasPropertyDeclarations,
+                                         AliasPropertyDeclarations &updatedAliasPropertyDeclarations,
+                                         PropertyDeclarationIds &propertyDeclarationIds)
     {
         std::sort(propertyDeclarations.begin(),
                   propertyDeclarations.end(),
@@ -947,8 +1058,12 @@ private:
                                                            view,
                                                            value,
                                                            sourceId);
+                propertyDeclarationIds.push_back(view.id);
             } else {
-                synchronizePropertyDeclarationsUpdateProperty(view, value, sourceId);
+                synchronizePropertyDeclarationsUpdateProperty(view,
+                                                              value,
+                                                              sourceId,
+                                                              propertyDeclarationIds);
             }
         };
 
@@ -962,14 +1077,20 @@ private:
             }
 
             deletePropertyDeclarationStatement.write(&view.id);
+            propertyDeclarationIds.push_back(view.id);
         };
 
         Sqlite::insertUpdateDelete(range, propertyDeclarations, compareKey, insert, update, remove);
     }
 
-    void resetRemovedAliasPropertyDeclarationsToNull(TypeId typeId,
-                                                     Storage::PropertyDeclarations &aliasDeclarations)
+    void resetRemovedAliasPropertyDeclarationsToNull(Storage::Type &type,
+                                                     PropertyDeclarationIds &propertyDeclarationIds)
     {
+        if (type.changeLevel == Storage::ChangeLevel::Minimal)
+            return;
+
+        Storage::PropertyDeclarations &aliasDeclarations = type.propertyDeclarations;
+
         class AliasPropertyDeclarationView
         {
         public:
@@ -992,7 +1113,7 @@ private:
         });
 
         auto range = selectPropertyDeclarationsWithAliasForTypeIdStatement
-                         .template range<AliasPropertyDeclarationView>(&typeId);
+                         .template range<AliasPropertyDeclarationView>(&type.typeId);
 
         auto compareKey = [](const AliasPropertyDeclarationView &view,
                              const Storage::PropertyDeclaration &value) {
@@ -1006,29 +1127,24 @@ private:
 
         auto remove = [&](const AliasPropertyDeclarationView &view) {
             updatePropertyDeclarationAliasIdToNullStatement.write(&view.id);
+            propertyDeclarationIds.push_back(view.id);
         };
 
         Sqlite::insertUpdateDelete(range, aliasDeclarations, compareKey, insert, update, remove);
     }
 
-    ModuleIds fetchModuleIdsUnguarded(const Storage::Modules &modules)
+    void resetRemovedAliasPropertyDeclarationsToNull(
+        Storage::Types &types, AliasPropertyDeclarations &relinkableAliasPropertyDeclarations)
     {
-        ModuleIds moduleIds;
-        moduleIds.reserve(moduleIds.size());
+        PropertyDeclarationIds propertyDeclarationIds;
+        propertyDeclarationIds.reserve(types.size());
 
-        for (auto &&module : modules)
-            moduleIds.push_back(fetchModuleIdUnguarded(module));
+        for (auto &&type : types)
+            resetRemovedAliasPropertyDeclarationsToNull(type, propertyDeclarationIds);
 
-        return moduleIds;
-    }
-
-    void addModuleIdToImports(Storage::Imports &imports)
-    {
-        for (Storage::Import &import : imports) {
-            import.moduleId = fetchModuleIdUnguarded(import.name);
-            if (!import.moduleId)
-                throw ModuleDoesNotExists{};
-        }
+        removeRelinkableEntries(relinkableAliasPropertyDeclarations,
+                                propertyDeclarationIds,
+                                PropertyCompare<AliasPropertyDeclaration>{});
     }
 
     void synchronizeDocumentImports(Storage::Imports &imports, const std::vector<int> &sourceIdValues)
@@ -1257,60 +1373,88 @@ private:
                               Storage::ExportedTypes &exportedTypes)
     {
         for (const auto &exportedType : type.exportedTypes)
-            exportedTypes.emplace_back(exportedType.name, exportedType.version, typeId, type.moduleId);
+            exportedTypes.emplace_back(exportedType.name,
+                                       exportedType.version,
+                                       typeId,
+                                       exportedType.moduleId);
     }
 
-    struct ModuleAndTypeId
-    {
-        ModuleAndTypeId() = default;
-        ModuleAndTypeId(int moduleId, long long typeId)
-            : moduleId{moduleId}
-            , typeId{typeId}
-        {}
-
-        ModuleId moduleId;
-        TypeId typeId;
-    };
-
     TypeId declareType(Storage::Type &type)
     {
-        if (!type.moduleId && type.typeName.isEmpty()) {
-            auto [moduleId, typeId] = selectModuleAndTypeIdBySourceIdStatement
-                                          .template value<ModuleAndTypeId>(&type.sourceId);
-            type.typeId = typeId;
-            type.moduleId = moduleId;
+        if (type.typeName.isEmpty()) {
+            type.typeId = selectTypeIdBySourceIdStatement.template value<TypeId>(&type.sourceId);
+
             return type.typeId;
         }
 
-        if (!type.moduleId)
-            throw ModuleDoesNotExists{};
-
-        type.typeId = upsertTypeStatement.template value<TypeId>(&type.moduleId,
+        type.typeId = upsertTypeStatement.template value<TypeId>(&type.sourceId,
                                                                  type.typeName,
-                                                                 static_cast<int>(type.accessSemantics),
-                                                                 &type.sourceId);
+                                                                 static_cast<int>(
+                                                                     type.accessSemantics));
 
         if (!type.typeId)
-            type.typeId = selectTypeIdByModuleIdAndNameStatement.template value<TypeId>(&type.moduleId,
+            type.typeId = selectTypeIdBySourceIdAndNameStatement.template value<TypeId>(&type.sourceId,
                                                                                         type.typeName);
-        upsertNativeType(type.moduleId, type.typeName, type.typeId);
 
         return type.typeId;
     }
 
     void syncDeclarations(Storage::Type &type,
-                          std::vector<AliasPropertyDeclaration> &insertedAliasPropertyDeclarations,
-                          std::vector<AliasPropertyDeclaration> &updatedAliasPropertyDeclarations)
+                          AliasPropertyDeclarations &insertedAliasPropertyDeclarations,
+                          AliasPropertyDeclarations &updatedAliasPropertyDeclarations,
+                          PropertyDeclarationIds &propertyDeclarationIds)
     {
-        auto typeId = type.typeId;
-        synchronizePropertyDeclarations(typeId,
+        if (type.changeLevel == Storage::ChangeLevel::Minimal)
+            return;
+
+        synchronizePropertyDeclarations(type.typeId,
                                         type.propertyDeclarations,
                                         type.sourceId,
                                         insertedAliasPropertyDeclarations,
-                                        updatedAliasPropertyDeclarations);
-        synchronizeFunctionDeclarations(typeId, type.functionDeclarations);
-        synchronizeSignalDeclarations(typeId, type.signalDeclarations);
-        synchronizeEnumerationDeclarations(typeId, type.enumerationDeclarations);
+                                        updatedAliasPropertyDeclarations,
+                                        propertyDeclarationIds);
+        synchronizeFunctionDeclarations(type.typeId, type.functionDeclarations);
+        synchronizeSignalDeclarations(type.typeId, type.signalDeclarations);
+        synchronizeEnumerationDeclarations(type.typeId, type.enumerationDeclarations);
+    }
+
+    template<typename Relinkable, typename Ids, typename Compare>
+    void removeRelinkableEntries(std::vector<Relinkable> &relinkables, Ids &ids, Compare compare)
+    {
+        std::vector<Relinkable> newRelinkables;
+        newRelinkables.reserve(relinkables.size());
+
+        std::sort(ids.begin(), ids.end());
+        std::sort(relinkables.begin(), relinkables.end(), compare);
+
+        Utils::set_greedy_difference(
+            relinkables.begin(),
+            relinkables.end(),
+            ids.cbegin(),
+            ids.cend(),
+            [&](Relinkable &entry) { newRelinkables.push_back(std::move(entry)); },
+            compare);
+
+        relinkables = std::move(newRelinkables);
+    }
+
+    void syncDeclarations(Storage::Types &types,
+                          AliasPropertyDeclarations &insertedAliasPropertyDeclarations,
+                          AliasPropertyDeclarations &updatedAliasPropertyDeclarations,
+                          PropertyDeclarations &relinkablePropertyDeclarations)
+    {
+        PropertyDeclarationIds propertyDeclarationIds;
+        propertyDeclarationIds.reserve(types.size() * 10);
+
+        for (auto &&type : types)
+            syncDeclarations(type,
+                             insertedAliasPropertyDeclarations,
+                             updatedAliasPropertyDeclarations,
+                             propertyDeclarationIds);
+
+        removeRelinkableEntries(relinkablePropertyDeclarations,
+                                propertyDeclarationIds,
+                                PropertyCompare<PropertyDeclaration>{});
     }
 
     void checkForPrototypeChainCycle(TypeId typeId) const
@@ -1338,7 +1482,7 @@ private:
                                                                         &propertyDeclarationId);
     }
 
-    void syncPrototypes(Storage::Type &type)
+    void syncPrototype(Storage::Type &type, TypeIds &typeIds)
     {
         if (type.changeLevel == Storage::ChangeLevel::Minimal)
             return;
@@ -1358,22 +1502,35 @@ private:
             updatePrototypeStatement.write(&type.typeId, &prototypeId, &prototypeTypeNameId);
             checkForPrototypeChainCycle(type.typeId);
         }
+
+        typeIds.push_back(type.typeId);
+    }
+
+    void syncPrototypes(Storage::Types &types, Prototypes &relinkablePrototypes)
+    {
+        TypeIds typeIds;
+        typeIds.reserve(types.size());
+
+        for (auto &type : types)
+            syncPrototype(type, typeIds);
+
+        removeRelinkableEntries(relinkablePrototypes, typeIds, TypeCompare<Prototype>{});
     }
 
     ImportId fetchImportId(SourceId sourceId, const Storage::Import &import) const
     {
         if (import.version) {
-            return selectImportIdBySourceIdAndImportNameAndVersionStatement.template value<ImportId>(
-                &sourceId, import.name, import.version.major.value, import.version.minor.value);
+            return selectImportIdBySourceIdAndModuleIdAndVersionStatement.template value<ImportId>(
+                &sourceId, &import.moduleId, import.version.major.value, import.version.minor.value);
         }
 
         if (import.version.major) {
-            return selectImportIdBySourceIdAndImportNameAndMajorVersionStatement
-                .template value<ImportId>(&sourceId, import.name, import.version.major.value);
+            return selectImportIdBySourceIdAndModuleIdAndMajorVersionStatement
+                .template value<ImportId>(&sourceId, &import.moduleId, import.version.major.value);
         }
 
-        return selectImportIdBySourceIdAndImportNameStatement.template value<ImportId>(&sourceId,
-                                                                                       import.name);
+        return selectImportIdBySourceIdAndModuleIdStatement.template value<ImportId>(&sourceId,
+                                                                                     &import.moduleId);
     }
 
     ImportedTypeNameId fetchImportedTypeNameId(const Storage::ImportedTypeName &name, SourceId sourceId)
@@ -1440,9 +1597,6 @@ private:
                 &typeNameId);
         }
 
-        if (kind == Storage::TypeNameKind::Native)
-            return selectTypeIdForNativeTypeNameNamesStatement.template value<TypeId>(&typeNameId);
-
         return selectTypeIdForImportedTypeNameNamesStatement.template value<TypeId>(&typeNameId);
     }
 
@@ -1649,21 +1803,16 @@ private:
             typesTable.setUseIfNotExists(true);
             typesTable.setName("types");
             typesTable.addColumn("typeId", Sqlite::ColumnType::Integer, {Sqlite::PrimaryKey{}});
-            auto &moduleIdColumn = typesTable.addForeignKeyColumn("moduleId",
-                                                                  foreignModuleIdColumn,
-                                                                  Sqlite::ForeignKeyAction::NoAction,
-                                                                  Sqlite::ForeignKeyAction::NoAction,
-                                                                  Sqlite::Enforment::Deferred);
+            auto &sourceIdColumn = typesTable.addColumn("sourceId");
             auto &typesNameColumn = typesTable.addColumn("name");
             typesTable.addColumn("accessSemantics");
-            typesTable.addColumn("sourceId");
             typesTable.addForeignKeyColumn("prototypeId",
                                            typesTable,
                                            Sqlite::ForeignKeyAction::NoAction,
                                            Sqlite::ForeignKeyAction::Restrict);
             typesTable.addColumn("prototypeNameId");
 
-            typesTable.addUniqueIndex({moduleIdColumn, typesNameColumn});
+            typesTable.addUniqueIndex({sourceIdColumn, typesNameColumn});
 
             typesTable.initialize(database);
 
@@ -1709,20 +1858,18 @@ private:
                                                              Sqlite::ForeignKeyAction::NoAction,
                                                              Sqlite::Enforment::Deferred);
             auto &nameColumn = table.addColumn("name");
-            auto &kindColumn = table.addColumn("kind");
             auto &typeIdColumn = table.addColumn("typeId");
             auto &majorVersionColumn = table.addColumn("majorVersion");
             auto &minorVersionColumn = table.addColumn("minorVersion");
 
-            table.addUniqueIndex({moduleIdColumn, nameColumn, kindColumn},
+            table.addUniqueIndex({moduleIdColumn, nameColumn},
                                  "majorVersion IS NULL AND minorVersion IS NULL");
-            table.addUniqueIndex({moduleIdColumn, nameColumn, kindColumn, majorVersionColumn},
+            table.addUniqueIndex({moduleIdColumn, nameColumn, majorVersionColumn},
                                  "majorVersion IS NOT NULL AND minorVersion IS NULL");
-            table.addUniqueIndex(
-                {moduleIdColumn, nameColumn, kindColumn, majorVersionColumn, minorVersionColumn},
-                "majorVersion IS NOT NULL AND minorVersion IS NOT NULL");
+            table.addUniqueIndex({moduleIdColumn, nameColumn, majorVersionColumn, minorVersionColumn},
+                                 "majorVersion IS NOT NULL AND minorVersion IS NOT NULL");
 
-            table.addIndex({typeIdColumn}, "kind=1");
+            table.addIndex({typeIdColumn});
 
             table.initialize(database);
         }
@@ -1823,6 +1970,7 @@ private:
                                                              Sqlite::Enforment::Deferred);
             auto &majorVersionColumn = table.addColumn("majorVersion");
             auto &minorVersionColumn = table.addColumn("minorVersion");
+            table.addColumn("kind");
 
             table.addUniqueIndex({sourceIdColumn, moduleIdColumn},
                                  "majorVersion IS NULL AND minorVersion IS NULL");
@@ -1856,18 +2004,18 @@ private:
 public:
     Database &database;
     Initializer initializer;
+    ModuleCache moduleCache{ModuleStorageAdapter{*this}};
     ReadWriteStatement<1> upsertTypeStatement{
-        "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",
+        "INSERT INTO types(sourceId, name,  accessSemantics) VALUES(?1, ?2, ?3) ON CONFLICT DO "
+        "UPDATE SET accessSemantics=excluded.accessSemantics WHERE accessSemantics IS NOT "
+        "excluded.accessSemantics RETURNING typeId",
         database};
     WriteStatement updatePrototypeStatement{
         "UPDATE types SET prototypeId=?2, prototypeNameId=?3 WHERE typeId=?1 AND (prototypeId IS "
         "NOT ?2 OR prototypeNameId IS NOT ?3)",
         database};
     mutable ReadStatement<1> selectTypeIdByExportedNameStatement{
-        "SELECT typeId FROM exportedTypeNames WHERE name=?1 AND kind=1", database};
+        "SELECT typeId FROM exportedTypeNames WHERE name=?1", database};
     mutable ReadStatement<1> selectPrototypeIdStatement{
         "WITH RECURSIVE "
         "  typeSelection(typeId) AS ("
@@ -1925,18 +2073,14 @@ public:
         "INSERT INTO sources(sourceContextId, sourceName) VALUES (?,?)", database};
     mutable ReadStatement<3> selectAllSourcesStatement{
         "SELECT sourceName, sourceContextId, sourceId  FROM sources", database};
-    mutable ReadStatement<5> selectTypeByTypeIdStatement{
-        "SELECT moduleId, name, (SELECT name FROM types WHERE typeId=outerTypes.prototypeId), "
-        "accessSemantics, ifnull(sourceId, -1) FROM types AS outerTypes WHERE typeId=?",
+    mutable ReadStatement<4> selectTypeByTypeIdStatement{
+        "SELECT sourceId, name, prototypeId, accessSemantics FROM types WHERE typeId=?", database};
+    mutable ReadStatement<4> selectExportedTypesByTypeIdStatement{
+        "SELECT moduleId, name, ifnull(majorVersion, -1), ifnull(minorVersion, -1) FROM "
+        "exportedTypeNames WHERE typeId=?",
         database};
-    mutable ReadStatement<3> selectExportedTypesByTypeIdStatement{
-        "SELECT name, ifnull(majorVersion, -1), ifnull(minorVersion, -1) FROM exportedTypeNames "
-        "WHERE typeId=? AND kind=1",
-        database};
-    mutable ReadStatement<6> selectTypesStatement{
-        "SELECT moduleId, name, typeId, (SELECT name FROM types WHERE "
-        "typeId=t.prototypeId), accessSemantics, ifnull(sourceId, -1) FROM types AS "
-        "t",
+    mutable ReadStatement<5> selectTypesStatement{
+        "SELECT sourceId, name, typeId, ifnull(prototypeId, -1), accessSemantics FROM types",
         database};
     ReadStatement<1> selectNotUpdatedTypesInSourcesStatement{
         "SELECT typeId FROM types WHERE (sourceId IN carray(?1) AND typeId NOT IN carray(?2))",
@@ -1953,10 +2097,9 @@ public:
         "DELETE FROM signalDeclarations WHERE typeId=?", database};
     WriteStatement deleteTypeStatement{"DELETE FROM types  WHERE typeId=?", database};
     mutable ReadStatement<4> selectPropertyDeclarationsByTypeIdStatement{
-        "SELECT name, (SELECT name FROM types WHERE typeId=pd.propertyTypeId), propertyTraits, "
-        "(SELECT name FROM propertyDeclarations WHERE "
-        "propertyDeclarationId=pd.aliasPropertyDeclarationId) FROM propertyDeclarations AS pd "
-        "WHERE typeId=?",
+        "SELECT name, nullif(propertyTypeId, -1), propertyTraits, (SELECT name FROM "
+        "propertyDeclarations WHERE propertyDeclarationId=pd.aliasPropertyDeclarationId) FROM "
+        "propertyDeclarations AS pd WHERE typeId=?",
         database};
     ReadStatement<6> selectPropertyDeclarationsForTypeIdStatement{
         "SELECT name, propertyTraits, propertyTypeId, propertyImportedTypeNameId, "
@@ -2081,25 +2224,18 @@ public:
         database};
     WriteStatement deleteEnumerationDeclarationStatement{
         "DELETE FROM enumerationDeclarations WHERE enumerationDeclarationId=?", database};
-    WriteStatement insertModuleStatement{"INSERT INTO modules(name, moduleId) VALUES(?1, ?2)",
-                                         database};
-    WriteStatement updateModuleStatement{"UPDATE modules SET name=?2 WHERE moduleId=?1", database};
-    WriteStatement deleteModuleStatement{"DELETE FROM modules WHERE moduleId=?", database};
     mutable ReadStatement<1> selectModuleIdByNameStatement{
         "SELECT moduleId FROM modules WHERE name=? LIMIT 1", database};
-    mutable ReadStatement<2> selectModulesForIdsStatement{
-        "SELECT name, moduleId FROM modules WHERE moduleId IN carray(?1) ORDER BY "
-        "moduleId",
-        database};
-    mutable ReadStatement<2> selectAllModulesStatement{
-        "SELECT name, moduleId FROM modules ORDER BY moduleId", database};
-    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 ReadWriteStatement<1> insertModuleNameStatement{
+        "INSERT INTO modules(name) VALUES(?1) RETURNING moduleId", database};
+    mutable ReadStatement<1> selectModuleNameStatement{
+        "SELECT name FROM modules WHERE moduleId =?1", database};
+    mutable ReadStatement<2> selectAllModulesStatement{"SELECT name, moduleId FROM modules", database};
+    mutable ReadStatement<1> selectTypeIdBySourceIdAndNameStatement{
+        "SELECT typeId FROM types WHERE sourceId=?1 and name=?2", database};
     mutable ReadStatement<1> selectTypeIdByModuleIdsAndExportedNameStatement{
         "SELECT typeId FROM exportedTypeNames WHERE moduleId IN carray(?1, ?2, 'int32') AND "
-        "name=?3 AND kind=1",
+        "name=?3",
         database};
     mutable ReadStatement<5> selectDocumentImportForSourceIdStatement{
         "SELECT importId, sourceId, moduleId, ifnull(majorVersion, -1), ifnull(minorVersion, -1) "
@@ -2241,8 +2377,8 @@ public:
     WriteStatement deleteFileStatusStatement{"DELETE FROM fileStatuses WHERE sourceId=?1", database};
     WriteStatement updateFileStatusStatement{
         "UPDATE fileStatuses SET size=?2, lastModified=?3 WHERE sourceId=?1", database};
-    ReadStatement<2> selectModuleAndTypeIdBySourceIdStatement{
-        "SELECT moduleId, typeId FROM types WHERE sourceId=?", database};
+    ReadStatement<1> selectTypeIdBySourceIdStatement{"SELECT typeId FROM types WHERE sourceId=?",
+                                                     database};
     mutable ReadStatement<1> selectImportedTypeNameIdStatement{
         "SELECT importedTypeNameId FROM importedTypeNames WHERE kind=?1 AND importOrSourceId=?2 "
         "AND name=?3 LIMIT 1",
@@ -2251,24 +2387,24 @@ public:
         "INSERT INTO importedTypeNames(kind, importOrSourceId, name) VALUES (?1, ?2, ?3) "
         "RETURNING importedTypeNameId",
         database};
-    mutable ReadStatement<1> selectImportIdBySourceIdAndImportNameStatement{
-        "SELECT importId FROM documentImports JOIN modules AS m USING(moduleId) WHERE sourceId=?1 "
-        "AND m.name=?2 AND majorVersion IS NULL AND minorVersion IS NULL LIMIT 1",
+    mutable ReadStatement<1> selectImportIdBySourceIdAndModuleIdStatement{
+        "SELECT importId FROM documentImports WHERE sourceId=?1 AND moduleId=?2 AND majorVersion "
+        "IS NULL AND minorVersion IS NULL LIMIT 1",
         database};
-    mutable ReadStatement<1> selectImportIdBySourceIdAndImportNameAndMajorVersionStatement{
-        "SELECT importId FROM documentImports JOIN modules AS m USING(moduleId) WHERE sourceId=?1 "
-        "AND m.name=?2 AND majorVersion=?3 AND minorVersion IS NULL LIMIT 1",
+    mutable ReadStatement<1> selectImportIdBySourceIdAndModuleIdAndMajorVersionStatement{
+        "SELECT importId FROM documentImports WHERE sourceId=?1 AND moduleId=?2 AND "
+        "majorVersion=?3 AND minorVersion IS NULL LIMIT 1",
         database};
-    mutable ReadStatement<1> selectImportIdBySourceIdAndImportNameAndVersionStatement{
-        "SELECT importId FROM documentImports JOIN modules AS m USING(moduleId) WHERE sourceId=?1 "
-        "AND m.name=?2 AND majorVersion=?3 AND minorVersion=?4 LIMIT 1",
+    mutable ReadStatement<1> selectImportIdBySourceIdAndModuleIdAndVersionStatement{
+        "SELECT importId FROM documentImports WHERE sourceId=?1 AND moduleId=?2 AND "
+        "majorVersion=?3 AND minorVersion=?4 LIMIT 1",
         database};
     mutable ReadStatement<1> selectKindFromImportedTypeNamesStatement{
         "SELECT kind FROM importedTypeNames WHERE importedTypeNameId=?1", database};
     mutable ReadStatement<1> selectTypeIdForQualifiedImportedTypeNameNamesStatement{
         "SELECT typeId FROM importedTypeNames AS itn JOIN documentImports AS di ON "
         "importOrSourceId=importId JOIN exportedTypeNames AS etn USING(moduleId) WHERE "
-        "itn.kind=2 AND importedTypeNameId=?1 AND itn.name=etn.name AND etn.kind=1 AND "
+        "itn.kind=2 AND importedTypeNameId=?1 AND itn.name=etn.name AND "
         "(di.majorVersion IS NULL OR (di.majorVersion=etn.majorVersion AND (di.minorVersion IS "
         "NULL OR di.minorVersion>=etn.minorVersion))) ORDER BY etn.majorVersion DESC NULLS FIRST, "
         "etn.minorVersion DESC NULLS FIRST LIMIT 1",
@@ -2276,39 +2412,29 @@ public:
     mutable ReadStatement<1> selectTypeIdForImportedTypeNameNamesStatement{
         "SELECT typeId FROM importedTypeNames AS itn JOIN documentImports AS di ON "
         "importOrSourceId=sourceId JOIN exportedTypeNames AS etn USING(moduleId) WHERE "
-        "itn.kind=1 AND importedTypeNameId=?1 AND itn.name=etn.name AND etn.kind=1 AND "
+        "itn.kind=1 AND importedTypeNameId=?1 AND itn.name=etn.name AND "
         "(di.majorVersion IS NULL OR (di.majorVersion=etn.majorVersion AND (di.minorVersion IS "
         "NULL OR di.minorVersion>=etn.minorVersion))) ORDER BY etn.majorVersion DESC NULLS FIRST, "
         "etn.minorVersion DESC NULLS FIRST LIMIT 1",
         database};
-    mutable ReadStatement<1> selectTypeIdForNativeTypeNameNamesStatement{
-        "SELECT typeId FROM importedTypeNames AS itn JOIN documentImports AS di ON "
-        "importOrSourceId=sourceId JOIN exportedTypeNames AS etn USING(moduleId) WHERE itn.kind=0 "
-        "AND importedTypeNameId=?1 AND itn.name=etn.name AND etn.kind=0 LIMIT 1",
-        database};
     WriteStatement deleteAllSourcesStatement{"DELETE FROM sources", database};
     WriteStatement deleteAllSourceContextsStatement{"DELETE FROM sourceContexts", database};
-    mutable ReadStatement<6> selectExportedTypesForTypeIdStatement{
-        "SELECT moduleId, name, ifnull(majorVersion, -1), ifnull(minorVersion, -1), typeId, "
-        "exportedTypeNameId FROM exportedTypeNames WHERE typeId IN carray(?1, ?2, 'int64') AND "
-        "kind=1 ORDER BY moduleId, name, majorVersion, minorVersion",
-        database};
-    WriteStatement upsertExportedTypeNamesWithVersionStatement{
-        "INSERT INTO exportedTypeNames(moduleId, name, kind, majorVersion, minorVersion, typeId) "
-        "VALUES(?1, ?2, ?3, ?4, ?5, ?6) ON CONFLICT DO UPDATE SET typeId=excluded.typeId",
-        database};
-    WriteStatement upsertExportedTypeNamesWithMajorVersionStatement{
-        "INSERT INTO exportedTypeNames(moduleId, name, kind, majorVersion, typeId) "
-        "VALUES(?1, ?2, ?3, ?4, ?5) ON CONFLICT DO UPDATE SET typeId=excluded.typeId",
-        database};
-    WriteStatement upsertExportedTypeNamesWithoutVersionStatement{
-        "INSERT INTO exportedTypeNames(moduleId, name, kind, typeId) VALUES(?1, ?2, ?3, ?4) ON "
-        "CONFLICT DO UPDATE SET typeId=excluded.typeId",
-        database};
-    WriteStatement upsertExportedTypeNameStatement{
-        "INSERT INTO exportedTypeNames(moduleId, name, kind, typeId) VALUES(?1, ?2, ?3, ?4) ON "
-        "CONFLICT DO UPDATE SET typeId=excluded.typeId WHERE typeId IS NOT excluded.typeId",
-        database};
+    mutable ReadStatement<6> selectExportedTypesForSourceIdsStatement{
+        "SELECT moduleId, etn.name, ifnull(majorVersion, -1), ifnull(minorVersion, -1), typeId, "
+        "exportedTypeNameId FROM exportedTypeNames AS etn JOIN types USING(typeId) WHERE sourceId "
+        "IN carray(?1) OR typeId in carray(?2) ORDER BY moduleId, etn.name, majorVersion, "
+        "minorVersion",
+        database};
+    WriteStatement insertExportedTypeNamesWithVersionStatement{
+        "INSERT INTO exportedTypeNames(moduleId, name, majorVersion, minorVersion, typeId) "
+        "VALUES(?1, ?2, ?3, ?4, ?5)",
+        database};
+    WriteStatement insertExportedTypeNamesWithMajorVersionStatement{
+        "INSERT INTO exportedTypeNames(moduleId, name, majorVersion, typeId) "
+        "VALUES(?1, ?2, ?3, ?4)",
+        database};
+    WriteStatement insertExportedTypeNamesWithoutVersionStatement{
+        "INSERT INTO exportedTypeNames(moduleId, name, typeId) VALUES(?1, ?2, ?3)", database};
     WriteStatement deleteExportedTypeNameStatement{
         "DELETE FROM exportedTypeNames WHERE exportedTypeNameId=?", database};
     WriteStatement updateExportedTypeNameTypeIdStatement{
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstorageinterface.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstorageinterface.h
index 302a1801a2..4eaa0527d2 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstorageinterface.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstorageinterface.h
@@ -33,13 +33,14 @@ namespace QmlDesigner {
 class ProjectStorageInterface
 {
 public:
-    virtual void synchronize(Storage::Modules modules,
-                             Storage::Imports imports,
+    virtual void synchronize(Storage::Imports imports,
                              Storage::Types types,
                              SourceIds sourceIds,
                              FileStatuses fileStatuses)
         = 0;
 
+    virtual ModuleId moduleId(Utils::SmallStringView name) = 0;
+
     virtual FileStatus fetchFileStatus(SourceId sourceId) const = 0;
     virtual SourceIds fetchSourceDependencieIds(SourceId sourceId) const = 0;
 
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h
index 592f510c8d..ffbfe7364c 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h
@@ -121,38 +121,6 @@ public:
     VersionNumber minor;
 };
 
-class Module
-{
-public:
-    explicit Module() = default;
-
-    explicit Module(Utils::SmallStringView name, SourceId sourceId = SourceId{})
-        : name{name}
-        , sourceId{sourceId}
-    {}
-
-    explicit Module(QStringView name, SourceId sourceId = SourceId{})
-        : name{name}
-        , sourceId{sourceId}
-    {}
-
-    explicit Module(Utils::SmallStringView name, int sourceId)
-        : name{name}
-        , sourceId{sourceId}
-    {}
-
-    friend bool operator==(const Module &first, const Module &second)
-    {
-        return first.name == second.name;
-    }
-
-public:
-    Utils::PathString name;
-    SourceId sourceId;
-};
-
-using Modules = std::vector<Module>;
-
 enum class IsQualified : int { No, Yes };
 
 inline int operator-(IsQualified first, IsQualified second)
@@ -172,41 +140,29 @@ class Import
 public:
     explicit Import() = default;
 
-    explicit Import(Utils::SmallStringView name,
-                    Version version,
-                    SourceId sourceId,
-                    ImportKind kind = ImportKind::Module)
-        : name{name}
-        , version{version}
-        , sourceId{sourceId}
-        , kind{kind}
-    {}
-
-    explicit Import(Version version, ModuleId moduleId, SourceId sourceId)
+    explicit Import(ModuleId moduleId, Version version, SourceId sourceId)
         : version{version}
         , moduleId{moduleId}
         , sourceId{sourceId}
     {}
 
-    explicit Import(Utils::SmallStringView name, int majorVersion, int minorVersion, int sourceId)
-        : name{name}
+    explicit Import(int moduleId, int majorVersion, int minorVersion, int sourceId)
+        : moduleId{moduleId}
         , version{majorVersion, minorVersion}
         , sourceId{sourceId}
     {}
 
     friend bool operator==(const Import &first, const Import &second)
     {
-        return first.name == second.name && first.version == second.version
-               && first.sourceId == second.sourceId && first.moduleId.id == second.moduleId.id;
+        return first.moduleId == second.moduleId && first.version == second.version
+               && first.sourceId == second.sourceId;
     }
 
 public:
-    Utils::SmallString name;
     Version version;
     ModuleId moduleId;
     SourceId sourceId;
     Utils::SmallString aliasName;
-    ImportKind kind = ImportKind::Module;
 };
 
 using Imports = std::vector<Import>;
@@ -296,9 +252,10 @@ public:
         , moduleId{moduleId}
     {}
 
-    explicit ExportedType(Utils::SmallStringView name, int majorVersion, int minorVersion)
+    explicit ExportedType(int moduleId, Utils::SmallStringView name, int majorVersion, int minorVersion)
         : name{name}
         , version{majorVersion, minorVersion}
+        , moduleId{moduleId}
     {}
 
     friend bool operator==(const ExportedType &first, const ExportedType &second)
@@ -577,6 +534,15 @@ public:
     {}
 
     explicit PropertyDeclaration(Utils::SmallStringView name,
+                                 TypeId propertyTypeId,
+                                 PropertyDeclarationTraits traits)
+        : name{name}
+        , traits{traits}
+        , propertyTypeId{propertyTypeId}
+        , kind{PropertyKind::Property}
+    {}
+
+    explicit PropertyDeclaration(Utils::SmallStringView name,
                                  ImportedTypeName typeName,
                                  PropertyDeclarationTraits traits,
                                  Utils::SmallStringView aliasPropertyName)
@@ -588,13 +554,24 @@ public:
     {}
 
     explicit PropertyDeclaration(Utils::SmallStringView name,
-                                 Utils::SmallStringView typeName,
+                                 TypeId propetyTypeId,
+                                 PropertyDeclarationTraits traits,
+                                 Utils::SmallStringView aliasPropertyName)
+        : name{name}
+        , aliasPropertyName{aliasPropertyName}
+        , traits{traits}
+        , propertyTypeId{propertyTypeId}
+        , kind{PropertyKind::Property}
+    {}
+
+    explicit PropertyDeclaration(Utils::SmallStringView name,
+                                 long long propertyTypeId,
                                  int traits,
                                  Utils::SmallStringView aliasPropertyName)
         : name{name}
-        , typeName{NativeType{typeName}}
         , aliasPropertyName{aliasPropertyName}
         , traits{static_cast<PropertyDeclarationTraits>(traits)}
+        , propertyTypeId{propertyTypeId}
         , kind{PropertyKind::Property}
     {}
 
@@ -619,6 +596,7 @@ public:
     ImportedTypeName typeName;
     Utils::SmallString aliasPropertyName;
     PropertyDeclarationTraits traits = {};
+    TypeId propertyTypeId;
     TypeId typeId;
     PropertyKind kind = PropertyKind::Property;
 };
@@ -657,8 +635,7 @@ class Type
 {
 public:
     explicit Type() = default;
-    explicit Type(ModuleId moduleId,
-                  Utils::SmallStringView typeName,
+    explicit Type(Utils::SmallStringView typeName,
                   ImportedTypeName prototype,
                   TypeAccessSemantics accessSemantics,
                   SourceId sourceId,
@@ -677,12 +654,20 @@ public:
         , enumerationDeclarations{std::move(enumerationDeclarations)}
         , accessSemantics{accessSemantics}
         , sourceId{sourceId}
-        , moduleId{moduleId}
         , changeLevel{changeLevel}
     {}
 
-    explicit Type(ModuleId moduleId,
-                  Utils::SmallStringView typeName,
+    explicit Type(Utils::SmallStringView typeName,
+                  TypeId prototypeId,
+                  TypeAccessSemantics accessSemantics,
+                  SourceId sourceId)
+        : typeName{typeName}
+        , accessSemantics{accessSemantics}
+        , sourceId{sourceId}
+        , prototypeId{prototypeId}
+    {}
+
+    explicit Type(Utils::SmallStringView typeName,
                   Utils::SmallStringView prototype,
                   int accessSemantics,
                   int sourceId)
@@ -690,22 +675,19 @@ public:
         , prototype{NativeType{prototype}}
         , accessSemantics{static_cast<TypeAccessSemantics>(accessSemantics)}
         , sourceId{sourceId}
-        , moduleId{moduleId}
 
     {}
 
-    explicit Type(int moduleId,
+    explicit Type(int sourceId,
                   Utils::SmallStringView typeName,
                   long long typeId,
-                  Utils::SmallStringView prototype,
-                  int accessSemantics,
-                  int sourceId)
+                  long long prototypeId,
+                  int accessSemantics)
         : typeName{typeName}
-        , prototype{NativeType{prototype}}
         , accessSemantics{static_cast<TypeAccessSemantics>(accessSemantics)}
         , sourceId{sourceId}
         , typeId{typeId}
-        , moduleId{moduleId}
+        , prototypeId{prototypeId}
     {}
 
     friend bool operator==(const Type &first, const Type &second) noexcept
@@ -715,7 +697,6 @@ public:
                && first.propertyDeclarations == second.propertyDeclarations
                && first.functionDeclarations == second.functionDeclarations
                && first.signalDeclarations == second.signalDeclarations
-               && first.moduleId == second.moduleId && first.sourceId == second.sourceId
                && first.sourceId == second.sourceId;
     }
 
@@ -730,28 +711,10 @@ public:
     TypeAccessSemantics accessSemantics = TypeAccessSemantics::None;
     SourceId sourceId;
     TypeId typeId;
-    ModuleId moduleId;
+    TypeId prototypeId;
     ChangeLevel changeLevel = ChangeLevel::Full;
 };
 
 using Types = std::vector<Type>;
 
-class ModuleView
-{
-public:
-    explicit ModuleView(Utils::SmallStringView name, int sourceId)
-        : name{name}
-        , sourceId{sourceId}
-    {}
-
-    friend bool operator==(const ModuleView &first, const ModuleView &second)
-    {
-        return first.name == second.name && first.sourceId == second.sourceId;
-    }
-
-public:
-    Utils::SmallStringView name;
-    SourceId sourceId;
-};
-
 } // namespace QmlDesigner::Storage
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.cpp b/src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.cpp
index a16859ae23..5a23b69944 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.cpp
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.cpp
@@ -52,7 +52,6 @@ ComponentReferences createComponentReferences(const QMultiHash<QString, QmlDirPa
 
 void ProjectUpdater::update()
 {
-    Storage::Modules modules;
     Storage::Imports imports;
     Storage::Types types;
     SourceIds sourceIds;
@@ -67,22 +66,17 @@ void ProjectUpdater::update()
             QmlDirParser parser;
             parser.parse(m_fileSystem.contentAsQString(qmldirPath));
 
-            modules.emplace_back(parser.typeNamespace(), qmlDirSourceId);
-
             sourceIds.push_back(qmlDirSourceId);
 
             SourceContextId directoryId = m_pathCache.sourceContextId(qmlDirSourceId);
 
-            parseTypeInfos(parser.typeInfos(),
-                           directoryId,
-                           ModuleId{&qmlDirSourceId},
-                           imports,
-                           types,
-                           sourceIds,
-                           fileStatuses);
+            ModuleId moduleId = m_projectStorage.moduleId(Utils::PathString{parser.typeNamespace()});
+
+            parseTypeInfos(
+                parser.typeInfos(), directoryId, moduleId, imports, types, sourceIds, fileStatuses);
             parseQmlComponents(createComponentReferences(parser.components()),
                                directoryId,
-                               ModuleId{&qmlDirSourceId},
+                               moduleId,
                                imports,
                                types,
                                sourceIds,
@@ -106,8 +100,7 @@ void ProjectUpdater::update()
         }
     }
 
-    m_projectStorage.synchronize(std::move(modules),
-                                 std::move(imports),
+    m_projectStorage.synchronize(std::move(imports),
                                  std::move(types),
                                  std::move(sourceIds),
                                  std::move(fileStatuses));
@@ -197,11 +190,11 @@ void ProjectUpdater::parseQmlComponents(ComponentReferences components,
         auto type = m_qmlDocumentParser.parse(content, imports);
 
         type.typeName = fileName;
-        type.moduleId = moduleId;
         type.accessSemantics = Storage::TypeAccessSemantics::Reference;
         type.sourceId = sourceId;
         type.exportedTypes.push_back(
-            Storage::ExportedType{Utils::SmallString{component.typeName},
+            Storage::ExportedType{moduleId,
+                                  Utils::SmallString{component.typeName},
                                   Storage::Version{component.majorVersion, component.minorVersion}});
 
         types.push_back(std::move(type));
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/qmldocumentparser.cpp b/src/plugins/qmldesigner/designercore/projectstorage/qmldocumentparser.cpp
index be0474e77f..c4a2bae617 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/qmldocumentparser.cpp
+++ b/src/plugins/qmldesigner/designercore/projectstorage/qmldocumentparser.cpp
@@ -69,19 +69,19 @@ void addImports(Storage::Imports &imports,
                 const QList<QmlDom::Import> &qmlImports,
                 SourceId sourceId,
                 SourceContextId sourceContextId,
-                QmlDocumentParser::PathCache &pathCache)
+                QmlDocumentParser::PathCache &pathCache,
+                QmlDocumentParser::ProjectStorage &storage)
 {
     for (const QmlDom::Import &qmlImport : qmlImports) {
         if (qmlImport.uri == u"file://.") {
-            SourceId directorySourceId = pathCache.sourceId(sourceContextId, ".");
-            imports.emplace_back(Storage::Version{}, ModuleId{&directorySourceId}, sourceId);
+            auto moduleId = storage.moduleId(pathCache.sourceContextPath(sourceContextId));
+            imports.emplace_back(moduleId, Storage::Version{}, sourceId);
         } else if (qmlImport.uri.startsWith(u"file://")) {
-            SourceId uriSourceId = pathCache.sourceId(sourceContextId, convertUri(qmlImport.uri));
-            imports.emplace_back(Storage::Version{}, ModuleId{&uriSourceId}, sourceId);
+            auto moduleId = storage.moduleId(convertUri(qmlImport.uri));
+            imports.emplace_back(moduleId, Storage::Version{}, sourceId);
         } else {
-            imports.emplace_back(Utils::SmallString{qmlImport.uri},
-                                 convertVersion(qmlImport.version),
-                                 sourceId);
+            auto moduleId = storage.moduleId(Utils::SmallString{qmlImport.uri});
+            imports.emplace_back(moduleId, convertVersion(qmlImport.version), sourceId);
         }
     }
 }
@@ -185,7 +185,7 @@ Storage::Type QmlDocumentParser::parse(const QString &sourceContent,
 
     type.prototype = Storage::ImportedType{Utils::SmallString{qmlObject.name()}};
 
-    addImports(imports, qmlFile->imports(), sourceId, sourceContextId, m_pathCache);
+    addImports(imports, qmlFile->imports(), sourceId, sourceContextId, m_pathCache, m_storage);
 
     addPropertyDeclarations(type, qmlObject);
     addFunctionAndSignalDeclarations(type, qmlObject);
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/qmldocumentparser.h b/src/plugins/qmldesigner/designercore/projectstorage/qmldocumentparser.h
index cc272dd422..e2dd243405 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/qmldocumentparser.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/qmldocumentparser.h
@@ -43,11 +43,12 @@ class SourcePathCache;
 class QmlDocumentParser
 {
 public:
-    using PathCache = QmlDesigner::SourcePathCache<QmlDesigner::ProjectStorage<Sqlite::Database>,
-                                                   NonLockingMutex>;
+    using ProjectStorage = QmlDesigner::ProjectStorage<Sqlite::Database>;
+    using PathCache = QmlDesigner::SourcePathCache<ProjectStorage, NonLockingMutex>;
 
-    QmlDocumentParser(PathCache &pathCache)
+    QmlDocumentParser(PathCache &pathCache, ProjectStorage &storage)
         : m_pathCache{pathCache}
+        , m_storage{storage}
     {}
 
     virtual Storage::Type parse(const QString &sourceContent,
@@ -57,5 +58,6 @@ public:
 
 private:
     PathCache &m_pathCache;
+    ProjectStorage &m_storage;
 };
 } // namespace QmlDesigner
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/qmltypesparser.cpp b/src/plugins/qmldesigner/designercore/projectstorage/qmltypesparser.cpp
index ed9352cd47..e394265321 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/qmltypesparser.cpp
+++ b/src/plugins/qmldesigner/designercore/projectstorage/qmltypesparser.cpp
@@ -45,15 +45,20 @@ namespace QmlDom = QQmlJS::Dom;
 namespace {
 void addType(const QQmlJSScope::Ptr &object, Storage::Types &types) {}
 
-Storage::Import createImport(const QString &dependency, SourceId sourceId)
+void appendImports(Storage::Imports &imports,
+                   const QString &dependency,
+                   SourceId sourceId,
+                   QmlTypesParser::ProjectStorage &storage)
 {
-    Storage::Import import;
-    import.kind = Storage::ImportKind::QmlTypesDependency;
-    import.sourceId = sourceId;
     auto spaceFound = std::find_if(dependency.begin(), dependency.end(), [](QChar c) {
         return c.isSpace();
     });
-    import.name = Utils::SmallString{QStringView(dependency.begin(), spaceFound)};
+
+    Utils::PathString moduleName{QStringView(dependency.begin(), spaceFound)};
+    ModuleId moduleId = storage.moduleId(moduleName);
+
+    moduleName.append("-cppnative");
+    ModuleId cppModuleId = storage.moduleId(moduleName);
 
     auto majorVersionFound = std::find_if(spaceFound, dependency.end(), [](QChar c) {
         return c.isDigit();
@@ -61,33 +66,39 @@ Storage::Import createImport(const QString &dependency, SourceId sourceId)
     auto majorVersionEnd = std::find_if(majorVersionFound, dependency.end(), [](QChar c) {
         return !c.isDigit();
     });
-    QStringView majorVersionString(majorVersionFound, majorVersionEnd);
-    if (majorVersionString.isEmpty())
-        return import;
-    import.version.major.value = majorVersionString.toInt();
 
-    auto minorVersionFound = std::find_if(majorVersionEnd, dependency.end(), [](QChar c) {
-        return c.isDigit();
-    });
-    auto minorVersionEnd = std::find_if(minorVersionFound, dependency.end(), [](QChar c) {
-        return !c.isDigit();
-    });
-    QStringView minorVersionString(minorVersionFound, minorVersionEnd);
-    if (minorVersionString.isEmpty())
-        return import;
-    import.version.minor.value = QStringView(minorVersionFound, minorVersionEnd).toInt();
+    Storage::Version version;
 
-    return import;
+    QStringView majorVersionString(majorVersionFound, majorVersionEnd);
+    if (!majorVersionString.isEmpty()) {
+        version.major.value = majorVersionString.toInt();
+
+        auto minorVersionFound = std::find_if(majorVersionEnd, dependency.end(), [](QChar c) {
+            return c.isDigit();
+        });
+        auto minorVersionEnd = std::find_if(minorVersionFound, dependency.end(), [](QChar c) {
+            return !c.isDigit();
+        });
+        QStringView minorVersionString(minorVersionFound, minorVersionEnd);
+        if (!minorVersionString.isEmpty())
+            version.minor.value = QStringView(minorVersionFound, minorVersionEnd).toInt();
+    }
+
+    imports.emplace_back(moduleId, version, sourceId);
+    imports.emplace_back(cppModuleId, version, sourceId);
 }
 
-void addImports(Storage::Imports &imports, SourceId sourceId, const QStringList &dependencies)
+void addImports(Storage::Imports &imports,
+                SourceId sourceId,
+                const QStringList &dependencies,
+                QmlTypesParser::ProjectStorage &storage)
 {
-    for (const QString &dependency : dependencies) {
-        imports.push_back(createImport(dependency, sourceId));
-    }
+    for (const QString &dependency : dependencies)
+        appendImports(imports, dependency, sourceId, storage);
 
-    imports.emplace_back("QML", Storage::Version{}, sourceId, Storage::ImportKind::QmlTypesDependency);
-    imports.emplace_back("QtQml", Storage::Version{}, sourceId, Storage::ImportKind::QmlTypesDependency);
+    imports.emplace_back(storage.moduleId("QML"), Storage::Version{}, sourceId);
+    imports.emplace_back(storage.moduleId("QtQml"), Storage::Version{}, sourceId);
+    imports.emplace_back(storage.moduleId("QtQml-cppnative"), Storage::Version{}, sourceId);
 }
 
 Storage::TypeAccessSemantics createTypeAccessSemantics(QQmlJSScope::AccessSemantics accessSematics)
@@ -249,8 +260,7 @@ Storage::EnumerationDeclarations createEnumeration(const QHash<QString, QQmlJSMe
 void addType(Storage::Types &types, SourceId sourceId, ModuleId moduleId, const QQmlJSScope &component)
 {
     auto [functionsDeclarations, signalDeclarations] = createFunctionAndSignals(component.ownMethods());
-    types.emplace_back(moduleId,
-                       Utils::SmallString{component.internalName()},
+    types.emplace_back(Utils::SmallString{component.internalName()},
                        Storage::NativeType{Utils::SmallString{component.baseTypeName()}},
                        createTypeAccessSemantics(component.accessSemantics()),
                        sourceId,
@@ -287,7 +297,7 @@ void QmlTypesParser::parse(const QString &sourceContent,
     if (!isValid)
         throw CannotParseQmlTypesFile{};
 
-    addImports(imports, sourceId, dependencies);
+    addImports(imports, sourceId, dependencies, m_storage);
     addTypes(types, sourceId, moduleId, components);
 }
 
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/qmltypesparser.h b/src/plugins/qmldesigner/designercore/projectstorage/qmltypesparser.h
index 04733f3ecd..eeb58f0e31 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/qmltypesparser.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/qmltypesparser.h
@@ -43,11 +43,12 @@ class SourcePathCache;
 class QmlTypesParser : public QmlTypesParserInterface
 {
 public:
-    using PathCache = QmlDesigner::SourcePathCache<QmlDesigner::ProjectStorage<Sqlite::Database>,
-                                                   NonLockingMutex>;
+    using ProjectStorage = QmlDesigner::ProjectStorage<Sqlite::Database>;
+    using PathCache = QmlDesigner::SourcePathCache<ProjectStorage, NonLockingMutex>;
 
-    QmlTypesParser(PathCache &pathCache)
+    QmlTypesParser(PathCache &pathCache, ProjectStorage &storage)
         : m_pathCache{pathCache}
+        , m_storage{storage}
     {}
 
     void parse(const QString &sourceContent,
@@ -58,5 +59,6 @@ public:
 
 private:
     PathCache &m_pathCache;
+    ProjectStorage &m_storage;
 };
 } // namespace QmlDesigner
diff --git a/tests/unit/unittest/gtest-creator-printing.cpp b/tests/unit/unittest/gtest-creator-printing.cpp
index 85ff406f95..3123ffcf1d 100644
--- a/tests/unit/unittest/gtest-creator-printing.cpp
+++ b/tests/unit/unittest/gtest-creator-printing.cpp
@@ -1095,8 +1095,8 @@ std::ostream &operator<<(std::ostream &out, Version version)
 
 std::ostream &operator<<(std::ostream &out, const ExportedType &exportedType)
 {
-    return out << "(\"" << exportedType.name << "\""
-               << ", " << exportedType.version << ")";
+    return out << "(\"" << exportedType.name << "\"," << exportedType.moduleId << ", "
+               << exportedType.version << ")";
 }
 
 std::ostream &operator<<(std::ostream &out, const NativeType &nativeType)
@@ -1116,10 +1116,9 @@ std::ostream &operator<<(std::ostream &out, const QualifiedImportedType &importe
 std::ostream &operator<<(std::ostream &out, const Type &type)
 {
     using Utils::operator<<;
-    return out << "(moduleId: " << type.moduleId << ", typename: \"" << type.typeName
-               << "\", prototype: " << type.prototype << ", " << type.accessSemantics
-               << ", source: " << type.sourceId << ", exports: " << type.exportedTypes
-               << ", properties: " << type.propertyDeclarations
+    return out << "( typename: \"" << type.typeName << "\", prototype: " << type.prototype << ", "
+               << type.prototypeId << ", " << type.accessSemantics << ", source: " << type.sourceId
+               << ", exports: " << type.exportedTypes << ", properties: " << type.propertyDeclarations
                << ", functions: " << type.functionDeclarations
                << ", signals: " << type.signalDeclarations << ")";
 }
@@ -1127,9 +1126,10 @@ std::ostream &operator<<(std::ostream &out, const Type &type)
 std::ostream &operator<<(std::ostream &out, const PropertyDeclaration &propertyDeclaration)
 {
     using Utils::operator<<;
-    return out << "(\"" << propertyDeclaration.name << "\", \"" << propertyDeclaration.typeName
-               << "\", " << propertyDeclaration.traits << ", " << propertyDeclaration.typeId
-               << ", \"" << propertyDeclaration.aliasPropertyName << "\")";
+    return out << "(\"" << propertyDeclaration.name << "\", " << propertyDeclaration.typeName
+               << ", " << propertyDeclaration.typeId << ", " << propertyDeclaration.traits << ", "
+               << propertyDeclaration.typeId << ", \"" << propertyDeclaration.aliasPropertyName
+               << "\")";
 }
 
 std::ostream &operator<<(std::ostream &out, PropertyDeclarationTraits traits)
@@ -1186,11 +1186,6 @@ std::ostream &operator<<(std::ostream &out, const EnumerationDeclaration &enumer
                << enumerationDeclaration.enumeratorDeclarations << ")";
 }
 
-std::ostream &operator<<(std::ostream &out, const Module &module)
-{
-    return out << "(" << module.name << ", " << module.sourceId << ")";
-}
-
 std::ostream &operator<<(std::ostream &out, const ImportKind &importKind)
 {
     return out << importKindToText(importKind);
@@ -1198,8 +1193,7 @@ std::ostream &operator<<(std::ostream &out, const ImportKind &importKind)
 
 std::ostream &operator<<(std::ostream &out, const Import &import)
 {
-    return out << "(" << import.name << ", " << import.version << ", " << import.sourceId << ", "
-               << import.moduleId << ", " << import.kind << ")";
+    return out << "(" << import.moduleId << ", " << import.version << ", " << import.sourceId << ")";
 }
 
 } // namespace Storage
diff --git a/tests/unit/unittest/gtest-creator-printing.h b/tests/unit/unittest/gtest-creator-printing.h
index 5b8cb51e8e..074fada6d9 100644
--- a/tests/unit/unittest/gtest-creator-printing.h
+++ b/tests/unit/unittest/gtest-creator-printing.h
@@ -260,8 +260,6 @@ class ParameterDeclaration;
 class SignalDeclaration;
 class EnumerationDeclaration;
 class EnumeratorDeclaration;
-class Module;
-class ModuleDependency;
 enum class ImportKind : char;
 class Import;
 enum class IsQualified : int;
@@ -281,8 +279,6 @@ 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 Module &module);
-std::ostream &operator<<(std::ostream &out, const ModuleDependency &module);
 std::ostream &operator<<(std::ostream &out, const ImportKind &importKind);
 std::ostream &operator<<(std::ostream &out, const Import &import);
 std::ostream &operator<<(std::ostream &out, IsQualified isQualified);
diff --git a/tests/unit/unittest/projectstorage-test.cpp b/tests/unit/unittest/projectstorage-test.cpp
index da71b36d31..bd6fda06bc 100644
--- a/tests/unit/unittest/projectstorage-test.cpp
+++ b/tests/unit/unittest/projectstorage-test.cpp
@@ -83,34 +83,18 @@ MATCHER_P2(IsSourceNameAndSourceContextId,
            && sourceNameAndSourceContextId.sourceContextId == id;
 }
 
-MATCHER_P5(IsStorageType,
-           moduleId,
-           typeName,
-           prototype,
-           accessSemantics,
+MATCHER_P4(IsStorageType,
            sourceId,
-           std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::Type{moduleId, typeName, prototype, accessSemantics, sourceId}))
-{
-    const Storage::Type &type = arg;
-
-    return type.moduleId == moduleId && type.typeName == typeName
-           && type.accessSemantics == accessSemantics && type.sourceId == sourceId
-           && Storage::ImportedTypeName{prototype} == type.prototype;
-}
-
-MATCHER_P4(IsStorageTypeWithInvalidSourceId,
-           moduleId,
            typeName,
-           prototype,
+           prototypeId,
            accessSemantics,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::Type{moduleId, typeName, prototype, accessSemantics, SourceId{}}))
+               + PrintToString(Storage::Type{typeName, prototypeId, accessSemantics, sourceId}))
 {
     const Storage::Type &type = arg;
 
-    return type.moduleId == moduleId && type.typeName == typeName && type.prototype == prototype
-           && type.accessSemantics == accessSemantics && !type.sourceId.isValid();
+    return type.sourceId == sourceId && type.typeName == typeName
+           && type.accessSemantics == accessSemantics && prototypeId.id == type.prototypeId.id;
 }
 
 MATCHER_P(IsExportedType,
@@ -122,6 +106,17 @@ MATCHER_P(IsExportedType,
     return type.name == name;
 }
 
+MATCHER_P2(IsExportedType,
+           moduleId,
+           name,
+           std::string(negation ? "isn't " : "is ")
+               + PrintToString(Storage::ExportedType{moduleId, name}))
+{
+    const Storage::ExportedType &type = arg;
+
+    return type.moduleId == moduleId && type.name == name;
+}
+
 MATCHER_P3(IsExportedType,
            name,
            majorVersion,
@@ -135,56 +130,51 @@ MATCHER_P3(IsExportedType,
     return type.name == name && type.version == Storage::Version{majorVersion, minorVersion};
 }
 
+MATCHER_P4(IsExportedType,
+           moduleId,
+           name,
+           majorVersion,
+           minorVersion,
+           std::string(negation ? "isn't " : "is ")
+               + PrintToString(Storage::ExportedType{moduleId,
+                                                     name,
+                                                     Storage::Version{majorVersion, minorVersion}}))
+{
+    const Storage::ExportedType &type = arg;
+
+    return type.moduleId == moduleId && type.name == name
+           && type.version == Storage::Version{majorVersion, minorVersion};
+}
+
 MATCHER_P3(IsPropertyDeclaration,
            name,
-           typeName,
+           propertyTypeId,
            traits,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::PropertyDeclaration{name, typeName, traits}))
+               + PrintToString(Storage::PropertyDeclaration{name, propertyTypeId, traits}))
 {
     const Storage::PropertyDeclaration &propertyDeclaration = arg;
 
-    return propertyDeclaration.name == name
-           && Storage::ImportedTypeName{typeName} == propertyDeclaration.typeName
+    return propertyDeclaration.name == name && propertyTypeId == propertyDeclaration.propertyTypeId
            && propertyDeclaration.traits == traits;
 }
 
 MATCHER_P4(IsPropertyDeclaration,
            name,
-           typeName,
+           propertyTypeId,
            traits,
            aliasPropertyName,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::PropertyDeclaration(name, typeName, traits, aliasPropertyName)))
+               + PrintToString(
+                   Storage::PropertyDeclaration{name, propertyTypeId, traits, aliasPropertyName}))
 {
     const Storage::PropertyDeclaration &propertyDeclaration = arg;
 
-    return propertyDeclaration.name == name
-           && Utils::visit([&](auto &&v) -> bool { return v.name == typeName.name; },
-                           propertyDeclaration.typeName)
+    return propertyDeclaration.name == name && propertyTypeId == propertyDeclaration.propertyTypeId
            && propertyDeclaration.aliasPropertyName == aliasPropertyName
            && propertyDeclaration.traits == traits;
 }
 
-MATCHER_P(IsModule,
-          name,
-          std::string(negation ? "isn't " : "is ") + PrintToString(Storage::Module{name}))
-{
-    const Storage::Module &module = arg;
-
-    return module.name == name;
-}
-
-MATCHER_P2(IsModule,
-           name,
-           sourceId,
-           std::string(negation ? "isn't " : "is ") + PrintToString(Storage::Module{name, sourceId}))
-{
-    const Storage::Module &module = arg;
-
-    return module.name == name;
-}
-
 class ProjectStorage : public testing::Test
 {
 protected:
@@ -214,25 +204,31 @@ protected:
 
     auto createTypes()
     {
-        imports.emplace_back("Qml", Storage::Version{}, sourceId1);
-        imports.emplace_back("Qml", Storage::Version{}, sourceId2);
-        imports.emplace_back("QtQuick", Storage::Version{}, sourceId1);
+        imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId1);
+        imports.emplace_back(qmlNativeModuleId, Storage::Version{}, sourceId1);
+        imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId1);
+        imports.emplace_back(qtQuickNativeModuleId, Storage::Version{}, sourceId1);
+        imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId2);
+        imports.emplace_back(qmlNativeModuleId, Storage::Version{}, sourceId2);
 
-        importsSourceId1.emplace_back("Qml", Storage::Version{}, sourceId1);
-        importsSourceId1.emplace_back("QtQuick", Storage::Version{}, sourceId1);
+        importsSourceId1.emplace_back(qmlModuleId, Storage::Version{}, sourceId1);
+        importsSourceId1.emplace_back(qmlNativeModuleId, Storage::Version{}, sourceId1);
+        importsSourceId1.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId1);
+        importsSourceId1.emplace_back(qtQuickNativeModuleId, Storage::Version{}, sourceId1);
 
-        importsSourceId2.emplace_back("Qml", Storage::Version{}, sourceId2);
+        importsSourceId2.emplace_back(qmlModuleId, Storage::Version{}, sourceId2);
+        importsSourceId2.emplace_back(qmlNativeModuleId, Storage::Version{}, sourceId2);
 
         return Storage::Types{
             Storage::Type{
-                qtQuickModuleId,
                 "QQuickItem",
-                Storage::NativeType{"QObject"},
+                Storage::ImportedType{"QObject"},
                 TypeAccessSemantics::Reference,
                 sourceId1,
-                {Storage::ExportedType{"Item"}},
+                {Storage::ExportedType{qtQuickModuleId, "Item"},
+                 Storage::ExportedType{qtQuickNativeModuleId, "QQuickItem"}},
                 {Storage::PropertyDeclaration{"data",
-                                              Storage::NativeType{"QObject"},
+                                              Storage::ImportedType{"QObject"},
                                               Storage::PropertyDeclarationTraits::IsList},
                  Storage::PropertyDeclaration{"children",
                                               Storage::ImportedType{"Item"},
@@ -261,48 +257,48 @@ protected:
                  Storage::EnumerationDeclaration{"Type",
                                                  {Storage::EnumeratorDeclaration{"Foo"},
                                                   Storage::EnumeratorDeclaration{"Poo", 12}}}}},
-            Storage::Type{qmlModuleId,
-                          "QObject",
-                          Storage::NativeType{},
+            Storage::Type{"QObject",
+                          Storage::ImportedType{},
                           TypeAccessSemantics::Reference,
                           sourceId2,
-                          {Storage::ExportedType{"Object", Storage::Version{2}},
-                           Storage::ExportedType{"Obj", Storage::Version{2}}}}};
+                          {Storage::ExportedType{qmlModuleId, "Object", Storage::Version{2}},
+                           Storage::ExportedType{qmlModuleId, "Obj", Storage::Version{2}},
+                           Storage::ExportedType{qmlNativeModuleId, "QObject"}}}};
     }
 
     auto createVersionedTypes()
     {
-        return Storage::Types{Storage::Type{qmlModuleId,
-                                            "QObject",
-                                            Storage::NativeType{},
-                                            TypeAccessSemantics::Reference,
-                                            sourceId1,
-                                            {Storage::ExportedType{"Object", Storage::Version{1}},
-                                             Storage::ExportedType{"Obj", Storage::Version{1, 2}},
-                                             Storage::ExportedType{"BuiltInObj", Storage::Version{}}}},
-                              Storage::Type{qmlModuleId,
-                                            "QObject2",
-                                            Storage::NativeType{},
-                                            TypeAccessSemantics::Reference,
-                                            sourceId1,
-                                            {Storage::ExportedType{"Object", Storage::Version{2, 0}},
-                                             Storage::ExportedType{"Obj", Storage::Version{2, 3}}}},
-                              Storage::Type{qmlModuleId,
-                                            "QObject3",
-                                            Storage::NativeType{},
-                                            TypeAccessSemantics::Reference,
-                                            sourceId1,
-                                            {Storage::ExportedType{"Object", Storage::Version{2, 11}},
-                                             Storage::ExportedType{"Obj", Storage::Version{2, 11}}}},
-                              Storage::Type{qmlModuleId,
-                                            "QObject4",
-                                            Storage::NativeType{},
-                                            TypeAccessSemantics::Reference,
-                                            sourceId1,
-                                            {Storage::ExportedType{"Object", Storage::Version{3, 4}},
-                                             Storage::ExportedType{"Obj", Storage::Version{3, 4}},
-                                             Storage::ExportedType{"BuiltInObj",
-                                                                   Storage::Version{3, 4}}}}};
+        return Storage::Types{
+            Storage::Type{"QObject",
+                          Storage::ImportedType{},
+                          TypeAccessSemantics::Reference,
+                          sourceId1,
+                          {Storage::ExportedType{qmlModuleId, "Object", Storage::Version{1}},
+                           Storage::ExportedType{qmlModuleId, "Obj", Storage::Version{1, 2}},
+                           Storage::ExportedType{qmlModuleId, "BuiltInObj"},
+                           Storage::ExportedType{qmlNativeModuleId, "QObject"}}},
+            Storage::Type{"QObject2",
+                          Storage::ImportedType{},
+                          TypeAccessSemantics::Reference,
+                          sourceId1,
+                          {Storage::ExportedType{qmlModuleId, "Object", Storage::Version{2, 0}},
+                           Storage::ExportedType{qmlModuleId, "Obj", Storage::Version{2, 3}},
+                           Storage::ExportedType{qmlNativeModuleId, "QObject2"}}},
+            Storage::Type{"QObject3",
+                          Storage::ImportedType{},
+                          TypeAccessSemantics::Reference,
+                          sourceId1,
+                          {Storage::ExportedType{qmlModuleId, "Object", Storage::Version{2, 11}},
+                           Storage::ExportedType{qmlModuleId, "Obj", Storage::Version{2, 11}},
+                           Storage::ExportedType{qmlNativeModuleId, "QObject3"}}},
+            Storage::Type{"QObject4",
+                          Storage::ImportedType{},
+                          TypeAccessSemantics::Reference,
+                          sourceId1,
+                          {Storage::ExportedType{qmlModuleId, "Object", Storage::Version{3, 4}},
+                           Storage::ExportedType{qmlModuleId, "Obj", Storage::Version{3, 4}},
+                           Storage::ExportedType{qmlModuleId, "BuiltInObj", Storage::Version{3, 4}},
+                           Storage::ExportedType{qmlNativeModuleId, "QObject4"}}}};
     }
 
     auto createTypesWithExportedTypeNamesOnly()
@@ -319,48 +315,53 @@ protected:
     {
         auto types = createTypes();
 
-        imports.emplace_back("Qml", Storage::Version{}, sourceId3);
-        imports.emplace_back("QtQuick", Storage::Version{}, sourceId3);
+        imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId3);
+        imports.emplace_back(qmlNativeModuleId, Storage::Version{}, sourceId3);
+        imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
+        imports.emplace_back(qtQuickNativeModuleId, Storage::Version{}, sourceId3);
 
-        imports.emplace_back("Qml", Storage::Version{}, sourceId4);
-        imports.emplace_back("/path/to", Storage::Version{}, sourceId4);
+        imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId4);
+        imports.emplace_back(qmlNativeModuleId, Storage::Version{}, sourceId4);
+        imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId4);
 
-        importsSourceId3.emplace_back("Qml", Storage::Version{}, sourceId3);
-        importsSourceId3.emplace_back("QtQuick", Storage::Version{}, sourceId3);
+        importsSourceId3.emplace_back(qmlModuleId, Storage::Version{}, sourceId3);
+        importsSourceId3.emplace_back(qmlNativeModuleId, Storage::Version{}, sourceId3);
+        importsSourceId3.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
+        importsSourceId3.emplace_back(qtQuickNativeModuleId, Storage::Version{}, sourceId3);
 
-        importsSourceId4.emplace_back("Qml", Storage::Version{}, sourceId4);
-        importsSourceId4.emplace_back("/path/to", Storage::Version{}, sourceId4);
+        importsSourceId4.emplace_back(qmlModuleId, Storage::Version{}, sourceId4);
+        importsSourceId4.emplace_back(qmlNativeModuleId, Storage::Version{}, sourceId4);
+        importsSourceId4.emplace_back(pathToModuleId, Storage::Version{}, sourceId4);
 
         types[1].propertyDeclarations.push_back(
             Storage::PropertyDeclaration{"objects",
-                                         Storage::NativeType{"QObject"},
+                                         Storage::ImportedType{"QObject"},
                                          Storage::PropertyDeclarationTraits::IsList});
 
-        types.push_back(Storage::Type{qtQuickModuleId,
-                                      "QAliasItem",
+        types.push_back(Storage::Type{"QAliasItem",
                                       Storage::ImportedType{"Item"},
                                       TypeAccessSemantics::Reference,
                                       sourceId3,
-                                      {Storage::ExportedType{"AliasItem"}}});
+                                      {Storage::ExportedType{qtQuickModuleId, "AliasItem"},
+                                       Storage::ExportedType{qtQuickNativeModuleId, "QAliasItem"}}});
         types.back().propertyDeclarations.push_back(
             Storage::PropertyDeclaration{"data",
-                                         Storage::NativeType{"QObject"},
+                                         Storage::ImportedType{"QObject"},
                                          Storage::PropertyDeclarationTraits::IsList});
         types.back().propertyDeclarations.push_back(
             Storage::PropertyDeclaration{"items", Storage::ImportedType{"Item"}, "children"});
         types.back().propertyDeclarations.push_back(
             Storage::PropertyDeclaration{"objects", Storage::ImportedType{"Item"}, "objects"});
 
-        types.push_back(
-            Storage::Type{pathToModuleId,
-                          "QObject2",
-                          Storage::NativeType{},
-                          TypeAccessSemantics::Reference,
-                          sourceId4,
-                          {Storage::ExportedType{"Object2"}, Storage::ExportedType{"Obj2"}}});
+        types.push_back(Storage::Type{"QObject2",
+                                      Storage::ImportedType{},
+                                      TypeAccessSemantics::Reference,
+                                      sourceId4,
+                                      {Storage::ExportedType{pathToModuleId, "Object2"},
+                                       Storage::ExportedType{pathToModuleId, "Obj2"}}});
         types[3].propertyDeclarations.push_back(
             Storage::PropertyDeclaration{"objects",
-                                         Storage::NativeType{"QObject"},
+                                         Storage::ImportedType{"QObject"},
                                          Storage::PropertyDeclarationTraits::IsList});
 
         return types;
@@ -368,16 +369,16 @@ protected:
 
     auto createTypesWithRecursiveAliases()
     {
-        imports.emplace_back("Qml", Storage::Version{}, sourceId5);
-        imports.emplace_back("QtQuick", Storage::Version{}, sourceId5);
+        imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId5);
+        imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId5);
 
         auto types = createTypesWithAliases();
-        types.push_back(Storage::Type{qtQuickModuleId,
-                                      "QAliasItem2",
+        types.push_back(Storage::Type{"QAliasItem2",
                                       Storage::ImportedType{"Object"},
                                       TypeAccessSemantics::Reference,
                                       sourceId5,
-                                      {Storage::ExportedType{"AliasItem2"}}});
+                                      {Storage::ExportedType{qtQuickModuleId, "AliasItem2"},
+                                       Storage::ExportedType{qtQuickNativeModuleId, "QAliasItem2"}}});
 
         types.back().propertyDeclarations.push_back(
             Storage::PropertyDeclaration{"objects", Storage::ImportedType{"AliasItem"}, "objects"});
@@ -388,38 +389,19 @@ protected:
     auto createTypesWithAliases2()
     {
         auto types = createTypesWithAliases();
-        types[2].prototype = Storage::NativeType{"QObject"};
+        types[2].prototype = Storage::ImportedType{"Object"};
         types[2].propertyDeclarations.erase(std::next(types[2].propertyDeclarations.begin()));
 
         return types;
     }
 
-    Storage::Modules createModules()
-    {
-        return Storage::Modules{Storage::Module{"Qml", qmlModuleSourceId},
-                                Storage::Module{"QtQuick", qtQuickModuleSourceId},
-                                Storage::Module{"/path/to", pathToModuleSourceId}};
-    }
-
     Storage::Imports createImports(SourceId sourceId)
     {
-        return Storage::Imports{Storage::Import{"Qml", Storage::Version{2}, sourceId},
-                                Storage::Import{"QtQuick", Storage::Version{}, sourceId},
-                                Storage::Import{"/path/to", Storage::Version{}, sourceId}};
-    }
-
-    static Storage::Imports createImports(const SourceIds &sourceIds)
-    {
-        Storage::Imports imports;
-        imports.reserve(3 * sourceIds.size());
-
-        for (SourceId sourceId : sourceIds) {
-            imports.emplace_back("Qml", Storage::Version{2}, sourceId);
-            imports.emplace_back("QtQuick", Storage::Version{}, sourceId);
-            imports.emplace_back("/path/to", Storage::Version{}, sourceId);
-        }
-
-        return imports;
+        return Storage::Imports{Storage::Import{qmlModuleId, Storage::Version{2}, sourceId},
+                                Storage::Import{qmlNativeModuleId, Storage::Version{}, sourceId},
+                                Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId},
+                                Storage::Import{qtQuickNativeModuleId, Storage::Version{}, sourceId},
+                                Storage::Import{pathToModuleId, Storage::Version{}, sourceId}};
     }
 
     template<typename Range>
@@ -428,9 +410,14 @@ protected:
         return FileStatuses(range.begin(), range.end());
     }
 
+    TypeId fetchTypeId(SourceId sourceId, Utils::SmallStringView name)
+    {
+        return storage.fetchTypeIdByName(sourceId, name);
+    }
+
 protected:
     Sqlite::Database database{":memory:", Sqlite::JournalMode::Memory};
-    //Sqlite::Database database{TESTDATA_DIR "/aaaa.db", Sqlite::JournalMode::Wal};
+    //Sqlite::Database database{TESTDATA_DIR "/aaaaa.db", Sqlite::JournalMode::Wal};
     QmlDesigner::ProjectStorage<Sqlite::Database> storage{database, database.isInitialized()};
     QmlDesigner::SourcePathCache<QmlDesigner::ProjectStorage<Sqlite::Database>> sourcePathCache{
         storage};
@@ -455,10 +442,11 @@ protected:
     SourceId pathToModuleSourceId{sourcePathCache.sourceId(modulePath3)};
     SourceId moduleSourceId4{sourcePathCache.sourceId(modulePath4)};
     SourceId moduleSourceId5{sourcePathCache.sourceId(modulePath5)};
-    Storage::Modules modules{createModules()};
-    ModuleId qmlModuleId{&qmlModuleSourceId};
-    ModuleId qtQuickModuleId{&qtQuickModuleSourceId};
-    ModuleId pathToModuleId{&pathToModuleSourceId};
+    ModuleId qmlModuleId{storage.moduleId("Qml")};
+    ModuleId qmlNativeModuleId{storage.moduleId("Qml-cppnative")};
+    ModuleId qtQuickModuleId{storage.moduleId("QtQuick")};
+    ModuleId qtQuickNativeModuleId{storage.moduleId("QtQuick-cppnative")};
+    ModuleId pathToModuleId{storage.moduleId("/path/to")};
     Storage::Imports imports;
     Storage::Imports importsSourceId1;
     Storage::Imports importsSourceId2;
@@ -674,28 +662,26 @@ TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypes)
     Storage::Types types{createTypes()};
 
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
 
-    ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(qmlModuleId,
-                                                         "QObject",
-                                                         Storage::NativeType{},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId2),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Object"),
-                                                                      IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(qtQuickModuleId,
-                                                         "QQuickItem",
-                                                         Storage::NativeType{"QObject"},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId1),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Item"))))));
+    ASSERT_THAT(
+        storage.fetchTypes(),
+        UnorderedElementsAre(
+            AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
+                                             IsExportedType(qmlModuleId, "Obj"),
+                                             IsExportedType(qmlNativeModuleId, "QObject")))),
+            AllOf(IsStorageType(sourceId1,
+                                "QQuickItem",
+                                fetchTypeId(sourceId2, "QObject"),
+                                TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
+                                             IsExportedType(qtQuickNativeModuleId, "QQuickItem"))))));
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypesWithExportedPrototypeName)
@@ -704,28 +690,26 @@ TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypesWithExportedPrototypeName)
     types[0].prototype = Storage::ImportedType{"Object"};
 
     storage.synchronize(
-        modules,
         importsSourceId1,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
 
-    ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(qmlModuleId,
-                                                         "QObject",
-                                                         Storage::NativeType{},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId2),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Object"),
-                                                                      IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(qtQuickModuleId,
-                                                         "QQuickItem",
-                                                         Storage::NativeType{"QObject"},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId1),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Item"))))));
+    ASSERT_THAT(
+        storage.fetchTypes(),
+        UnorderedElementsAre(
+            AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
+                                             IsExportedType(qmlModuleId, "Obj"),
+                                             IsExportedType(qmlNativeModuleId, "QObject")))),
+            AllOf(IsStorageType(sourceId1,
+                                "QQuickItem",
+                                fetchTypeId(sourceId2, "QObject"),
+                                TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
+                                             IsExportedType(qtQuickNativeModuleId, "QQuickItem"))))));
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypesThrowsWithWrongPrototypeName)
@@ -733,8 +717,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypesThrowsWithWrongPrototypeName)
     Storage::Types types{createTypes()};
     types[0].prototype = Storage::ImportedType{"Objec"};
 
-    ASSERT_THROW(storage.synchronize(modules,
-                                     imports,
+    ASSERT_THROW(storage.synchronize(imports,
                                      types,
                                      {sourceId1,
                                       sourceId2,
@@ -748,80 +731,55 @@ TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypesThrowsWithWrongPrototypeName)
 TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypesWithMissingModuleAndPrototypeName)
 {
     Storage::Types types{createTypes()};
-    types.push_back(Storage::Type{pathToModuleId,
-                                  "QObject2",
-                                  Storage::NativeType{},
+    types.push_back(Storage::Type{"QObject2",
+                                  Storage::ImportedType{},
                                   TypeAccessSemantics::Reference,
                                   sourceId3,
-                                  {Storage::ExportedType{"Object2"}, Storage::ExportedType{"Obj2"}}});
+                                  {Storage::ExportedType{ModuleId{22}, "Object2"},
+                                   Storage::ExportedType{pathToModuleId, "Obj2"}}});
     storage.synchronize(
-        modules,
         imports,
         {},
         {sourceId1, sourceId2, sourceId3, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[1].prototype = Storage::ImportedType{"Object2"};
 
-    ASSERT_THROW(storage.synchronize({}, importsSourceId2, {types[1]}, {sourceId2}, {}),
+    ASSERT_THROW(storage.synchronize(importsSourceId2, {types[1]}, {sourceId2}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
-TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypesWithMissingModule)
-{
-    Storage::Types types{createTypes()};
-    storage.synchronize(modules,
-                        imports,
-                        {},
-                        {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
-                        {});
-
-    ASSERT_THROW(storage.synchronize({},
-                                     imports,
-                                     types,
-                                     {sourceId1,
-                                      sourceId2,
-                                      qmlModuleSourceId,
-                                      qtQuickModuleSourceId,
-                                      pathToModuleSourceId},
-                                     {}),
-                 QmlDesigner::ModuleDoesNotExists);
-}
-
 TEST_F(ProjectStorage, SynchronizeTypesAddsNewTypesReverseOrder)
 {
     Storage::Types types{createTypes()};
     std::reverse(types.begin(), types.end());
 
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
 
-    ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(qmlModuleId,
-                                                         "QObject",
-                                                         Storage::NativeType{},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId2),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Object"),
-                                                                      IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(qtQuickModuleId,
-                                                         "QQuickItem",
-                                                         Storage::NativeType{"QObject"},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId1),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Item"))))));
+    ASSERT_THAT(
+        storage.fetchTypes(),
+        UnorderedElementsAre(
+            AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
+                                             IsExportedType(qmlModuleId, "Obj"),
+                                             IsExportedType(qmlNativeModuleId, "QObject")))),
+            AllOf(IsStorageType(sourceId1,
+                                "QQuickItem",
+                                fetchTypeId(sourceId2, "QObject"),
+                                TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
+                                             IsExportedType(qtQuickNativeModuleId, "QQuickItem"))))));
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesOverwritesTypeAccessSemantics)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
@@ -829,31 +787,29 @@ TEST_F(ProjectStorage, SynchronizeTypesOverwritesTypeAccessSemantics)
     types[0].accessSemantics = TypeAccessSemantics::Value;
     types[1].accessSemantics = TypeAccessSemantics::Value;
 
-    storage.synchronize({}, imports, types, {sourceId1, sourceId2}, {});
+    storage.synchronize(imports, types, {sourceId1, sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(qmlModuleId,
-                                                         "QObject",
-                                                         Storage::NativeType{},
-                                                         TypeAccessSemantics::Value,
-                                                         sourceId2),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Object"),
-                                                                      IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(qtQuickModuleId,
-                                                         "QQuickItem",
-                                                         Storage::NativeType{"QObject"},
-                                                         TypeAccessSemantics::Value,
-                                                         sourceId1),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Item"))))));
+                UnorderedElementsAre(
+                    AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeAccessSemantics::Value),
+                          Field(&Storage::Type::exportedTypes,
+                                UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
+                                                     IsExportedType(qmlModuleId, "Obj"),
+                                                     IsExportedType(qmlNativeModuleId, "QObject")))),
+                    AllOf(IsStorageType(sourceId1,
+                                        "QQuickItem",
+                                        fetchTypeId(sourceId2, "QObject"),
+                                        TypeAccessSemantics::Value),
+                          Field(&Storage::Type::exportedTypes,
+                                UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
+                                                     IsExportedType(qtQuickNativeModuleId,
+                                                                    "QQuickItem"))))));
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesOverwritesSources)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
@@ -861,132 +817,129 @@ TEST_F(ProjectStorage, SynchronizeTypesOverwritesSources)
     types[0].sourceId = sourceId3;
     types[1].sourceId = sourceId4;
     Storage::Imports newImports;
-    newImports.emplace_back("Qml", Storage::Version{}, sourceId3);
-    newImports.emplace_back("Qml", Storage::Version{}, sourceId4);
-    newImports.emplace_back("QtQuick", Storage::Version{}, sourceId3);
+    newImports.emplace_back(qmlModuleId, Storage::Version{}, sourceId3);
+    newImports.emplace_back(qmlNativeModuleId, Storage::Version{}, sourceId3);
+    newImports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
+    newImports.emplace_back(qtQuickNativeModuleId, Storage::Version{}, sourceId3);
+    newImports.emplace_back(qmlModuleId, Storage::Version{}, sourceId4);
+    newImports.emplace_back(qmlNativeModuleId, Storage::Version{}, sourceId4);
 
-    storage.synchronize({}, newImports, types, {sourceId1, sourceId2, sourceId3, sourceId4}, {});
+    storage.synchronize(newImports, types, {sourceId1, sourceId2, sourceId3, sourceId4}, {});
 
-    ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(qmlModuleId,
-                                                         "QObject",
-                                                         Storage::NativeType{},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId4),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Object"),
-                                                                      IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(qtQuickModuleId,
-                                                         "QQuickItem",
-                                                         Storage::NativeType{"QObject"},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId3),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Item"))))));
+    ASSERT_THAT(
+        storage.fetchTypes(),
+        UnorderedElementsAre(
+            AllOf(IsStorageType(sourceId4, "QObject", TypeId{}, TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
+                                             IsExportedType(qmlModuleId, "Obj"),
+                                             IsExportedType(qmlNativeModuleId, "QObject")))),
+            AllOf(IsStorageType(sourceId3,
+                                "QQuickItem",
+                                fetchTypeId(sourceId4, "QObject"),
+                                TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
+                                             IsExportedType(qtQuickNativeModuleId, "QQuickItem"))))));
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesInsertTypeIntoPrototypeChain)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
-    types[0].prototype = Storage::NativeType{"QQuickObject"};
-    types.push_back(Storage::Type{qtQuickModuleId,
-                                  "QQuickObject",
-                                  Storage::NativeType{"QObject"},
+    types[0].prototype = Storage::ImportedType{"QQuickObject"};
+    types.push_back(Storage::Type{"QQuickObject",
+                                  Storage::ImportedType{"QObject"},
                                   TypeAccessSemantics::Reference,
                                   sourceId1,
-                                  {Storage::ExportedType{"Object"}}});
+                                  {Storage::ExportedType{qtQuickModuleId, "Object"},
+                                   Storage::ExportedType{qtQuickNativeModuleId, "QQuickObject"}}});
 
-    storage.synchronize({}, importsSourceId1, {types[0], types[2]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0], types[2]}, {sourceId1}, {});
 
-    ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(qmlModuleId,
-                                                         "QObject",
-                                                         Storage::NativeType{},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId2),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Object"),
-                                                                      IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(qtQuickModuleId,
-                                                         "QQuickObject",
-                                                         Storage::NativeType{"QObject"},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId1),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Object")))),
-                                     AllOf(IsStorageType(qtQuickModuleId,
-                                                         "QQuickItem",
-                                                         Storage::NativeType{"QQuickObject"},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId1),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Item"))))));
+    ASSERT_THAT(
+        storage.fetchTypes(),
+        UnorderedElementsAre(
+            AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
+                                             IsExportedType(qmlModuleId, "Obj"),
+                                             IsExportedType(qmlNativeModuleId, "QObject")))),
+            AllOf(IsStorageType(sourceId1,
+                                "QQuickObject",
+                                fetchTypeId(sourceId2, "QObject"),
+                                TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Object"),
+                                             IsExportedType(qtQuickNativeModuleId, "QQuickObject")))),
+            AllOf(IsStorageType(sourceId1,
+                                "QQuickItem",
+                                fetchTypeId(sourceId1, "QQuickObject"),
+                                TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
+                                             IsExportedType(qtQuickNativeModuleId, "QQuickItem"))))));
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesAddQualifiedPrototype)
 {
     Storage::Types types{createTypes()};
     types[0].prototype = Storage::QualifiedImportedType{"Object",
-                                                        Storage::Import{"QtQuick",
+                                                        Storage::Import{qtQuickModuleId,
                                                                         Storage::Version{},
                                                                         sourceId1}};
-    types.push_back(Storage::Type{qtQuickModuleId,
-                                  "QQuickObject",
-                                  Storage::NativeType{"QObject"},
+    types.push_back(Storage::Type{"QQuickObject",
+                                  Storage::ImportedType{"QObject"},
                                   TypeAccessSemantics::Reference,
                                   sourceId1,
-                                  {Storage::ExportedType{"Object"}}});
+                                  {Storage::ExportedType{qtQuickModuleId, "Object"},
+                                   Storage::ExportedType{qtQuickNativeModuleId, "QQuickObject"}}});
 
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
 
-    ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(qmlModuleId,
-                                                         "QObject",
-                                                         Storage::NativeType{},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId2),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Object"),
-                                                                      IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(qtQuickModuleId,
-                                                         "QQuickObject",
-                                                         Storage::NativeType{"QObject"},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId1),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Object")))),
-                                     AllOf(IsStorageType(qtQuickModuleId,
-                                                         "QQuickItem",
-                                                         Storage::NativeType{"QQuickObject"},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId1),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Item"))))));
+    ASSERT_THAT(
+        storage.fetchTypes(),
+        UnorderedElementsAre(
+            AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
+                                             IsExportedType(qmlModuleId, "Obj"),
+                                             IsExportedType(qmlNativeModuleId, "QObject")))),
+            AllOf(IsStorageType(sourceId1,
+                                "QQuickObject",
+                                fetchTypeId(sourceId2, "QObject"),
+                                TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Object"),
+                                             IsExportedType(qtQuickNativeModuleId, "QQuickObject")))),
+            AllOf(IsStorageType(sourceId1,
+                                "QQuickItem",
+                                fetchTypeId(sourceId1, "QQuickObject"),
+                                TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
+                                             IsExportedType(qtQuickNativeModuleId, "QQuickItem"))))));
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesThrowsForMissingPrototype)
 {
     sourceId1 = sourcePathCache.sourceId(path1);
-    Storage::Types types{Storage::Type{qtQuickModuleId,
-                                       "QQuickItem",
-                                       Storage::NativeType{"QObject"},
+    Storage::Types types{Storage::Type{"QQuickItem",
+                                       Storage::ImportedType{"QObject"},
                                        TypeAccessSemantics::Reference,
                                        sourceId1,
-                                       {Storage::ExportedType{"Item"}}}};
+                                       {Storage::ExportedType{qtQuickModuleId, "Item"},
+                                        Storage::ExportedType{qtQuickNativeModuleId, "QQuickItem"}}}};
 
     ASSERT_THROW(storage.synchronize(
-                     modules,
                      imports,
                      types,
                      {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
@@ -997,28 +950,25 @@ TEST_F(ProjectStorage, SynchronizeTypesThrowsForMissingPrototype)
 TEST_F(ProjectStorage, SynchronizeTypesThrowsForInvalidModule)
 {
     sourceId1 = sourcePathCache.sourceId(path1);
-    Storage::Types types{Storage::Type{ModuleId{},
-                                       "QQuickItem",
-                                       Storage::NativeType{"QObject"},
+    Storage::Types types{Storage::Type{"QQuickItem",
+                                       Storage::ImportedType{"QObject"},
                                        TypeAccessSemantics::Reference,
                                        sourceId1,
-                                       {Storage::ExportedType{"Item"}}}};
+                                       {Storage::ExportedType{ModuleId{}, "Item"}}}};
 
-    ASSERT_THROW(storage.synchronize({}, imports, types, {sourceId1}, {}),
+    ASSERT_THROW(storage.synchronize(imports, types, {sourceId1}, {}),
                  QmlDesigner::ModuleDoesNotExists);
 }
 
 TEST_F(ProjectStorage, TypeWithInvalidSourceIdThrows)
 {
-    Storage::Types types{Storage::Type{qtQuickModuleId,
-                                       "QQuickItem",
-                                       Storage::NativeType{""},
+    Storage::Types types{Storage::Type{"QQuickItem",
+                                       Storage::ImportedType{""},
                                        TypeAccessSemantics::Reference,
                                        SourceId{},
-                                       {Storage::ExportedType{"Item"}}}};
+                                       {Storage::ExportedType{qtQuickModuleId, "Item"}}}};
 
     ASSERT_THROW(storage.synchronize(
-                     modules,
                      imports,
                      types,
                      {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
@@ -1030,100 +980,92 @@ TEST_F(ProjectStorage, DeleteTypeIfSourceIdIsSynchronized)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types.erase(types.begin());
 
-    storage.synchronize({}, importsSourceId2, types, {sourceId1, sourceId2}, {});
+    storage.synchronize(importsSourceId2, types, {sourceId1, sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(qmlModuleId,
-                                                         "QObject",
-                                                         Storage::NativeType{},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId2),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Object"),
-                                                                      IsExportedType("Obj"))))));
+                UnorderedElementsAre(
+                    AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeAccessSemantics::Reference),
+                          Field(&Storage::Type::exportedTypes,
+                                UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
+                                                     IsExportedType(qmlModuleId, "Obj"),
+                                                     IsExportedType(qmlNativeModuleId, "QObject"))))));
 }
 
 TEST_F(ProjectStorage, DontDeleteTypeIfSourceIdIsNotSynchronized)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types.pop_back();
 
-    storage.synchronize({}, importsSourceId1, types, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, types, {sourceId1}, {});
 
-    ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(qmlModuleId,
-                                                         "QObject",
-                                                         Storage::NativeType{},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId2),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Object"),
-                                                                      IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(qtQuickModuleId,
-                                                         "QQuickItem",
-                                                         Storage::NativeType{"QObject"},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId1),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Item"))))));
+    ASSERT_THAT(
+        storage.fetchTypes(),
+        UnorderedElementsAre(
+            AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
+                                             IsExportedType(qmlModuleId, "Obj"),
+                                             IsExportedType(qmlNativeModuleId, "QObject")))),
+            AllOf(IsStorageType(sourceId1,
+                                "QQuickItem",
+                                fetchTypeId(sourceId2, "QObject"),
+                                TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
+                                             IsExportedType(qtQuickNativeModuleId, "QQuickItem"))))));
 }
 
 TEST_F(ProjectStorage, UpdateExportedTypesIfTypeNameChanges)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].typeName = "QQuickItem2";
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
-    ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(qmlModuleId,
-                                                         "QObject",
-                                                         Storage::NativeType{},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId2),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Object"),
-                                                                      IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(qtQuickModuleId,
-                                                         "QQuickItem2",
-                                                         Storage::NativeType{"QObject"},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId1),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Item"))))));
+    ASSERT_THAT(
+        storage.fetchTypes(),
+        UnorderedElementsAre(
+            AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
+                                             IsExportedType(qmlModuleId, "Obj"),
+                                             IsExportedType(qmlNativeModuleId, "QObject")))),
+            AllOf(IsStorageType(sourceId1,
+                                "QQuickItem2",
+                                fetchTypeId(sourceId2, "QObject"),
+                                TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
+                                             IsExportedType(qtQuickNativeModuleId, "QQuickItem"))))));
 }
 
 TEST_F(ProjectStorage, BreakingPrototypeChainByDeletingBaseComponentThrows)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types.pop_back();
 
-    ASSERT_THROW(storage.synchronize({}, importsSourceId1, types, {sourceId1, sourceId2}, {}),
+    ASSERT_THROW(storage.synchronize(importsSourceId1, types, {sourceId1, sourceId2}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
@@ -1132,7 +1074,6 @@ TEST_F(ProjectStorage, SynchronizeTypesAddPropertyDeclarations)
     Storage::Types types{createTypes()};
 
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
@@ -1140,19 +1081,18 @@ TEST_F(ProjectStorage, SynchronizeTypesAddPropertyDeclarations)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(
-                    AllOf(IsStorageType(qtQuickModuleId,
+                    AllOf(IsStorageType(sourceId1,
                                         "QQuickItem",
-                                        Storage::NativeType{"QObject"},
-                                        TypeAccessSemantics::Reference,
-                                        sourceId1),
+                                        fetchTypeId(sourceId2, "QObject"),
+                                        TypeAccessSemantics::Reference),
                           Field(&Storage::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("data",
-                                                          Storage::NativeType{"QObject"},
+                                                          fetchTypeId(sourceId2, "QObject"),
                                                           Storage::PropertyDeclarationTraits::IsList),
                                     IsPropertyDeclaration(
                                         "children",
-                                        Storage::NativeType{"QQuickItem"},
+                                        fetchTypeId(sourceId1, "QQuickItem"),
                                         Storage::PropertyDeclarationTraits::IsList
                                             | Storage::PropertyDeclarationTraits::IsReadOnly))))));
 }
@@ -1162,8 +1102,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddPropertyDeclarationsWithMissingImports
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations.pop_back();
 
-    ASSERT_THROW(storage.synchronize(modules,
-                                     {},
+    ASSERT_THROW(storage.synchronize({},
                                      types,
                                      {sourceId1,
                                       sourceId2,
@@ -1178,14 +1117,13 @@ TEST_F(ProjectStorage, SynchronizeTypesAddPropertyDeclarationsWithMissingImports
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].propertyDeclarations[0].typeName = Storage::ImportedType{"Obj"};
 
-    ASSERT_THROW(storage.synchronize({}, {}, {types[0]}, {sourceId1}, {}),
+    ASSERT_THROW(storage.synchronize({}, {types[0]}, {sourceId1}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
@@ -1193,16 +1131,14 @@ TEST_F(ProjectStorage, SynchronizeTypesAddPropertyDeclarationQualifiedType)
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::QualifiedImportedType{
-        "Object", Storage::Import{"QtQuick", Storage::Version{}, sourceId1}};
-    types.push_back(Storage::Type{qtQuickModuleId,
-                                  "QQuickObject",
-                                  Storage::NativeType{"QObject"},
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId1}};
+    types.push_back(Storage::Type{"QQuickObject",
+                                  Storage::ImportedType{"QObject"},
                                   TypeAccessSemantics::Reference,
                                   sourceId1,
-                                  {Storage::ExportedType{"Object"}}});
+                                  {Storage::ExportedType{qtQuickModuleId, "Object"}}});
 
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
@@ -1210,19 +1146,18 @@ TEST_F(ProjectStorage, SynchronizeTypesAddPropertyDeclarationQualifiedType)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(
-                    AllOf(IsStorageType(qtQuickModuleId,
+                    AllOf(IsStorageType(sourceId1,
                                         "QQuickItem",
-                                        Storage::NativeType{"QObject"},
-                                        TypeAccessSemantics::Reference,
-                                        sourceId1),
+                                        fetchTypeId(sourceId2, "QObject"),
+                                        TypeAccessSemantics::Reference),
                           Field(&Storage::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("data",
-                                                          Storage::NativeType{"QQuickObject"},
+                                                          fetchTypeId(sourceId1, "QQuickObject"),
                                                           Storage::PropertyDeclarationTraits::IsList),
                                     IsPropertyDeclaration(
                                         "children",
-                                        Storage::NativeType{"QQuickItem"},
+                                        fetchTypeId(sourceId1, "QQuickItem"),
                                         Storage::PropertyDeclarationTraits::IsList
                                             | Storage::PropertyDeclarationTraits::IsReadOnly))))));
 }
@@ -1231,29 +1166,27 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesPropertyDeclarationType)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
-    types[0].propertyDeclarations[0].typeName = Storage::NativeType{"QQuickItem"};
+    types[0].propertyDeclarations[0].typeName = Storage::ImportedType{"QQuickItem"};
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(
-                    AllOf(IsStorageType(qtQuickModuleId,
+                    AllOf(IsStorageType(sourceId1,
                                         "QQuickItem",
-                                        Storage::NativeType{"QObject"},
-                                        TypeAccessSemantics::Reference,
-                                        sourceId1),
+                                        fetchTypeId(sourceId2, "QObject"),
+                                        TypeAccessSemantics::Reference),
                           Field(&Storage::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("data",
-                                                          Storage::NativeType{"QQuickItem"},
+                                                          fetchTypeId(sourceId1, "QQuickItem"),
                                                           Storage::PropertyDeclarationTraits::IsList),
                                     IsPropertyDeclaration(
                                         "children",
-                                        Storage::NativeType{"QQuickItem"},
+                                        fetchTypeId(sourceId1, "QQuickItem"),
                                         Storage::PropertyDeclarationTraits::IsList
                                             | Storage::PropertyDeclarationTraits::IsReadOnly))))));
 }
@@ -1262,30 +1195,28 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesDeclarationTraits)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].propertyDeclarations[0].traits = Storage::PropertyDeclarationTraits::IsPointer;
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(
-                    AllOf(IsStorageType(qtQuickModuleId,
+                    AllOf(IsStorageType(sourceId1,
                                         "QQuickItem",
-                                        Storage::NativeType{"QObject"},
-                                        TypeAccessSemantics::Reference,
-                                        sourceId1),
+                                        fetchTypeId(sourceId2, "QObject"),
+                                        TypeAccessSemantics::Reference),
                           Field(&Storage::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("data",
-                                                          Storage::NativeType{"QObject"},
+                                                          fetchTypeId(sourceId2, "QObject"),
                                                           Storage::PropertyDeclarationTraits::IsPointer),
                                     IsPropertyDeclaration(
                                         "children",
-                                        Storage::NativeType{"QQuickItem"},
+                                        fetchTypeId(sourceId1, "QQuickItem"),
                                         Storage::PropertyDeclarationTraits::IsList
                                             | Storage::PropertyDeclarationTraits::IsReadOnly))))));
 }
@@ -1294,31 +1225,29 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesDeclarationTraitsAndType)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].propertyDeclarations[0].traits = Storage::PropertyDeclarationTraits::IsPointer;
-    types[0].propertyDeclarations[0].typeName = Storage::NativeType{"QQuickItem"};
+    types[0].propertyDeclarations[0].typeName = Storage::ImportedType{"QQuickItem"};
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(
-                    AllOf(IsStorageType(qtQuickModuleId,
+                    AllOf(IsStorageType(sourceId1,
                                         "QQuickItem",
-                                        Storage::NativeType{"QObject"},
-                                        TypeAccessSemantics::Reference,
-                                        sourceId1),
+                                        fetchTypeId(sourceId2, "QObject"),
+                                        TypeAccessSemantics::Reference),
                           Field(&Storage::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("data",
-                                                          Storage::NativeType{"QQuickItem"},
+                                                          fetchTypeId(sourceId1, "QQuickItem"),
                                                           Storage::PropertyDeclarationTraits::IsPointer),
                                     IsPropertyDeclaration(
                                         "children",
-                                        Storage::NativeType{"QQuickItem"},
+                                        fetchTypeId(sourceId1, "QQuickItem"),
                                         Storage::PropertyDeclarationTraits::IsList
                                             | Storage::PropertyDeclarationTraits::IsReadOnly))))));
 }
@@ -1327,25 +1256,23 @@ TEST_F(ProjectStorage, SynchronizeTypesRemovesAPropertyDeclaration)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].propertyDeclarations.pop_back();
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::propertyDeclarations,
                                      UnorderedElementsAre(IsPropertyDeclaration(
                                          "data",
-                                         Storage::NativeType{"QObject"},
+                                         fetchTypeId(sourceId2, "QObject"),
                                          Storage::PropertyDeclarationTraits::IsList))))));
 }
 
@@ -1353,36 +1280,34 @@ TEST_F(ProjectStorage, SynchronizeTypesAddsAPropertyDeclaration)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].propertyDeclarations.push_back(
         Storage::PropertyDeclaration{"object",
-                                     Storage::NativeType{"QObject"},
+                                     Storage::ImportedType{"QObject"},
                                      Storage::PropertyDeclarationTraits::IsPointer});
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(
         storage.fetchTypes(),
         Contains(AllOf(
-            IsStorageType(qtQuickModuleId,
+            IsStorageType(sourceId1,
                           "QQuickItem",
-                          Storage::NativeType{"QObject"},
-                          TypeAccessSemantics::Reference,
-                          sourceId1),
+                          fetchTypeId(sourceId2, "QObject"),
+                          TypeAccessSemantics::Reference),
             Field(&Storage::Type::propertyDeclarations,
                   UnorderedElementsAre(
                       IsPropertyDeclaration("object",
-                                            Storage::NativeType{"QObject"},
+                                            fetchTypeId(sourceId2, "QObject"),
                                             Storage::PropertyDeclarationTraits::IsPointer),
                       IsPropertyDeclaration("data",
-                                            Storage::NativeType{"QObject"},
+                                            fetchTypeId(sourceId2, "QObject"),
                                             Storage::PropertyDeclarationTraits::IsList),
                       IsPropertyDeclaration("children",
-                                            Storage::NativeType{"QQuickItem"},
+                                            fetchTypeId(sourceId1, "QQuickItem"),
                                             Storage::PropertyDeclarationTraits::IsList
                                                 | Storage::PropertyDeclarationTraits::IsReadOnly))))));
 }
@@ -1391,30 +1316,28 @@ TEST_F(ProjectStorage, SynchronizeTypesRenameAPropertyDeclaration)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].propertyDeclarations[1].name = "objects";
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(
-                    AllOf(IsStorageType(qtQuickModuleId,
+                    AllOf(IsStorageType(sourceId1,
                                         "QQuickItem",
-                                        Storage::NativeType{"QObject"},
-                                        TypeAccessSemantics::Reference,
-                                        sourceId1),
+                                        fetchTypeId(sourceId2, "QObject"),
+                                        TypeAccessSemantics::Reference),
                           Field(&Storage::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("data",
-                                                          Storage::NativeType{"QObject"},
+                                                          fetchTypeId(sourceId2, "QObject"),
                                                           Storage::PropertyDeclarationTraits::IsList),
                                     IsPropertyDeclaration(
                                         "objects",
-                                        Storage::NativeType{"QQuickItem"},
+                                        fetchTypeId(sourceId1, "QQuickItem"),
                                         Storage::PropertyDeclarationTraits::IsList
                                             | Storage::PropertyDeclarationTraits::IsReadOnly))))));
 }
@@ -1422,11 +1345,10 @@ TEST_F(ProjectStorage, SynchronizeTypesRenameAPropertyDeclaration)
 TEST_F(ProjectStorage, UsingNonExistingNativePropertyTypeThrows)
 {
     Storage::Types types{createTypes()};
-    types[0].propertyDeclarations[0].typeName = Storage::NativeType{"QObject2"};
+    types[0].propertyDeclarations[0].typeName = Storage::ImportedType{"QObject2"};
     types.pop_back();
 
-    ASSERT_THROW(storage.synchronize(modules,
-                                     importsSourceId1,
+    ASSERT_THROW(storage.synchronize(importsSourceId1,
                                      types,
                                      {sourceId1,
                                       sourceId2,
@@ -1443,8 +1365,7 @@ TEST_F(ProjectStorage, UsingNonExistingExportedPropertyTypeThrows)
     types[0].propertyDeclarations[0].typeName = Storage::ImportedType{"QObject2"};
     types.pop_back();
 
-    ASSERT_THROW(storage.synchronize(modules,
-                                     importsSourceId1,
+    ASSERT_THROW(storage.synchronize(importsSourceId1,
                                      types,
                                      {sourceId1,
                                       sourceId2,
@@ -1459,11 +1380,10 @@ TEST_F(ProjectStorage, UsingNonExistingQualifiedExportedPropertyTypeWithWrongNam
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::QualifiedImportedType{
-        "QObject2", Storage::Import{"Qml", Storage::Version{}, sourceId1}};
+        "QObject2", Storage::Import{qmlNativeModuleId, Storage::Version{}, sourceId1}};
     types.pop_back();
 
-    ASSERT_THROW(storage.synchronize(modules,
-                                     importsSourceId1,
+    ASSERT_THROW(storage.synchronize(importsSourceId1,
                                      types,
                                      {sourceId1,
                                       sourceId2,
@@ -1478,11 +1398,10 @@ TEST_F(ProjectStorage, UsingNonExistingQualifiedExportedPropertyTypeWithWrongMod
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::QualifiedImportedType{
-        "QObject", Storage::Import{"QtQuick", Storage::Version{}, sourceId1}};
+        "QObject", Storage::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     types.pop_back();
 
-    ASSERT_THROW(storage.synchronize(modules,
-                                     importsSourceId1,
+    ASSERT_THROW(storage.synchronize(importsSourceId1,
                                      types,
                                      {sourceId1,
                                       sourceId2,
@@ -1497,16 +1416,14 @@ TEST_F(ProjectStorage, BreakingPropertyDeclarationTypeDependencyByDeletingTypeTh
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
-    types[0].prototype = Storage::NativeType{};
+    types[0].prototype = Storage::ImportedType{};
     types.pop_back();
 
-    ASSERT_THROW(storage.synchronize(modules,
-                                     importsSourceId1,
+    ASSERT_THROW(storage.synchronize(importsSourceId1,
                                      types,
                                      {sourceId1,
                                       sourceId2,
@@ -1522,18 +1439,16 @@ TEST_F(ProjectStorage, SynchronizeTypesAddFunctionDeclarations)
     Storage::Types types{createTypes()};
 
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::functionDeclarations,
                                      UnorderedElementsAre(Eq(types[0].functionDeclarations[0]),
                                                           Eq(types[0].functionDeclarations[1]))))));
@@ -1543,21 +1458,19 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesFunctionDeclarationReturnType)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].functionDeclarations[1].returnTypeName = "item";
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::functionDeclarations,
                                      UnorderedElementsAre(Eq(types[0].functionDeclarations[0]),
                                                           Eq(types[0].functionDeclarations[1]))))));
@@ -1567,21 +1480,19 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesFunctionDeclarationName)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].functionDeclarations[1].name = "name";
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::functionDeclarations,
                                      UnorderedElementsAre(Eq(types[0].functionDeclarations[0]),
                                                           Eq(types[0].functionDeclarations[1]))))));
@@ -1591,21 +1502,19 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesFunctionDeclarationPopParameters)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].functionDeclarations[1].parameters.pop_back();
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::functionDeclarations,
                                      UnorderedElementsAre(Eq(types[0].functionDeclarations[0]),
                                                           Eq(types[0].functionDeclarations[1]))))));
@@ -1615,21 +1524,19 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesFunctionDeclarationAppendParameter
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].functionDeclarations[1].parameters.push_back(Storage::ParameterDeclaration{"arg4", "int"});
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::functionDeclarations,
                                      UnorderedElementsAre(Eq(types[0].functionDeclarations[0]),
                                                           Eq(types[0].functionDeclarations[1]))))));
@@ -1639,21 +1546,19 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesFunctionDeclarationChangeParameter
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].functionDeclarations[1].parameters[0].name = "other";
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::functionDeclarations,
                                      UnorderedElementsAre(Eq(types[0].functionDeclarations[0]),
                                                           Eq(types[0].functionDeclarations[1]))))));
@@ -1663,21 +1568,19 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesFunctionDeclarationChangeParameter
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].functionDeclarations[1].parameters[0].name = "long long";
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::functionDeclarations,
                                      UnorderedElementsAre(Eq(types[0].functionDeclarations[0]),
                                                           Eq(types[0].functionDeclarations[1]))))));
@@ -1687,21 +1590,19 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesFunctionDeclarationChangeParameter
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].functionDeclarations[1].parameters[0].traits = QmlDesigner::Storage::PropertyDeclarationTraits::IsList;
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::functionDeclarations,
                                      UnorderedElementsAre(Eq(types[0].functionDeclarations[0]),
                                                           Eq(types[0].functionDeclarations[1]))))));
@@ -1711,21 +1612,19 @@ TEST_F(ProjectStorage, SynchronizeTypesRemovesFunctionDeclaration)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].functionDeclarations.pop_back();
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::functionDeclarations,
                                      UnorderedElementsAre(Eq(types[0].functionDeclarations[0]))))));
 }
@@ -1734,7 +1633,6 @@ TEST_F(ProjectStorage, SynchronizeTypesAddFunctionDeclaration)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
@@ -1742,14 +1640,13 @@ TEST_F(ProjectStorage, SynchronizeTypesAddFunctionDeclaration)
     types[0].functionDeclarations.push_back(
         Storage::FunctionDeclaration{"name", "string", {Storage::ParameterDeclaration{"arg", "int"}}});
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::functionDeclarations,
                                      UnorderedElementsAre(Eq(types[0].functionDeclarations[0]),
                                                           Eq(types[0].functionDeclarations[1]),
@@ -1761,18 +1658,16 @@ TEST_F(ProjectStorage, SynchronizeTypesAddSignalDeclarations)
     Storage::Types types{createTypes()};
 
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::signalDeclarations,
                                      UnorderedElementsAre(Eq(types[0].signalDeclarations[0]),
                                                           Eq(types[0].signalDeclarations[1]))))));
@@ -1782,21 +1677,19 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesSignalDeclarationName)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].signalDeclarations[1].name = "name";
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::signalDeclarations,
                                      UnorderedElementsAre(Eq(types[0].signalDeclarations[0]),
                                                           Eq(types[0].signalDeclarations[1]))))));
@@ -1806,21 +1699,19 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesSignalDeclarationPopParameters)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].signalDeclarations[1].parameters.pop_back();
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::signalDeclarations,
                                      UnorderedElementsAre(Eq(types[0].signalDeclarations[0]),
                                                           Eq(types[0].signalDeclarations[1]))))));
@@ -1830,21 +1721,19 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesSignalDeclarationAppendParameters)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].signalDeclarations[1].parameters.push_back(Storage::ParameterDeclaration{"arg4", "int"});
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::signalDeclarations,
                                      UnorderedElementsAre(Eq(types[0].signalDeclarations[0]),
                                                           Eq(types[0].signalDeclarations[1]))))));
@@ -1854,21 +1743,19 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesSignalDeclarationChangeParameterNa
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].signalDeclarations[1].parameters[0].name = "other";
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::signalDeclarations,
                                      UnorderedElementsAre(Eq(types[0].signalDeclarations[0]),
                                                           Eq(types[0].signalDeclarations[1]))))));
@@ -1878,21 +1765,19 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesSignalDeclarationChangeParameterTy
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].signalDeclarations[1].parameters[0].typeName = "long long";
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::signalDeclarations,
                                      UnorderedElementsAre(Eq(types[0].signalDeclarations[0]),
                                                           Eq(types[0].signalDeclarations[1]))))));
@@ -1902,21 +1787,19 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesSignalDeclarationChangeParameterTr
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].signalDeclarations[1].parameters[0].traits = QmlDesigner::Storage::PropertyDeclarationTraits::IsList;
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::signalDeclarations,
                                      UnorderedElementsAre(Eq(types[0].signalDeclarations[0]),
                                                           Eq(types[0].signalDeclarations[1]))))));
@@ -1926,21 +1809,19 @@ TEST_F(ProjectStorage, SynchronizeTypesRemovesSignalDeclaration)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].signalDeclarations.pop_back();
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::signalDeclarations,
                                      UnorderedElementsAre(Eq(types[0].signalDeclarations[0]))))));
 }
@@ -1949,7 +1830,6 @@ TEST_F(ProjectStorage, SynchronizeTypesAddSignalDeclaration)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
@@ -1957,14 +1837,13 @@ TEST_F(ProjectStorage, SynchronizeTypesAddSignalDeclaration)
     types[0].signalDeclarations.push_back(
         Storage::SignalDeclaration{"name", {Storage::ParameterDeclaration{"arg", "int"}}});
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::signalDeclarations,
                                      UnorderedElementsAre(Eq(types[0].signalDeclarations[0]),
                                                           Eq(types[0].signalDeclarations[1]),
@@ -1976,18 +1855,16 @@ TEST_F(ProjectStorage, SynchronizeTypesAddEnumerationDeclarations)
     Storage::Types types{createTypes()};
 
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::enumerationDeclarations,
                                      UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]),
                                                           Eq(types[0].enumerationDeclarations[1]))))));
@@ -1997,21 +1874,19 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesEnumerationDeclarationName)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].enumerationDeclarations[1].name = "Name";
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::enumerationDeclarations,
                                      UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]),
                                                           Eq(types[0].enumerationDeclarations[1]))))));
@@ -2021,21 +1896,19 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesEnumerationDeclarationPopEnumerato
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].enumerationDeclarations[1].enumeratorDeclarations.pop_back();
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::enumerationDeclarations,
                                      UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]),
                                                           Eq(types[0].enumerationDeclarations[1]))))));
@@ -2045,7 +1918,6 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesEnumerationDeclarationAppendEnumer
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
@@ -2053,14 +1925,13 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesEnumerationDeclarationAppendEnumer
     types[0].enumerationDeclarations[1].enumeratorDeclarations.push_back(
         Storage::EnumeratorDeclaration{"Haa", 54});
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::enumerationDeclarations,
                                      UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]),
                                                           Eq(types[0].enumerationDeclarations[1]))))));
@@ -2070,21 +1941,19 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesEnumerationDeclarationChangeEnumer
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].enumerationDeclarations[1].enumeratorDeclarations[0].name = "Hoo";
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::enumerationDeclarations,
                                      UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]),
                                                           Eq(types[0].enumerationDeclarations[1]))))));
@@ -2094,21 +1963,19 @@ TEST_F(ProjectStorage, SynchronizeTypesChangesEnumerationDeclarationChangeEnumer
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].enumerationDeclarations[1].enumeratorDeclarations[1].value = 11;
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::enumerationDeclarations,
                                      UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]),
                                                           Eq(types[0].enumerationDeclarations[1]))))));
@@ -2119,7 +1986,6 @@ TEST_F(ProjectStorage,
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
@@ -2127,14 +1993,13 @@ TEST_F(ProjectStorage,
     types[0].enumerationDeclarations[1].enumeratorDeclarations[0].value = 11;
     types[0].enumerationDeclarations[1].enumeratorDeclarations[0].hasValue = true;
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::enumerationDeclarations,
                                      UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]),
                                                           Eq(types[0].enumerationDeclarations[1]))))));
@@ -2145,21 +2010,19 @@ TEST_F(ProjectStorage,
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].enumerationDeclarations[1].enumeratorDeclarations[0].hasValue = false;
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::enumerationDeclarations,
                                      UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]),
                                                           Eq(types[0].enumerationDeclarations[1]))))));
@@ -2169,21 +2032,19 @@ TEST_F(ProjectStorage, SynchronizeTypesRemovesEnumerationDeclaration)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].enumerationDeclarations.pop_back();
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::enumerationDeclarations,
                                      UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]))))));
 }
@@ -2192,7 +2053,6 @@ TEST_F(ProjectStorage, SynchronizeTypesAddEnumerationDeclaration)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
@@ -2200,203 +2060,29 @@ TEST_F(ProjectStorage, SynchronizeTypesAddEnumerationDeclaration)
     types[0].enumerationDeclarations.push_back(
         Storage::EnumerationDeclaration{"name", {Storage::EnumeratorDeclaration{"Foo", 98, true}}});
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::enumerationDeclarations,
                                      UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]),
                                                           Eq(types[0].enumerationDeclarations[1]),
                                                           Eq(types[0].enumerationDeclarations[2]))))));
 }
 
-TEST_F(ProjectStorage, SynchronizeModulesAddModules)
-{
-    Storage::Modules modules{createModules()};
-
-    storage.synchronize(modules, {}, {}, {qmlModuleSourceId, qtQuickModuleSourceId, moduleSourceId5}, {});
-
-    ASSERT_THAT(storage.fetchAllModules(),
-                UnorderedElementsAre(IsModule("Qml", qmlModuleSourceId),
-                                     IsModule("QtQuick", qtQuickModuleSourceId),
-                                     IsModule("/path/to", pathToModuleSourceId)));
-}
-
-TEST_F(ProjectStorage, SynchronizeModulesAddModulesAgain)
-{
-    Storage::Modules modules{createModules()};
-    storage.synchronize(modules,
-                        {},
-                        {},
-                        {qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
-                        {});
-
-    storage.synchronize(modules,
-                        {},
-                        {},
-                        {qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
-                        {});
-
-    ASSERT_THAT(storage.fetchAllModules(),
-                UnorderedElementsAre(IsModule("Qml", qmlModuleSourceId),
-                                     IsModule("QtQuick", qtQuickModuleSourceId),
-                                     IsModule("/path/to", pathToModuleSourceId)));
-}
-
-TEST_F(ProjectStorage, SynchronizeModulesUpdateToMoreModules)
-{
-    Storage::Modules modules{createModules()};
-    storage.synchronize(modules,
-                        {},
-                        {},
-                        {qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
-                        {});
-    modules.push_back(Storage::Module{"QtQuick.Foo", moduleSourceId4});
-
-    storage.synchronize(modules,
-                        {},
-                        {},
-                        {qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId, moduleSourceId4},
-                        {});
-
-    ASSERT_THAT(storage.fetchAllModules(),
-                UnorderedElementsAre(IsModule("Qml", qmlModuleSourceId),
-                                     IsModule("QtQuick", qtQuickModuleSourceId),
-                                     IsModule("/path/to", pathToModuleSourceId),
-                                     IsModule("QtQuick.Foo", moduleSourceId4)));
-}
-
-TEST_F(ProjectStorage, SynchronizeModulesAddOneMoreModules)
-{
-    Storage::Modules modules{createModules()};
-    storage.synchronize(modules,
-                        {},
-                        {},
-                        {qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
-                        {});
-    auto newModule = Storage::Module{"QtQuick.Foo", moduleSourceId4};
-
-    storage.synchronize({newModule}, {}, {}, {moduleSourceId4}, {});
-
-    ASSERT_THAT(storage.fetchAllModules(),
-                UnorderedElementsAre(IsModule("Qml", qmlModuleSourceId),
-                                     IsModule("QtQuick", qtQuickModuleSourceId),
-                                     IsModule("/path/to", pathToModuleSourceId),
-                                     IsModule("QtQuick.Foo", moduleSourceId4)));
-}
-
-TEST_F(ProjectStorage, SynchronizeModulesRemoveModule)
-{
-    Storage::Modules modules{createModules()};
-    storage.synchronize(modules,
-                        {},
-                        {},
-                        {qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
-                        {});
-
-    storage.synchronize({}, {}, {}, {pathToModuleSourceId}, {});
-
-    ASSERT_THAT(storage.fetchAllModules(),
-                UnorderedElementsAre(IsModule("Qml", qmlModuleSourceId),
-                                     IsModule("QtQuick", qtQuickModuleSourceId)));
-}
-
-TEST_F(ProjectStorage, SynchronizeModulesChangeSourceId)
-{
-    Storage::Modules modules{createModules()};
-    storage.synchronize(modules,
-                        {},
-                        {},
-                        {qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
-                        {});
-    modules[1].sourceId = moduleSourceId4;
-
-    storage.synchronize({modules[1]}, {}, {}, {qtQuickModuleSourceId, moduleSourceId4}, {});
-
-    ASSERT_THAT(storage.fetchAllModules(),
-                UnorderedElementsAre(IsModule("Qml", qmlModuleSourceId),
-                                     IsModule("QtQuick", moduleSourceId4),
-                                     IsModule("/path/to", pathToModuleSourceId)));
-}
-
-TEST_F(ProjectStorage, SynchronizeModulesChangeName)
-{
-    Storage::Modules modules{createModules()};
-    storage.synchronize(modules,
-                        {},
-                        {},
-                        {qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
-                        {});
-    modules[0].name = "Qml2";
-
-    storage.synchronize(modules,
-                        {},
-                        {},
-                        {qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
-                        {});
-
-    ASSERT_THAT(storage.fetchAllModules(),
-                UnorderedElementsAre(IsModule("Qml2", qmlModuleSourceId),
-                                     IsModule("QtQuick", qtQuickModuleSourceId),
-                                     IsModule("/path/to", pathToModuleSourceId)));
-}
-
-TEST_F(ProjectStorage, RemovingModuleRemovesDependentTypesToo)
+TEST_F(ProjectStorage, FetchTypeIdBySourceIdAndName)
 {
     Storage::Types types{createTypes()};
-    types[0].prototype = Storage::NativeType{""};
-    types[0].propertyDeclarations.clear();
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
 
-    storage.synchronize({}, {}, {}, {qtQuickModuleSourceId, pathToModuleSourceId}, {});
-
-    ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(IsStorageType(qmlModuleId,
-                                                   "QObject",
-                                                   Storage::NativeType{},
-                                                   TypeAccessSemantics::Reference,
-                                                   sourceId2)));
-}
-
-TEST_F(ProjectStorage, RemovingModuleThrowsForMissingType)
-{
-    Storage::Types types{createTypes()};
-    imports.emplace_back("QtQuick", Storage::Version{}, sourceId2);
-    types[0].prototype = Storage::NativeType{""};
-    types[0].propertyDeclarations.clear();
-    types[1].prototype = Storage::ImportedType{"Item"};
-    storage.synchronize(
-        modules,
-        imports,
-        types,
-        {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
-        {});
-
-    ASSERT_THROW(storage.synchronize({}, {}, {}, {qtQuickModuleSourceId, pathToModuleSourceId}, {}),
-                 QmlDesigner::TypeNameDoesNotExists);
-}
-
-TEST_F(ProjectStorage, FetchTypeIdByModuleIdAndName)
-{
-    Storage::Types types{createTypes()};
-    storage.synchronize(
-        modules,
-        imports,
-        types,
-        {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
-        {});
-    auto qmlModuleId = storage.fetchModuleId("Qml");
-
-    auto typeId = storage.fetchTypeIdByName(qmlModuleId, "QObject");
+    auto typeId = storage.fetchTypeIdByName(sourceId2, "QObject");
 
     ASSERT_THAT(storage.fetchTypeIdByExportedName("Object"), Eq(typeId));
 }
@@ -2405,45 +2091,40 @@ TEST_F(ProjectStorage, FetchTypeIdByExportedName)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
-    auto qmlModuleId = storage.fetchModuleId("Qml");
 
     auto typeId = storage.fetchTypeIdByExportedName("Object");
 
-    ASSERT_THAT(storage.fetchTypeIdByName(qmlModuleId, "QObject"), Eq(typeId));
+    ASSERT_THAT(storage.fetchTypeIdByName(sourceId2, "QObject"), Eq(typeId));
 }
 
 TEST_F(ProjectStorage, FetchTypeIdByImporIdsAndExportedName)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
-    auto qmlModuleId = storage.fetchModuleId("Qml");
-    auto qtQuickModuleId = storage.fetchModuleId("QtQuick");
 
     auto typeId = storage.fetchTypeIdByModuleIdsAndExportedName({qmlModuleId, qtQuickModuleId},
                                                                 "Object");
 
-    ASSERT_THAT(storage.fetchTypeIdByName(qmlModuleId, "QObject"), Eq(typeId));
+    ASSERT_THAT(storage.fetchTypeIdByName(sourceId2, "QObject"), Eq(typeId));
 }
 
 TEST_F(ProjectStorage, FetchInvalidTypeIdByImporIdsAndExportedNameIfModuleIdsAreEmpty)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
+
     auto typeId = storage.fetchTypeIdByModuleIdsAndExportedName({}, "Object");
 
     ASSERT_FALSE(typeId.isValid());
@@ -2453,11 +2134,11 @@ TEST_F(ProjectStorage, FetchInvalidTypeIdByImporIdsAndExportedNameIfModuleIdsAre
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
+
     auto typeId = storage.fetchTypeIdByModuleIdsAndExportedName({ModuleId{}}, "Object");
 
     ASSERT_FALSE(typeId.isValid());
@@ -2467,12 +2148,12 @@ TEST_F(ProjectStorage, FetchInvalidTypeIdByImporIdsAndExportedNameIfNotInModule)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
-    auto qtQuickModuleId = storage.fetchModuleId("QtQuick");
+    auto qtQuickModuleId = storage.moduleId("QtQuick");
+
     auto typeId = storage.fetchTypeIdByModuleIdsAndExportedName({qtQuickModuleId}, "Object");
 
     ASSERT_FALSE(typeId.isValid());
@@ -2482,8 +2163,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddAliasDeclarations)
 {
     Storage::Types types{createTypesWithAliases()};
 
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -2496,30 +2176,28 @@ TEST_F(ProjectStorage, SynchronizeTypesAddAliasDeclarations)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(qtQuickModuleId,
+                    IsStorageType(sourceId3,
                                   "QAliasItem",
-                                  Storage::NativeType{"QQuickItem"},
-                                  TypeAccessSemantics::Reference,
-                                  sourceId3),
+                                  fetchTypeId(sourceId1, "QQuickItem"),
+                                  TypeAccessSemantics::Reference),
                     Field(&Storage::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
-                                                    Storage::NativeType{"QQuickItem"},
+                                                    fetchTypeId(sourceId1, "QQuickItem"),
                                                     Storage::PropertyDeclarationTraits::IsList
                                                         | Storage::PropertyDeclarationTraits::IsReadOnly),
                               IsPropertyDeclaration("objects",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList),
                               IsPropertyDeclaration("data",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList))))));
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesAddAliasDeclarationsAgain)
 {
     Storage::Types types{createTypesWithAliases()};
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -2530,8 +2208,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddAliasDeclarationsAgain)
                          pathToModuleSourceId},
                         {});
 
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -2544,30 +2221,28 @@ TEST_F(ProjectStorage, SynchronizeTypesAddAliasDeclarationsAgain)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(qtQuickModuleId,
+                    IsStorageType(sourceId3,
                                   "QAliasItem",
-                                  Storage::NativeType{"QQuickItem"},
-                                  TypeAccessSemantics::Reference,
-                                  sourceId3),
+                                  fetchTypeId(sourceId1, "QQuickItem"),
+                                  TypeAccessSemantics::Reference),
                     Field(&Storage::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
-                                                    Storage::NativeType{"QQuickItem"},
+                                                    fetchTypeId(sourceId1, "QQuickItem"),
                                                     Storage::PropertyDeclarationTraits::IsList
                                                         | Storage::PropertyDeclarationTraits::IsReadOnly),
                               IsPropertyDeclaration("objects",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList),
                               IsPropertyDeclaration("data",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList))))));
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesRemoveAliasDeclarations)
 {
     Storage::Types types{createTypesWithAliases()};
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -2579,32 +2254,31 @@ TEST_F(ProjectStorage, SynchronizeTypesRemoveAliasDeclarations)
                         {});
     types[2].propertyDeclarations.pop_back();
 
-    storage.synchronize({}, importsSourceId3, {types[2]}, {sourceId3}, {});
+    storage.synchronize(importsSourceId3, {types[2]}, {sourceId3}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(qtQuickModuleId,
+                    IsStorageType(sourceId3,
                                   "QAliasItem",
-                                  Storage::NativeType{"QQuickItem"},
-                                  TypeAccessSemantics::Reference,
-                                  sourceId3),
+                                  fetchTypeId(sourceId1, "QQuickItem"),
+                                  TypeAccessSemantics::Reference),
                     Field(&Storage::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
-                                                    Storage::NativeType{"QQuickItem"},
+                                                    fetchTypeId(sourceId1, "QQuickItem"),
                                                     Storage::PropertyDeclarationTraits::IsList
                                                         | Storage::PropertyDeclarationTraits::IsReadOnly),
                               IsPropertyDeclaration("data",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList))))));
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesAddAliasDeclarationsThrowsForWrongTypeName)
 {
     Storage::Types types{createTypesWithAliases()};
-    types[2].propertyDeclarations[1].typeName = Storage::NativeType{"QQuickItemWrong"};
+    types[2].propertyDeclarations[1].typeName = Storage::ImportedType{"QQuickItemWrong"};
 
-    ASSERT_THROW(storage.synchronize(modules, importsSourceId4, {types[2]}, {sourceId4}, {}),
+    ASSERT_THROW(storage.synchronize(importsSourceId4, {types[2]}, {sourceId4}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 TEST_F(ProjectStorage, SynchronizeTypesAddAliasDeclarationsThrowsForWrongPropertyName)
@@ -2612,15 +2286,14 @@ TEST_F(ProjectStorage, SynchronizeTypesAddAliasDeclarationsThrowsForWrongPropert
     Storage::Types types{createTypesWithAliases()};
     types[2].propertyDeclarations[1].aliasPropertyName = "childrenWrong";
 
-    ASSERT_THROW(storage.synchronize(modules, imports, types, {sourceId4}, {}),
+    ASSERT_THROW(storage.synchronize(imports, types, {sourceId4}, {}),
                  QmlDesigner::PropertyNameDoesNotExists);
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesChangeAliasDeclarationsTypeName)
 {
     Storage::Types types{createTypesWithAliases()};
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -2631,36 +2304,34 @@ TEST_F(ProjectStorage, SynchronizeTypesChangeAliasDeclarationsTypeName)
                          pathToModuleSourceId},
                         {});
     types[2].propertyDeclarations[2].typeName = Storage::ImportedType{"Obj2"};
-    importsSourceId3.emplace_back("/path/to", Storage::Version{}, sourceId3);
+    importsSourceId3.emplace_back(pathToModuleId, Storage::Version{}, sourceId3);
 
-    storage.synchronize({}, importsSourceId3, {types[2]}, {sourceId3}, {});
+    storage.synchronize(importsSourceId3, {types[2]}, {sourceId3}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(qtQuickModuleId,
+                    IsStorageType(sourceId3,
                                   "QAliasItem",
-                                  Storage::NativeType{"QQuickItem"},
-                                  TypeAccessSemantics::Reference,
-                                  sourceId3),
+                                  fetchTypeId(sourceId1, "QQuickItem"),
+                                  TypeAccessSemantics::Reference),
                     Field(&Storage::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
-                                                    Storage::NativeType{"QQuickItem"},
+                                                    fetchTypeId(sourceId1, "QQuickItem"),
                                                     Storage::PropertyDeclarationTraits::IsList
                                                         | Storage::PropertyDeclarationTraits::IsReadOnly),
                               IsPropertyDeclaration("objects",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList),
                               IsPropertyDeclaration("data",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList))))));
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesChangeAliasDeclarationsPropertyName)
 {
     Storage::Types types{createTypesWithAliases()};
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -2672,36 +2343,34 @@ TEST_F(ProjectStorage, SynchronizeTypesChangeAliasDeclarationsPropertyName)
                         {});
     types[2].propertyDeclarations[2].aliasPropertyName = "children";
 
-    storage.synchronize({}, importsSourceId3, {types[2]}, {sourceId3}, {});
+    storage.synchronize(importsSourceId3, {types[2]}, {sourceId3}, {});
 
     ASSERT_THAT(
         storage.fetchTypes(),
         Contains(
-            AllOf(IsStorageType(qtQuickModuleId,
+            AllOf(IsStorageType(sourceId3,
                                 "QAliasItem",
-                                Storage::NativeType{"QQuickItem"},
-                                TypeAccessSemantics::Reference,
-                                sourceId3),
+                                fetchTypeId(sourceId1, "QQuickItem"),
+                                TypeAccessSemantics::Reference),
                   Field(&Storage::Type::propertyDeclarations,
                         UnorderedElementsAre(
                             IsPropertyDeclaration("items",
-                                                  Storage::NativeType{"QQuickItem"},
+                                                  fetchTypeId(sourceId1, "QQuickItem"),
                                                   Storage::PropertyDeclarationTraits::IsList
                                                       | Storage::PropertyDeclarationTraits::IsReadOnly),
                             IsPropertyDeclaration("objects",
-                                                  Storage::NativeType{"QQuickItem"},
+                                                  fetchTypeId(sourceId1, "QQuickItem"),
                                                   Storage::PropertyDeclarationTraits::IsList
                                                       | Storage::PropertyDeclarationTraits::IsReadOnly),
                             IsPropertyDeclaration("data",
-                                                  Storage::NativeType{"QObject"},
+                                                  fetchTypeId(sourceId2, "QObject"),
                                                   Storage::PropertyDeclarationTraits::IsList))))));
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesChangeAliasDeclarationsToPropertyDeclaration)
 {
     Storage::Types types{createTypesWithAliases()};
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -2714,32 +2383,31 @@ TEST_F(ProjectStorage, SynchronizeTypesChangeAliasDeclarationsToPropertyDeclarat
     types[2].propertyDeclarations.pop_back();
     types[2].propertyDeclarations.push_back(
         Storage::PropertyDeclaration{"objects",
-                                     Storage::NativeType{"QQuickItem"},
+                                     Storage::ImportedType{"QQuickItem"},
                                      Storage::PropertyDeclarationTraits::IsList
                                          | Storage::PropertyDeclarationTraits::IsReadOnly});
 
-    storage.synchronize({}, importsSourceId3, {types[2]}, {sourceId3}, {});
+    storage.synchronize(importsSourceId3, {types[2]}, {sourceId3}, {});
 
     ASSERT_THAT(
         storage.fetchTypes(),
         Contains(
-            AllOf(IsStorageType(qtQuickModuleId,
+            AllOf(IsStorageType(sourceId3,
                                 "QAliasItem",
-                                Storage::NativeType{"QQuickItem"},
-                                TypeAccessSemantics::Reference,
-                                sourceId3),
+                                fetchTypeId(sourceId1, "QQuickItem"),
+                                TypeAccessSemantics::Reference),
                   Field(&Storage::Type::propertyDeclarations,
                         UnorderedElementsAre(
                             IsPropertyDeclaration("items",
-                                                  Storage::NativeType{"QQuickItem"},
+                                                  fetchTypeId(sourceId1, "QQuickItem"),
                                                   Storage::PropertyDeclarationTraits::IsList
                                                       | Storage::PropertyDeclarationTraits::IsReadOnly),
                             IsPropertyDeclaration("objects",
-                                                  Storage::NativeType{"QQuickItem"},
+                                                  fetchTypeId(sourceId1, "QQuickItem"),
                                                   Storage::PropertyDeclarationTraits::IsList
                                                       | Storage::PropertyDeclarationTraits::IsReadOnly),
                             IsPropertyDeclaration("data",
-                                                  Storage::NativeType{"QObject"},
+                                                  fetchTypeId(sourceId2, "QObject"),
                                                   Storage::PropertyDeclarationTraits::IsList))))));
 }
 
@@ -2750,11 +2418,10 @@ TEST_F(ProjectStorage, SynchronizeTypesChangePropertyDeclarationsToAliasDeclarat
     typesChanged[2].propertyDeclarations.pop_back();
     typesChanged[2].propertyDeclarations.push_back(
         Storage::PropertyDeclaration{"objects",
-                                     Storage::NativeType{"QQuickItem"},
+                                     Storage::ImportedType{"QQuickItem"},
                                      Storage::PropertyDeclarationTraits::IsList
                                          | Storage::PropertyDeclarationTraits::IsReadOnly});
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         typesChanged,
                         {sourceId1,
                          sourceId2,
@@ -2765,34 +2432,32 @@ TEST_F(ProjectStorage, SynchronizeTypesChangePropertyDeclarationsToAliasDeclarat
                          pathToModuleSourceId},
                         {});
 
-    storage.synchronize({}, imports, types, {sourceId1, sourceId2, sourceId3, sourceId4}, {});
+    storage.synchronize(imports, types, {sourceId1, sourceId2, sourceId3, sourceId4}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(qtQuickModuleId,
+                    IsStorageType(sourceId3,
                                   "QAliasItem",
-                                  Storage::NativeType{"QQuickItem"},
-                                  TypeAccessSemantics::Reference,
-                                  sourceId3),
+                                  fetchTypeId(sourceId1, "QQuickItem"),
+                                  TypeAccessSemantics::Reference),
                     Field(&Storage::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
-                                                    Storage::NativeType{"QQuickItem"},
+                                                    fetchTypeId(sourceId1, "QQuickItem"),
                                                     Storage::PropertyDeclarationTraits::IsList
                                                         | Storage::PropertyDeclarationTraits::IsReadOnly),
                               IsPropertyDeclaration("objects",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList),
                               IsPropertyDeclaration("data",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList))))));
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesChangeAliasTargetPropertyDeclarationTraits)
 {
     Storage::Types types{createTypesWithAliases()};
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -2805,36 +2470,34 @@ TEST_F(ProjectStorage, SynchronizeTypesChangeAliasTargetPropertyDeclarationTrait
     types[1].propertyDeclarations[0].traits = Storage::PropertyDeclarationTraits::IsList
                                               | Storage::PropertyDeclarationTraits::IsReadOnly;
 
-    storage.synchronize({}, importsSourceId2, {types[1]}, {sourceId2}, {});
+    storage.synchronize(importsSourceId2, {types[1]}, {sourceId2}, {});
 
     ASSERT_THAT(
         storage.fetchTypes(),
         Contains(
-            AllOf(IsStorageType(qtQuickModuleId,
+            AllOf(IsStorageType(sourceId3,
                                 "QAliasItem",
-                                Storage::NativeType{"QQuickItem"},
-                                TypeAccessSemantics::Reference,
-                                sourceId3),
+                                fetchTypeId(sourceId1, "QQuickItem"),
+                                TypeAccessSemantics::Reference),
                   Field(&Storage::Type::propertyDeclarations,
                         UnorderedElementsAre(
                             IsPropertyDeclaration("items",
-                                                  Storage::NativeType{"QQuickItem"},
+                                                  fetchTypeId(sourceId1, "QQuickItem"),
                                                   Storage::PropertyDeclarationTraits::IsList
                                                       | Storage::PropertyDeclarationTraits::IsReadOnly),
                             IsPropertyDeclaration("objects",
-                                                  Storage::NativeType{"QObject"},
+                                                  fetchTypeId(sourceId2, "QObject"),
                                                   Storage::PropertyDeclarationTraits::IsList
                                                       | Storage::PropertyDeclarationTraits::IsReadOnly),
                             IsPropertyDeclaration("data",
-                                                  Storage::NativeType{"QObject"},
+                                                  fetchTypeId(sourceId2, "QObject"),
                                                   Storage::PropertyDeclarationTraits::IsList))))));
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesChangeAliasTargetPropertyDeclarationTypeName)
 {
     Storage::Types types{createTypesWithAliases()};
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -2845,36 +2508,34 @@ TEST_F(ProjectStorage, SynchronizeTypesChangeAliasTargetPropertyDeclarationTypeN
                          pathToModuleSourceId},
                         {});
     types[1].propertyDeclarations[0].typeName = Storage::ImportedType{"Item"};
-    importsSourceId2.emplace_back("QtQuick", Storage::Version{}, sourceId2);
+    importsSourceId2.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
 
-    storage.synchronize({}, importsSourceId2, {types[1]}, {sourceId2}, {});
+    storage.synchronize(importsSourceId2, {types[1]}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(qtQuickModuleId,
+                    IsStorageType(sourceId3,
                                   "QAliasItem",
-                                  Storage::NativeType{"QQuickItem"},
-                                  TypeAccessSemantics::Reference,
-                                  sourceId3),
+                                  fetchTypeId(sourceId1, "QQuickItem"),
+                                  TypeAccessSemantics::Reference),
                     Field(&Storage::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
-                                                    Storage::NativeType{"QQuickItem"},
+                                                    fetchTypeId(sourceId1, "QQuickItem"),
                                                     Storage::PropertyDeclarationTraits::IsList
                                                         | Storage::PropertyDeclarationTraits::IsReadOnly),
                               IsPropertyDeclaration("objects",
-                                                    Storage::NativeType{"QQuickItem"},
+                                                    fetchTypeId(sourceId1, "QQuickItem"),
                                                     Storage::PropertyDeclarationTraits::IsList),
                               IsPropertyDeclaration("data",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList))))));
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesRemovePropertyDeclarationWithAnAliasThrows)
 {
     Storage::Types types{createTypesWithAliases()};
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -2886,15 +2547,14 @@ TEST_F(ProjectStorage, SynchronizeTypesRemovePropertyDeclarationWithAnAliasThrow
                         {});
     types[1].propertyDeclarations.pop_back();
 
-    ASSERT_THROW(storage.synchronize({}, importsSourceId2, {types[1]}, {sourceId2}, {}),
+    ASSERT_THROW(storage.synchronize(importsSourceId2, {types[1]}, {sourceId2}, {}),
                  Sqlite::ConstraintPreventsModification);
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesRemovePropertyDeclarationAndAlias)
 {
     Storage::Types types{createTypesWithAliases()};
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -2907,27 +2567,25 @@ TEST_F(ProjectStorage, SynchronizeTypesRemovePropertyDeclarationAndAlias)
     types[1].propertyDeclarations.pop_back();
     types[2].propertyDeclarations.pop_back();
 
-    storage.synchronize({},
-                        importsSourceId2 + importsSourceId3,
+    storage.synchronize(importsSourceId2 + importsSourceId3,
                         {types[1], types[2]},
                         {sourceId2, sourceId3},
                         {});
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(qtQuickModuleId,
+                    IsStorageType(sourceId3,
                                   "QAliasItem",
-                                  Storage::NativeType{"QQuickItem"},
-                                  TypeAccessSemantics::Reference,
-                                  sourceId3),
+                                  fetchTypeId(sourceId1, "QQuickItem"),
+                                  TypeAccessSemantics::Reference),
                     Field(&Storage::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
-                                                    Storage::NativeType{"QQuickItem"},
+                                                    fetchTypeId(sourceId1, "QQuickItem"),
                                                     Storage::PropertyDeclarationTraits::IsList
                                                         | Storage::PropertyDeclarationTraits::IsReadOnly),
                               IsPropertyDeclaration("data",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList))))));
 }
 
@@ -2935,9 +2593,8 @@ TEST_F(ProjectStorage, SynchronizeTypesRemoveTypeWithAliasTargetPropertyDeclarat
 {
     Storage::Types types{createTypesWithAliases()};
     types[2].propertyDeclarations[2].typeName = Storage::ImportedType{"Object2"};
-    imports.emplace_back("/path/to", Storage::Version{}, sourceId3);
-    storage.synchronize(modules,
-                        imports,
+    imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId3);
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -2948,16 +2605,15 @@ TEST_F(ProjectStorage, SynchronizeTypesRemoveTypeWithAliasTargetPropertyDeclarat
                          pathToModuleSourceId},
                         {});
 
-    ASSERT_THROW(storage.synchronize({}, {}, {}, {sourceId4}, {}), QmlDesigner::TypeNameDoesNotExists);
+    ASSERT_THROW(storage.synchronize({}, {}, {sourceId4}, {}), QmlDesigner::TypeNameDoesNotExists);
 }
 
 TEST_F(ProjectStorage, SynchronizeTypesRemoveTypeAndAliasPropertyDeclaration)
 {
     Storage::Types types{createTypesWithAliases()};
     types[2].propertyDeclarations[2].typeName = Storage::ImportedType{"Object2"};
-    imports.emplace_back("/path/to", Storage::Version{}, sourceId3);
-    storage.synchronize(modules,
-                        imports,
+    imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId3);
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -2969,35 +2625,32 @@ TEST_F(ProjectStorage, SynchronizeTypesRemoveTypeAndAliasPropertyDeclaration)
                         {});
     types[2].propertyDeclarations.pop_back();
 
-    storage.synchronize({},
-                        importsSourceId1 + importsSourceId3,
+    storage.synchronize(importsSourceId1 + importsSourceId3,
                         {types[0], types[2]},
                         {sourceId1, sourceId3},
                         {});
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(qtQuickModuleId,
+                    IsStorageType(sourceId3,
                                   "QAliasItem",
-                                  Storage::NativeType{"QQuickItem"},
-                                  TypeAccessSemantics::Reference,
-                                  sourceId3),
+                                  fetchTypeId(sourceId1, "QQuickItem"),
+                                  TypeAccessSemantics::Reference),
                     Field(&Storage::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
-                                                    Storage::NativeType{"QQuickItem"},
+                                                    fetchTypeId(sourceId1, "QQuickItem"),
                                                     Storage::PropertyDeclarationTraits::IsList
                                                         | Storage::PropertyDeclarationTraits::IsReadOnly),
                               IsPropertyDeclaration("data",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList))))));
 }
 
 TEST_F(ProjectStorage, UpdateAliasPropertyIfPropertyIsOverloaded)
 {
     Storage::Types types{createTypesWithAliases()};
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3009,32 +2662,31 @@ TEST_F(ProjectStorage, UpdateAliasPropertyIfPropertyIsOverloaded)
                         {});
     types[0].propertyDeclarations.push_back(
         Storage::PropertyDeclaration{"objects",
-                                     Storage::NativeType{"QQuickItem"},
+                                     Storage::ImportedType{"QQuickItem"},
                                      Storage::PropertyDeclarationTraits::IsList
                                          | Storage::PropertyDeclarationTraits::IsReadOnly});
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(
         storage.fetchTypes(),
         Contains(
-            AllOf(IsStorageType(qtQuickModuleId,
+            AllOf(IsStorageType(sourceId3,
                                 "QAliasItem",
-                                Storage::NativeType{"QQuickItem"},
-                                TypeAccessSemantics::Reference,
-                                sourceId3),
+                                fetchTypeId(sourceId1, "QQuickItem"),
+                                TypeAccessSemantics::Reference),
                   Field(&Storage::Type::propertyDeclarations,
                         UnorderedElementsAre(
                             IsPropertyDeclaration("items",
-                                                  Storage::NativeType{"QQuickItem"},
+                                                  fetchTypeId(sourceId1, "QQuickItem"),
                                                   Storage::PropertyDeclarationTraits::IsList
                                                       | Storage::PropertyDeclarationTraits::IsReadOnly),
                             IsPropertyDeclaration("objects",
-                                                  Storage::NativeType{"QQuickItem"},
+                                                  fetchTypeId(sourceId1, "QQuickItem"),
                                                   Storage::PropertyDeclarationTraits::IsList
                                                       | Storage::PropertyDeclarationTraits::IsReadOnly),
                             IsPropertyDeclaration("data",
-                                                  Storage::NativeType{"QObject"},
+                                                  fetchTypeId(sourceId2, "QObject"),
                                                   Storage::PropertyDeclarationTraits::IsList))))));
 }
 
@@ -3043,12 +2695,11 @@ TEST_F(ProjectStorage, AliasPropertyIsOverloaded)
     Storage::Types types{createTypesWithAliases()};
     types[0].propertyDeclarations.push_back(
         Storage::PropertyDeclaration{"objects",
-                                     Storage::NativeType{"QQuickItem"},
+                                     Storage::ImportedType{"QQuickItem"},
                                      Storage::PropertyDeclarationTraits::IsList
                                          | Storage::PropertyDeclarationTraits::IsReadOnly});
 
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3062,23 +2713,22 @@ TEST_F(ProjectStorage, AliasPropertyIsOverloaded)
     ASSERT_THAT(
         storage.fetchTypes(),
         Contains(
-            AllOf(IsStorageType(qtQuickModuleId,
+            AllOf(IsStorageType(sourceId3,
                                 "QAliasItem",
-                                Storage::NativeType{"QQuickItem"},
-                                TypeAccessSemantics::Reference,
-                                sourceId3),
+                                fetchTypeId(sourceId1, "QQuickItem"),
+                                TypeAccessSemantics::Reference),
                   Field(&Storage::Type::propertyDeclarations,
                         UnorderedElementsAre(
                             IsPropertyDeclaration("items",
-                                                  Storage::NativeType{"QQuickItem"},
+                                                  fetchTypeId(sourceId1, "QQuickItem"),
                                                   Storage::PropertyDeclarationTraits::IsList
                                                       | Storage::PropertyDeclarationTraits::IsReadOnly),
                             IsPropertyDeclaration("objects",
-                                                  Storage::NativeType{"QQuickItem"},
+                                                  fetchTypeId(sourceId1, "QQuickItem"),
                                                   Storage::PropertyDeclarationTraits::IsList
                                                       | Storage::PropertyDeclarationTraits::IsReadOnly),
                             IsPropertyDeclaration("data",
-                                                  Storage::NativeType{"QObject"},
+                                                  fetchTypeId(sourceId2, "QObject"),
                                                   Storage::PropertyDeclarationTraits::IsList))))));
 }
 
@@ -3087,11 +2737,10 @@ TEST_F(ProjectStorage, UpdateAliasPropertyIfOverloadedPropertyIsRemoved)
     Storage::Types types{createTypesWithAliases()};
     types[0].propertyDeclarations.push_back(
         Storage::PropertyDeclaration{"objects",
-                                     Storage::NativeType{"QQuickItem"},
+                                     Storage::ImportedType{"QQuickItem"},
                                      Storage::PropertyDeclarationTraits::IsList
                                          | Storage::PropertyDeclarationTraits::IsReadOnly});
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3103,37 +2752,35 @@ TEST_F(ProjectStorage, UpdateAliasPropertyIfOverloadedPropertyIsRemoved)
                         {});
     types[0].propertyDeclarations.pop_back();
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(qtQuickModuleId,
+                    IsStorageType(sourceId3,
                                   "QAliasItem",
-                                  Storage::NativeType{"QQuickItem"},
-                                  TypeAccessSemantics::Reference,
-                                  sourceId3),
+                                  fetchTypeId(sourceId1, "QQuickItem"),
+                                  TypeAccessSemantics::Reference),
                     Field(&Storage::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
-                                                    Storage::NativeType{"QQuickItem"},
+                                                    fetchTypeId(sourceId1, "QQuickItem"),
                                                     Storage::PropertyDeclarationTraits::IsList
                                                         | Storage::PropertyDeclarationTraits::IsReadOnly),
                               IsPropertyDeclaration("objects",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList),
                               IsPropertyDeclaration("data",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList))))));
 }
 
 TEST_F(ProjectStorage, RelinkAliasProperty)
 {
     Storage::Types types{createTypesWithAliases()};
-    types[1].propertyDeclarations[0].typeName = Storage::NativeType{"QObject2"};
-    imports.emplace_back("/path/to", Storage::Version{}, sourceId2);
-    imports.emplace_back("QtQuick", Storage::Version{}, sourceId2);
-    storage.synchronize(modules,
-                        imports,
+    types[1].propertyDeclarations[0].typeName = Storage::ImportedType{"Object2"};
+    imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
+    imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3143,28 +2790,27 @@ TEST_F(ProjectStorage, RelinkAliasProperty)
                          qtQuickModuleSourceId,
                          pathToModuleSourceId},
                         {});
-    types[3].moduleId = qtQuickModuleId;
+    types[3].exportedTypes[0].moduleId = qtQuickModuleId;
 
-    storage.synchronize({}, importsSourceId4, {types[3]}, {sourceId4}, {});
+    storage.synchronize(importsSourceId4, {types[3]}, {sourceId4}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(qtQuickModuleId,
+                    IsStorageType(sourceId3,
                                   "QAliasItem",
-                                  Storage::NativeType{"QQuickItem"},
-                                  TypeAccessSemantics::Reference,
-                                  sourceId3),
+                                  fetchTypeId(sourceId1, "QQuickItem"),
+                                  TypeAccessSemantics::Reference),
                     Field(&Storage::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
-                                                    Storage::NativeType{"QQuickItem"},
+                                                    fetchTypeId(sourceId1, "QQuickItem"),
                                                     Storage::PropertyDeclarationTraits::IsList
                                                         | Storage::PropertyDeclarationTraits::IsReadOnly),
                               IsPropertyDeclaration("objects",
-                                                    Storage::NativeType{"QObject2"},
+                                                    fetchTypeId(sourceId4, "QObject2"),
                                                     Storage::PropertyDeclarationTraits::IsList),
                               IsPropertyDeclaration("data",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList))))));
 }
 
@@ -3172,10 +2818,9 @@ TEST_F(ProjectStorage, DoNotRelinkAliasPropertyForQualifiedImportedTypeName)
 {
     Storage::Types types{createTypesWithAliases()};
     types[1].propertyDeclarations[0].typeName = Storage::QualifiedImportedType{
-        "Object2", Storage::Import{"/path/to", Storage::Version{}, sourceId2}};
-    imports.emplace_back("/path/to", Storage::Version{}, sourceId2);
-    storage.synchronize(modules,
-                        imports,
+        "Object2", Storage::Import{pathToModuleId, Storage::Version{}, sourceId2}};
+    imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3185,10 +2830,10 @@ TEST_F(ProjectStorage, DoNotRelinkAliasPropertyForQualifiedImportedTypeName)
                          qtQuickModuleSourceId,
                          pathToModuleSourceId},
                         {});
-    types[3].moduleId = qtQuickModuleId;
-    importsSourceId4.emplace_back("QtQuick", Storage::Version{}, sourceId4);
+    types[3].exportedTypes[0].moduleId = qtQuickModuleId;
+    importsSourceId4.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId4);
 
-    ASSERT_THROW(storage.synchronize({}, importsSourceId4, {types[3]}, {sourceId4}, {}),
+    ASSERT_THROW(storage.synchronize(importsSourceId4, {types[3]}, {sourceId4}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
@@ -3197,17 +2842,16 @@ TEST_F(ProjectStorage,
 {
     Storage::Types types{createTypesWithAliases()};
     types[1].propertyDeclarations[0].typeName = Storage::QualifiedImportedType{
-        "Object2", Storage::Import{"/path/to", Storage::Version{}, sourceId2}};
-    imports.emplace_back("/path/to", Storage::Version{}, sourceId2);
-    types.push_back(Storage::Type{qtQuickModuleId,
-                                  "QObject2",
-                                  Storage::NativeType{},
+        "Object2", Storage::Import{pathToModuleId, Storage::Version{}, sourceId2}};
+    imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
+    types.push_back(Storage::Type{"QObject2",
+                                  Storage::ImportedType{},
                                   TypeAccessSemantics::Reference,
                                   sourceId5,
-                                  {Storage::ExportedType{"Object2"}, Storage::ExportedType{"Obj2"}}});
+                                  {Storage::ExportedType{qtQuickModuleId, "Object2"},
+                                   Storage::ExportedType{qtQuickModuleId, "Obj2"}}});
 
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3221,22 +2865,21 @@ TEST_F(ProjectStorage,
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(qtQuickModuleId,
+                    IsStorageType(sourceId3,
                                   "QAliasItem",
-                                  Storage::NativeType{"QQuickItem"},
-                                  TypeAccessSemantics::Reference,
-                                  sourceId3),
+                                  fetchTypeId(sourceId1, "QQuickItem"),
+                                  TypeAccessSemantics::Reference),
                     Field(&Storage::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
-                                                    Storage::NativeType{"QQuickItem"},
+                                                    fetchTypeId(sourceId1, "QQuickItem"),
                                                     Storage::PropertyDeclarationTraits::IsList
                                                         | Storage::PropertyDeclarationTraits::IsReadOnly),
                               IsPropertyDeclaration("objects",
-                                                    Storage::NativeType{"QObject2"},
+                                                    fetchTypeId(sourceId4, "QObject2"),
                                                     Storage::PropertyDeclarationTraits::IsList),
                               IsPropertyDeclaration("data",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList))))));
 }
 
@@ -3245,8 +2888,7 @@ TEST_F(ProjectStorage, RelinkAliasPropertyReactToTypeNameChange)
     Storage::Types types{createTypesWithAliases2()};
     types[2].propertyDeclarations.push_back(
         Storage::PropertyDeclaration{"items", Storage::ImportedType{"Item"}, "children"});
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3258,38 +2900,35 @@ TEST_F(ProjectStorage, RelinkAliasPropertyReactToTypeNameChange)
                         {});
     types[0].typeName = "QQuickItem2";
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(AllOf(
-                    IsStorageType(qtQuickModuleId,
+                    IsStorageType(sourceId3,
                                   "QAliasItem",
-                                  Storage::NativeType{"QObject"},
-                                  TypeAccessSemantics::Reference,
-                                  sourceId3),
+                                  fetchTypeId(sourceId2, "QObject"),
+                                  TypeAccessSemantics::Reference),
                     Field(&Storage::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
-                                                    Storage::NativeType{"QQuickItem2"},
+                                                    fetchTypeId(sourceId1, "QQuickItem2"),
                                                     Storage::PropertyDeclarationTraits::IsList
                                                         | Storage::PropertyDeclarationTraits::IsReadOnly),
                               IsPropertyDeclaration("objects",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList),
                               IsPropertyDeclaration("data",
-                                                    Storage::NativeType{"QObject"},
+                                                    fetchTypeId(sourceId2, "QObject"),
                                                     Storage::PropertyDeclarationTraits::IsList))))));
 }
 
 TEST_F(ProjectStorage, DoNotRelinkAliasPropertyForDeletedType)
 {
     Storage::Types types{createTypesWithAliases()};
-    types[1].propertyDeclarations[0].typeName = Storage::NativeType{"QObject2"};
-    imports.emplace_back("/path/to", Storage::Version{}, sourceId2);
-    imports.emplace_back("QtQuick", Storage::Version{}, sourceId2);
-
-    storage.synchronize(modules,
-                        imports,
+    types[1].propertyDeclarations[0].typeName = Storage::ImportedType{"Object2"};
+    imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
+    imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3299,25 +2938,24 @@ TEST_F(ProjectStorage, DoNotRelinkAliasPropertyForDeletedType)
                          qtQuickModuleSourceId,
                          pathToModuleSourceId},
                         {});
-    types[3].moduleId = qtQuickModuleId;
+    types[3].exportedTypes[0].moduleId = qtQuickModuleId;
 
-    storage.synchronize({}, importsSourceId4, {types[3]}, {sourceId3, sourceId4}, {});
+    storage.synchronize(importsSourceId4, {types[3]}, {sourceId3, sourceId4}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Not(Contains(AllOf(IsStorageType(qtQuickModuleId,
-                                                 "QAliasItem",
-                                                 Storage::NativeType{"QQuickItem"},
-                                                 TypeAccessSemantics::Reference,
-                                                 sourceId3)))));
+                Not(Contains(IsStorageType(sourceId3,
+                                           "QAliasItem",
+                                           fetchTypeId(sourceId1, "QQuickItem"),
+                                           TypeAccessSemantics::Reference))));
 }
 
 TEST_F(ProjectStorage, DoNotRelinkAliasPropertyForDeletedTypeAndPropertyType)
 {
     Storage::Types types{createTypesWithAliases()};
-    types[1].propertyDeclarations[0].typeName = Storage::NativeType{"QObject2"};
-    imports.emplace_back("/path/to", Storage::Version{}, sourceId2);
-    storage.synchronize(modules,
-                        imports,
+    types[1].propertyDeclarations[0].typeName = Storage::ImportedType{"Object2"};
+    imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
+    imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3327,14 +2965,13 @@ TEST_F(ProjectStorage, DoNotRelinkAliasPropertyForDeletedTypeAndPropertyType)
                          qtQuickModuleSourceId,
                          pathToModuleSourceId},
                         {});
-    types[0].prototype = Storage::NativeType{};
-    importsSourceId1.emplace_back("/path/to", Storage::Version{}, sourceId1);
-    importsSourceId4.emplace_back("QtQuick", Storage::Version{}, sourceId4);
+    types[0].prototype = Storage::ImportedType{};
+    importsSourceId1.emplace_back(pathToModuleId, Storage::Version{}, sourceId1);
+    importsSourceId4.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId4);
     types[0].propertyDeclarations[0].typeName = Storage::ImportedType{"Object2"};
     types[3].propertyDeclarations[0].typeName = Storage::ImportedType{"Item"};
 
-    storage.synchronize({},
-                        importsSourceId1 + importsSourceId4,
+    storage.synchronize(importsSourceId1 + importsSourceId4,
                         {types[0], types[3]},
                         {sourceId1, sourceId2, sourceId3, sourceId4},
                         {});
@@ -3345,10 +2982,9 @@ TEST_F(ProjectStorage, DoNotRelinkAliasPropertyForDeletedTypeAndPropertyType)
 TEST_F(ProjectStorage, DoNotRelinkAliasPropertyForDeletedTypeAndPropertyTypeNameChange)
 {
     Storage::Types types{createTypesWithAliases()};
-    types[1].propertyDeclarations[0].typeName = Storage::NativeType{"QObject2"};
-    imports.emplace_back("/path/to", Storage::Version{}, sourceId2);
-    storage.synchronize(modules,
-                        imports,
+    types[1].propertyDeclarations[0].typeName = Storage::ImportedType{"Object2"};
+    imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3358,32 +2994,29 @@ TEST_F(ProjectStorage, DoNotRelinkAliasPropertyForDeletedTypeAndPropertyTypeName
                          qtQuickModuleSourceId,
                          pathToModuleSourceId},
                         {});
-    types[3].moduleId = qtQuickModuleId;
-    types[1].propertyDeclarations[0].typeName = Storage::NativeType{"QObject"};
-    importsSourceId4.emplace_back("QtQuick", Storage::Version{}, sourceId4);
+    types[3].exportedTypes[0].moduleId = qtQuickModuleId;
+    types[1].propertyDeclarations[0].typeName = Storage::ImportedType{"QObject"};
+    importsSourceId4.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId4);
 
-    storage.synchronize({},
-                        importsSourceId2 + importsSourceId4,
+    storage.synchronize(importsSourceId2 + importsSourceId4,
                         {types[1], types[3]},
                         {sourceId2, sourceId3, sourceId4},
                         {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Not(Contains(IsStorageType(qtQuickModuleId,
+                Not(Contains(IsStorageType(sourceId3,
                                            "QAliasItem",
-                                           Storage::NativeType{"QQuickItem"},
-                                           TypeAccessSemantics::Reference,
-                                           sourceId3))));
+                                           fetchTypeId(sourceId1, "QQuickItem"),
+                                           TypeAccessSemantics::Reference))));
 }
 
 TEST_F(ProjectStorage, DoNotRelinkPropertyTypeDoesNotExists)
 {
     Storage::Types types{createTypesWithAliases()};
-    types[1].propertyDeclarations[0].typeName = Storage::NativeType{"QObject2"};
-    imports.emplace_back("/path/to", Storage::Version{}, sourceId2);
-    imports.emplace_back("QtQuick", Storage::Version{}, sourceId2);
-    storage.synchronize(modules,
-                        imports,
+    types[1].propertyDeclarations[0].typeName = Storage::ImportedType{"Object2"};
+    imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
+    imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3393,18 +3026,16 @@ TEST_F(ProjectStorage, DoNotRelinkPropertyTypeDoesNotExists)
                          qtQuickModuleSourceId,
                          pathToModuleSourceId},
                         {});
-    types.pop_back();
 
-    ASSERT_THROW(storage.synchronize({}, {}, {}, {sourceId4}, {}), QmlDesigner::TypeNameDoesNotExists);
+    ASSERT_THROW(storage.synchronize({}, {}, {sourceId4}, {}), QmlDesigner::TypeNameDoesNotExists);
 }
 
 TEST_F(ProjectStorage, DoNotRelinkAliasPropertyTypeDoesNotExists)
 {
     Storage::Types types{createTypesWithAliases2()};
-    types[1].propertyDeclarations[0].typeName = Storage::NativeType{"QObject2"};
-    imports.emplace_back("/path/to", Storage::Version{}, sourceId2);
-    storage.synchronize(modules,
-                        imports,
+    types[1].propertyDeclarations[0].typeName = Storage::ImportedType{"Object2"};
+    imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3415,67 +3046,62 @@ TEST_F(ProjectStorage, DoNotRelinkAliasPropertyTypeDoesNotExists)
                          pathToModuleSourceId},
                         {});
 
-    ASSERT_THROW(storage.synchronize({}, {}, {}, {sourceId1}, {}), QmlDesigner::TypeNameDoesNotExists);
+    ASSERT_THROW(storage.synchronize({}, {}, {sourceId1}, {}), QmlDesigner::TypeNameDoesNotExists);
 }
 
 TEST_F(ProjectStorage, ChangePrototypeTypeName)
 {
     Storage::Types types{createTypesWithExportedTypeNamesOnly()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[1].typeName = "QObject3";
 
-    storage.synchronize({}, importsSourceId2, {types[1]}, {sourceId2}, {});
+    storage.synchronize(importsSourceId2, {types[1]}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId1,
                                        "QQuickItem",
-                                       Storage::NativeType{"QObject3"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId1)));
+                                       fetchTypeId(sourceId2, "QObject3"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, ChangePrototypeTypeModuleId)
 {
     Storage::Types types{createTypes()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
-    types[1].moduleId = qtQuickModuleId;
+    types[1].exportedTypes[2].moduleId = qtQuickModuleId;
 
-    storage.synchronize({}, importsSourceId2, {types[1]}, {sourceId2}, {});
+    storage.synchronize(importsSourceId2, {types[1]}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId1,
                                        "QQuickItem",
-                                       Storage::NativeType{"QObject"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId1)));
+                                       fetchTypeId(sourceId2, "QObject"),
+                                       TypeAccessSemantics::Reference)));
 }
 
-TEST_F(ProjectStorage, ChangeQualifiedPrototypeTypeModuleIdThows)
+TEST_F(ProjectStorage, ChangeQualifiedPrototypeTypeModuleIdThrows)
 {
     Storage::Types types{createTypes()};
     types[0].prototype = Storage::QualifiedImportedType{"Object",
-                                                        Storage::Import{"Qml",
+                                                        Storage::Import{qmlModuleId,
                                                                         Storage::Version{},
                                                                         sourceId1}};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
-    types[1].moduleId = qtQuickModuleId;
+    types[1].exportedTypes[0].moduleId = qtQuickModuleId;
 
-    ASSERT_THROW(storage.synchronize({}, importsSourceId2, {types[1]}, {sourceId2}, {}),
+    ASSERT_THROW(storage.synchronize(importsSourceId2, {types[1]}, {sourceId2}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
@@ -3483,55 +3109,53 @@ TEST_F(ProjectStorage, ChangeQualifiedPrototypeTypeModuleId)
 {
     Storage::Types types{createTypes()};
     types[0].prototype = Storage::QualifiedImportedType{"Object",
-                                                        Storage::Import{"Qml",
+                                                        Storage::Import{qmlModuleId,
                                                                         Storage::Version{},
                                                                         sourceId1}};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
-    types[1].moduleId = qtQuickModuleId;
+    types[1].exportedTypes[0].moduleId = qtQuickModuleId;
     types[0].prototype = Storage::QualifiedImportedType{"Object",
-                                                        Storage::Import{"QtQuick",
+                                                        Storage::Import{qtQuickModuleId,
                                                                         Storage::Version{},
                                                                         sourceId1}};
 
-    storage.synchronize({},
-                        importsSourceId1 + importsSourceId2,
+    storage.synchronize(importsSourceId1 + importsSourceId2,
                         {types[0], types[1]},
                         {sourceId1, sourceId2},
                         {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId1,
                                        "QQuickItem",
-                                       Storage::NativeType{"QObject"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId1)));
+                                       fetchTypeId(sourceId2, "QObject"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, ChangePrototypeTypeNameAndModuleId)
 {
     Storage::Types types{createTypesWithExportedTypeNamesOnly()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
-    types[1].moduleId = qtQuickModuleId;
+    types[1].exportedTypes[0].moduleId = qtQuickModuleId;
+    types[1].exportedTypes[1].moduleId = qtQuickModuleId;
+    types[1].exportedTypes[2].moduleId = qtQuickModuleId;
+    types[1].exportedTypes[2].name = "QObject3";
     types[1].typeName = "QObject3";
 
-    storage.synchronize({}, importsSourceId2, {types[1]}, {sourceId2}, {});
+    storage.synchronize(importsSourceId2, {types[1]}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId1,
                                        "QQuickItem",
-                                       Storage::NativeType{"QObject3"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId1)));
+                                       fetchTypeId(sourceId2, "QObject3"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, ChangePrototypeTypeNameThrowsForWrongNativePrototupeTypeName)
@@ -3539,14 +3163,14 @@ TEST_F(ProjectStorage, ChangePrototypeTypeNameThrowsForWrongNativePrototupeTypeN
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::ImportedType{"Object"};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
+    types[1].exportedTypes[2].name = "QObject3";
     types[1].typeName = "QObject3";
 
-    ASSERT_THROW(storage.synchronize({}, importsSourceId2, {types[1]}, {sourceId2}, {}),
+    ASSERT_THROW(storage.synchronize(importsSourceId2, {types[1]}, {sourceId2}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
@@ -3554,18 +3178,17 @@ TEST_F(ProjectStorage, ThrowForPrototypeChainCycles)
 {
     Storage::Types types{createTypes()};
     types[1].prototype = Storage::ImportedType{"Object2"};
-    types.push_back(Storage::Type{pathToModuleId,
-                                  "QObject2",
+    types.push_back(Storage::Type{"QObject2",
                                   Storage::ImportedType{"Item"},
                                   TypeAccessSemantics::Reference,
                                   sourceId3,
-                                  {Storage::ExportedType{"Object2"}, Storage::ExportedType{"Obj2"}}});
-    imports.emplace_back("/path/to", Storage::Version{}, sourceId2);
-    imports.emplace_back("QtQuick", Storage::Version{}, sourceId3);
-    imports.emplace_back("/path/to", Storage::Version{}, sourceId3);
+                                  {Storage::ExportedType{pathToModuleId, "Object2"},
+                                   Storage::ExportedType{pathToModuleId, "Obj2"}}});
+    imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
+    imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
+    imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId3);
 
-    ASSERT_THROW(storage.synchronize(modules,
-                                     imports,
+    ASSERT_THROW(storage.synchronize(imports,
                                      types,
                                      {sourceId1,
                                       sourceId2,
@@ -3582,8 +3205,7 @@ TEST_F(ProjectStorage, ThrowForTypeIdAndPrototypeIdAreTheSame)
     Storage::Types types{createTypes()};
     types[1].prototype = Storage::ImportedType{"Object"};
 
-    ASSERT_THROW(storage.synchronize(modules,
-                                     imports,
+    ASSERT_THROW(storage.synchronize(imports,
                                      types,
                                      {sourceId1,
                                       sourceId2,
@@ -3598,16 +3220,15 @@ TEST_F(ProjectStorage, ThrowForTypeIdAndPrototypeIdAreTheSameForRelinking)
 {
     Storage::Types types{createTypesWithExportedTypeNamesOnly()};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[1].prototype = Storage::ImportedType{"Item"};
     types[1].typeName = "QObject2";
-    importsSourceId2.emplace_back("QtQuick", Storage::Version{}, sourceId2);
+    importsSourceId2.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
 
-    ASSERT_THROW(storage.synchronize({}, importsSourceId2, {types[1]}, {sourceId2}, {}),
+    ASSERT_THROW(storage.synchronize(importsSourceId2, {types[1]}, {sourceId2}, {}),
                  QmlDesigner::PrototypeChainCycle);
 }
 
@@ -3615,8 +3236,7 @@ TEST_F(ProjectStorage, RecursiveAliases)
 {
     Storage::Types types{createTypesWithRecursiveAliases()};
 
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3629,23 +3249,21 @@ TEST_F(ProjectStorage, RecursiveAliases)
                         {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId5,
                                              "QAliasItem2",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId5),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::propertyDeclarations,
                                      ElementsAre(IsPropertyDeclaration(
                                          "objects",
-                                         Storage::NativeType{"QObject"},
+                                         fetchTypeId(sourceId2, "QObject"),
                                          Storage::PropertyDeclarationTraits::IsList))))));
 }
 
 TEST_F(ProjectStorage, RecursiveAliasesChangePropertyType)
 {
     Storage::Types types{createTypesWithRecursiveAliases()};
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3657,28 +3275,26 @@ TEST_F(ProjectStorage, RecursiveAliasesChangePropertyType)
                          pathToModuleSourceId},
                         {});
     types[1].propertyDeclarations[0].typeName = Storage::ImportedType{"Object2"};
-    importsSourceId2.emplace_back("/path/to", Storage::Version{}, sourceId2);
+    importsSourceId2.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
 
-    storage.synchronize({}, importsSourceId2, {types[1]}, {sourceId2}, {});
+    storage.synchronize(importsSourceId2, {types[1]}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId5,
                                              "QAliasItem2",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId5),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::propertyDeclarations,
                                      ElementsAre(IsPropertyDeclaration(
                                          "objects",
-                                         Storage::NativeType{"QObject2"},
+                                         fetchTypeId(sourceId4, "QObject2"),
                                          Storage::PropertyDeclarationTraits::IsList))))));
 }
 
 TEST_F(ProjectStorage, UpdateAliasesAfterInjectingProperty)
 {
     Storage::Types types{createTypesWithRecursiveAliases()};
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3695,18 +3311,17 @@ TEST_F(ProjectStorage, UpdateAliasesAfterInjectingProperty)
                                      Storage::PropertyDeclarationTraits::IsList
                                          | Storage::PropertyDeclarationTraits::IsReadOnly});
 
-    storage.synchronize({}, importsSourceId1, {types[0]}, {sourceId1}, {});
+    storage.synchronize(importsSourceId1, {types[0]}, {sourceId1}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId5,
                                              "QAliasItem2",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId5),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::propertyDeclarations,
                                      ElementsAre(IsPropertyDeclaration(
                                          "objects",
-                                         Storage::NativeType{"QQuickItem"},
+                                         fetchTypeId(sourceId1, "QQuickItem"),
                                          Storage::PropertyDeclarationTraits::IsList
                                              | Storage::PropertyDeclarationTraits::IsReadOnly))))));
 }
@@ -3714,8 +3329,7 @@ TEST_F(ProjectStorage, UpdateAliasesAfterInjectingProperty)
 TEST_F(ProjectStorage, UpdateAliasesAfterChangeAliasToProperty)
 {
     Storage::Types types{createTypesWithRecursiveAliases()};
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3733,30 +3347,28 @@ TEST_F(ProjectStorage, UpdateAliasesAfterChangeAliasToProperty)
                                      Storage::PropertyDeclarationTraits::IsList
                                          | Storage::PropertyDeclarationTraits::IsReadOnly});
 
-    storage.synchronize({}, importsSourceId3, {types[2]}, {sourceId3}, {});
+    storage.synchronize(importsSourceId3, {types[2]}, {sourceId3}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                AllOf(Contains(AllOf(IsStorageType(qtQuickModuleId,
+                AllOf(Contains(AllOf(IsStorageType(sourceId5,
                                                    "QAliasItem2",
-                                                   Storage::NativeType{"QObject"},
-                                                   TypeAccessSemantics::Reference,
-                                                   sourceId5),
+                                                   fetchTypeId(sourceId2, "QObject"),
+                                                   TypeAccessSemantics::Reference),
                                      Field(&Storage::Type::propertyDeclarations,
                                            ElementsAre(IsPropertyDeclaration(
                                                "objects",
-                                               Storage::NativeType{"QQuickItem"},
+                                               fetchTypeId(sourceId1, "QQuickItem"),
                                                Storage::PropertyDeclarationTraits::IsList
                                                    | Storage::PropertyDeclarationTraits::IsReadOnly,
                                                "objects"))))),
-                      Contains(AllOf(IsStorageType(qtQuickModuleId,
+                      Contains(AllOf(IsStorageType(sourceId3,
                                                    "QAliasItem",
-                                                   Storage::NativeType{"QQuickItem"},
-                                                   TypeAccessSemantics::Reference,
-                                                   sourceId3),
+                                                   fetchTypeId(sourceId1, "QQuickItem"),
+                                                   TypeAccessSemantics::Reference),
                                      Field(&Storage::Type::propertyDeclarations,
                                            ElementsAre(IsPropertyDeclaration(
                                                "objects",
-                                               Storage::NativeType{"QQuickItem"},
+                                               fetchTypeId(sourceId1, "QQuickItem"),
                                                Storage::PropertyDeclarationTraits::IsList
                                                    | Storage::PropertyDeclarationTraits::IsReadOnly,
                                                "")))))));
@@ -3767,8 +3379,7 @@ TEST_F(ProjectStorage, UpdateAliasesAfterChangePropertyToAlias)
     Storage::Types types{createTypesWithRecursiveAliases()};
     types[3].propertyDeclarations[0].traits = Storage::PropertyDeclarationTraits::IsList
                                               | Storage::PropertyDeclarationTraits::IsReadOnly;
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3782,20 +3393,19 @@ TEST_F(ProjectStorage, UpdateAliasesAfterChangePropertyToAlias)
     types[1].propertyDeclarations.clear();
     types[1].propertyDeclarations.push_back(
         Storage::PropertyDeclaration{"objects", Storage::ImportedType{"Object2"}, "objects"});
-    importsSourceId2.emplace_back("/path/to", Storage::Version{}, sourceId2);
+    importsSourceId2.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
 
-    storage.synchronize({}, importsSourceId2, {types[1]}, {sourceId2}, {});
+    storage.synchronize(importsSourceId2, {types[1]}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId5,
                                              "QAliasItem2",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId5),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::propertyDeclarations,
                                      ElementsAre(IsPropertyDeclaration(
                                          "objects",
-                                         Storage::NativeType{"QObject"},
+                                         fetchTypeId(sourceId2, "QObject"),
                                          Storage::PropertyDeclarationTraits::IsList
                                              | Storage::PropertyDeclarationTraits::IsReadOnly,
                                          "objects"))))));
@@ -3807,10 +3417,9 @@ TEST_F(ProjectStorage, CheckForProtoTypeCycleThrows)
     types[1].propertyDeclarations.clear();
     types[1].propertyDeclarations.push_back(
         Storage::PropertyDeclaration{"objects", Storage::ImportedType{"AliasItem2"}, "objects"});
-    imports.emplace_back("QtQuick", Storage::Version{}, sourceId2);
+    imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
 
-    ASSERT_THROW(storage.synchronize(modules,
-                                     imports,
+    ASSERT_THROW(storage.synchronize(imports,
                                      types,
                                      {sourceId1,
                                       sourceId2,
@@ -3827,8 +3436,7 @@ TEST_F(ProjectStorage, CheckForProtoTypeCycleThrows)
 TEST_F(ProjectStorage, CheckForProtoTypeCycleAfterUpdateThrows)
 {
     Storage::Types types{createTypesWithRecursiveAliases()};
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -3842,9 +3450,9 @@ TEST_F(ProjectStorage, CheckForProtoTypeCycleAfterUpdateThrows)
     types[1].propertyDeclarations.clear();
     types[1].propertyDeclarations.push_back(
         Storage::PropertyDeclaration{"objects", Storage::ImportedType{"AliasItem2"}, "objects"});
-    importsSourceId2.emplace_back("QtQuick", Storage::Version{}, sourceId2);
+    importsSourceId2.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
 
-    ASSERT_THROW(storage.synchronize({}, importsSourceId2, {types[1]}, {sourceId2}, {}),
+    ASSERT_THROW(storage.synchronize(importsSourceId2, {types[1]}, {sourceId2}, {}),
                  QmlDesigner::AliasChainCycle);
 }
 
@@ -3852,42 +3460,38 @@ TEST_F(ProjectStorage, QualifiedPrototype)
 {
     Storage::Types types{createTypes()};
     types[0].prototype = Storage::QualifiedImportedType{"Object",
-                                                        Storage::Import{"Qml",
+                                                        Storage::Import{qmlModuleId,
                                                                         Storage::Version{},
                                                                         sourceId1}};
-    types.push_back(Storage::Type{qtQuickModuleId,
-                                  "QQuickObject",
-                                  Storage::NativeType{},
+    types.push_back(Storage::Type{"QQuickObject",
+                                  Storage::ImportedType{},
                                   TypeAccessSemantics::Reference,
                                   sourceId3,
-                                  {Storage::ExportedType{"Object"}}});
-    imports.emplace_back("QtQuick", Storage::Version{}, sourceId3);
+                                  {Storage::ExportedType{qtQuickModuleId, "Object"}}});
+    imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
 
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, sourceId3, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId1,
                                        "QQuickItem",
-                                       Storage::NativeType{"QObject"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId1)));
+                                       fetchTypeId(sourceId2, "QObject"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, QualifiedPrototypeUpperDownTheModuleChainThrows)
 {
     Storage::Types types{createTypes()};
     types[0].prototype = Storage::QualifiedImportedType{"Object",
-                                                        Storage::Import{"QtQuick",
+                                                        Storage::Import{qtQuickModuleId,
                                                                         Storage::Version{},
                                                                         sourceId1}};
 
-    ASSERT_THROW(storage.synchronize(modules,
-                                     imports,
+    ASSERT_THROW(storage.synchronize(imports,
                                      types,
                                      {sourceId1,
                                       sourceId2,
@@ -3902,49 +3506,44 @@ TEST_F(ProjectStorage, QualifiedPrototypeUpperInTheModuleChain)
 {
     Storage::Types types{createTypes()};
     types[0].prototype = Storage::QualifiedImportedType{"Object",
-                                                        Storage::Import{"QtQuick",
+                                                        Storage::Import{qtQuickModuleId,
                                                                         Storage::Version{},
                                                                         sourceId1}};
-    types.push_back(Storage::Type{qtQuickModuleId,
-                                  "QQuickObject",
-                                  Storage::NativeType{},
+    types.push_back(Storage::Type{"QQuickObject",
+                                  Storage::ImportedType{},
                                   TypeAccessSemantics::Reference,
                                   sourceId3,
-                                  {Storage::ExportedType{"Object"}}});
-    imports.emplace_back("QtQuick", Storage::Version{}, sourceId3);
+                                  {Storage::ExportedType{qtQuickModuleId, "Object"}}});
+    imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
 
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, sourceId3, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId1,
                                        "QQuickItem",
-                                       Storage::NativeType{"QQuickObject"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId1)));
+                                       fetchTypeId(sourceId3, "QQuickObject"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, QualifiedPrototypeWithWrongVersionThrows)
 {
     Storage::Types types{createTypes()};
     types[0].prototype = Storage::QualifiedImportedType{"Object",
-                                                        Storage::Import{"Qml",
+                                                        Storage::Import{qmlModuleId,
                                                                         Storage::Version{4},
                                                                         sourceId1}};
-    types.push_back(Storage::Type{qtQuickModuleId,
-                                  "QQuickObject",
-                                  Storage::NativeType{},
+    types.push_back(Storage::Type{"QQuickObject",
+                                  Storage::ImportedType{},
                                   TypeAccessSemantics::Reference,
                                   sourceId3,
-                                  {Storage::ExportedType{"Object"}}});
-    imports.emplace_back("QtQuick", Storage::Version{}, sourceId3);
+                                  {Storage::ExportedType{qtQuickModuleId, "Object"}}});
+    imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
 
-    ASSERT_THROW(storage.synchronize(modules,
-                                     imports,
+    ASSERT_THROW(storage.synchronize(imports,
                                      types,
                                      {sourceId1,
                                       sourceId2,
@@ -3961,27 +3560,24 @@ TEST_F(ProjectStorage, QualifiedPrototypeWithVersion)
     Storage::Types types{createTypes()};
     imports[0].version = Storage::Version{2};
     types[0].prototype = Storage::QualifiedImportedType{"Object", imports[0]};
-    types.push_back(Storage::Type{qtQuickModuleId,
-                                  "QQuickObject",
-                                  Storage::NativeType{},
+    types.push_back(Storage::Type{"QQuickObject",
+                                  Storage::ImportedType{},
                                   TypeAccessSemantics::Reference,
                                   sourceId3,
-                                  {Storage::ExportedType{"Object"}}});
-    imports.emplace_back("QtQuick", Storage::Version{}, sourceId3);
+                                  {Storage::ExportedType{qtQuickModuleId, "Object"}}});
+    imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
 
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, sourceId3, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId1,
                                        "QQuickItem",
-                                       Storage::NativeType{"QObject"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId1)));
+                                       fetchTypeId(sourceId2, "QObject"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, QualifiedPrototypeWithVersionInTheProtoTypeChain)
@@ -3990,39 +3586,36 @@ TEST_F(ProjectStorage, QualifiedPrototypeWithVersionInTheProtoTypeChain)
     imports[2].version = Storage::Version{2};
     types[0].prototype = Storage::QualifiedImportedType{"Object", imports[2]};
     types[0].exportedTypes[0].version = Storage::Version{2};
-    types.push_back(Storage::Type{qtQuickModuleId,
-                                  "QQuickObject",
-                                  Storage::NativeType{},
-                                  TypeAccessSemantics::Reference,
-                                  sourceId3,
-                                  {Storage::ExportedType{"Object", Storage::Version{2}}}});
-    imports.emplace_back("QtQuick", Storage::Version{}, sourceId3);
+    types.push_back(
+        Storage::Type{"QQuickObject",
+                      Storage::ImportedType{},
+                      TypeAccessSemantics::Reference,
+                      sourceId3,
+                      {Storage::ExportedType{qtQuickModuleId, "Object", Storage::Version{2}}}});
+    imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
 
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, sourceId3, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId1,
                                        "QQuickItem",
-                                       Storage::NativeType{"QQuickObject"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId1)));
+                                       fetchTypeId(sourceId3, "QQuickObject"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, QualifiedPrototypeWithVersionDownTheProtoTypeChainThrows)
 {
     Storage::Types types{createTypes()};
     types[0].prototype = Storage::QualifiedImportedType{"Object",
-                                                        Storage::Import{"QtQuick",
+                                                        Storage::Import{qtQuickModuleId,
                                                                         Storage::Version{2},
                                                                         sourceId1}};
 
-    ASSERT_THROW(storage.synchronize(modules,
-                                     imports,
+    ASSERT_THROW(storage.synchronize(imports,
                                      types,
                                      {sourceId1,
                                       sourceId2,
@@ -4038,17 +3631,15 @@ TEST_F(ProjectStorage, QualifiedPropertyDeclarationTypeName)
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::QualifiedImportedType{
-        "Object", Storage::Import{"Qml", Storage::Version{}, sourceId1}};
-    types.push_back(Storage::Type{qtQuickModuleId,
-                                  "QQuickObject",
-                                  Storage::NativeType{},
+        "Object", Storage::Import{qmlModuleId, Storage::Version{}, sourceId1}};
+    types.push_back(Storage::Type{"QQuickObject",
+                                  Storage::ImportedType{},
                                   TypeAccessSemantics::Reference,
                                   sourceId3,
-                                  {Storage::ExportedType{"Object"}}});
-    imports.emplace_back("QtQuick", Storage::Version{}, sourceId3);
+                                  {Storage::ExportedType{qtQuickModuleId, "Object"}}});
+    imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
 
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, sourceId3, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
@@ -4058,7 +3649,7 @@ TEST_F(ProjectStorage, QualifiedPropertyDeclarationTypeName)
                 Contains(
                     Field(&Storage::Type::propertyDeclarations,
                           Contains(IsPropertyDeclaration("data",
-                                                         Storage::NativeType{"QObject"},
+                                                         fetchTypeId(sourceId2, "QObject"),
                                                          Storage::PropertyDeclarationTraits::IsList)))));
 }
 
@@ -4066,10 +3657,9 @@ TEST_F(ProjectStorage, QualifiedPropertyDeclarationTypeNameDownTheModuleChainThr
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::QualifiedImportedType{
-        "Object", Storage::Import{"QtQuick", Storage::Version{}, sourceId1}};
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId1}};
 
-    ASSERT_THROW(storage.synchronize(modules,
-                                     imports,
+    ASSERT_THROW(storage.synchronize(imports,
                                      types,
                                      {sourceId1,
                                       sourceId2,
@@ -4085,17 +3675,15 @@ TEST_F(ProjectStorage, QualifiedPropertyDeclarationTypeNameInTheModuleChain)
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::QualifiedImportedType{
-        "Object", Storage::Import{"QtQuick", Storage::Version{}, sourceId1}};
-    types.push_back(Storage::Type{qtQuickModuleId,
-                                  "QQuickObject",
-                                  Storage::NativeType{},
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId1}};
+    types.push_back(Storage::Type{"QQuickObject",
+                                  Storage::ImportedType{},
                                   TypeAccessSemantics::Reference,
                                   sourceId3,
-                                  {Storage::ExportedType{"Object"}}});
-    imports.emplace_back("QtQuick", Storage::Version{}, sourceId3);
+                                  {Storage::ExportedType{qtQuickModuleId, "Object"}}});
+    imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
 
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, sourceId3, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
@@ -4105,7 +3693,7 @@ TEST_F(ProjectStorage, QualifiedPropertyDeclarationTypeNameInTheModuleChain)
                 Contains(
                     Field(&Storage::Type::propertyDeclarations,
                           Contains(IsPropertyDeclaration("data",
-                                                         Storage::NativeType{"QQuickObject"},
+                                                         fetchTypeId(sourceId3, "QQuickObject"),
                                                          Storage::PropertyDeclarationTraits::IsList)))));
 }
 
@@ -4113,11 +3701,10 @@ TEST_F(ProjectStorage, QualifiedPropertyDeclarationTypeNameWithVersion)
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::QualifiedImportedType{
-        "Object", Storage::Import{"Qml", Storage::Version{2}, sourceId1}};
-    imports.emplace_back("Qml", Storage::Version{2}, sourceId1);
+        "Object", Storage::Import{qmlModuleId, Storage::Version{2}, sourceId1}};
+    imports.emplace_back(qmlModuleId, Storage::Version{2}, sourceId1);
 
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
@@ -4127,7 +3714,7 @@ TEST_F(ProjectStorage, QualifiedPropertyDeclarationTypeNameWithVersion)
                 Contains(
                     Field(&Storage::Type::propertyDeclarations,
                           Contains(IsPropertyDeclaration("data",
-                                                         Storage::NativeType{"QObject"},
+                                                         fetchTypeId(sourceId2, "QObject"),
                                                          Storage::PropertyDeclarationTraits::IsList)))));
 }
 
@@ -4135,16 +3722,15 @@ TEST_F(ProjectStorage, ChangePropertyTypeModuleIdWithQualifiedTypeThrows)
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::QualifiedImportedType{
-        "Object", Storage::Import{"Qml", Storage::Version{}, sourceId1}};
+        "Object", Storage::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
-    types[1].moduleId = qtQuickModuleId;
+    types[1].exportedTypes[0].moduleId = qtQuickModuleId;
 
-    ASSERT_THROW(storage.synchronize({}, importsSourceId2, {types[1]}, {sourceId2}, {}),
+    ASSERT_THROW(storage.synchronize(importsSourceId2, {types[1]}, {sourceId2}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
@@ -4152,30 +3738,28 @@ TEST_F(ProjectStorage, ChangePropertyTypeModuleIdWithQualifiedType)
 {
     Storage::Types types{createTypes()};
     types[0].propertyDeclarations[0].typeName = Storage::QualifiedImportedType{
-        "Object", Storage::Import{"Qml", Storage::Version{}, sourceId1}};
+        "Object", Storage::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
     types[0].propertyDeclarations[0].typeName = Storage::QualifiedImportedType{
-        "Object", Storage::Import{"QtQuick", Storage::Version{}, sourceId1}};
-    types[1].moduleId = qtQuickModuleId;
-    imports.emplace_back("QtQuick", Storage::Version{}, sourceId2);
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId1}};
+    types[1].exportedTypes[0].moduleId = qtQuickModuleId;
+    imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
 
-    storage.synchronize({}, imports, types, {sourceId1, sourceId2}, {});
+    storage.synchronize(imports, types, {sourceId1, sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(qtQuickModuleId,
+                Contains(AllOf(IsStorageType(sourceId1,
                                              "QQuickItem",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId1),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::propertyDeclarations,
                                      Contains(IsPropertyDeclaration(
                                          "data",
-                                         Storage::NativeType{"QObject"},
+                                         fetchTypeId(sourceId2, "QObject"),
                                          Storage::PropertyDeclarationTraits::IsList))))));
 }
 
@@ -4184,7 +3768,7 @@ TEST_F(ProjectStorage, AddFileStatuses)
     FileStatus fileStatus1{sourceId1, 100, 100};
     FileStatus fileStatus2{sourceId2, 101, 101};
 
-    storage.synchronize({}, {}, {}, {sourceId1, sourceId2}, {fileStatus1, fileStatus2});
+    storage.synchronize({}, {}, {sourceId1, sourceId2}, {fileStatus1, fileStatus2});
 
     ASSERT_THAT(convert(storage.fetchAllFileStatuses()),
                 UnorderedElementsAre(fileStatus1, fileStatus2));
@@ -4194,9 +3778,9 @@ TEST_F(ProjectStorage, RemoveFileStatus)
 {
     FileStatus fileStatus1{sourceId1, 100, 100};
     FileStatus fileStatus2{sourceId2, 101, 101};
-    storage.synchronize({}, {}, {}, {sourceId1, sourceId2}, {fileStatus1, fileStatus2});
+    storage.synchronize({}, {}, {sourceId1, sourceId2}, {fileStatus1, fileStatus2});
 
-    storage.synchronize({}, {}, {}, {sourceId1, sourceId2}, {fileStatus1});
+    storage.synchronize({}, {}, {sourceId1, sourceId2}, {fileStatus1});
 
     ASSERT_THAT(convert(storage.fetchAllFileStatuses()), UnorderedElementsAre(fileStatus1));
 }
@@ -4206,9 +3790,9 @@ TEST_F(ProjectStorage, UpdateFileStatus)
     FileStatus fileStatus1{sourceId1, 100, 100};
     FileStatus fileStatus2{sourceId2, 101, 101};
     FileStatus fileStatus2b{sourceId2, 102, 102};
-    storage.synchronize({}, {}, {}, {sourceId1, sourceId2}, {fileStatus1, fileStatus2});
+    storage.synchronize({}, {}, {sourceId1, sourceId2}, {fileStatus1, fileStatus2});
 
-    storage.synchronize({}, {}, {}, {sourceId1, sourceId2}, {fileStatus1, fileStatus2b});
+    storage.synchronize({}, {}, {sourceId1, sourceId2}, {fileStatus1, fileStatus2b});
 
     ASSERT_THAT(convert(storage.fetchAllFileStatuses()),
                 UnorderedElementsAre(fileStatus1, fileStatus2b));
@@ -4218,7 +3802,7 @@ TEST_F(ProjectStorage, ThrowForInvalidSourceId)
 {
     FileStatus fileStatus1{SourceId{}, 100, 100};
 
-    ASSERT_THROW(storage.synchronize({}, {}, {}, {sourceId1}, {fileStatus1}),
+    ASSERT_THROW(storage.synchronize({}, {}, {sourceId1}, {fileStatus1}),
                  Sqlite::ConstraintPreventsModification);
 }
 
@@ -4226,7 +3810,7 @@ TEST_F(ProjectStorage, FetchAllFileStatuses)
 {
     FileStatus fileStatus1{sourceId1, 100, 100};
     FileStatus fileStatus2{sourceId2, 101, 101};
-    storage.synchronize({}, {}, {}, {sourceId1, sourceId2}, {fileStatus1, fileStatus2});
+    storage.synchronize({}, {}, {sourceId1, sourceId2}, {fileStatus1, fileStatus2});
 
     auto fileStatuses = convert(storage.fetchAllFileStatuses());
 
@@ -4237,7 +3821,7 @@ TEST_F(ProjectStorage, FetchAllFileStatusesReverse)
 {
     FileStatus fileStatus1{sourceId1, 100, 100};
     FileStatus fileStatus2{sourceId2, 101, 101};
-    storage.synchronize({}, {}, {}, {sourceId1, sourceId2}, {fileStatus2, fileStatus1});
+    storage.synchronize({}, {}, {sourceId1, sourceId2}, {fileStatus2, fileStatus1});
 
     auto fileStatuses = convert(storage.fetchAllFileStatuses());
 
@@ -4248,7 +3832,7 @@ TEST_F(ProjectStorage, FetchFileStatus)
 {
     FileStatus fileStatus1{sourceId1, 100, 100};
     FileStatus fileStatus2{sourceId2, 101, 101};
-    storage.synchronize({}, {}, {}, {sourceId1, sourceId2}, {fileStatus1, fileStatus2});
+    storage.synchronize({}, {}, {sourceId1, sourceId2}, {fileStatus1, fileStatus2});
 
     auto fileStatus = storage.fetchFileStatus(sourceId1);
 
@@ -4258,8 +3842,7 @@ TEST_F(ProjectStorage, FetchFileStatus)
 TEST_F(ProjectStorage, SynchronizeTypesWithoutTypeName)
 {
     Storage::Types types{createTypesWithAliases()};
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1,
                          sourceId2,
@@ -4270,17 +3853,15 @@ TEST_F(ProjectStorage, SynchronizeTypesWithoutTypeName)
                          pathToModuleSourceId},
                         {});
     types[3].typeName.clear();
-    types[3].moduleId = ModuleId{};
     types[3].prototype = Storage::ImportedType{"Object"};
 
-    storage.synchronize({}, importsSourceId4, {types[3]}, {sourceId4}, {});
+    storage.synchronize(importsSourceId4, {types[3]}, {sourceId4}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(AllOf(IsStorageType(pathToModuleId,
+                Contains(AllOf(IsStorageType(sourceId4,
                                              "QObject2",
-                                             Storage::NativeType{"QObject"},
-                                             TypeAccessSemantics::Reference,
-                                             sourceId4),
+                                             fetchTypeId(sourceId2, "QObject"),
+                                             TypeAccessSemantics::Reference),
                                Field(&Storage::Type::exportedTypes,
                                      UnorderedElementsAre(IsExportedType("Object2"),
                                                           IsExportedType("Obj2"))))));
@@ -4289,125 +3870,111 @@ TEST_F(ProjectStorage, SynchronizeTypesWithoutTypeName)
 TEST_F(ProjectStorage, FetchByMajorVersionForImportedType)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Type type{"Item",
                        Storage::ImportedType{"Object"},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
-    Storage::Import import{"Qml", Storage::Version{1}, sourceId2};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
+    Storage::Import import{qmlModuleId, Storage::Version{1}, sourceId2};
 
-    storage.synchronize({}, {import}, {type}, {sourceId2}, {});
+    storage.synchronize({import}, {type}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId2,
                                        "Item",
-                                       Storage::NativeType{"QObject"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId2)));
+                                       fetchTypeId(sourceId1, "QObject"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, FetchByMajorVersionForQualifiedImportedType)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Import import{"Qml", Storage::Version{1}, sourceId2};
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Import import{qmlModuleId, Storage::Version{1}, sourceId2};
+    Storage::Type type{"Item",
                        Storage::QualifiedImportedType{"Object", import},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
 
-    storage.synchronize({}, {import}, {type}, {sourceId2}, {});
+    storage.synchronize({import}, {type}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId2,
                                        "Item",
-                                       Storage::NativeType{"QObject"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId2)));
+                                       fetchTypeId(sourceId1, "QObject"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, FetchByMajorVersionAndMinorVersionForImportedType)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Type type{"Item",
                        Storage::ImportedType{"Obj"},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
-    Storage::Import import{"Qml", Storage::Version{1, 2}, sourceId2};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
+    Storage::Import import{qmlModuleId, Storage::Version{1, 2}, sourceId2};
 
-    storage.synchronize({}, {import}, {type}, {sourceId2}, {});
+    storage.synchronize({import}, {type}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId2,
                                        "Item",
-                                       Storage::NativeType{"QObject"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId2)));
+                                       fetchTypeId(sourceId1, "QObject"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, FetchByMajorVersionAndMinorVersionForQualifiedImportedType)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Import import{"Qml", Storage::Version{1, 2}, sourceId2};
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Import import{qmlModuleId, Storage::Version{1, 2}, sourceId2};
+    Storage::Type type{"Item",
                        Storage::QualifiedImportedType{"Obj", import},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
 
-    storage.synchronize({}, {import}, {type}, {sourceId2}, {});
+    storage.synchronize({import}, {type}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId2,
                                        "Item",
-                                       Storage::NativeType{"QObject"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId2)));
+                                       fetchTypeId(sourceId1, "QObject"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage,
        FetchByMajorVersionAndMinorVersionForImportedTypeIfMinorVersionIsNotExportedThrows)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Type type{"Item",
                        Storage::ImportedType{"Object"},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
-    Storage::Import import{"Qml", Storage::Version{1, 1}, sourceId2};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
+    Storage::Import import{qmlModuleId, Storage::Version{1, 1}, sourceId2};
 
-    ASSERT_THROW(storage.synchronize({}, {import}, {type}, {sourceId2}, {}),
+    ASSERT_THROW(storage.synchronize({import}, {type}, {sourceId2}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
@@ -4415,436 +3982,439 @@ TEST_F(ProjectStorage,
        FetchByMajorVersionAndMinorVersionForQualifiedImportedTypeIfMinorVersionIsNotExportedThrows)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Import import{"Qml", Storage::Version{1, 1}, sourceId2};
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Import import{qmlModuleId, Storage::Version{1, 1}, sourceId2};
+    Storage::Type type{"Item",
                        Storage::QualifiedImportedType{"Object", import},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
 
-    ASSERT_THROW(storage.synchronize({}, {import}, {type}, {sourceId2}, {}),
+    ASSERT_THROW(storage.synchronize({import}, {type}, {sourceId2}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
 TEST_F(ProjectStorage, FetchLowMinorVersionForImportedTypeThrows)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Type type{"Item",
                        Storage::ImportedType{"Obj"},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
-    Storage::Import import{"Qml", Storage::Version{1, 1}, sourceId2};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
+    Storage::Import import{qmlModuleId, Storage::Version{1, 1}, sourceId2};
 
-    ASSERT_THROW(storage.synchronize({}, {import}, {type}, {sourceId2}, {}),
+    ASSERT_THROW(storage.synchronize({import}, {type}, {sourceId2}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
 TEST_F(ProjectStorage, FetchLowMinorVersionForQualifiedImportedTypeThrows)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Import import{"Qml", Storage::Version{1, 1}, sourceId2};
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Import import{qmlModuleId, Storage::Version{1, 1}, sourceId2};
+    Storage::Type type{"Item",
                        Storage::QualifiedImportedType{"Obj", import},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
 
-    ASSERT_THROW(storage.synchronize({}, {import}, {type}, {sourceId2}, {}),
+    ASSERT_THROW(storage.synchronize({import}, {type}, {sourceId2}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
 TEST_F(ProjectStorage, FetchHigherMinorVersionForImportedType)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Type type{"Item",
                        Storage::ImportedType{"Obj"},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
-    Storage::Import import{"Qml", Storage::Version{1, 3}, sourceId2};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
+    Storage::Import import{qmlModuleId, Storage::Version{1, 3}, sourceId2};
 
-    storage.synchronize({}, {import}, {type}, {sourceId2}, {});
+    storage.synchronize({import}, {type}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId2,
                                        "Item",
-                                       Storage::NativeType{"QObject"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId2)));
+                                       fetchTypeId(sourceId1, "QObject"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, FetchHigherMinorVersionForQualifiedImportedType)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Import import{"Qml", Storage::Version{1, 3}, sourceId2};
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Import import{qmlModuleId, Storage::Version{1, 3}, sourceId2};
+    Storage::Type type{"Item",
                        Storage::QualifiedImportedType{"Obj", import},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
 
-    storage.synchronize({}, {import}, {type}, {sourceId2}, {});
+    storage.synchronize({import}, {type}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId2,
                                        "Item",
-                                       Storage::NativeType{"QObject"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId2)));
+                                       fetchTypeId(sourceId1, "QObject"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, FetchDifferentMajorVersionForImportedTypeThrows)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Type type{"Item",
                        Storage::ImportedType{"Obj"},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
-    Storage::Import import{"Qml", Storage::Version{3, 1}, sourceId2};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
+    Storage::Import import{qmlModuleId, Storage::Version{3, 1}, sourceId2};
 
-    ASSERT_THROW(storage.synchronize({}, {import}, {type}, {sourceId2}, {}),
+    ASSERT_THROW(storage.synchronize({import}, {type}, {sourceId2}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
 TEST_F(ProjectStorage, FetchDifferentMajorVersionForQualifiedImportedTypeThrows)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Import import{"Qml", Storage::Version{3, 1}, sourceId2};
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Import import{qmlModuleId, Storage::Version{3, 1}, sourceId2};
+    Storage::Type type{"Item",
                        Storage::QualifiedImportedType{"Obj", import},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
 
-    ASSERT_THROW(storage.synchronize({}, {import}, {type}, {sourceId2}, {}),
+    ASSERT_THROW(storage.synchronize({import}, {type}, {sourceId2}, {}),
                  QmlDesigner::TypeNameDoesNotExists);
 }
 
 TEST_F(ProjectStorage, FetchOtherTypeByDifferentVersionForImportedType)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Type type{"Item",
                        Storage::ImportedType{"Obj"},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
-    Storage::Import import{"Qml", Storage::Version{2, 3}, sourceId2};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
+    Storage::Import import{qmlModuleId, Storage::Version{2, 3}, sourceId2};
 
-    storage.synchronize({}, {import}, {type}, {sourceId2}, {});
+    storage.synchronize({import}, {type}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId2,
                                        "Item",
-                                       Storage::NativeType{"QObject2"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId2)));
+                                       fetchTypeId(sourceId1, "QObject2"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, FetchOtherTypeByDifferentVersionForQualifiedImportedType)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Import import{"Qml", Storage::Version{2, 3}, sourceId2};
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Import import{qmlModuleId, Storage::Version{2, 3}, sourceId2};
+    Storage::Type type{"Item",
                        Storage::QualifiedImportedType{"Obj", import},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
 
-    storage.synchronize({}, {import}, {type}, {sourceId2}, {});
+    storage.synchronize({import}, {type}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId2,
                                        "Item",
-                                       Storage::NativeType{"QObject2"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId2)));
+                                       fetchTypeId(sourceId1, "QObject2"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, FetchHighestVersionForImportWithoutVersionForImportedType)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Type type{"Item",
                        Storage::ImportedType{"Obj"},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
-    Storage::Import import{"Qml", Storage::Version{}, sourceId2};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
+    Storage::Import import{qmlModuleId, Storage::Version{}, sourceId2};
 
-    storage.synchronize({}, {import}, {type}, {sourceId2}, {});
+    storage.synchronize({import}, {type}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId2,
                                        "Item",
-                                       Storage::NativeType{"QObject4"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId2)));
+                                       fetchTypeId(sourceId1, "QObject4"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, FetchHighestVersionForImportWithoutVersionForQualifiedImportedType)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Import import{"Qml", Storage::Version{}, sourceId2};
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Import import{qmlModuleId, Storage::Version{}, sourceId2};
+    Storage::Type type{"Item",
                        Storage::QualifiedImportedType{"Obj", import},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
 
-    storage.synchronize({}, {import}, {type}, {sourceId2}, {});
+    storage.synchronize({import}, {type}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId2,
                                        "Item",
-                                       Storage::NativeType{"QObject4"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId2)));
+                                       fetchTypeId(sourceId1, "QObject4"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, FetchHighestVersionForImportWithMajorVersionForImportedType)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Type type{"Item",
                        Storage::ImportedType{"Obj"},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
-    Storage::Import import{"Qml", Storage::Version{2}, sourceId2};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
+    Storage::Import import{qmlModuleId, Storage::Version{2}, sourceId2};
 
-    storage.synchronize({}, {import}, {type}, {sourceId2}, {});
+    storage.synchronize({import}, {type}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId2,
                                        "Item",
-                                       Storage::NativeType{"QObject3"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId2)));
+                                       fetchTypeId(sourceId1, "QObject3"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, FetchHighestVersionForImportWithMajorVersionForQualifiedImportedType)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Import import{"Qml", Storage::Version{2}, sourceId2};
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Import import{qmlModuleId, Storage::Version{2}, sourceId2};
+    Storage::Type type{"Item",
                        Storage::QualifiedImportedType{"Obj", import},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
 
-    storage.synchronize({}, {import}, {type}, {sourceId2}, {});
+    storage.synchronize({import}, {type}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId2,
                                        "Item",
-                                       Storage::NativeType{"QObject3"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId2)));
+                                       fetchTypeId(sourceId1, "QObject3"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, FetchExportedTypeWithoutVersionFirstForImportedType)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Type type{"Item",
                        Storage::ImportedType{"BuiltInObj"},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
-    Storage::Import import{"Qml", Storage::Version{}, sourceId2};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
+    Storage::Import import{qmlModuleId, Storage::Version{}, sourceId2};
 
-    storage.synchronize({}, {import}, {type}, {sourceId2}, {});
+    storage.synchronize({import}, {type}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId2,
                                        "Item",
-                                       Storage::NativeType{"QObject"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId2)));
+                                       fetchTypeId(sourceId1, "QObject"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, FetchExportedTypeWithoutVersionFirstForQualifiedImportedType)
 {
     auto types = createVersionedTypes();
-    storage.synchronize(modules,
-                        imports,
+    storage.synchronize(imports,
                         types,
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
-    Storage::Import import{"Qml", Storage::Version{}, sourceId2};
-    Storage::Type type{qtQuickModuleId,
-                       "Item",
+    Storage::Import import{qmlModuleId, Storage::Version{}, sourceId2};
+    Storage::Type type{"Item",
                        Storage::QualifiedImportedType{"BuiltInObj", import},
                        TypeAccessSemantics::Reference,
                        sourceId2,
-                       {Storage::ExportedType{"Item", Storage::Version{}}}};
+                       {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{}}}};
 
-    storage.synchronize({}, {import}, {type}, {sourceId2}, {});
+    storage.synchronize({import}, {type}, {sourceId2}, {});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(IsStorageType(qtQuickModuleId,
+                Contains(IsStorageType(sourceId2,
                                        "Item",
-                                       Storage::NativeType{"QObject"},
-                                       TypeAccessSemantics::Reference,
-                                       sourceId2)));
+                                       fetchTypeId(sourceId1, "QObject"),
+                                       TypeAccessSemantics::Reference)));
 }
 
 TEST_F(ProjectStorage, EnsureThatPropertiesForRemovedTypesAreNotAnymoreRelinked)
 {
-    Storage::Type type{qmlModuleId,
-                       "QObject",
-                       Storage::NativeType{""},
+    Storage::Type type{"QObject",
+                       Storage::ImportedType{""},
                        TypeAccessSemantics::Reference,
                        sourceId1,
-                       {Storage::ExportedType{"Object", Storage::Version{}}},
+                       {Storage::ExportedType{qmlModuleId, "Object", Storage::Version{}}},
                        {Storage::PropertyDeclaration{"data",
-                                                     Storage::NativeType{"QObject"},
+                                                     Storage::ImportedType{"Object"},
                                                      Storage::PropertyDeclarationTraits::IsList}}};
-    Storage::Import import{"Qml", Storage::Version{}, sourceId1};
-    storage.synchronize(modules,
-                        {import},
+    Storage::Import import{qmlModuleId, Storage::Version{}, sourceId1};
+    storage.synchronize({import},
                         {type},
                         {sourceId1, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
                         {});
 
-    ASSERT_NO_THROW(storage.synchronize({}, {}, {}, {sourceId1}, {}));
+    ASSERT_NO_THROW(storage.synchronize({}, {}, {sourceId1}, {}));
 }
 
 TEST_F(ProjectStorage, EnsureThatPrototypesForRemovedTypesAreNotAnymoreRelinked)
 {
     auto types = createTypes();
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
 
-    ASSERT_NO_THROW(storage.synchronize({}, {}, {}, {sourceId1, sourceId2}, {}));
+    ASSERT_NO_THROW(storage.synchronize({}, {}, {sourceId1, sourceId2}, {}));
 }
 
 TEST_F(ProjectStorage, MinimalUpdates)
 {
     auto types = createTypes();
     storage.synchronize(
-        modules,
         imports,
         types,
         {sourceId1, sourceId2, qmlModuleSourceId, qtQuickModuleSourceId, pathToModuleSourceId},
         {});
-    Storage::Type quickType{qtQuickModuleId,
-                            "QQuickItem",
+    Storage::Type quickType{"QQuickItem",
                             {},
                             TypeAccessSemantics::Reference,
                             sourceId1,
-                            {Storage::ExportedType{"Item", Storage::Version{2, 0}}},
+                            {Storage::ExportedType{qtQuickModuleId, "Item", Storage::Version{2, 0}},
+                             Storage::ExportedType{qtQuickNativeModuleId, "QQuickItem"}},
                             {},
                             {},
                             {},
                             {},
                             Storage::ChangeLevel::Minimal};
 
-    storage.synchronize({modules[1]}, {}, {quickType}, {qtQuickModuleSourceId}, {});
+    storage.synchronize({}, {quickType}, {}, {});
 
-    ASSERT_THAT(storage.fetchTypes(),
-                UnorderedElementsAre(AllOf(IsStorageType(qmlModuleId,
-                                                         "QObject",
-                                                         Storage::NativeType{},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId2),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Object"),
-                                                                      IsExportedType("Obj")))),
-                                     AllOf(IsStorageType(qtQuickModuleId,
-                                                         "QQuickItem",
-                                                         Storage::NativeType{"QObject"},
-                                                         TypeAccessSemantics::Reference,
-                                                         sourceId1),
-                                           Field(&Storage::Type::exportedTypes,
-                                                 UnorderedElementsAre(IsExportedType("Item", 2, 0))))));
+    ASSERT_THAT(
+        storage.fetchTypes(),
+        UnorderedElementsAre(
+            AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
+                                             IsExportedType(qmlModuleId, "Obj"),
+                                             IsExportedType(qmlNativeModuleId, "QObject")))),
+            AllOf(IsStorageType(sourceId1,
+                                "QQuickItem",
+                                fetchTypeId(sourceId2, "QObject"),
+                                TypeAccessSemantics::Reference),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item", 2, 0),
+                                             IsExportedType(qtQuickNativeModuleId, "QQuickItem"))),
+                  Field(&Storage::Type::propertyDeclarations, Not(IsEmpty())),
+                  Field(&Storage::Type::functionDeclarations, Not(IsEmpty())),
+                  Field(&Storage::Type::signalDeclarations, Not(IsEmpty())),
+                  Field(&Storage::Type::enumerationDeclarations, Not(IsEmpty())))));
+}
+
+TEST_F(ProjectStorage, GetModuleId)
+{
+    auto id = storage.moduleId("Qml");
+
+    ASSERT_TRUE(id);
+}
+
+TEST_F(ProjectStorage, GetSameModuleIdAgain)
+{
+    auto initialId = storage.moduleId("Qml");
+
+    auto id = storage.moduleId("Qml");
+
+    ASSERT_THAT(id, Eq(initialId));
+}
+
+TEST_F(ProjectStorage, ModuleNameThrowsIfIdIsInvalid)
+{
+    ASSERT_THROW(storage.moduleName(ModuleId{}), QmlDesigner::ModuleDoesNotExists);
+}
+
+TEST_F(ProjectStorage, ModuleNameThrowsIfIdDoesNotExists)
+{
+    ASSERT_THROW(storage.moduleName(ModuleId{222}), QmlDesigner::ModuleDoesNotExists);
+}
+
+TEST_F(ProjectStorage, GetModuleName)
+{
+    auto id = storage.moduleId("Qml");
+
+    auto name = storage.moduleName(id);
+
+    ASSERT_THAT(name, Eq("Qml"));
+}
+
+TEST_F(ProjectStorage, PopulateModuleCache)
+{
+    auto id = storage.moduleId("Qml");
+
+    QmlDesigner::ProjectStorage<Sqlite::Database> newStorage{database, database.isInitialized()};
+
+    ASSERT_THAT(newStorage.moduleName(id), Eq("Qml"));
 }
 
 } // namespace
diff --git a/tests/unit/unittest/projectstoragemock.h b/tests/unit/unittest/projectstoragemock.h
index 6fecc58ad4..0f4c40e56e 100644
--- a/tests/unit/unittest/projectstoragemock.h
+++ b/tests/unit/unittest/projectstoragemock.h
@@ -38,13 +38,14 @@ class ProjectStorageMock : public QmlDesigner::ProjectStorageInterface
 public:
     MOCK_METHOD(void,
                 synchronize,
-                (QmlDesigner::Storage::Modules modules,
-                 QmlDesigner::Storage::Imports imports,
+                (QmlDesigner::Storage::Imports imports,
                  QmlDesigner::Storage::Types types,
                  QmlDesigner::SourceIds sourceIds,
                  QmlDesigner::FileStatuses fileStatuses),
                 (override));
 
+    MOCK_METHOD(QmlDesigner::ModuleId, moduleId, (Utils::SmallStringView), (override));
+
     MOCK_METHOD(QmlDesigner::FileStatus,
                 fetchFileStatus,
                 (QmlDesigner::SourceId sourceId),
diff --git a/tests/unit/unittest/projectstorageupdater-test.cpp b/tests/unit/unittest/projectstorageupdater-test.cpp
index d6a26bb109..2b70d332c7 100644
--- a/tests/unit/unittest/projectstorageupdater-test.cpp
+++ b/tests/unit/unittest/projectstorageupdater-test.cpp
@@ -42,26 +42,25 @@ namespace {
 namespace Storage = QmlDesigner::Storage;
 
 using QmlDesigner::FileStatus;
+using QmlDesigner::ModuleId;
 using QmlDesigner::SourceId;
 using QmlDesigner::Storage::TypeAccessSemantics;
 namespace Storage = QmlDesigner::Storage;
 using QmlDesigner::IdPaths;
 using QmlDesigner::Storage::Version;
 
-MATCHER_P5(IsStorageType,
-           moduleId,
+MATCHER_P4(IsStorageType,
            typeName,
            prototype,
            accessSemantics,
            sourceId,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::Type{moduleId, typeName, prototype, accessSemantics, sourceId}))
+               + PrintToString(Storage::Type{typeName, prototype, accessSemantics, sourceId}))
 {
     const Storage::Type &type = arg;
 
-    return type.moduleId == moduleId && type.typeName == typeName
-           && type.accessSemantics == accessSemantics && type.sourceId == sourceId
-           && Storage::ImportedTypeName{prototype} == type.prototype;
+    return type.typeName == typeName && type.accessSemantics == accessSemantics
+           && type.sourceId == sourceId && Storage::ImportedTypeName{prototype} == type.prototype;
 }
 
 MATCHER_P3(IsPropertyDeclaration,
@@ -78,27 +77,20 @@ MATCHER_P3(IsPropertyDeclaration,
            && propertyDeclaration.traits == traits;
 }
 
-MATCHER_P3(IsExportedType,
+MATCHER_P4(IsExportedType,
+           moduleId,
            name,
            majorVersion,
            minorVersion,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::ExportedType{name,
+               + PrintToString(Storage::ExportedType{moduleId,
+                                                     name,
                                                      Storage::Version{majorVersion, minorVersion}}))
 {
     const Storage::ExportedType &type = arg;
 
-    return type.name == name && type.version == Storage::Version{majorVersion, minorVersion};
-}
-
-MATCHER_P2(IsModule,
-           name,
-           sourceId,
-           std::string(negation ? "isn't " : "is ") + PrintToString(Storage::Module{name, sourceId}))
-{
-    const Storage::Module &module = arg;
-
-    return module.name == name && module.sourceId == sourceId;
+    return type.moduleId == moduleId && type.name == name
+           && type.version == Storage::Version{majorVersion, minorVersion};
 }
 
 MATCHER_P3(IsFileStatus,
@@ -154,6 +146,8 @@ public:
             .WillByDefault(Return(FileStatus{qmlDocumentSourceId3, 22, 14}));
         ON_CALL(projectStorageMock, fetchFileStatus(Eq(qmlDocumentSourceId3)))
             .WillByDefault(Return(FileStatus{qmlDocumentSourceId3, 22, 2}));
+        ON_CALL(projectStorageMock, moduleId(Eq("Example"))).WillByDefault(Return(exampleModuleId));
+        ON_CALL(projectStorageMock, moduleId(Eq("Qml"))).WillByDefault(Return(qmlModuleId));
 
         firstType.prototype = Storage::ImportedType{"Object"};
         secondType.prototype = Storage::ImportedType{"Object2"};
@@ -203,25 +197,26 @@ protected:
     SourceId qmltypesPathSourceId = sourcePathCache.sourceId("/path/example.qmltypes");
     SourceId qmltypes2PathSourceId = sourcePathCache.sourceId("/path/example2.qmltypes");
     SourceId qmlDirPathSourceId = sourcePathCache.sourceId("/path/qmldir");
-    QmlDesigner::ModuleId exampleModuleId{&qmlDirPathSourceId};
     SourceId qmlDocumentSourceId1 = sourcePathCache.sourceId("/path/First.qml");
     SourceId qmlDocumentSourceId2 = sourcePathCache.sourceId("/path/First.2.qml");
     SourceId qmlDocumentSourceId3 = sourcePathCache.sourceId("/path/Second.qml");
-    Storage::Type objectType{exampleModuleId,
-                             "QObject",
+    ModuleId qmlModuleId{storage.moduleId("Qml")};
+    ModuleId exampleModuleId{storage.moduleId("Example")};
+    Storage::Type objectType{"QObject",
                              Storage::NativeType{},
                              Storage::TypeAccessSemantics::Reference,
                              objectTypeSourceId,
-                             {Storage::ExportedType{"Object"}, Storage::ExportedType{"Obj"}}};
+                             {Storage::ExportedType{exampleModuleId, "Object"},
+                              Storage::ExportedType{exampleModuleId, "Obj"}}};
     QString qmlDocument1{"First{}"};
     QString qmlDocument2{"Second{}"};
     QString qmlDocument3{"Third{}"};
     Storage::Type firstType;
     Storage::Type secondType;
     Storage::Type thirdType;
-    Storage::Import import1{"Qml", Storage::Version{2, 3}, qmlDocumentSourceId1};
-    Storage::Import import2{"Qml", Storage::Version{}, qmlDocumentSourceId2};
-    Storage::Import import3{"Qml", Storage::Version{2}, qmlDocumentSourceId3};
+    Storage::Import import1{qmlModuleId, Storage::Version{2, 3}, qmlDocumentSourceId1};
+    Storage::Import import2{qmlModuleId, Storage::Version{}, qmlDocumentSourceId2};
+    Storage::Import import3{qmlModuleId, Storage::Version{2}, qmlDocumentSourceId3};
 };
 
 TEST_F(ProjectStorageUpdater, GetContentForQmlDirPathsIfFileStatusIsDifferent)
@@ -320,8 +315,7 @@ TEST_F(ProjectStorageUpdater, SynchronizeIsEmptyForNoChange)
     ON_CALL(projectStorageMock, fetchFileStatus(Eq(qmlDirPathSourceId)))
         .WillByDefault(Return(FileStatus{qmlDirPathSourceId, 21, 421}));
 
-    EXPECT_CALL(projectStorageMock,
-                synchronize(IsEmpty(), IsEmpty(), IsEmpty(), IsEmpty(), IsEmpty()));
+    EXPECT_CALL(projectStorageMock, synchronize(IsEmpty(), IsEmpty(), IsEmpty(), IsEmpty()));
 
     updater.update();
 }
@@ -330,7 +324,7 @@ TEST_F(ProjectStorageUpdater, SynchronizeQmlTypes)
 {
     auto qmlDirPathSourceId = sourcePathCache.sourceId("/path/qmldir");
     auto qmltypesPathSourceId = sourcePathCache.sourceId("/path/example.qmltypes");
-    Storage::Import import{"Qml", Storage::Version{2, 3}, qmltypesPathSourceId};
+    Storage::Import import{qmlModuleId, Storage::Version{2, 3}, qmltypesPathSourceId};
     QString qmltypes{"Module {\ndependencies: []}"};
     ON_CALL(fileSystemMock, contentAsQString(Eq(QString("/path/example.qmltypes"))))
         .WillByDefault(Return(qmltypes));
@@ -340,9 +334,9 @@ TEST_F(ProjectStorageUpdater, SynchronizeQmlTypes)
             imports.push_back(import);
         });
 
+    EXPECT_CALL(projectStorageMock, moduleId(Eq("Example")));
     EXPECT_CALL(projectStorageMock,
-                synchronize(ElementsAre(IsModule("Example", qmlDirPathSourceId)),
-                            ElementsAre(import),
+                synchronize(ElementsAre(import),
                             ElementsAre(Eq(objectType)),
                             UnorderedElementsAre(qmlDirPathSourceId, qmltypesPathSourceId),
                             UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 21, 421),
@@ -366,8 +360,7 @@ TEST_F(ProjectStorageUpdater, SynchronizeQmlTypesAreEmptyIfFileDoesNotChanged)
     ON_CALL(fileSystemMock, fileStatus(Eq(qmlDirPathSourceId)))
         .WillByDefault(Return(FileStatus{qmlDirPathSourceId, 2, 421}));
 
-    EXPECT_CALL(projectStorageMock,
-                synchronize(IsEmpty(), IsEmpty(), IsEmpty(), IsEmpty(), IsEmpty()));
+    EXPECT_CALL(projectStorageMock, synchronize(IsEmpty(), IsEmpty(), IsEmpty(), IsEmpty()));
 
     updater.update();
 }
@@ -414,39 +407,36 @@ TEST_F(ProjectStorageUpdater, SynchronizeQmlDocuments)
                    "First.2.qml\nSecondType 2.1 OldSecond.qml\nSecondType 2.2 Second.qml\n"};
     ON_CALL(fileSystemMock, contentAsQString(Eq(QString("/path/qmldir")))).WillByDefault(Return(qmldir));
 
-    EXPECT_CALL(projectStorageMock,
-                synchronize(ElementsAre(IsModule("Example", qmlDirPathSourceId)),
-                            UnorderedElementsAre(import1, import2, import3),
-                            UnorderedElementsAre(
-                                AllOf(IsStorageType(exampleModuleId,
-                                                    "First.qml",
-                                                    Storage::ImportedType{"Object"},
-                                                    TypeAccessSemantics::Reference,
-                                                    qmlDocumentSourceId1),
-                                      Field(&Storage::Type::exportedTypes,
-                                            ElementsAre(IsExportedType("FirstType", 1, 0)))),
-                                AllOf(IsStorageType(exampleModuleId,
-                                                    "First.2.qml",
-                                                    Storage::ImportedType{"Object2"},
-                                                    TypeAccessSemantics::Reference,
-                                                    qmlDocumentSourceId2),
-                                      Field(&Storage::Type::exportedTypes,
-                                            ElementsAre(IsExportedType("FirstType", 2, 2)))),
-                                AllOf(IsStorageType(exampleModuleId,
-                                                    "Second.qml",
-                                                    Storage::ImportedType{"Object3"},
-                                                    TypeAccessSemantics::Reference,
-                                                    qmlDocumentSourceId3),
-                                      Field(&Storage::Type::exportedTypes,
-                                            ElementsAre(IsExportedType("SecondType", 2, 2))))),
-                            UnorderedElementsAre(qmlDirPathSourceId,
-                                                 qmlDocumentSourceId1,
-                                                 qmlDocumentSourceId2,
-                                                 qmlDocumentSourceId3),
-                            UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 21, 421),
-                                                 IsFileStatus(qmlDocumentSourceId1, 22, 12),
-                                                 IsFileStatus(qmlDocumentSourceId2, 22, 13),
-                                                 IsFileStatus(qmlDocumentSourceId3, 22, 14))));
+    EXPECT_CALL(
+        projectStorageMock,
+        synchronize(UnorderedElementsAre(import1, import2, import3),
+                    UnorderedElementsAre(
+                        AllOf(IsStorageType("First.qml",
+                                            Storage::ImportedType{"Object"},
+                                            TypeAccessSemantics::Reference,
+                                            qmlDocumentSourceId1),
+                              Field(&Storage::Type::exportedTypes,
+                                    ElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0)))),
+                        AllOf(IsStorageType("First.2.qml",
+                                            Storage::ImportedType{"Object2"},
+                                            TypeAccessSemantics::Reference,
+                                            qmlDocumentSourceId2),
+                              Field(&Storage::Type::exportedTypes,
+                                    ElementsAre(IsExportedType(exampleModuleId, "FirstType", 2, 2)))),
+                        AllOf(IsStorageType("Second.qml",
+                                            Storage::ImportedType{"Object3"},
+                                            TypeAccessSemantics::Reference,
+                                            qmlDocumentSourceId3),
+                              Field(&Storage::Type::exportedTypes,
+                                    ElementsAre(IsExportedType(exampleModuleId, "SecondType", 2, 2))))),
+                    UnorderedElementsAre(qmlDirPathSourceId,
+                                         qmlDocumentSourceId1,
+                                         qmlDocumentSourceId2,
+                                         qmlDocumentSourceId3),
+                    UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 21, 421),
+                                         IsFileStatus(qmlDocumentSourceId1, 22, 12),
+                                         IsFileStatus(qmlDocumentSourceId2, 22, 13),
+                                         IsFileStatus(qmlDocumentSourceId3, 22, 14))));
 
     updater.update();
 }
@@ -461,22 +451,20 @@ TEST_F(ProjectStorageUpdater, SynchronizeQmlDocumentsDontUpdateIfUpToDate)
 
     EXPECT_CALL(
         projectStorageMock,
-        synchronize(ElementsAre(IsModule("Example", qmlDirPathSourceId)),
-                    UnorderedElementsAre(import1, import2),
-                    UnorderedElementsAre(AllOf(IsStorageType(exampleModuleId,
-                                                             "First.qml",
-                                                             Storage::ImportedType{"Object"},
-                                                             TypeAccessSemantics::Reference,
-                                                             qmlDocumentSourceId1),
-                                               Field(&Storage::Type::exportedTypes,
-                                                     ElementsAre(IsExportedType("FirstType", 1, 0)))),
-                                         AllOf(IsStorageType(exampleModuleId,
-                                                             "First.2.qml",
-                                                             Storage::ImportedType{"Object2"},
-                                                             TypeAccessSemantics::Reference,
-                                                             qmlDocumentSourceId2),
-                                               Field(&Storage::Type::exportedTypes,
-                                                     ElementsAre(IsExportedType("FirstType", 2, 2))))),
+        synchronize(UnorderedElementsAre(import1, import2),
+                    UnorderedElementsAre(
+                        AllOf(IsStorageType("First.qml",
+                                            Storage::ImportedType{"Object"},
+                                            TypeAccessSemantics::Reference,
+                                            qmlDocumentSourceId1),
+                              Field(&Storage::Type::exportedTypes,
+                                    ElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0)))),
+                        AllOf(IsStorageType("First.2.qml",
+                                            Storage::ImportedType{"Object2"},
+                                            TypeAccessSemantics::Reference,
+                                            qmlDocumentSourceId2),
+                              Field(&Storage::Type::exportedTypes,
+                                    ElementsAre(IsExportedType(exampleModuleId, "FirstType", 2, 2))))),
                     UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId1, qmlDocumentSourceId2),
                     UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 21, 421),
                                          IsFileStatus(qmlDocumentSourceId1, 22, 12),
@@ -485,31 +473,6 @@ TEST_F(ProjectStorageUpdater, SynchronizeQmlDocumentsDontUpdateIfUpToDate)
     updater.update();
 }
 
-TEST_F(ProjectStorageUpdater, SynchronizeModules)
-{
-    SourceId qmlDirPathSourceId2 = sourcePathCache.sourceId("/path2/qmldir");
-    ON_CALL(fileSystemMock, fileStatus(Eq(qmlDirPathSourceId2)))
-        .WillByDefault(Return(FileStatus{qmlDirPathSourceId2, 22, 423}));
-    ON_CALL(projectStorageMock, fetchFileStatus(Eq(qmlDirPathSourceId2)))
-        .WillByDefault(Return(FileStatus{qmlDirPathSourceId2, 2, 421}));
-    QString qmldir2{"module Example2\n"};
-    ON_CALL(projectManagerMock, qtQmlDirs())
-        .WillByDefault(Return(QStringList{"/path/qmldir", "/path2/qmldir"}));
-    ON_CALL(fileSystemMock, contentAsQString(Eq(QString("/path2/qmldir")))).WillByDefault(Return(qmldir2));
-
-    EXPECT_CALL(projectStorageMock,
-                synchronize(UnorderedElementsAre(IsModule("Example", qmlDirPathSourceId),
-                                                 IsModule("Example2", qmlDirPathSourceId2)),
-                            _,
-                            _,
-                            _,
-                            UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 21, 421),
-                                                 IsFileStatus(qmltypesPathSourceId, 21, 421),
-                                                 IsFileStatus(qmlDirPathSourceId2, 22, 423))));
-
-    updater.update();
-}
-
 TEST_F(ProjectStorageUpdater, UpdateQmldirDocuments)
 {
     QString qmldir{"module Example\nFirstType 1.1 First.qml\nFirstType 2.2 "
diff --git a/tests/unit/unittest/qmldocumentparser-test.cpp b/tests/unit/unittest/qmldocumentparser-test.cpp
index 4cadf8253d..451003ba33 100644
--- a/tests/unit/unittest/qmldocumentparser-test.cpp
+++ b/tests/unit/unittest/qmldocumentparser-test.cpp
@@ -129,7 +129,7 @@ protected:
     QmlDesigner::ProjectStorage<Sqlite::Database> storage{database, database.isInitialized()};
     QmlDesigner::SourcePathCache<QmlDesigner::ProjectStorage<Sqlite::Database>> sourcePathCache{
         storage};
-    QmlDesigner::QmlDocumentParser parser{sourcePathCache};
+    QmlDesigner::QmlDocumentParser parser{sourcePathCache, storage};
     Storage::Imports imports;
     SourceId qmlFileSourceId{sourcePathCache.sourceId("path/to/qmlfile.qml")};
     SourceContextId qmlFileSourceContextId{sourcePathCache.sourceContextId(qmlFileSourceId)};
@@ -146,6 +146,7 @@ TEST_F(QmlDocumentParser, Prototype)
 
 TEST_F(QmlDocumentParser, DISABLED_QualifiedPrototype)
 {
+    auto exampleModuleId = storage.moduleId("Example");
     auto type = parser.parse("import Example as Example\n Example.Item{}",
                              imports,
                              qmlFileSourceId,
@@ -153,7 +154,7 @@ TEST_F(QmlDocumentParser, DISABLED_QualifiedPrototype)
 
     ASSERT_THAT(type,
                 HasPrototype(Storage::QualifiedImportedType(
-                    "Item", Storage::Import{"Example", Storage::Version{}, qmlFileSourceId})));
+                    "Item", Storage::Import{exampleModuleId, Storage::Version{}, qmlFileSourceId})));
 }
 
 TEST_F(QmlDocumentParser, Properties)
@@ -171,7 +172,10 @@ TEST_F(QmlDocumentParser, Properties)
 
 TEST_F(QmlDocumentParser, DISABLED_Imports)
 {
-    ModuleId fooDirectoryModuleId{&sourcePathCache.sourceId("path/to/foo/.")};
+    ModuleId fooDirectoryModuleId = storage.moduleId("path/to/foo/.");
+    ModuleId qmlModuleId = storage.moduleId("QML");
+    ModuleId qtQmlModuleId = storage.moduleId("QtQml");
+    ModuleId qtQuickModuleId = storage.moduleId("QtQuick");
     auto type = parser.parse("import QtQuick\n import \"../foo\"\nExample{}",
                              imports,
                              qmlFileSourceId,
@@ -179,11 +183,11 @@ TEST_F(QmlDocumentParser, DISABLED_Imports)
 
     ASSERT_THAT(imports,
                 UnorderedElementsAre(
-                    Storage::Import{Storage::Version{}, directoryModuleId, qmlFileSourceId},
-                    Storage::Import{Storage::Version{}, fooDirectoryModuleId, qmlFileSourceId},
-                    Storage::Import{"QML", Storage::Version{1, 0}, qmlFileSourceId},
-                    Storage::Import{"QtQml", Storage::Version{6, 0}, qmlFileSourceId},
-                    Storage::Import{"QtQuick", Storage::Version{}, qmlFileSourceId}));
+                    Storage::Import{directoryModuleId, Storage::Version{}, qmlFileSourceId},
+                    Storage::Import{fooDirectoryModuleId, Storage::Version{}, qmlFileSourceId},
+                    Storage::Import{qmlModuleId, Storage::Version{1, 0}, qmlFileSourceId},
+                    Storage::Import{qtQmlModuleId, Storage::Version{6, 0}, qmlFileSourceId},
+                    Storage::Import{qtQuickModuleId, Storage::Version{}, qmlFileSourceId}));
 }
 
 TEST_F(QmlDocumentParser, Functions)
diff --git a/tests/unit/unittest/qmltypesparser-test.cpp b/tests/unit/unittest/qmltypesparser-test.cpp
index fcd182b920..8fd4263d22 100644
--- a/tests/unit/unittest/qmltypesparser-test.cpp
+++ b/tests/unit/unittest/qmltypesparser-test.cpp
@@ -39,18 +39,16 @@ using QmlDesigner::ModuleId;
 using QmlDesigner::SourceContextId;
 using QmlDesigner::SourceId;
 
-MATCHER_P4(IsImport,
-           name,
+MATCHER_P3(IsImport,
+           moduleId,
            version,
            sourceId,
-           kind,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::Import{name, version, sourceId, kind}))
+               + PrintToString(Storage::Import{moduleId, version, sourceId}))
 {
     const Storage::Import &import = arg;
 
-    return import.name == name && import.version == version && import.sourceId == sourceId
-           && import.kind == kind;
+    return import.moduleId == moduleId && import.version == version && import.sourceId == sourceId;
 }
 
 MATCHER_P(HasPrototype, prototype, std::string(negation ? "isn't " : "is ") + PrintToString(prototype))
@@ -60,19 +58,17 @@ MATCHER_P(HasPrototype, prototype, std::string(negation ? "isn't " : "is ") + Pr
     return Storage::ImportedTypeName{prototype} == type.prototype;
 }
 
-MATCHER_P5(IsType,
-           moduleId,
+MATCHER_P4(IsType,
            typeName,
            prototype,
            accessSemantics,
            sourceId,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::Type{moduleId, typeName, prototype, accessSemantics, sourceId}))
+               + PrintToString(Storage::Type{typeName, prototype, accessSemantics, sourceId}))
 {
     const Storage::Type &type = arg;
 
-    return type.moduleId == moduleId && type.typeName == typeName
-           && type.prototype == Storage::ImportedTypeName{prototype}
+    return type.typeName == typeName && type.prototype == Storage::ImportedTypeName{prototype}
            && type.accessSemantics == accessSemantics && type.sourceId == sourceId;
 }
 
@@ -173,13 +169,12 @@ protected:
     QmlDesigner::ProjectStorage<Sqlite::Database> storage{database, database.isInitialized()};
     QmlDesigner::SourcePathCache<QmlDesigner::ProjectStorage<Sqlite::Database>> sourcePathCache{
         storage};
-    QmlDesigner::QmlTypesParser parser{sourcePathCache};
+    QmlDesigner::QmlTypesParser parser{sourcePathCache, storage};
     Storage::Imports imports;
     Storage::Types types;
     SourceId qmltypesFileSourceId{sourcePathCache.sourceId("path/to/types.qmltypes")};
     SourceContextId qmltypesFileSourceContextId{sourcePathCache.sourceContextId(qmltypesFileSourceId)};
-    SourceId directorySourceId{sourcePathCache.sourceId("path/to/.")};
-    ModuleId directoryModuleId{&directorySourceId};
+    ModuleId directoryModuleId{storage.moduleId("path/to/")};
 };
 
 TEST_F(QmlTypesParser, Imports)
@@ -191,27 +186,20 @@ TEST_F(QmlTypesParser, Imports)
 
     parser.parse(source, imports, types, qmltypesFileSourceId, directoryModuleId);
 
-    ASSERT_THAT(imports,
-                UnorderedElementsAre(IsImport("QtQuick",
-                                              Storage::Version{2, 15},
-                                              qmltypesFileSourceId,
-                                              Storage::ImportKind::QmlTypesDependency),
-                                     IsImport("QtQuick.Window",
-                                              Storage::Version{2, 1},
-                                              qmltypesFileSourceId,
-                                              Storage::ImportKind::QmlTypesDependency),
-                                     IsImport("QML",
-                                              Storage::Version{},
-                                              qmltypesFileSourceId,
-                                              Storage::ImportKind::QmlTypesDependency),
-                                     IsImport("QtQml",
-                                              Storage::Version{},
-                                              qmltypesFileSourceId,
-                                              Storage::ImportKind::QmlTypesDependency),
-                                     IsImport("QtFoo",
-                                              Storage::Version{6},
-                                              qmltypesFileSourceId,
-                                              Storage::ImportKind::QmlTypesDependency)));
+    ASSERT_THAT(
+        imports,
+        UnorderedElementsAre(
+            IsImport(storage.moduleId("QML"), Storage::Version{}, qmltypesFileSourceId),
+            IsImport(storage.moduleId("QtQml"), Storage::Version{}, qmltypesFileSourceId),
+            IsImport(storage.moduleId("QtQml-cppnative"), Storage::Version{}, qmltypesFileSourceId),
+            IsImport(storage.moduleId("QtQuick"), Storage::Version{2, 15}, qmltypesFileSourceId),
+            IsImport(storage.moduleId("QtQuick-cppnative"), Storage::Version{2, 15}, qmltypesFileSourceId),
+            IsImport(storage.moduleId("QtQuick.Window"), Storage::Version{2, 1}, qmltypesFileSourceId),
+            IsImport(storage.moduleId("QtQuick.Window-cppnative"),
+                     Storage::Version{2, 1},
+                     qmltypesFileSourceId),
+            IsImport(storage.moduleId("QtFoo"), Storage::Version{6}, qmltypesFileSourceId),
+            IsImport(storage.moduleId("QtFoo-cppnative"), Storage::Version{6}, qmltypesFileSourceId)));
 }
 
 TEST_F(QmlTypesParser, Types)
@@ -225,13 +213,11 @@ TEST_F(QmlTypesParser, Types)
     parser.parse(source, imports, types, qmltypesFileSourceId, directoryModuleId);
 
     ASSERT_THAT(types,
-                UnorderedElementsAre(IsType(directoryModuleId,
-                                            "QObject",
+                UnorderedElementsAre(IsType("QObject",
                                             Storage::NativeType{},
                                             Storage::TypeAccessSemantics::Reference,
                                             qmltypesFileSourceId),
-                                     IsType(directoryModuleId,
-                                            "QQmlComponent",
+                                     IsType("QQmlComponent",
                                             Storage::NativeType{"QObject"},
                                             Storage::TypeAccessSemantics::Reference,
                                             qmltypesFileSourceId)));