QmlDesigner: Move Version to different namespace

We want to use it not only for synchronization.

Task-number: QDS-9766
Change-Id: I26a2ade8203d9c5131e8dec101885434713f8252
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>

13 files changed, 456 insertions, 442 deletions

diff --git a/src/plugins/qmldesigner/designercore/model/model.cpp b/src/plugins/qmldesigner/designercore/model/model.cpp
index d410a3c87a..c1d6c07863 100644
--- a/src/plugins/qmldesigner/designercore/model/model.cpp
+++ b/src/plugins/qmldesigner/designercore/model/model.cpp
@@ -2084,8 +2084,7 @@ NodeMetaInfo Model::metaInfo(const TypeName &typeName, int majorVersion, int min
         ModuleId moduleId = d->projectStorage->moduleId(module);
         TypeId typeId = d->projectStorage->typeId(moduleId,
                                                   componentName,
-                                                  Storage::Synchronization::Version{majorVersion,
-                                                                                    minorVersion});
+                                                  Storage::Version{majorVersion, minorVersion});
         return NodeMetaInfo(typeId, d->projectStorage);
     } else {
         return NodeMetaInfo(metaInfoProxyModel(), typeName, majorVersion, minorVersion);
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/commontypecache.h b/src/plugins/qmldesigner/designercore/projectstorage/commontypecache.h
index eda1daba5f..d60dfa3abc 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/commontypecache.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/commontypecache.h
@@ -250,9 +250,7 @@ public:
         if (!type.moduleId)
             type.moduleId = m_projectStorage.moduleId(moduleName);
 
-        type.typeId = m_projectStorage.typeId(type.moduleId,
-                                              typeName,
-                                              QmlDesigner::Storage::Synchronization::Version{});
+        type.typeId = m_projectStorage.typeId(type.moduleId, typeName, QmlDesigner::Storage::Version{});
 
         return type.typeId;
     }
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
index a036653f4f..3ebe87da76 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
@@ -119,7 +119,7 @@ public:
 
     TypeId typeId(ModuleId moduleId,
                   Utils::SmallStringView exportedTypeName,
-                  Storage::Synchronization::Version version) const
+                  Storage::Version version) const
     {
         if (version.minor)
             return selectTypeIdByModuleIdAndExportedNameAndVersionStatement
@@ -1533,7 +1533,7 @@ private:
                                 ModuleExportedImportId moduleExportedImportId) {
                 Storage::Synchronization::Import additionImport{
                     exportedModuleId,
-                    Storage::Synchronization::Version{majorVersion, minorVersion},
+                    Storage::Version{majorVersion, minorVersion},
                     import.sourceId};
 
                 auto exportedImportKind = importKind == Storage::Synchronization::ImportKind::Import
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h
index f26ec622ca..8337289378 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h
@@ -13,11 +13,7 @@
 #include <variant>
 #include <vector>
 
-namespace QmlDesigner::Storage::Synchronization {
-
-enum class TypeNameKind { Exported = 1, QualifiedExported = 2 };
-
-enum class FileType : char { QmlTypes, QmlDocument };
+namespace QmlDesigner::Storage {
 
 class VersionNumber
 {
@@ -83,6 +79,12 @@ public:
     VersionNumber minor;
 };
 
+namespace Synchronization {
+
+enum class TypeNameKind { Exported = 1, QualifiedExported = 2 };
+
+enum class FileType : char { QmlTypes, QmlDocument };
+
 enum class IsQualified : int { No, Yes };
 
 inline int operator-(IsQualified first, IsQualified second)
@@ -107,7 +109,7 @@ class Import
 public:
     explicit Import() = default;
 
-    explicit Import(ModuleId moduleId, Version version, SourceId sourceId)
+    explicit Import(ModuleId moduleId, Storage::Version version, SourceId sourceId)
         : version{version}
         , moduleId{moduleId}
         , sourceId{sourceId}
@@ -132,7 +134,7 @@ public:
     }
 
 public:
-    Version version;
+    Storage::Version version;
     ModuleId moduleId;
     SourceId sourceId;
 };
@@ -162,7 +164,7 @@ public:
     ImportId importId;
     SourceId sourceId;
     ModuleId moduleId;
-    Version version;
+    Storage::Version version;
 };
 
 enum class IsAutoVersion : char { No, Yes };
@@ -177,7 +179,7 @@ class ModuleExportedImport
 public:
     explicit ModuleExportedImport(ModuleId moduleId,
                                   ModuleId exportedModuleId,
-                                  Version version,
+                                  Storage::Version version,
                                   IsAutoVersion isAutoVersion)
         : version{version}
         , moduleId{moduleId}
@@ -199,7 +201,7 @@ public:
     }
 
 public:
-    Version version;
+    Storage::Version version;
     ModuleId moduleId;
     ModuleId exportedModuleId;
     IsAutoVersion isAutoVersion = IsAutoVersion::No;
@@ -234,7 +236,7 @@ public:
 
 public:
     ModuleExportedImportId moduleExportedImportId;
-    Version version;
+    Storage::Version version;
     ModuleId moduleId;
     ModuleId exportedModuleId;
     IsAutoVersion isAutoVersion = IsAutoVersion::No;
@@ -282,18 +284,23 @@ class ExportedType
 {
 public:
     explicit ExportedType() = default;
-    explicit ExportedType(::Utils::SmallStringView name, Version version = Version{})
+    explicit ExportedType(::Utils::SmallStringView name, Storage::Version version = Storage::Version{})
         : name{name}
         , version{version}
     {}
 
-    explicit ExportedType(ModuleId moduleId, ::Utils::SmallStringView name, Version version = Version{})
+    explicit ExportedType(ModuleId moduleId,
+                          ::Utils::SmallStringView name,
+                          Storage::Version version = Storage::Version{})
         : name{name}
         , version{version}
         , moduleId{moduleId}
     {}
 
-    explicit ExportedType(::Utils::SmallStringView name, Version version, TypeId typeId, ModuleId moduleId)
+    explicit ExportedType(::Utils::SmallStringView name,
+                          Storage::Version version,
+                          TypeId typeId,
+                          ModuleId moduleId)
         : name{name}
         , version{version}
         , typeId{typeId}
@@ -322,7 +329,7 @@ public:
 
 public:
     ::Utils::SmallString name;
-    Version version;
+    Storage::Version version;
     TypeId typeId;
     ModuleId moduleId;
 };
@@ -333,7 +340,7 @@ class ExportedTypeView
 {
 public:
     explicit ExportedTypeView() = default;
-    explicit ExportedTypeView(ModuleId moduleId, ::Utils::SmallStringView name, Version version)
+    explicit ExportedTypeView(ModuleId moduleId, ::Utils::SmallStringView name, Storage::Version version)
         : name{name}
         , version{version}
         , moduleId{moduleId}
@@ -353,7 +360,7 @@ public:
 
 public:
     ::Utils::SmallStringView name;
-    Version version;
+    Storage::Version version;
     TypeId typeId;
     ModuleId moduleId;
     ExportedTypeNameId exportedTypeNameId;
@@ -858,5 +865,5 @@ public:
     ModuleIds updatedModuleIds;
 };
 
-} // namespace QmlDesigner::Storage::Synchronization
-
+} // namespace Synchronization
+} // namespace QmlDesigner::Storage
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.cpp b/src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.cpp
index a02a9c47aa..4713dd0136 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.cpp
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.cpp
@@ -113,9 +113,9 @@ void addSourceIds(SourceIds &sourceIds, const Storage::Synchronization::ProjectD
         sourceIds.push_back(projectData.sourceId);
 }
 
-Storage::Synchronization::Version convertVersion(LanguageUtils::ComponentVersion version)
+Storage::Version convertVersion(LanguageUtils::ComponentVersion version)
 {
-    return Storage::Synchronization::Version{version.majorVersion(), version.minorVersion()};
+    return Storage::Version{version.majorVersion(), version.minorVersion()};
 }
 
 Storage::Synchronization::IsAutoVersion convertToIsAutoVersion(QmlDirParser::Import::Flags flags)
@@ -133,7 +133,7 @@ void addDependencies(Storage::Synchronization::Imports &dependencies,
     for (const QmlDirParser::Import &qmldirDependency : qmldirDependencies) {
         ModuleId moduleId = projectStorage.moduleId(Utils::PathString{qmldirDependency.module}
                                                     + "-cppnative");
-        dependencies.emplace_back(moduleId, Storage::Synchronization::Version{}, sourceId);
+        dependencies.emplace_back(moduleId, Storage::Version{}, sourceId);
     }
 }
 
@@ -154,7 +154,7 @@ void addModuleExportedImports(Storage::Synchronization::ModuleExportedImports &i
             Utils::PathString{qmldirImport.module} + "-cppnative");
         imports.emplace_back(cppModuleId,
                              exportedCppModuleId,
-                             Storage::Synchronization::Version{},
+                             Storage::Version{},
                              Storage::Synchronization::IsAutoVersion::No);
     }
 }
@@ -644,8 +644,7 @@ Storage::Synchronization::ExportedTypes createExportedTypes(ProjectStorageUpdate
     for (const ProjectStorageUpdater::Component &component : components) {
         exportedTypes.emplace_back(component.moduleId,
                                    Utils::SmallString{component.typeName},
-                                   Storage::Synchronization::Version{component.majorVersion,
-                                                                     component.minorVersion});
+                                   Storage::Version{component.majorVersion, component.minorVersion});
     }
 
     return exportedTypes;
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/qmldocumentparser.cpp b/src/plugins/qmldesigner/designercore/projectstorage/qmldocumentparser.cpp
index 894299e795..b530dc84e3 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/qmldocumentparser.cpp
+++ b/src/plugins/qmldesigner/designercore/projectstorage/qmldocumentparser.cpp
@@ -32,9 +32,9 @@ int convertVersionNumber(qint32 versionNumber)
     return versionNumber < 0 ? -1 : versionNumber;
 }
 
-Storage::Synchronization::Version convertVersion(QmlDom::Version version)
+Storage::Version convertVersion(QmlDom::Version version)
 {
-    return Storage::Synchronization::Version{convertVersionNumber(version.majorVersion),
+    return Storage::Version{convertVersionNumber(version.majorVersion),
                                              convertVersionNumber(version.minorVersion)};
 }
 
@@ -66,7 +66,7 @@ Storage::Synchronization::Import createImport(const QmlDom::Import &qmlImport,
     if (uri.kind() == QmlUriKind::RelativePath) {
         auto path = createNormalizedPath(directoryPath, uri.localPath());
         auto moduleId = storage.moduleId(createNormalizedPath(directoryPath, uri.localPath()));
-        return Storage::Synchronization::Import(moduleId, Storage::Synchronization::Version{}, sourceId);
+        return Storage::Synchronization::Import(moduleId, Storage::Version{}, sourceId);
     }
 
     if (uri.kind() == QmlUriKind::ModuleUri) {
@@ -109,11 +109,11 @@ void addImports(Storage::Synchronization::Imports &imports,
     }
 
     auto localDirectoryModuleId = storage.moduleId(directoryPath);
-    imports.emplace_back(localDirectoryModuleId, Storage::Synchronization::Version{}, sourceId);
+    imports.emplace_back(localDirectoryModuleId, Storage::Version{}, sourceId);
     ++importCount;
 
     auto qmlModuleId = storage.moduleId("QML");
-    imports.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId);
+    imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId);
     ++importCount;
 
     auto end = imports.end();
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/qmltypesparser.cpp b/src/plugins/qmldesigner/designercore/projectstorage/qmltypesparser.cpp
index aebe57a14b..46613b015a 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/qmltypesparser.cpp
+++ b/src/plugins/qmldesigner/designercore/projectstorage/qmltypesparser.cpp
@@ -62,7 +62,7 @@ void appendImports(Storage::Synchronization::Imports &imports,
     moduleName.append("-cppnative");
     ModuleId cppModuleId = storage.moduleId(moduleName);
 
-    imports.emplace_back(cppModuleId, Storage::Synchronization::Version{}, sourceId);
+    imports.emplace_back(cppModuleId, Storage::Version{}, sourceId);
 }
 
 void addImports(Storage::Synchronization::Imports &imports,
@@ -74,10 +74,10 @@ void addImports(Storage::Synchronization::Imports &imports,
     for (const QString &dependency : dependencies)
         appendImports(imports, dependency, sourceId, storage);
 
-    imports.emplace_back(cppModuleId, Storage::Synchronization::Version{}, sourceId);
+    imports.emplace_back(cppModuleId, Storage::Version{}, sourceId);
 
     if (ModuleId qmlCppModuleId = storage.moduleId("QML-cppnative"); cppModuleId != qmlCppModuleId)
-        imports.emplace_back(qmlCppModuleId, Storage::Synchronization::Version{}, sourceId);
+        imports.emplace_back(qmlCppModuleId, Storage::Version{}, sourceId);
 }
 
 Storage::TypeTraits createTypeTraits(QQmlJSScope::AccessSemantics accessSematics)
@@ -96,9 +96,9 @@ Storage::TypeTraits createTypeTraits(QQmlJSScope::AccessSemantics accessSematics
     return Storage::TypeTraits::None;
 }
 
-Storage::Synchronization::Version createVersion(QTypeRevision qmlVersion)
+Storage::Version createVersion(QTypeRevision qmlVersion)
 {
-    return Storage::Synchronization::Version{qmlVersion.majorVersion(), qmlVersion.minorVersion()};
+    return Storage::Version{qmlVersion.majorVersion(), qmlVersion.minorVersion()};
 }
 
 Storage::Synchronization::ExportedTypes createExports(const QList<QQmlJSScope::Export> &qmlExports,
diff --git a/tests/unit/unittest/gtest-creator-printing.cpp b/tests/unit/unittest/gtest-creator-printing.cpp
index 3dbba3f50d..cd69504461 100644
--- a/tests/unit/unittest/gtest-creator-printing.cpp
+++ b/tests/unit/unittest/gtest-creator-printing.cpp
@@ -583,6 +583,17 @@ std::ostream &operator<<(std::ostream &out, PropertyDeclarationTraits traits)
 
     return out << ")";
 }
+
+std::ostream &operator<<(std::ostream &out, VersionNumber versionNumber)
+{
+    return out << versionNumber.value;
+}
+
+std::ostream &operator<<(std::ostream &out, Version version)
+{
+    return out << "(" << version.major << ", " << version.minor << ")";
+}
+
 } // namespace Storage
 
 namespace Storage::Info {
@@ -703,16 +714,6 @@ std::ostream &operator<<(std::ostream &out, IsQualified isQualified)
     return out << isQualifiedToString(isQualified);
 }
 
-std::ostream &operator<<(std::ostream &out, VersionNumber versionNumber)
-{
-    return out << versionNumber.value;
-}
-
-std::ostream &operator<<(std::ostream &out, Version version)
-{
-    return out << "(" << version.major << ", " << version.minor << ")";
-}
-
 std::ostream &operator<<(std::ostream &out, const ExportedType &exportedType)
 {
     return out << "(\"" << exportedType.name << "\"," << exportedType.moduleId << ", "
diff --git a/tests/unit/unittest/gtest-creator-printing.h b/tests/unit/unittest/gtest-creator-printing.h
index 5aad4c40c3..f63cec1f28 100644
--- a/tests/unit/unittest/gtest-creator-printing.h
+++ b/tests/unit/unittest/gtest-creator-printing.h
@@ -160,10 +160,13 @@ std::ostream &operator<<(std::ostream &out, TypeTraits traits);
 namespace Storage::Info {
 class ProjectDeclaration;
 class Type;
+class Version;
+class VersionNumber;
 
 std::ostream &operator<<(std::ostream &out, const ProjectDeclaration &declaration);
 std::ostream &operator<<(std::ostream &out, const Type &type);
-
+std::ostream &operator<<(std::ostream &out, VersionNumber versionNumber);
+std::ostream &operator<<(std::ostream &out, Version version);
 } // namespace Storage::Info
 
 namespace Storage::Synchronization {
@@ -171,8 +174,6 @@ class Type;
 class ExportedType;
 class ImportedType;
 class QualifiedImportedType;
-class Version;
-class VersionNumber;
 class PropertyDeclaration;
 class FunctionDeclaration;
 class ParameterDeclaration;
@@ -189,8 +190,6 @@ enum class FileType : char;
 enum class ChangeLevel : char;
 class ModuleExportedImport;
 
-std::ostream &operator<<(std::ostream &out, VersionNumber versionNumber);
-std::ostream &operator<<(std::ostream &out, Version version);
 std::ostream &operator<<(std::ostream &out, const Type &type);
 std::ostream &operator<<(std::ostream &out, const ExportedType &exportedType);
 std::ostream &operator<<(std::ostream &out, const ImportedType &importedType);
diff --git a/tests/unit/unittest/projectstorage-test.cpp b/tests/unit/unittest/projectstorage-test.cpp
index a11b804a5a..7ff1df47c9 100644
--- a/tests/unit/unittest/projectstorage-test.cpp
+++ b/tests/unit/unittest/projectstorage-test.cpp
@@ -122,12 +122,12 @@ MATCHER_P3(IsExportedType,
            minorVersion,
            std::string(negation ? "isn't " : "is ")
                + PrintToString(Storage::Synchronization::ExportedType{
-                   name, Storage::Synchronization::Version{majorVersion, minorVersion}}))
+                   name, Storage::Version{majorVersion, minorVersion}}))
 {
     const Storage::Synchronization::ExportedType &type = arg;
 
     return type.name == name
-           && type.version == Storage::Synchronization::Version{majorVersion, minorVersion};
+           && type.version == Storage::Version{majorVersion, minorVersion};
 }
 
 MATCHER_P4(IsExportedType,
@@ -137,12 +137,12 @@ MATCHER_P4(IsExportedType,
            minorVersion,
            std::string(negation ? "isn't " : "is ")
                + PrintToString(Storage::Synchronization::ExportedType{
-                   moduleId, name, Storage::Synchronization::Version{majorVersion, minorVersion}}))
+                   moduleId, name, Storage::Version{majorVersion, minorVersion}}))
 {
     const Storage::Synchronization::ExportedType &type = arg;
 
     return type.moduleId == moduleId && type.name == name
-           && type.version == Storage::Synchronization::Version{majorVersion, minorVersion};
+           && type.version == Storage::Version{majorVersion, minorVersion};
 }
 
 MATCHER_P3(
@@ -284,33 +284,33 @@ protected:
     {
         SynchronizationPackage package;
 
-        package.imports.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId1);
-        package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId1);
-        package.imports.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId2);
+        package.imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId1);
+        package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId1);
+        package.imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId2);
         package.moduleDependencies.emplace_back(qmlNativeModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId1);
         package.moduleDependencies.emplace_back(qtQuickNativeModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId1);
         package.moduleDependencies.emplace_back(qmlNativeModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId2);
         package.updatedModuleDependencySourceIds.push_back(sourceId1);
         package.updatedModuleDependencySourceIds.push_back(sourceId2);
 
-        importsSourceId1.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId1);
-        importsSourceId1.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId1);
+        importsSourceId1.emplace_back(qmlModuleId, Storage::Version{}, sourceId1);
+        importsSourceId1.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId1);
         moduleDependenciesSourceId1.emplace_back(qmlNativeModuleId,
-                                                 Storage::Synchronization::Version{},
+                                                 Storage::Version{},
                                                  sourceId1);
         moduleDependenciesSourceId1.emplace_back(qtQuickNativeModuleId,
-                                                 Storage::Synchronization::Version{},
+                                                 Storage::Version{},
                                                  sourceId1);
 
-        importsSourceId2.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId2);
+        importsSourceId2.emplace_back(qmlModuleId, Storage::Version{}, sourceId2);
         moduleDependenciesSourceId2.emplace_back(qmlNativeModuleId,
-                                                 Storage::Synchronization::Version{},
+                                                 Storage::Version{},
                                                  sourceId2);
 
         package.types.push_back(Storage::Synchronization::Type{
@@ -365,10 +365,10 @@ protected:
             sourceId2,
             {Storage::Synchronization::ExportedType{qmlModuleId,
                                                     "Object",
-                                                    Storage::Synchronization::Version{2}},
+                                                    Storage::Version{2}},
              Storage::Synchronization::ExportedType{qmlModuleId,
                                                     "Obj",
-                                                    Storage::Synchronization::Version{2}},
+                                                    Storage::Version{2}},
              Storage::Synchronization::ExportedType{qmlNativeModuleId, "QObject"}}});
 
         package.updatedSourceIds = {sourceId1, sourceId2};
@@ -380,15 +380,15 @@ protected:
     {
         SynchronizationPackage package;
 
-        package.imports.emplace_back(QMLModuleId, Storage::Synchronization::Version{}, sourceId1);
+        package.imports.emplace_back(QMLModuleId, Storage::Version{}, sourceId1);
         package.moduleDependencies.emplace_back(QMLModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId1);
         package.updatedModuleDependencySourceIds.push_back(sourceId1);
 
-        importsSourceId1.emplace_back(QMLModuleId, Storage::Synchronization::Version{}, sourceId1);
+        importsSourceId1.emplace_back(QMLModuleId, Storage::Version{}, sourceId1);
         moduleDependenciesSourceId1.emplace_back(QMLModuleId,
-                                                 Storage::Synchronization::Version{},
+                                                 Storage::Version{},
                                                  sourceId1);
 
         package.types.push_back(
@@ -417,36 +417,36 @@ protected:
     {
         auto package{createSimpleSynchronizationPackage()};
 
-        package.imports.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId3);
-        package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
+        package.imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId3);
+        package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
         package.moduleDependencies.emplace_back(qmlNativeModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId3);
         package.moduleDependencies.emplace_back(qtQuickNativeModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId3);
         package.updatedModuleDependencySourceIds.push_back(sourceId3);
 
-        package.imports.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId4);
-        package.imports.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId4);
+        package.imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId4);
+        package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId4);
         package.moduleDependencies.emplace_back(qmlNativeModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId4);
         package.updatedModuleDependencySourceIds.push_back(sourceId4);
 
-        importsSourceId3.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId3);
-        importsSourceId3.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
+        importsSourceId3.emplace_back(qmlModuleId, Storage::Version{}, sourceId3);
+        importsSourceId3.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
         moduleDependenciesSourceId3.emplace_back(qmlNativeModuleId,
-                                                 Storage::Synchronization::Version{},
+                                                 Storage::Version{},
                                                  sourceId3);
         moduleDependenciesSourceId3.emplace_back(qtQuickNativeModuleId,
-                                                 Storage::Synchronization::Version{},
+                                                 Storage::Version{},
                                                  sourceId3);
 
-        importsSourceId4.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId4);
-        importsSourceId4.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId4);
+        importsSourceId4.emplace_back(qmlModuleId, Storage::Version{}, sourceId4);
+        importsSourceId4.emplace_back(pathToModuleId, Storage::Version{}, sourceId4);
         moduleDependenciesSourceId4.emplace_back(qmlNativeModuleId,
-                                                 Storage::Synchronization::Version{},
+                                                 Storage::Version{},
                                                  sourceId4);
 
         package.types[1].propertyDeclarations.push_back(
@@ -498,35 +498,35 @@ protected:
     {
         SynchronizationPackage package;
 
-        package.imports.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId1);
-        package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId1);
-        package.imports.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId2);
+        package.imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId1);
+        package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId1);
+        package.imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId2);
 
         package.moduleDependencies.emplace_back(qmlNativeModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId1);
         package.moduleDependencies.emplace_back(qtQuickNativeModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId1);
         package.moduleDependencies.emplace_back(qmlNativeModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId2);
 
         package.updatedModuleDependencySourceIds.push_back(sourceId1);
         package.updatedModuleDependencySourceIds.push_back(sourceId2);
 
-        importsSourceId1.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId1);
-        importsSourceId1.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId1);
+        importsSourceId1.emplace_back(qmlModuleId, Storage::Version{}, sourceId1);
+        importsSourceId1.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId1);
         moduleDependenciesSourceId1.emplace_back(qmlNativeModuleId,
-                                                 Storage::Synchronization::Version{},
+                                                 Storage::Version{},
                                                  sourceId1);
         moduleDependenciesSourceId1.emplace_back(qtQuickNativeModuleId,
-                                                 Storage::Synchronization::Version{},
+                                                 Storage::Version{},
                                                  sourceId1);
 
-        importsSourceId2.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId2);
+        importsSourceId2.emplace_back(qmlModuleId, Storage::Version{}, sourceId2);
         moduleDependenciesSourceId2.emplace_back(qmlNativeModuleId,
-                                                 Storage::Synchronization::Version{},
+                                                 Storage::Version{},
                                                  sourceId2);
 
         package.types.push_back(Storage::Synchronization::Type{
@@ -554,52 +554,52 @@ protected:
             sourceId2,
             {Storage::Synchronization::ExportedType{qmlModuleId,
                                                     "Object",
-                                                    Storage::Synchronization::Version{2}},
+                                                    Storage::Version{2}},
              Storage::Synchronization::ExportedType{qmlModuleId,
                                                     "Obj",
-                                                    Storage::Synchronization::Version{2}},
+                                                    Storage::Version{2}},
              Storage::Synchronization::ExportedType{qmlNativeModuleId, "QObject"}}});
 
         package.updatedSourceIds = {sourceId1, sourceId2};
 
-        package.imports.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId3);
-        package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
+        package.imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId3);
+        package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
         package.moduleDependencies.emplace_back(qmlNativeModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId3);
         package.moduleDependencies.emplace_back(qtQuickNativeModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId3);
         package.updatedModuleDependencySourceIds.push_back(sourceId3);
 
-        package.imports.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId4);
-        package.imports.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId4);
-        package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId4);
+        package.imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId4);
+        package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId4);
+        package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId4);
         package.moduleDependencies.emplace_back(qmlNativeModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId4);
         package.moduleDependencies.emplace_back(qtQuickNativeModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId4);
         package.updatedModuleDependencySourceIds.push_back(sourceId4);
 
-        importsSourceId3.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId3);
-        importsSourceId3.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
+        importsSourceId3.emplace_back(qmlModuleId, Storage::Version{}, sourceId3);
+        importsSourceId3.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
         moduleDependenciesSourceId3.emplace_back(qmlNativeModuleId,
-                                                 Storage::Synchronization::Version{},
+                                                 Storage::Version{},
                                                  sourceId3);
         moduleDependenciesSourceId3.emplace_back(qtQuickNativeModuleId,
-                                                 Storage::Synchronization::Version{},
+                                                 Storage::Version{},
                                                  sourceId3);
 
-        importsSourceId4.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId4);
-        importsSourceId4.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId4);
-        importsSourceId4.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId4);
+        importsSourceId4.emplace_back(qmlModuleId, Storage::Version{}, sourceId4);
+        importsSourceId4.emplace_back(pathToModuleId, Storage::Version{}, sourceId4);
+        importsSourceId4.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId4);
         moduleDependenciesSourceId4.emplace_back(qmlNativeModuleId,
-                                                 Storage::Synchronization::Version{},
+                                                 Storage::Version{},
                                                  sourceId4);
         moduleDependenciesSourceId4.emplace_back(qtQuickNativeModuleId,
-                                                 Storage::Synchronization::Version{},
+                                                 Storage::Version{},
                                                  sourceId4);
 
         package.types[1].propertyDeclarations.push_back(
@@ -646,7 +646,7 @@ protected:
             sourceId5,
             {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                     "Children",
-                                                    Storage::Synchronization::Version{2}},
+                                                    Storage::Version{2}},
              Storage::Synchronization::ExportedType{qtQuickNativeModuleId, "QChildren"}},
             {Storage::Synchronization::PropertyDeclaration{"items",
                                                            Storage::Synchronization::ImportedType{
@@ -658,21 +658,21 @@ protected:
                  Storage::PropertyDeclarationTraits::IsList
                      | Storage::PropertyDeclarationTraits::IsReadOnly}}});
 
-        package.imports.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId5);
-        package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId5);
+        package.imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId5);
+        package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId5);
         package.moduleDependencies.emplace_back(qmlNativeModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId5);
         package.moduleDependencies.emplace_back(qtQuickNativeModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId5);
-        importsSourceId5.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId5);
-        importsSourceId5.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId5);
+        importsSourceId5.emplace_back(qmlModuleId, Storage::Version{}, sourceId5);
+        importsSourceId5.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId5);
         moduleDependenciesSourceId5.emplace_back(qmlNativeModuleId,
-                                                 Storage::Synchronization::Version{},
+                                                 Storage::Version{},
                                                  sourceId5);
         moduleDependenciesSourceId5.emplace_back(qtQuickNativeModuleId,
-                                                 Storage::Synchronization::Version{},
+                                                 Storage::Version{},
                                                  sourceId5);
         package.updatedModuleDependencySourceIds.push_back(sourceId5);
         package.updatedSourceIds.push_back(sourceId5);
@@ -685,7 +685,7 @@ protected:
             sourceId6,
             {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                     "Children2",
-                                                    Storage::Synchronization::Version{2}},
+                                                    Storage::Version{2}},
              Storage::Synchronization::ExportedType{qtQuickNativeModuleId, "QChildren2"}},
             {Storage::Synchronization::PropertyDeclaration{"items",
                                                            Storage::Synchronization::ImportedType{
@@ -697,14 +697,14 @@ protected:
                  Storage::PropertyDeclarationTraits::IsList
                      | Storage::PropertyDeclarationTraits::IsReadOnly}}});
 
-        package.imports.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId6);
-        package.imports.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId6);
-        package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId6);
+        package.imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId6);
+        package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId6);
+        package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId6);
         package.moduleDependencies.emplace_back(qmlNativeModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId6);
         package.moduleDependencies.emplace_back(qtQuickNativeModuleId,
-                                                Storage::Synchronization::Version{},
+                                                Storage::Version{},
                                                 sourceId6);
         package.updatedModuleDependencySourceIds.push_back(sourceId6);
         package.updatedSourceIds.push_back(sourceId6);
@@ -727,8 +727,8 @@ protected:
     {
         auto package{createSynchronizationPackageWithAliases()};
 
-        package.imports.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId5);
-        package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId5);
+        package.imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId5);
+        package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId5);
 
         package.types.push_back(Storage::Synchronization::Type{
             "QAliasItem2",
@@ -769,10 +769,10 @@ protected:
             sourceId1,
             {Storage::Synchronization::ExportedType{qmlModuleId,
                                                     "Object",
-                                                    Storage::Synchronization::Version{1}},
+                                                    Storage::Version{1}},
              Storage::Synchronization::ExportedType{qmlModuleId,
                                                     "Obj",
-                                                    Storage::Synchronization::Version{1, 2}},
+                                                    Storage::Version{1, 2}},
              Storage::Synchronization::ExportedType{qmlModuleId, "BuiltInObj"},
              Storage::Synchronization::ExportedType{qmlNativeModuleId, "QObject"}}});
         package.types.push_back(Storage::Synchronization::Type{
@@ -783,10 +783,10 @@ protected:
             sourceId1,
             {Storage::Synchronization::ExportedType{qmlModuleId,
                                                     "Object",
-                                                    Storage::Synchronization::Version{2, 0}},
+                                                    Storage::Version{2, 0}},
              Storage::Synchronization::ExportedType{qmlModuleId,
                                                     "Obj",
-                                                    Storage::Synchronization::Version{2, 3}},
+                                                    Storage::Version{2, 3}},
              Storage::Synchronization::ExportedType{qmlNativeModuleId, "QObject2"}}});
         package.types.push_back(Storage::Synchronization::Type{
             "QObject3",
@@ -796,10 +796,10 @@ protected:
             sourceId1,
             {Storage::Synchronization::ExportedType{qmlModuleId,
                                                     "Object",
-                                                    Storage::Synchronization::Version{2, 11}},
+                                                    Storage::Version{2, 11}},
              Storage::Synchronization::ExportedType{qmlModuleId,
                                                     "Obj",
-                                                    Storage::Synchronization::Version{2, 11}},
+                                                    Storage::Version{2, 11}},
              Storage::Synchronization::ExportedType{qmlNativeModuleId, "QObject3"}}});
         package.types.push_back(Storage::Synchronization::Type{
             "QObject4",
@@ -809,13 +809,13 @@ protected:
             sourceId1,
             {Storage::Synchronization::ExportedType{qmlModuleId,
                                                     "Object",
-                                                    Storage::Synchronization::Version{3, 4}},
+                                                    Storage::Version{3, 4}},
              Storage::Synchronization::ExportedType{qmlModuleId,
                                                     "Obj",
-                                                    Storage::Synchronization::Version{3, 4}},
+                                                    Storage::Version{3, 4}},
              Storage::Synchronization::ExportedType{qmlModuleId,
                                                     "BuiltInObj",
-                                                    Storage::Synchronization::Version{3, 4}},
+                                                    Storage::Version{3, 4}},
              Storage::Synchronization::ExportedType{qmlNativeModuleId, "QObject4"}}});
 
         package.updatedSourceIds.push_back(sourceId1);
@@ -829,7 +829,7 @@ protected:
     {
         SynchronizationPackage package;
 
-        package.imports.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId1);
+        package.imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId1);
 
         package.types.push_back(Storage::Synchronization::Type{
             "QObject",
@@ -839,7 +839,7 @@ protected:
             sourceId1,
             {Storage::Synchronization::ExportedType{qmlModuleId,
                                                     "Object",
-                                                    Storage::Synchronization::Version{}}},
+                                                    Storage::Version{}}},
             {Storage::Synchronization::PropertyDeclaration{"data",
                                                            Storage::Synchronization::ImportedType{"Object"},
                                                            Storage::PropertyDeclarationTraits::IsList},
@@ -858,7 +858,7 @@ protected:
             sourceId1,
             {Storage::Synchronization::ExportedType{qmlModuleId,
                                                     "Object2",
-                                                    Storage::Synchronization::Version{}}},
+                                                    Storage::Version{}}},
             {Storage::Synchronization::PropertyDeclaration{
                  "data2",
                  Storage::Synchronization::ImportedType{"Object3"},
@@ -878,7 +878,7 @@ protected:
             sourceId1,
             {Storage::Synchronization::ExportedType{qmlModuleId,
                                                     "Object3",
-                                                    Storage::Synchronization::Version{}}},
+                                                    Storage::Version{}}},
             {Storage::Synchronization::PropertyDeclaration{"data3",
                                                            Storage::Synchronization::ImportedType{
                                                                "Object2"},
@@ -902,7 +902,7 @@ protected:
     {
         SynchronizationPackage package;
 
-        package.imports.emplace_back(qmlModuleId, Storage::Synchronization::Version{1}, sourceId1);
+        package.imports.emplace_back(qmlModuleId, Storage::Version{1}, sourceId1);
         package.updatedModuleIds.push_back(qtQuickModuleId);
         package.types.push_back(Storage::Synchronization::Type{
             "QQuickItem",
@@ -912,12 +912,12 @@ protected:
             sourceId1,
             {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                     "Item",
-                                                    Storage::Synchronization::Version{1, 0}}}});
+                                                    Storage::Version{1, 0}}}});
 
         package.updatedModuleIds.push_back(qmlModuleId);
         package.moduleExportedImports.emplace_back(qtQuickModuleId,
                                                    qmlModuleId,
-                                                   Storage::Synchronization::Version{},
+                                                   Storage::Version{},
                                                    Storage::Synchronization::IsAutoVersion::Yes);
         package.types.push_back(Storage::Synchronization::Type{
             "QObject",
@@ -927,12 +927,12 @@ protected:
             sourceId2,
             {Storage::Synchronization::ExportedType{qmlModuleId,
                                                     "Object",
-                                                    Storage::Synchronization::Version{1, 0}}}});
+                                                    Storage::Version{1, 0}}}});
 
-        package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{1}, sourceId3);
+        package.imports.emplace_back(qtQuickModuleId, Storage::Version{1}, sourceId3);
         package.moduleExportedImports.emplace_back(qtQuick3DModuleId,
                                                    qtQuickModuleId,
-                                                   Storage::Synchronization::Version{},
+                                                   Storage::Version{},
                                                    Storage::Synchronization::IsAutoVersion::Yes);
         package.updatedModuleIds.push_back(qtQuick3DModuleId);
         package.types.push_back(Storage::Synchronization::Type{
@@ -943,9 +943,9 @@ protected:
             sourceId3,
             {Storage::Synchronization::ExportedType{qtQuick3DModuleId,
                                                     "Item3D",
-                                                    Storage::Synchronization::Version{1, 0}}}});
+                                                    Storage::Version{1, 0}}}});
 
-        package.imports.emplace_back(qtQuick3DModuleId, Storage::Synchronization::Version{1}, sourceId4);
+        package.imports.emplace_back(qtQuick3DModuleId, Storage::Version{1}, sourceId4);
         package.types.push_back(Storage::Synchronization::Type{
             "MyItem",
             Storage::Synchronization::ImportedType{"Object"},
@@ -954,7 +954,7 @@ protected:
             sourceId4,
             {Storage::Synchronization::ExportedType{myModuleModuleId,
                                                     "MyItem",
-                                                    Storage::Synchronization::Version{1, 0}}}});
+                                                    Storage::Version{1, 0}}}});
 
         package.updatedSourceIds = {sourceId1, sourceId2, sourceId3, sourceId4};
 
@@ -1439,12 +1439,12 @@ TEST_F(ProjectStorage, SynchronizeTypesOverwritesSources)
     package.types[0].sourceId = sourceId3;
     package.types[1].sourceId = sourceId4;
     Storage::Synchronization::Imports newImports;
-    newImports.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId3);
-    newImports.emplace_back(qmlNativeModuleId, Storage::Synchronization::Version{}, sourceId3);
-    newImports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
-    newImports.emplace_back(qtQuickNativeModuleId, Storage::Synchronization::Version{}, sourceId3);
-    newImports.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId4);
-    newImports.emplace_back(qmlNativeModuleId, Storage::Synchronization::Version{}, sourceId4);
+    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(SynchronizationPackage{newImports,
                                                package.types,
@@ -1560,7 +1560,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddQualifiedPrototype)
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
         "Object",
         Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Synchronization::Version{},
+                                         Storage::Version{},
                                          sourceId1}};
     package.types.push_back(Storage::Synchronization::Type{
         "QQuickObject",
@@ -1606,7 +1606,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddQualifiedExtension)
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
         "Object",
         Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Synchronization::Version{},
+                                         Storage::Version{},
                                          sourceId1}};
     package.types.push_back(Storage::Synchronization::Type{
         "QQuickObject",
@@ -1828,7 +1828,7 @@ TEST_F(ProjectStorage, SynchronizeTypesAddPropertyDeclarationQualifiedType)
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
         "Object",
         Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Synchronization::Version{},
+                                         Storage::Version{},
                                          sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
@@ -2018,7 +2018,7 @@ TEST_F(ProjectStorage, UsingNonExistingQualifiedExportedPropertyTypeWithWrongNam
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
         "QObject2",
         Storage::Synchronization::Import{qmlNativeModuleId,
-                                         Storage::Synchronization::Version{},
+                                         Storage::Version{},
                                          sourceId1}};
     package.types.pop_back();
     package.imports = importsSourceId1;
@@ -2031,7 +2031,7 @@ TEST_F(ProjectStorage, UsingNonExistingQualifiedExportedPropertyTypeWithWrongMod
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
         "QObject",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Synchronization::Version{}, sourceId1}};
+        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     package.types.pop_back();
     package.imports = importsSourceId1;
 
@@ -2900,7 +2900,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangeAliasDeclarationsTypeName)
     storage.synchronize(package);
     package.types[2].propertyDeclarations[2].typeName = Storage::Synchronization::ImportedType{
         "Obj2"};
-    importsSourceId3.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId3);
+    importsSourceId3.emplace_back(pathToModuleId, Storage::Version{}, sourceId3);
 
     storage.synchronize(SynchronizationPackage{importsSourceId3, {package.types[2]}, {sourceId3}});
 
@@ -3049,7 +3049,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangeAliasTargetPropertyDeclarationTypeN
     storage.synchronize(package);
     package.types[1].propertyDeclarations[0].typeName = Storage::Synchronization::ImportedType{
         "Item"};
-    importsSourceId2.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId2);
+    importsSourceId2.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
 
     storage.synchronize(SynchronizationPackage{importsSourceId2, {package.types[1]}, {sourceId2}});
 
@@ -3117,7 +3117,7 @@ TEST_F(ProjectStorage, SynchronizeTypesRemoveTypeWithAliasTargetPropertyDeclarat
     auto package{createSynchronizationPackageWithAliases()};
     package.types[2].propertyDeclarations[2].typeName = Storage::Synchronization::ImportedType{
         "Object2"};
-    package.imports.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId3);
+    package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId3);
     storage.synchronize(package);
 
     ASSERT_THROW(storage.synchronize(SynchronizationPackage{{sourceId4}}),
@@ -3129,7 +3129,7 @@ TEST_F(ProjectStorage, SynchronizeTypesRemoveTypeAndAliasPropertyDeclaration)
     auto package{createSynchronizationPackageWithAliases()};
     package.types[2].propertyDeclarations[2].typeName = Storage::Synchronization::ImportedType{
         "Object2"};
-    package.imports.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId3);
+    package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId3);
     storage.synchronize(package);
     package.types[2].propertyDeclarations.pop_back();
 
@@ -3250,8 +3250,8 @@ TEST_F(ProjectStorage, RelinkAliasProperty)
     auto package{createSynchronizationPackageWithAliases()};
     package.types[1].propertyDeclarations[0].typeName = Storage::Synchronization::ImportedType{
         "Object2"};
-    package.imports.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId2);
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId2);
+    package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
     storage.synchronize(package);
     package.types[3].exportedTypes[0].moduleId = qtQuickModuleId;
 
@@ -3282,11 +3282,11 @@ TEST_F(ProjectStorage, DoNotRelinkAliasPropertyForQualifiedImportedTypeName)
     auto package{createSynchronizationPackageWithAliases()};
     package.types[1].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
         "Object2",
-        Storage::Synchronization::Import{pathToModuleId, Storage::Synchronization::Version{}, sourceId2}};
-    package.imports.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId2);
+        Storage::Synchronization::Import{pathToModuleId, Storage::Version{}, sourceId2}};
+    package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
     storage.synchronize(package);
     package.types[3].exportedTypes[0].moduleId = qtQuickModuleId;
-    importsSourceId4.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId4);
+    importsSourceId4.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId4);
 
     ASSERT_THROW(storage.synchronize(
                      SynchronizationPackage{importsSourceId4, {package.types[3]}, {sourceId4}}),
@@ -3299,8 +3299,8 @@ TEST_F(ProjectStorage,
     auto package{createSynchronizationPackageWithAliases()};
     package.types[1].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
         "Object2",
-        Storage::Synchronization::Import{pathToModuleId, Storage::Synchronization::Version{}, sourceId2}};
-    package.imports.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId2);
+        Storage::Synchronization::Import{pathToModuleId, Storage::Version{}, sourceId2}};
+    package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
     package.types.push_back(Storage::Synchronization::Type{
         "QObject2",
         Storage::Synchronization::ImportedType{},
@@ -3366,8 +3366,8 @@ TEST_F(ProjectStorage, DoNotRelinkAliasPropertyForDeletedType)
     auto package{createSynchronizationPackageWithAliases()};
     package.types[1].propertyDeclarations[0].typeName = Storage::Synchronization::ImportedType{
         "Object2"};
-    package.imports.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId2);
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId2);
+    package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
     storage.synchronize(package);
     package.types[3].exportedTypes[0].moduleId = qtQuickModuleId;
 
@@ -3386,12 +3386,12 @@ TEST_F(ProjectStorage, DoNotRelinkAliasPropertyForDeletedTypeAndPropertyType)
     auto package{createSynchronizationPackageWithAliases()};
     package.types[1].propertyDeclarations[0].typeName = Storage::Synchronization::ImportedType{
         "Object2"};
-    package.imports.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId2);
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId2);
+    package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
     storage.synchronize(package);
     package.types[0].prototype = Storage::Synchronization::ImportedType{};
-    importsSourceId1.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId1);
-    importsSourceId4.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId4);
+    importsSourceId1.emplace_back(pathToModuleId, Storage::Version{}, sourceId1);
+    importsSourceId4.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId4);
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::ImportedType{
         "Object2"};
     package.types[3].propertyDeclarations[0].typeName = Storage::Synchronization::ImportedType{
@@ -3409,12 +3409,12 @@ TEST_F(ProjectStorage, DoNotRelinkAliasPropertyForDeletedTypeAndPropertyTypeName
     auto package{createSynchronizationPackageWithAliases()};
     package.types[1].propertyDeclarations[0].typeName = Storage::Synchronization::ImportedType{
         "Object2"};
-    package.imports.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId2);
+    package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
     storage.synchronize(package);
     package.types[3].exportedTypes[0].moduleId = qtQuickModuleId;
     package.types[1].propertyDeclarations[0].typeName = Storage::Synchronization::ImportedType{
         "QObject"};
-    importsSourceId4.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId4);
+    importsSourceId4.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId4);
 
     storage.synchronize(SynchronizationPackage{importsSourceId2 + importsSourceId4,
                                                {package.types[1], package.types[3]},
@@ -3432,8 +3432,8 @@ TEST_F(ProjectStorage, DoNotRelinkPropertyTypeDoesNotExists)
     auto package{createSynchronizationPackageWithAliases()};
     package.types[1].propertyDeclarations[0].typeName = Storage::Synchronization::ImportedType{
         "Object2"};
-    package.imports.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId2);
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId2);
+    package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
     storage.synchronize(package);
 
     ASSERT_THROW(storage.synchronize(SynchronizationPackage{{sourceId4}}),
@@ -3445,7 +3445,7 @@ TEST_F(ProjectStorage, DoNotRelinkAliasPropertyTypeDoesNotExists)
     auto package{createSynchronizationPackageWithAliases2()};
     package.types[1].propertyDeclarations[0].typeName = Storage::Synchronization::ImportedType{
         "Object2"};
-    package.imports.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId2);
+    package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
     storage.synchronize(package);
 
     ASSERT_THROW(storage.synchronize(SynchronizationPackage{{sourceId1}}),
@@ -3523,7 +3523,7 @@ TEST_F(ProjectStorage, ChangeQualifiedPrototypeTypeModuleIdThrows)
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
         "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Synchronization::Version{}, sourceId1}};
+        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     storage.synchronize(package);
     package.types[1].exportedTypes[0].moduleId = qtQuickModuleId;
 
@@ -3538,7 +3538,7 @@ TEST_F(ProjectStorage, ChangeQualifiedExtensionTypeModuleIdThrows)
     std::swap(package.types.front().extension, package.types.front().prototype);
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
         "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Synchronization::Version{}, sourceId1}};
+        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     storage.synchronize(package);
     package.types[1].exportedTypes[0].moduleId = qtQuickModuleId;
 
@@ -3552,13 +3552,13 @@ TEST_F(ProjectStorage, ChangeQualifiedPrototypeTypeModuleId)
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
         "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Synchronization::Version{}, sourceId1}};
+        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     storage.synchronize(package);
     package.types[1].exportedTypes[0].moduleId = qtQuickModuleId;
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
         "Object",
         Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Synchronization::Version{},
+                                         Storage::Version{},
                                          sourceId1}};
 
     storage.synchronize(SynchronizationPackage{importsSourceId1 + importsSourceId2,
@@ -3579,13 +3579,13 @@ TEST_F(ProjectStorage, ChangeQualifiedExtensionTypeModuleId)
     std::swap(package.types.front().extension, package.types.front().prototype);
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
         "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Synchronization::Version{}, sourceId1}};
+        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     storage.synchronize(package);
     package.types[1].exportedTypes[0].moduleId = qtQuickModuleId;
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
         "Object",
         Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Synchronization::Version{},
+                                         Storage::Version{},
                                          sourceId1}};
 
     storage.synchronize(SynchronizationPackage{importsSourceId1 + importsSourceId2,
@@ -3688,9 +3688,9 @@ TEST_F(ProjectStorage, ThrowForPrototypeChainCycles)
         sourceId3,
         {Storage::Synchronization::ExportedType{pathToModuleId, "Object2"},
          Storage::Synchronization::ExportedType{pathToModuleId, "Obj2"}}});
-    package.imports.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId2);
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
-    package.imports.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId3);
+    package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
+    package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId3);
 
     ASSERT_THROW(storage.synchronize(SynchronizationPackage{package.imports,
                                                             package.types,
@@ -3713,9 +3713,9 @@ TEST_F(ProjectStorage, ThrowForExtensionChainCycles)
         sourceId3,
         {Storage::Synchronization::ExportedType{pathToModuleId, "Object2"},
          Storage::Synchronization::ExportedType{pathToModuleId, "Obj2"}}});
-    package.imports.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId2);
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
-    package.imports.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId3);
+    package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
+    package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId3);
 
     ASSERT_THROW(storage.synchronize(SynchronizationPackage{package.imports,
                                                             package.types,
@@ -3748,7 +3748,7 @@ TEST_F(ProjectStorage, ThrowForTypeIdAndPrototypeIdAreTheSameForRelinking)
     storage.synchronize(package);
     package.types[1].prototype = Storage::Synchronization::ImportedType{"Item"};
     package.types[1].typeName = "QObject2";
-    importsSourceId2.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId2);
+    importsSourceId2.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
 
     ASSERT_THROW(storage.synchronize(
                      SynchronizationPackage{importsSourceId2, {package.types[1]}, {sourceId2}}),
@@ -3762,7 +3762,7 @@ TEST_F(ProjectStorage, ThrowForTypeIdAndExtenssionIdAreTheSameForRelinking)
     storage.synchronize(package);
     package.types[1].extension = Storage::Synchronization::ImportedType{"Item"};
     package.types[1].typeName = "QObject2";
-    importsSourceId2.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId2);
+    importsSourceId2.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
 
     ASSERT_THROW(storage.synchronize(
                      SynchronizationPackage{importsSourceId2, {package.types[1]}, {sourceId2}}),
@@ -3793,7 +3793,7 @@ TEST_F(ProjectStorage, RecursiveAliasesChangePropertyType)
     storage.synchronize(package);
     package.types[1].propertyDeclarations[0].typeName = Storage::Synchronization::ImportedType{
         "Object2"};
-    importsSourceId2.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId2);
+    importsSourceId2.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
 
     storage.synchronize(SynchronizationPackage{importsSourceId2, {package.types[1]}, {sourceId2}});
 
@@ -3879,7 +3879,7 @@ TEST_F(ProjectStorage, UpdateAliasesAfterChangePropertyToAlias)
     package.types[1].propertyDeclarations.clear();
     package.types[1].propertyDeclarations.push_back(Storage::Synchronization::PropertyDeclaration{
         "objects", Storage::Synchronization::ImportedType{"Object2"}, "objects"});
-    importsSourceId2.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId2);
+    importsSourceId2.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
 
     storage.synchronize(SynchronizationPackage{importsSourceId2, {package.types[1]}, {sourceId2}});
 
@@ -3903,7 +3903,7 @@ TEST_F(ProjectStorage, CheckForProtoTypeCycleThrows)
     package.types[1].propertyDeclarations.clear();
     package.types[1].propertyDeclarations.push_back(Storage::Synchronization::PropertyDeclaration{
         "objects", Storage::Synchronization::ImportedType{"AliasItem2"}, "objects"});
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId2);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
 
     ASSERT_THROW(storage.synchronize(package), QmlDesigner::AliasChainCycle);
 }
@@ -3915,7 +3915,7 @@ TEST_F(ProjectStorage, CheckForProtoTypeCycleAfterUpdateThrows)
     package.types[1].propertyDeclarations.clear();
     package.types[1].propertyDeclarations.push_back(Storage::Synchronization::PropertyDeclaration{
         "objects", Storage::Synchronization::ImportedType{"AliasItem2"}, "objects"});
-    importsSourceId2.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId2);
+    importsSourceId2.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
 
     ASSERT_THROW(storage.synchronize(
                      SynchronizationPackage{importsSourceId2, {package.types[1]}, {sourceId2}}),
@@ -3927,7 +3927,7 @@ TEST_F(ProjectStorage, QualifiedPrototype)
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
         "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Synchronization::Version{}, sourceId1}};
+        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
                                        Storage::Synchronization::ImportedType{},
@@ -3936,7 +3936,7 @@ TEST_F(ProjectStorage, QualifiedPrototype)
                                        sourceId3,
                                        {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                                                "Object"}}});
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
     package.updatedSourceIds.push_back(sourceId3);
 
     storage.synchronize(package);
@@ -3955,7 +3955,7 @@ TEST_F(ProjectStorage, QualifiedExtension)
     std::swap(package.types.front().extension, package.types.front().prototype);
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
         "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Synchronization::Version{}, sourceId1}};
+        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
                                        Storage::Synchronization::ImportedType{},
@@ -3964,7 +3964,7 @@ TEST_F(ProjectStorage, QualifiedExtension)
                                        sourceId3,
                                        {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                                                "Object"}}});
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
     package.updatedSourceIds.push_back(sourceId3);
 
     storage.synchronize(package);
@@ -3983,7 +3983,7 @@ TEST_F(ProjectStorage, QualifiedPrototypeUpperDownTheModuleChainThrows)
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
         "Object",
         Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Synchronization::Version{},
+                                         Storage::Version{},
                                          sourceId1}};
 
     ASSERT_THROW(storage.synchronize(package), QmlDesigner::TypeNameDoesNotExists);
@@ -3996,7 +3996,7 @@ TEST_F(ProjectStorage, QualifiedExtensionUpperDownTheModuleChainThrows)
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
         "Object",
         Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Synchronization::Version{},
+                                         Storage::Version{},
                                          sourceId1}};
 
     ASSERT_THROW(storage.synchronize(package), QmlDesigner::TypeNameDoesNotExists);
@@ -4008,7 +4008,7 @@ TEST_F(ProjectStorage, QualifiedPrototypeUpperInTheModuleChain)
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
         "Object",
         Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Synchronization::Version{},
+                                         Storage::Version{},
                                          sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
@@ -4018,7 +4018,7 @@ TEST_F(ProjectStorage, QualifiedPrototypeUpperInTheModuleChain)
                                        sourceId3,
                                        {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                                                "Object"}}});
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
     package.updatedSourceIds.push_back(sourceId3);
 
     storage.synchronize(package);
@@ -4038,7 +4038,7 @@ TEST_F(ProjectStorage, QualifiedExtensionUpperInTheModuleChain)
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
         "Object",
         Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Synchronization::Version{},
+                                         Storage::Version{},
                                          sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
@@ -4048,7 +4048,7 @@ TEST_F(ProjectStorage, QualifiedExtensionUpperInTheModuleChain)
                                        sourceId3,
                                        {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                                                "Object"}}});
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
     package.updatedSourceIds.push_back(sourceId3);
 
     storage.synchronize(package);
@@ -4066,7 +4066,7 @@ TEST_F(ProjectStorage, QualifiedPrototypeWithWrongVersionThrows)
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
         "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Synchronization::Version{4}, sourceId1}};
+        Storage::Synchronization::Import{qmlModuleId, Storage::Version{4}, sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
                                        Storage::Synchronization::ImportedType{},
@@ -4075,7 +4075,7 @@ TEST_F(ProjectStorage, QualifiedPrototypeWithWrongVersionThrows)
                                        sourceId3,
                                        {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                                                "Object"}}});
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
     package.updatedSourceIds.push_back(sourceId3);
 
     ASSERT_THROW(storage.synchronize(package), QmlDesigner::TypeNameDoesNotExists);
@@ -4087,7 +4087,7 @@ TEST_F(ProjectStorage, QualifiedExtensionWithWrongVersionThrows)
     std::swap(package.types.front().extension, package.types.front().prototype);
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
         "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Synchronization::Version{4}, sourceId1}};
+        Storage::Synchronization::Import{qmlModuleId, Storage::Version{4}, sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
                                        Storage::Synchronization::ImportedType{},
@@ -4096,7 +4096,7 @@ TEST_F(ProjectStorage, QualifiedExtensionWithWrongVersionThrows)
                                        sourceId3,
                                        {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                                                "Object"}}});
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
     package.updatedSourceIds.push_back(sourceId3);
 
     ASSERT_THROW(storage.synchronize(package), QmlDesigner::TypeNameDoesNotExists);
@@ -4105,7 +4105,7 @@ TEST_F(ProjectStorage, QualifiedExtensionWithWrongVersionThrows)
 TEST_F(ProjectStorage, QualifiedPrototypeWithVersion)
 {
     auto package{createSimpleSynchronizationPackage()};
-    package.imports[0].version = Storage::Synchronization::Version{2};
+    package.imports[0].version = Storage::Version{2};
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{"Object",
                                                                                  package.imports[0]};
     package.types.push_back(
@@ -4116,7 +4116,7 @@ TEST_F(ProjectStorage, QualifiedPrototypeWithVersion)
                                        sourceId3,
                                        {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                                                "Object"}}});
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
     package.updatedSourceIds.push_back(sourceId3);
 
     storage.synchronize(package);
@@ -4133,7 +4133,7 @@ TEST_F(ProjectStorage, QualifiedExtensionWithVersion)
 {
     auto package{createSimpleSynchronizationPackage()};
     std::swap(package.types.front().extension, package.types.front().prototype);
-    package.imports[0].version = Storage::Synchronization::Version{2};
+    package.imports[0].version = Storage::Version{2};
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{"Object",
                                                                                  package.imports[0]};
     package.types.push_back(
@@ -4144,7 +4144,7 @@ TEST_F(ProjectStorage, QualifiedExtensionWithVersion)
                                        sourceId3,
                                        {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                                                "Object"}}});
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
     package.updatedSourceIds.push_back(sourceId3);
 
     storage.synchronize(package);
@@ -4160,10 +4160,10 @@ TEST_F(ProjectStorage, QualifiedExtensionWithVersion)
 TEST_F(ProjectStorage, QualifiedPrototypeWithVersionInTheProtoTypeChain)
 {
     auto package{createSimpleSynchronizationPackage()};
-    package.imports[1].version = Storage::Synchronization::Version{2};
+    package.imports[1].version = Storage::Version{2};
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{"Object",
                                                                                  package.imports[1]};
-    package.types[0].exportedTypes[0].version = Storage::Synchronization::Version{2};
+    package.types[0].exportedTypes[0].version = Storage::Version{2};
     package.types.push_back(Storage::Synchronization::Type{
         "QQuickObject",
         Storage::Synchronization::ImportedType{},
@@ -4172,8 +4172,8 @@ TEST_F(ProjectStorage, QualifiedPrototypeWithVersionInTheProtoTypeChain)
         sourceId3,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Object",
-                                                Storage::Synchronization::Version{2}}}});
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
+                                                Storage::Version{2}}}});
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
     package.updatedSourceIds.push_back(sourceId3);
 
     storage.synchronize(package);
@@ -4190,10 +4190,10 @@ TEST_F(ProjectStorage, QualifiedExtensionWithVersionInTheProtoTypeChain)
 {
     auto package{createSimpleSynchronizationPackage()};
     std::swap(package.types.front().extension, package.types.front().prototype);
-    package.imports[1].version = Storage::Synchronization::Version{2};
+    package.imports[1].version = Storage::Version{2};
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{"Object",
                                                                                  package.imports[1]};
-    package.types[0].exportedTypes[0].version = Storage::Synchronization::Version{2};
+    package.types[0].exportedTypes[0].version = Storage::Version{2};
     package.types.push_back(Storage::Synchronization::Type{
         "QQuickObject",
         Storage::Synchronization::ImportedType{},
@@ -4202,8 +4202,8 @@ TEST_F(ProjectStorage, QualifiedExtensionWithVersionInTheProtoTypeChain)
         sourceId3,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Object",
-                                                Storage::Synchronization::Version{2}}}});
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
+                                                Storage::Version{2}}}});
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
     package.updatedSourceIds.push_back(sourceId3);
 
     storage.synchronize(package);
@@ -4222,7 +4222,7 @@ TEST_F(ProjectStorage, QualifiedPrototypeWithVersionDownTheProtoTypeChainThrows)
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
         "Object",
         Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Synchronization::Version{2},
+                                         Storage::Version{2},
                                          sourceId1}};
 
     ASSERT_THROW(storage.synchronize(package), QmlDesigner::TypeNameDoesNotExists);
@@ -4235,7 +4235,7 @@ TEST_F(ProjectStorage, QualifiedExtensionWithVersionDownTheProtoTypeChainThrows)
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
         "Object",
         Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Synchronization::Version{2},
+                                         Storage::Version{2},
                                          sourceId1}};
 
     ASSERT_THROW(storage.synchronize(package), QmlDesigner::TypeNameDoesNotExists);
@@ -4246,7 +4246,7 @@ TEST_F(ProjectStorage, QualifiedPropertyDeclarationTypeName)
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
         "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Synchronization::Version{}, sourceId1}};
+        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
                                        Storage::Synchronization::ImportedType{},
@@ -4255,7 +4255,7 @@ TEST_F(ProjectStorage, QualifiedPropertyDeclarationTypeName)
                                        sourceId3,
                                        {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                                                "Object"}}});
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
     package.updatedSourceIds.push_back(sourceId3);
 
     storage.synchronize(package);
@@ -4274,7 +4274,7 @@ TEST_F(ProjectStorage, QualifiedPropertyDeclarationTypeNameDownTheModuleChainThr
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
         "Object",
         Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Synchronization::Version{},
+                                         Storage::Version{},
                                          sourceId1}};
 
     ASSERT_THROW(storage.synchronize(package), QmlDesigner::TypeNameDoesNotExists);
@@ -4286,7 +4286,7 @@ TEST_F(ProjectStorage, QualifiedPropertyDeclarationTypeNameInTheModuleChain)
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
         "Object",
         Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Synchronization::Version{},
+                                         Storage::Version{},
                                          sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
@@ -4296,7 +4296,7 @@ TEST_F(ProjectStorage, QualifiedPropertyDeclarationTypeNameInTheModuleChain)
                                        sourceId3,
                                        {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                                                "Object"}}});
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId3);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
     package.updatedSourceIds.push_back(sourceId3);
 
     storage.synchronize(package);
@@ -4314,8 +4314,8 @@ TEST_F(ProjectStorage, QualifiedPropertyDeclarationTypeNameWithVersion)
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
         "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Synchronization::Version{2}, sourceId1}};
-    package.imports.emplace_back(qmlModuleId, Storage::Synchronization::Version{2}, sourceId1);
+        Storage::Synchronization::Import{qmlModuleId, Storage::Version{2}, sourceId1}};
+    package.imports.emplace_back(qmlModuleId, Storage::Version{2}, sourceId1);
 
     storage.synchronize(package);
 
@@ -4332,7 +4332,7 @@ TEST_F(ProjectStorage, ChangePropertyTypeModuleIdWithQualifiedTypeThrows)
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
         "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Synchronization::Version{}, sourceId1}};
+        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     storage.synchronize(package);
     package.types[1].exportedTypes[0].moduleId = qtQuickModuleId;
 
@@ -4346,15 +4346,15 @@ TEST_F(ProjectStorage, ChangePropertyTypeModuleIdWithQualifiedType)
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
         "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Synchronization::Version{}, sourceId1}};
+        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     storage.synchronize(package);
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
         "Object",
         Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Synchronization::Version{},
+                                         Storage::Version{},
                                          sourceId1}};
     package.types[1].exportedTypes[0].moduleId = qtQuickModuleId;
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{}, sourceId2);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
 
     storage.synchronize(package);
 
@@ -4475,9 +4475,9 @@ TEST_F(ProjectStorage, FetchByMajorVersionForImportedType)
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{1},
+                                            Storage::Version{1},
                                             sourceId2};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
@@ -4492,7 +4492,7 @@ TEST_F(ProjectStorage, FetchByMajorVersionForQualifiedImportedType)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{1},
+                                            Storage::Version{1},
                                             sourceId2};
     Storage::Synchronization::Type type{
         "Item",
@@ -4502,7 +4502,7 @@ TEST_F(ProjectStorage, FetchByMajorVersionForQualifiedImportedType)
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
 
@@ -4523,9 +4523,9 @@ TEST_F(ProjectStorage, FetchByMajorVersionAndMinorVersionForImportedType)
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{1, 2},
+                                            Storage::Version{1, 2},
                                             sourceId2};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
@@ -4540,7 +4540,7 @@ TEST_F(ProjectStorage, FetchByMajorVersionAndMinorVersionForQualifiedImportedTyp
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{1, 2},
+                                            Storage::Version{1, 2},
                                             sourceId2};
     Storage::Synchronization::Type type{
         "Item",
@@ -4550,7 +4550,7 @@ TEST_F(ProjectStorage, FetchByMajorVersionAndMinorVersionForQualifiedImportedTyp
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
 
@@ -4572,9 +4572,9 @@ TEST_F(ProjectStorage,
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{1, 1},
+                                            Storage::Version{1, 1},
                                             sourceId2};
 
     ASSERT_THROW(storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}}),
@@ -4587,7 +4587,7 @@ TEST_F(ProjectStorage,
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{1, 1},
+                                            Storage::Version{1, 1},
                                             sourceId2};
     Storage::Synchronization::Type type{
         "Item",
@@ -4597,7 +4597,7 @@ TEST_F(ProjectStorage,
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
 
     ASSERT_THROW(storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}}),
                  QmlDesigner::TypeNameDoesNotExists);
@@ -4615,9 +4615,9 @@ TEST_F(ProjectStorage, FetchLowMinorVersionForImportedTypeThrows)
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{1, 1},
+                                            Storage::Version{1, 1},
                                             sourceId2};
 
     ASSERT_THROW(storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}}),
@@ -4629,7 +4629,7 @@ TEST_F(ProjectStorage, FetchLowMinorVersionForQualifiedImportedTypeThrows)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{1, 1},
+                                            Storage::Version{1, 1},
                                             sourceId2};
     Storage::Synchronization::Type type{
         "Item",
@@ -4639,7 +4639,7 @@ TEST_F(ProjectStorage, FetchLowMinorVersionForQualifiedImportedTypeThrows)
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
 
     ASSERT_THROW(storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}}),
                  QmlDesigner::TypeNameDoesNotExists);
@@ -4657,9 +4657,9 @@ TEST_F(ProjectStorage, FetchHigherMinorVersionForImportedType)
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{1, 3},
+                                            Storage::Version{1, 3},
                                             sourceId2};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
@@ -4674,7 +4674,7 @@ TEST_F(ProjectStorage, FetchHigherMinorVersionForQualifiedImportedType)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{1, 3},
+                                            Storage::Version{1, 3},
                                             sourceId2};
     Storage::Synchronization::Type type{
         "Item",
@@ -4684,7 +4684,7 @@ TEST_F(ProjectStorage, FetchHigherMinorVersionForQualifiedImportedType)
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
 
@@ -4705,9 +4705,9 @@ TEST_F(ProjectStorage, FetchDifferentMajorVersionForImportedTypeThrows)
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{3, 1},
+                                            Storage::Version{3, 1},
                                             sourceId2};
 
     ASSERT_THROW(storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}}),
@@ -4719,7 +4719,7 @@ TEST_F(ProjectStorage, FetchDifferentMajorVersionForQualifiedImportedTypeThrows)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{3, 1},
+                                            Storage::Version{3, 1},
                                             sourceId2};
     Storage::Synchronization::Type type{
         "Item",
@@ -4729,7 +4729,7 @@ TEST_F(ProjectStorage, FetchDifferentMajorVersionForQualifiedImportedTypeThrows)
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
 
     ASSERT_THROW(storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}}),
                  QmlDesigner::TypeNameDoesNotExists);
@@ -4747,9 +4747,9 @@ TEST_F(ProjectStorage, FetchOtherTypeByDifferentVersionForImportedType)
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{2, 3},
+                                            Storage::Version{2, 3},
                                             sourceId2};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
@@ -4764,7 +4764,7 @@ TEST_F(ProjectStorage, FetchOtherTypeByDifferentVersionForQualifiedImportedType)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{2, 3},
+                                            Storage::Version{2, 3},
                                             sourceId2};
     Storage::Synchronization::Type type{
         "Item",
@@ -4774,7 +4774,7 @@ TEST_F(ProjectStorage, FetchOtherTypeByDifferentVersionForQualifiedImportedType)
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
 
@@ -4795,8 +4795,8 @@ TEST_F(ProjectStorage, FetchHighestVersionForImportWithoutVersionForImportedType
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
-    Storage::Synchronization::Import import{qmlModuleId, Storage::Synchronization::Version{}, sourceId2};
+                                                Storage::Version{}}}};
+    Storage::Synchronization::Import import{qmlModuleId, Storage::Version{}, sourceId2};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
 
@@ -4809,7 +4809,7 @@ TEST_F(ProjectStorage, FetchHighestVersionForImportWithoutVersionForQualifiedImp
 {
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
-    Storage::Synchronization::Import import{qmlModuleId, Storage::Synchronization::Version{}, sourceId2};
+    Storage::Synchronization::Import import{qmlModuleId, Storage::Version{}, sourceId2};
     Storage::Synchronization::Type type{
         "Item",
         Storage::Synchronization::QualifiedImportedType{"Obj", import},
@@ -4818,7 +4818,7 @@ TEST_F(ProjectStorage, FetchHighestVersionForImportWithoutVersionForQualifiedImp
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
 
@@ -4839,9 +4839,9 @@ TEST_F(ProjectStorage, FetchHighestVersionForImportWithMajorVersionForImportedTy
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{2},
+                                            Storage::Version{2},
                                             sourceId2};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
@@ -4856,7 +4856,7 @@ TEST_F(ProjectStorage, FetchHighestVersionForImportWithMajorVersionForQualifiedI
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{2},
+                                            Storage::Version{2},
                                             sourceId2};
     Storage::Synchronization::Type type{
         "Item",
@@ -4866,7 +4866,7 @@ TEST_F(ProjectStorage, FetchHighestVersionForImportWithMajorVersionForQualifiedI
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
 
@@ -4887,8 +4887,8 @@ TEST_F(ProjectStorage, FetchExportedTypeWithoutVersionFirstForImportedType)
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
-    Storage::Synchronization::Import import{qmlModuleId, Storage::Synchronization::Version{}, sourceId2};
+                                                Storage::Version{}}}};
+    Storage::Synchronization::Import import{qmlModuleId, Storage::Version{}, sourceId2};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
 
@@ -4901,7 +4901,7 @@ TEST_F(ProjectStorage, FetchExportedTypeWithoutVersionFirstForQualifiedImportedT
 {
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
-    Storage::Synchronization::Import import{qmlModuleId, Storage::Synchronization::Version{}, sourceId2};
+    Storage::Synchronization::Import import{qmlModuleId, Storage::Version{}, sourceId2};
     Storage::Synchronization::Type type{
         "Item",
         Storage::Synchronization::QualifiedImportedType{"BuiltInObj", import},
@@ -4910,7 +4910,7 @@ TEST_F(ProjectStorage, FetchExportedTypeWithoutVersionFirstForQualifiedImportedT
         sourceId2,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{}}}};
+                                                Storage::Version{}}}};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
 
@@ -4929,12 +4929,12 @@ TEST_F(ProjectStorage, EnsureThatPropertiesForRemovedTypesAreNotAnymoreRelinked)
         sourceId1,
         {Storage::Synchronization::ExportedType{qmlModuleId,
                                                 "Object",
-                                                Storage::Synchronization::Version{}}},
+                                                Storage::Version{}}},
         {Storage::Synchronization::PropertyDeclaration{"data",
                                                        Storage::Synchronization::ImportedType{
                                                            "Object"},
                                                        Storage::PropertyDeclarationTraits::IsList}}};
-    Storage::Synchronization::Import import{qmlModuleId, Storage::Synchronization::Version{}, sourceId1};
+    Storage::Synchronization::Import import{qmlModuleId, Storage::Version{}, sourceId1};
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId1}});
 
     ASSERT_NO_THROW(storage.synchronize(SynchronizationPackage{{sourceId1}}));
@@ -4969,7 +4969,7 @@ TEST_F(ProjectStorage, MinimalUpdates)
         sourceId1,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
-                                                Storage::Synchronization::Version{2, 0}},
+                                                Storage::Version{2, 0}},
          Storage::Synchronization::ExportedType{qtQuickNativeModuleId, "QQuickItem"}},
         {},
         {},
@@ -5319,7 +5319,7 @@ TEST_F(ProjectStorage, ModuleExportedImportWithDifferentVersions)
     package.imports.back().version.major.value = 2;
     package.types[2].exportedTypes.front().version.major.value = 2;
     package.moduleExportedImports.back().isAutoVersion = Storage::Synchronization::IsAutoVersion::No;
-    package.moduleExportedImports.back().version = Storage::Synchronization::Version{1};
+    package.moduleExportedImports.back().version = Storage::Version{1};
 
     storage.synchronize(std::move(package));
 
@@ -5356,7 +5356,7 @@ TEST_F(ProjectStorage, ModuleExportedImportWithIndirectDifferentVersions)
     package.types[0].exportedTypes.front().version.major.value = 2;
     package.types[2].exportedTypes.front().version.major.value = 2;
     package.moduleExportedImports[0].isAutoVersion = Storage::Synchronization::IsAutoVersion::No;
-    package.moduleExportedImports[0].version = Storage::Synchronization::Version{1};
+    package.moduleExportedImports[0].version = Storage::Version{1};
 
     storage.synchronize(std::move(package));
 
@@ -5389,14 +5389,14 @@ TEST_F(ProjectStorage, ModuleExportedImportPreventCollisionIfModuleIsIndirectlyR
 {
     ModuleId qtQuick4DModuleId{storage.moduleId("QtQuick4D")};
     auto package{createModuleExportedImportSynchronizationPackage()};
-    package.imports.emplace_back(qtQuickModuleId, Storage::Synchronization::Version{1}, sourceId5);
+    package.imports.emplace_back(qtQuickModuleId, Storage::Version{1}, sourceId5);
     package.moduleExportedImports.emplace_back(qtQuick4DModuleId,
                                                qtQuickModuleId,
-                                               Storage::Synchronization::Version{},
+                                               Storage::Version{},
                                                Storage::Synchronization::IsAutoVersion::Yes);
     package.moduleExportedImports.emplace_back(qtQuick4DModuleId,
                                                qmlModuleId,
-                                               Storage::Synchronization::Version{},
+                                               Storage::Version{},
                                                Storage::Synchronization::IsAutoVersion::Yes);
     package.updatedModuleIds.push_back(qtQuick4DModuleId);
     package.types.push_back(Storage::Synchronization::Type{
@@ -5407,8 +5407,8 @@ TEST_F(ProjectStorage, ModuleExportedImportPreventCollisionIfModuleIsIndirectlyR
         sourceId5,
         {Storage::Synchronization::ExportedType{qtQuick4DModuleId,
                                                 "Item4D",
-                                                Storage::Synchronization::Version{1, 0}}}});
-    package.imports.emplace_back(qtQuick4DModuleId, Storage::Synchronization::Version{1}, sourceId4);
+                                                Storage::Version{1, 0}}}});
+    package.imports.emplace_back(qtQuick4DModuleId, Storage::Version{1}, sourceId4);
 
     storage.synchronize(std::move(package));
 
@@ -5448,15 +5448,15 @@ TEST_F(ProjectStorage, DistinguishBetweenImportKinds)
     ModuleId qml1ModuleId{storage.moduleId("Qml1")};
     ModuleId qml11ModuleId{storage.moduleId("Qml11")};
     auto package{createSimpleSynchronizationPackage()};
-    package.moduleDependencies.emplace_back(qmlModuleId, Storage::Synchronization::Version{}, sourceId1);
+    package.moduleDependencies.emplace_back(qmlModuleId, Storage::Version{}, sourceId1);
     package.moduleDependencies.emplace_back(qml1ModuleId,
-                                            Storage::Synchronization::Version{1},
+                                            Storage::Version{1},
                                             sourceId1);
-    package.imports.emplace_back(qml1ModuleId, Storage::Synchronization::Version{}, sourceId1);
+    package.imports.emplace_back(qml1ModuleId, Storage::Version{}, sourceId1);
     package.moduleDependencies.emplace_back(qml11ModuleId,
-                                            Storage::Synchronization::Version{1, 1},
+                                            Storage::Version{1, 1},
                                             sourceId1);
-    package.imports.emplace_back(qml11ModuleId, Storage::Synchronization::Version{1, 1}, sourceId1);
+    package.imports.emplace_back(qml11ModuleId, Storage::Version{1, 1}, sourceId1);
 
     storage.synchronize(std::move(package));
 
@@ -5481,7 +5481,7 @@ TEST_F(ProjectStorage, ModuleExportedImportDistinguishBetweenDependencyAndImport
 {
     auto package{createModuleExportedImportSynchronizationPackage()};
     package.moduleDependencies.emplace_back(qtQuick3DModuleId,
-                                            Storage::Synchronization::Version{1},
+                                            Storage::Version{1},
                                             sourceId4);
 
     storage.synchronize(std::move(package));
@@ -5517,7 +5517,7 @@ TEST_F(ProjectStorage, ModuleExportedImportWithQualifiedImportedType)
     package.types.back().prototype = Storage::Synchronization::QualifiedImportedType{
         "Object",
         Storage::Synchronization::Import{qtQuick3DModuleId,
-                                         Storage::Synchronization::Version{1},
+                                         Storage::Version{1},
                                          sourceId4}};
 
     storage.synchronize(std::move(package));
@@ -5659,7 +5659,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangeIndirectAliasDeclarationTypeName)
     storage.synchronize(package);
     package.types[2].propertyDeclarations[1].typeName = Storage::Synchronization::ImportedType{
         "Obj2"};
-    importsSourceId3.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId3);
+    importsSourceId3.emplace_back(pathToModuleId, Storage::Version{}, sourceId3);
 
     storage.synchronize(SynchronizationPackage{
         importsSourceId3, {package.types[2]}, {sourceId3}, moduleDependenciesSourceId3, {sourceId3}});
@@ -5685,7 +5685,7 @@ TEST_F(ProjectStorage, SynchronizeTypesChangeIndirectAliasDeclarationTailsTypeNa
     storage.synchronize(package);
     package.types[4].propertyDeclarations[1].typeName = Storage::Synchronization::ImportedType{
         "Obj2"};
-    importsSourceId5.emplace_back(pathToModuleId, Storage::Synchronization::Version{}, sourceId5);
+    importsSourceId5.emplace_back(pathToModuleId, Storage::Version{}, sourceId5);
 
     storage.synchronize(SynchronizationPackage{
         importsSourceId5, {package.types[4]}, {sourceId5}, moduleDependenciesSourceId5, {sourceId5}});
@@ -5947,7 +5947,7 @@ TEST_F(ProjectStorage, GetTypeId)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
 
-    auto typeId = storage.typeId(qmlModuleId, "Object", Storage::Synchronization::Version{});
+    auto typeId = storage.typeId(qmlModuleId, "Object", Storage::Version{});
 
     ASSERT_THAT(typeId, fetchTypeId(sourceId1, "QObject4"));
 }
@@ -5957,7 +5957,7 @@ TEST_F(ProjectStorage, GetNoTypeIdForNonExistingTypeName)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
 
-    auto typeId = storage.typeId(qmlModuleId, "Object2", Storage::Synchronization::Version{});
+    auto typeId = storage.typeId(qmlModuleId, "Object2", Storage::Version{});
 
     ASSERT_FALSE(typeId);
 }
@@ -5967,7 +5967,7 @@ TEST_F(ProjectStorage, GetNoTypeIdForInvalidModuleId)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
 
-    auto typeId = storage.typeId(ModuleId{}, "Object", Storage::Synchronization::Version{});
+    auto typeId = storage.typeId(ModuleId{}, "Object", Storage::Version{});
 
     ASSERT_FALSE(typeId);
 }
@@ -5977,7 +5977,7 @@ TEST_F(ProjectStorage, GetNoTypeIdForWrongModuleId)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
 
-    auto typeId = storage.typeId(qtQuick3DModuleId, "Object", Storage::Synchronization::Version{});
+    auto typeId = storage.typeId(qtQuick3DModuleId, "Object", Storage::Version{});
 
     ASSERT_FALSE(typeId);
 }
@@ -5987,7 +5987,7 @@ TEST_F(ProjectStorage, GetTypeIdWithMajorVersion)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
 
-    auto typeId = storage.typeId(qmlModuleId, "Object", Storage::Synchronization::Version{2});
+    auto typeId = storage.typeId(qmlModuleId, "Object", Storage::Version{2});
 
     ASSERT_THAT(typeId, fetchTypeId(sourceId1, "QObject3"));
 }
@@ -5997,7 +5997,7 @@ TEST_F(ProjectStorage, GetNoTypeIdWithMajorVersionForNonExistingTypeName)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
 
-    auto typeId = storage.typeId(qmlModuleId, "Object2", Storage::Synchronization::Version{2});
+    auto typeId = storage.typeId(qmlModuleId, "Object2", Storage::Version{2});
 
     ASSERT_FALSE(typeId);
 }
@@ -6007,7 +6007,7 @@ TEST_F(ProjectStorage, GetNoTypeIdWithMajorVersionForInvalidModuleId)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
 
-    auto typeId = storage.typeId(ModuleId{}, "Object", Storage::Synchronization::Version{2});
+    auto typeId = storage.typeId(ModuleId{}, "Object", Storage::Version{2});
 
     ASSERT_FALSE(typeId);
 }
@@ -6017,7 +6017,7 @@ TEST_F(ProjectStorage, GetNoTypeIdWithMajorVersionForWrongModuleId)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
 
-    auto typeId = storage.typeId(qtQuick3DModuleId, "Object", Storage::Synchronization::Version{2});
+    auto typeId = storage.typeId(qtQuick3DModuleId, "Object", Storage::Version{2});
 
     ASSERT_FALSE(typeId);
 }
@@ -6027,7 +6027,7 @@ TEST_F(ProjectStorage, GetNoTypeIdWithMajorVersionForWrongVersion)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
 
-    auto typeId = storage.typeId(qmlModuleId, "Object", Storage::Synchronization::Version{4});
+    auto typeId = storage.typeId(qmlModuleId, "Object", Storage::Version{4});
 
     ASSERT_FALSE(typeId);
 }
@@ -6037,7 +6037,7 @@ TEST_F(ProjectStorage, GetTypeIdWithCompleteVersion)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
 
-    auto typeId = storage.typeId(qmlModuleId, "Object", Storage::Synchronization::Version{2, 0});
+    auto typeId = storage.typeId(qmlModuleId, "Object", Storage::Version{2, 0});
 
     ASSERT_THAT(typeId, fetchTypeId(sourceId1, "QObject2"));
 }
@@ -6047,7 +6047,7 @@ TEST_F(ProjectStorage, GetNoTypeIdWithCompleteVersionWithHigherMinorVersion)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
 
-    auto typeId = storage.typeId(qmlModuleId, "Object", Storage::Synchronization::Version{2, 12});
+    auto typeId = storage.typeId(qmlModuleId, "Object", Storage::Version{2, 12});
 
     ASSERT_THAT(typeId, fetchTypeId(sourceId1, "QObject3"));
 }
@@ -6057,7 +6057,7 @@ TEST_F(ProjectStorage, GetNoTypeIdWithCompleteVersionForNonExistingTypeName)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
 
-    auto typeId = storage.typeId(qmlModuleId, "Object2", Storage::Synchronization::Version{2, 0});
+    auto typeId = storage.typeId(qmlModuleId, "Object2", Storage::Version{2, 0});
 
     ASSERT_FALSE(typeId);
 }
@@ -6067,7 +6067,7 @@ TEST_F(ProjectStorage, GetNoTypeIdWithCompleteVersionForInvalidModuleId)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
 
-    auto typeId = storage.typeId(ModuleId{}, "Object", Storage::Synchronization::Version{2, 0});
+    auto typeId = storage.typeId(ModuleId{}, "Object", Storage::Version{2, 0});
 
     ASSERT_FALSE(typeId);
 }
@@ -6077,7 +6077,7 @@ TEST_F(ProjectStorage, GetNoTypeIdWithCompleteVersionForWrongModuleId)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
 
-    auto typeId = storage.typeId(qtQuick3DModuleId, "Object", Storage::Synchronization::Version{2, 0});
+    auto typeId = storage.typeId(qtQuick3DModuleId, "Object", Storage::Version{2, 0});
 
     ASSERT_FALSE(typeId);
 }
@@ -6087,7 +6087,7 @@ TEST_F(ProjectStorage, GetNoTypeIdWithCompleteVersionForWrongMajorVersion)
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
 
-    auto typeId = storage.typeId(qmlModuleId, "Object", Storage::Synchronization::Version{4, 0});
+    auto typeId = storage.typeId(qmlModuleId, "Object", Storage::Version{4, 0});
 
     ASSERT_FALSE(typeId);
 }
diff --git a/tests/unit/unittest/projectstorageupdater-test.cpp b/tests/unit/unittest/projectstorageupdater-test.cpp
index 05b3166bbc..f2f52d401f 100644
--- a/tests/unit/unittest/projectstorageupdater-test.cpp
+++ b/tests/unit/unittest/projectstorageupdater-test.cpp
@@ -31,7 +31,7 @@ using QmlDesigner::Storage::Synchronization::IsAutoVersion;
 using QmlDesigner::Storage::Synchronization::ModuleExportedImport;
 using QmlDesigner::Storage::Synchronization::ProjectData;
 using QmlDesigner::Storage::Synchronization::SynchronizationPackage;
-using QmlDesigner::Storage::Synchronization::Version;
+using QmlDesigner::Storage::Version;
 
 MATCHER_P5(IsStorageType,
            typeName,
@@ -71,12 +71,12 @@ MATCHER_P4(IsExportedType,
            minorVersion,
            std::string(negation ? "isn't " : "is ")
                + PrintToString(Storage::Synchronization::ExportedType{
-                   moduleId, name, Storage::Synchronization::Version{majorVersion, minorVersion}}))
+                   moduleId, name, Storage::Version{majorVersion, minorVersion}}))
 {
     const Storage::Synchronization::ExportedType &type = arg;
 
     return type.moduleId == moduleId && type.name == name
-           && type.version == Storage::Synchronization::Version{majorVersion, minorVersion};
+           && type.version == Storage::Version{majorVersion, minorVersion};
 }
 
 MATCHER_P3(IsFileStatus,
@@ -328,19 +328,19 @@ protected:
     Storage::Synchronization::Type secondType;
     Storage::Synchronization::Type thirdType;
     Storage::Synchronization::Import import1{qmlModuleId,
-                                             Storage::Synchronization::Version{2, 3},
+                                             Storage::Version{2, 3},
                                              qmlDocumentSourceId1};
     Storage::Synchronization::Import import2{qmlModuleId,
-                                             Storage::Synchronization::Version{},
+                                             Storage::Version{},
                                              qmlDocumentSourceId2};
     Storage::Synchronization::Import import3{qmlModuleId,
-                                             Storage::Synchronization::Version{2},
+                                             Storage::Version{2},
                                              qmlDocumentSourceId3};
     Storage::Synchronization::Import import4{qmlModuleId,
-                                             Storage::Synchronization::Version{2, 3},
+                                             Storage::Version{2, 3},
                                              qmltypesPathSourceId};
     Storage::Synchronization::Import import5{qmlModuleId,
-                                             Storage::Synchronization::Version{2, 3},
+                                             Storage::Version{2, 3},
                                              qmltypes2PathSourceId};
     QString qmldirContent{"module Example\ntypeinfo example.qmltypes\n"};
     QString qmltypes1{"Module {\ndependencies: [module1]}"};
@@ -456,7 +456,7 @@ TEST_F(ProjectStorageUpdater, SynchronizeIsEmptyForNoChange)
 TEST_F(ProjectStorageUpdater, SynchronizeQmlTypes)
 {
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{2, 3},
+                                            Storage::Version{2, 3},
                                             qmltypesPathSourceId};
     QString qmltypes{"Module {\ndependencies: []}"};
     setQmlFileNames(u"/path", {});
@@ -493,7 +493,7 @@ TEST_F(ProjectStorageUpdater, SynchronizeQmlTypes)
 TEST_F(ProjectStorageUpdater, SynchronizeQmlTypesThrowsIfQmltpesDoesNotExists)
 {
     Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Synchronization::Version{2, 3},
+                                            Storage::Version{2, 3},
                                             qmltypesPathSourceId};
     setFilesDontExists({qmltypesPathSourceId});
 
@@ -1329,16 +1329,16 @@ TEST_F(ProjectStorageUpdater, SynchronizeQmldirDependencies)
                 synchronize(
                     AllOf(Field(&SynchronizationPackage::moduleDependencies,
                                 UnorderedElementsAre(Import{qmlCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             qmltypesPathSourceId},
                                                      Import{builtinCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             qmltypesPathSourceId},
                                                      Import{qmlCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             qmltypes2PathSourceId},
                                                      Import{builtinCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             qmltypes2PathSourceId})),
                           Field(&SynchronizationPackage::updatedModuleDependencySourceIds,
                                 UnorderedElementsAre(qmltypesPathSourceId, qmltypes2PathSourceId)))));
@@ -1361,16 +1361,16 @@ TEST_F(ProjectStorageUpdater, SynchronizeQmldirDependenciesWithDoubleEntries)
                 synchronize(
                     AllOf(Field(&SynchronizationPackage::moduleDependencies,
                                 UnorderedElementsAre(Import{qmlCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             qmltypesPathSourceId},
                                                      Import{builtinCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             qmltypesPathSourceId},
                                                      Import{qmlCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             qmltypes2PathSourceId},
                                                      Import{builtinCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             qmltypes2PathSourceId})),
                           Field(&SynchronizationPackage::updatedModuleDependencySourceIds,
                                 UnorderedElementsAre(qmltypesPathSourceId, qmltypes2PathSourceId)))));
@@ -1393,16 +1393,16 @@ TEST_F(ProjectStorageUpdater, SynchronizeQmldirDependenciesWithCollidingImports)
                 synchronize(
                     AllOf(Field(&SynchronizationPackage::moduleDependencies,
                                 UnorderedElementsAre(Import{qmlCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             qmltypesPathSourceId},
                                                      Import{builtinCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             qmltypesPathSourceId},
                                                      Import{qmlCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             qmltypes2PathSourceId},
                                                      Import{builtinCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             qmltypes2PathSourceId})),
                           Field(&SynchronizationPackage::updatedModuleDependencySourceIds,
                                 UnorderedElementsAre(qmltypesPathSourceId, qmltypes2PathSourceId)))));
@@ -1442,27 +1442,27 @@ TEST_F(ProjectStorageUpdater, SynchronizeQmldirImports)
             Field(&SynchronizationPackage::moduleExportedImports,
                   UnorderedElementsAre(ModuleExportedImport{exampleModuleId,
                                                             qmlModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             IsAutoVersion::Yes},
                                        ModuleExportedImport{exampleCppNativeModuleId,
                                                             qmlCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             IsAutoVersion::No},
                                        ModuleExportedImport{exampleModuleId,
                                                             builtinModuleId,
-                                                            Storage::Synchronization::Version{2, 1},
+                                                            Storage::Version{2, 1},
                                                             IsAutoVersion::No},
                                        ModuleExportedImport{exampleCppNativeModuleId,
                                                             builtinCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             IsAutoVersion::No},
                                        ModuleExportedImport{exampleModuleId,
                                                             quickModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             IsAutoVersion::No},
                                        ModuleExportedImport{exampleCppNativeModuleId,
                                                             quickCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             IsAutoVersion::No})),
             Field(&SynchronizationPackage::updatedModuleIds, ElementsAre(exampleModuleId)))));
 
@@ -1499,27 +1499,27 @@ TEST_F(ProjectStorageUpdater, SynchronizeQmldirImportsWithDoubleEntries)
             Field(&SynchronizationPackage::moduleExportedImports,
                   UnorderedElementsAre(ModuleExportedImport{exampleModuleId,
                                                             qmlModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             IsAutoVersion::Yes},
                                        ModuleExportedImport{exampleCppNativeModuleId,
                                                             qmlCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             IsAutoVersion::No},
                                        ModuleExportedImport{exampleModuleId,
                                                             builtinModuleId,
-                                                            Storage::Synchronization::Version{2, 1},
+                                                            Storage::Version{2, 1},
                                                             IsAutoVersion::No},
                                        ModuleExportedImport{exampleCppNativeModuleId,
                                                             builtinCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             IsAutoVersion::No},
                                        ModuleExportedImport{exampleModuleId,
                                                             quickModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             IsAutoVersion::No},
                                        ModuleExportedImport{exampleCppNativeModuleId,
                                                             quickCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             IsAutoVersion::No})),
             Field(&SynchronizationPackage::updatedModuleIds, ElementsAre(exampleModuleId)))));
 
@@ -1541,27 +1541,27 @@ TEST_F(ProjectStorageUpdater, SynchronizeQmldirOptionalImports)
             Field(&SynchronizationPackage::moduleExportedImports,
                   UnorderedElementsAre(ModuleExportedImport{exampleModuleId,
                                                             qmlModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             IsAutoVersion::Yes},
                                        ModuleExportedImport{exampleCppNativeModuleId,
                                                             qmlCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             IsAutoVersion::No},
                                        ModuleExportedImport{exampleModuleId,
                                                             builtinModuleId,
-                                                            Storage::Synchronization::Version{2, 1},
+                                                            Storage::Version{2, 1},
                                                             IsAutoVersion::No},
                                        ModuleExportedImport{exampleCppNativeModuleId,
                                                             builtinCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             IsAutoVersion::No},
                                        ModuleExportedImport{exampleModuleId,
                                                             quickModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             IsAutoVersion::No},
                                        ModuleExportedImport{exampleCppNativeModuleId,
                                                             quickCppNativeModuleId,
-                                                            Storage::Synchronization::Version{},
+                                                            Storage::Version{},
                                                             IsAutoVersion::No})),
             Field(&SynchronizationPackage::updatedModuleIds, ElementsAre(exampleModuleId)))));
 
diff --git a/tests/unit/unittest/qmldocumentparser-test.cpp b/tests/unit/unittest/qmldocumentparser-test.cpp
index 7ed83ef891..a9103d06ea 100644
--- a/tests/unit/unittest/qmldocumentparser-test.cpp
+++ b/tests/unit/unittest/qmldocumentparser-test.cpp
@@ -166,10 +166,11 @@ TEST_F(QmlDocumentParser, QualifiedPrototype)
     auto type = parser.parse(text, imports, qmlFileSourceId, directoryPath);
 
     ASSERT_THAT(type,
-                HasPrototype(Storage::QualifiedImportedType("Item",
-                                                            Storage::Import{exampleModuleId,
-                                                                            Storage::Version{2, 1},
-                                                                            qmlFileSourceId})));
+                HasPrototype(
+                    Storage::QualifiedImportedType("Item",
+                                                   Storage::Import{exampleModuleId,
+                                                                   QmlDesigner::Storage::Version{2, 1},
+                                                                   qmlFileSourceId})));
 }
 
 TEST_F(QmlDocumentParser, Properties)
@@ -198,7 +199,7 @@ TEST_F(QmlDocumentParser, QualifiedProperties)
                     "foo",
                     Storage::QualifiedImportedType("Foo",
                                                    Storage::Import{exampleModuleId,
-                                                                   Storage::Version{2, 1},
+                                                                   QmlDesigner::Storage::Version{2, 1},
                                                                    qmlFileSourceId}),
                     QmlDesigner::Storage::PropertyDeclarationTraits::None)));
 }
@@ -233,7 +234,7 @@ TEST_F(QmlDocumentParser, QualifiedEnumerationInProperties)
                     "foo",
                     Storage::QualifiedImportedType("Enumeration.Foo",
                                                    Storage::Import{exampleModuleId,
-                                                                   Storage::Version{2, 1},
+                                                                   QmlDesigner::Storage::Version{2, 1},
                                                                    qmlFileSourceId}),
                     QmlDesigner::Storage::PropertyDeclarationTraits::None)));
 }
@@ -251,12 +252,13 @@ TEST_F(QmlDocumentParser, Imports)
                              qmlFileSourceId,
                              directoryPath);
 
-    ASSERT_THAT(imports,
-                UnorderedElementsAre(
-                    Storage::Import{directoryModuleId, Storage::Version{}, qmlFileSourceId},
-                    Storage::Import{fooDirectoryModuleId, Storage::Version{}, qmlFileSourceId},
-                    Storage::Import{qmlModuleId, Storage::Version{}, qmlFileSourceId},
-                    Storage::Import{qtQuickModuleId, Storage::Version{}, qmlFileSourceId}));
+    ASSERT_THAT(
+        imports,
+        UnorderedElementsAre(
+            Storage::Import{directoryModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
+            Storage::Import{fooDirectoryModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
+            Storage::Import{qmlModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
+            Storage::Import{qtQuickModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId}));
 }
 
 TEST_F(QmlDocumentParser, ImportsWithVersion)
@@ -272,12 +274,13 @@ TEST_F(QmlDocumentParser, ImportsWithVersion)
                              qmlFileSourceId,
                              directoryPath);
 
-    ASSERT_THAT(imports,
-                UnorderedElementsAre(
-                    Storage::Import{directoryModuleId, Storage::Version{}, qmlFileSourceId},
-                    Storage::Import{fooDirectoryModuleId, Storage::Version{}, qmlFileSourceId},
-                    Storage::Import{qmlModuleId, Storage::Version{}, qmlFileSourceId},
-                    Storage::Import{qtQuickModuleId, Storage::Version{2, 1}, qmlFileSourceId}));
+    ASSERT_THAT(
+        imports,
+        UnorderedElementsAre(
+            Storage::Import{directoryModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
+            Storage::Import{fooDirectoryModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
+            Storage::Import{qmlModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
+            Storage::Import{qtQuickModuleId, QmlDesigner::Storage::Version{2, 1}, qmlFileSourceId}));
 }
 
 TEST_F(QmlDocumentParser, ImportsWithExplictDirectory)
@@ -293,11 +296,11 @@ TEST_F(QmlDocumentParser, ImportsWithExplictDirectory)
                              qmlFileSourceId,
                              directoryPath);
 
-    ASSERT_THAT(
-        imports,
-        UnorderedElementsAre(Storage::Import{directoryModuleId, Storage::Version{}, qmlFileSourceId},
-                             Storage::Import{qmlModuleId, Storage::Version{}, qmlFileSourceId},
-                             Storage::Import{qtQuickModuleId, Storage::Version{}, qmlFileSourceId}));
+    ASSERT_THAT(imports,
+                UnorderedElementsAre(
+                    Storage::Import{directoryModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
+                    Storage::Import{qmlModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
+                    Storage::Import{qtQuickModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId}));
 }
 
 TEST_F(QmlDocumentParser, Functions)
@@ -373,13 +376,14 @@ TEST_F(QmlDocumentParser, DISABLED_DuplicateImportsAreRemoved)
                              qmlFileSourceId,
                              directoryPath);
 
-    ASSERT_THAT(imports,
-                UnorderedElementsAre(
-                    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}));
+    ASSERT_THAT(
+        imports,
+        UnorderedElementsAre(
+            Storage::Import{directoryModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
+            Storage::Import{fooDirectoryModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
+            Storage::Import{qmlModuleId, QmlDesigner::Storage::Version{1, 0}, qmlFileSourceId},
+            Storage::Import{qtQmlModuleId, QmlDesigner::Storage::Version{6, 0}, qmlFileSourceId},
+            Storage::Import{qtQuickModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId}));
 }
 
 TEST_F(QmlDocumentParser, AliasItemProperties)
@@ -510,7 +514,7 @@ TEST_F(QmlDocumentParser, QualifiedListProperty)
                     "foos",
                     Storage::QualifiedImportedType{"Foo",
                                                    Storage::Import{exampleModuleId,
-                                                                   Storage::Version{2, 1},
+                                                                   QmlDesigner::Storage::Version{2, 1},
                                                                    qmlFileSourceId}},
                     QmlDesigner::Storage::PropertyDeclarationTraits::IsList)));
 }
diff --git a/tests/unit/unittest/qmltypesparser-test.cpp b/tests/unit/unittest/qmltypesparser-test.cpp
index cc4fe6def4..3fbbaa6b8c 100644
--- a/tests/unit/unittest/qmltypesparser-test.cpp
+++ b/tests/unit/unittest/qmltypesparser-test.cpp
@@ -171,14 +171,22 @@ TEST_F(QmlTypesParser, Imports)
 
     parser.parse(source, imports, types, projectData);
 
-    ASSERT_THAT(
-        imports,
-        UnorderedElementsAre(
-            IsImport(storage.moduleId("QML-cppnative"), Storage::Version{}, qmltypesFileSourceId),
-            IsImport(storage.moduleId("QtQml-cppnative"), Storage::Version{}, qmltypesFileSourceId),
-            IsImport(storage.moduleId("QtQuick-cppnative"), Storage::Version{}, qmltypesFileSourceId),
-            IsImport(storage.moduleId("QtQuick.Window-cppnative"), Storage::Version{}, qmltypesFileSourceId),
-            IsImport(storage.moduleId("QtFoo-cppnative"), Storage::Version{}, qmltypesFileSourceId)));
+    ASSERT_THAT(imports,
+                UnorderedElementsAre(IsImport(storage.moduleId("QML-cppnative"),
+                                              QmlDesigner::Storage::Version{},
+                                              qmltypesFileSourceId),
+                                     IsImport(storage.moduleId("QtQml-cppnative"),
+                                              QmlDesigner::Storage::Version{},
+                                              qmltypesFileSourceId),
+                                     IsImport(storage.moduleId("QtQuick-cppnative"),
+                                              QmlDesigner::Storage::Version{},
+                                              qmltypesFileSourceId),
+                                     IsImport(storage.moduleId("QtQuick.Window-cppnative"),
+                                              QmlDesigner::Storage::Version{},
+                                              qmltypesFileSourceId),
+                                     IsImport(storage.moduleId("QtFoo-cppnative"),
+                                              QmlDesigner::Storage::Version{},
+                                              qmltypesFileSourceId)));
 }
 
 TEST_F(QmlTypesParser, Types)
@@ -261,13 +269,14 @@ TEST_F(QmlTypesParser, ExportedTypes)
 
     parser.parse(source, imports, types, projectData);
 
-    ASSERT_THAT(types,
-                ElementsAre(
-                    Field(&Storage::Type::exportedTypes,
-                          UnorderedElementsAre(
-                              IsExportedType(qmlModuleId, "QtObject", Storage::Version{1, 0}),
-                              IsExportedType(qtQmlModuleId, "QtObject", Storage::Version{2, 1}),
-                              IsExportedType(qtQmlNativeModuleId, "QObject", Storage::Version{})))));
+    ASSERT_THAT(
+        types,
+        ElementsAre(Field(
+            &Storage::Type::exportedTypes,
+            UnorderedElementsAre(
+                IsExportedType(qmlModuleId, "QtObject", QmlDesigner::Storage::Version{1, 0}),
+                IsExportedType(qtQmlModuleId, "QtObject", QmlDesigner::Storage::Version{2, 1}),
+                IsExportedType(qtQmlNativeModuleId, "QObject", QmlDesigner::Storage::Version{})))));
 }
 
 TEST_F(QmlTypesParser, Properties)
@@ -567,30 +576,28 @@ TEST_F(QmlTypesParser, EnumerationIsExportedAsType)
 
     parser.parse(source, imports, types, projectData);
 
-    ASSERT_THAT(types,
-                UnorderedElementsAre(
-                    AllOf(IsType("QObject::NamedColorSpace",
-                                 Storage::ImportedType{},
-                                 Storage::ImportedType{},
-                                 QmlDesigner::Storage::TypeTraits::Value
-                                     | QmlDesigner::Storage::TypeTraits::IsEnum,
-                                 qmltypesFileSourceId),
-                          Field(&Storage::Type::exportedTypes,
-                                UnorderedElementsAre(IsExportedType(qtQmlNativeModuleId,
-                                                                    "QObject::NamedColorSpace",
-                                                                    Storage::Version{})))),
-                    AllOf(IsType("QObject::VerticalLayoutDirection",
-                                 Storage::ImportedType{},
-                                 Storage::ImportedType{},
-                                 QmlDesigner::Storage::TypeTraits::Value
-                                     | QmlDesigner::Storage::TypeTraits::IsEnum,
-                                 qmltypesFileSourceId),
-                          Field(&Storage::Type::exportedTypes,
-                                UnorderedElementsAre(
-                                    IsExportedType(qtQmlNativeModuleId,
-                                                   "QObject::VerticalLayoutDirection",
-                                                   Storage::Version{})))),
-                    _));
+    ASSERT_THAT(
+        types,
+        UnorderedElementsAre(
+            AllOf(IsType("QObject::NamedColorSpace",
+                         Storage::ImportedType{},
+                         Storage::ImportedType{},
+                         QmlDesigner::Storage::TypeTraits::Value | QmlDesigner::Storage::TypeTraits::IsEnum,
+                         qmltypesFileSourceId),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qtQmlNativeModuleId,
+                                                            "QObject::NamedColorSpace",
+                                                            QmlDesigner::Storage::Version{})))),
+            AllOf(IsType("QObject::VerticalLayoutDirection",
+                         Storage::ImportedType{},
+                         Storage::ImportedType{},
+                         QmlDesigner::Storage::TypeTraits::Value | QmlDesigner::Storage::TypeTraits::IsEnum,
+                         qmltypesFileSourceId),
+                  Field(&Storage::Type::exportedTypes,
+                        UnorderedElementsAre(IsExportedType(qtQmlNativeModuleId,
+                                                            "QObject::VerticalLayoutDirection",
+                                                            QmlDesigner::Storage::Version{})))),
+            _));
 }
 
 TEST_F(QmlTypesParser, EnumerationIsExportedAsTypeWithAlias)
@@ -624,10 +631,10 @@ TEST_F(QmlTypesParser, EnumerationIsExportedAsTypeWithAlias)
                           Field(&Storage::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQmlNativeModuleId,
                                                                     "QObject::NamedColorSpace",
-                                                                    Storage::Version{}),
+                                                                    QmlDesigner::Storage::Version{}),
                                                      IsExportedType(qtQmlNativeModuleId,
                                                                     "QObject::NamedColorSpaces",
-                                                                    Storage::Version{})))),
+                                                                    QmlDesigner::Storage::Version{})))),
                     _));
 }
 
@@ -671,10 +678,10 @@ TEST_F(QmlTypesParser, EnumerationIsExportedAsTypeWithAliasToo)
                           Field(&Storage::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQmlNativeModuleId,
                                                                     "QObject::NamedColorSpace",
-                                                                    Storage::Version{}),
+                                                                    QmlDesigner::Storage::Version{}),
                                                      IsExportedType(qtQmlNativeModuleId,
                                                                     "QObject::NamedColorSpaces",
-                                                                    Storage::Version{})))),
+                                                                    QmlDesigner::Storage::Version{})))),
                     _));
 }