diff --git a/src/plugins/qmldesigner/components/assetslibrary/assetslibrarywidget.cpp b/src/plugins/qmldesigner/components/assetslibrary/assetslibrarywidget.cpp
index 067cff57a49..3b98eb6baf9 100644
--- a/src/plugins/qmldesigner/components/assetslibrary/assetslibrarywidget.cpp
+++ b/src/plugins/qmldesigner/components/assetslibrary/assetslibrarywidget.cpp
@@ -273,8 +273,11 @@ void AssetsLibraryWidget::setHasSceneEnv(bool b)
     emit hasSceneEnvChanged();
 }
 
-void AssetsLibraryWidget::handleDeleteEffects(const QStringList &effectNames)
+void AssetsLibraryWidget::handleDeleteEffects([[maybe_unused]] const QStringList &effectNames)
 {
+#ifdef QDS_USE_PROJECTSTORAGE
+// That code has to rewritten with modules. Seem try to find all effects nodes.
+#else
     DesignDocument *document = QmlDesignerPlugin::instance()->currentDesignDocument();
     if (!document)
         return;
@@ -340,6 +343,7 @@ void AssetsLibraryWidget::handleDeleteEffects(const QStringList &effectNames)
         document->clearUndoRedoStacks();
 
     m_assetsView->emitCustomNotification("effectcomposer_effects_deleted", {}, {effectNames});
+#endif
 }
 
 void AssetsLibraryWidget::invalidateThumbnail(const QString &id)
diff --git a/src/plugins/qmldesigner/components/bindingeditor/actioneditor.cpp b/src/plugins/qmldesigner/components/bindingeditor/actioneditor.cpp
index 5336f6b4dd4..bd63742d5e7 100644
--- a/src/plugins/qmldesigner/components/bindingeditor/actioneditor.cpp
+++ b/src/plugins/qmldesigner/components/bindingeditor/actioneditor.cpp
@@ -229,6 +229,7 @@ void ActionEditor::prepareConnections()
     QList<ActionEditorDialog::SingletonOption> singletons;
     QStringList states;
 
+    [[maybe_unused]] auto model = m_modelNode.model();
     const QList<QmlDesigner::ModelNode> allNodes = m_modelNode.view()->allModelNodes();
     for (const auto &modelNode : allNodes) {
         // Skip nodes without specified id
@@ -240,11 +241,19 @@ void ActionEditor::prepareConnections()
         for (const auto &property : modelNode.metaInfo().properties()) {
             if (isSkippedType(property.propertyType()))
                 continue;
-
+#ifdef QDS_USE_PROJECTSTORAGE
+            auto exportedTypeName = model->exportedTypeNameForMetaInfo(property.propertyType())
+                                        .name.toQByteArray();
+            connection.properties.append(
+                ActionEditorDialog::PropertyOption(QString::fromUtf8(property.name()),
+                                                   exportedTypeName,
+                                                   property.isWritable()));
+#else
             connection.properties.append(
                 ActionEditorDialog::PropertyOption(QString::fromUtf8(property.name()),
                                                    skipCpp(property.propertyType().typeName()),
                                                    property.isWritable()));
+#endif
         }
 
         for (const VariantProperty &variantProperty : modelNode.variantProperties()) {
@@ -305,11 +314,21 @@ void ActionEditor::prepareConnections()
                     for (const auto &property : metaInfo.properties()) {
                         if (isSkippedType(property.propertyType()))
                             continue;
-
+#ifdef QDS_USE_PROJECTSTORAGE
+                        auto exportedTypeName = model
+                                                    ->exportedTypeNameForMetaInfo(
+                                                        property.propertyType())
+                                                    .name.toQByteArray();
+                        singelton.properties.append(
+                            ActionEditorDialog::PropertyOption(QString::fromUtf8(property.name()),
+                                                               exportedTypeName,
+                                                               property.isWritable()));
+#else
                         singelton.properties.append(ActionEditorDialog::PropertyOption(
                             QString::fromUtf8(property.name()),
                             skipCpp(property.propertyType().typeName()),
                             property.isWritable()));
+#endif
                     }
 
                     if (!singelton.properties.isEmpty()) {
diff --git a/src/plugins/qmldesigner/components/bindingeditor/bindingeditor.cpp b/src/plugins/qmldesigner/components/bindingeditor/bindingeditor.cpp
index c03c31208fc..6a77b6235eb 100644
--- a/src/plugins/qmldesigner/components/bindingeditor/bindingeditor.cpp
+++ b/src/plugins/qmldesigner/components/bindingeditor/bindingeditor.cpp
@@ -176,22 +176,22 @@ bool isType(const TypeName &first, const TypeName &second, const Tuple &...types
 
 bool compareTypes(const NodeMetaInfo &sourceType, const NodeMetaInfo &targetType)
 {
-    if constexpr (useProjectStorage()) {
-        return targetType.isVariant() || sourceType.isVariant() || targetType == sourceType
-               || (targetType.isNumber() && sourceType.isNumber())
-               || (targetType.isColor() && sourceType.isColor())
-               || (targetType.isString() && sourceType.isString());
-    } else {
-        const TypeName source = sourceType.simplifiedTypeName();
-        const TypeName target = targetType.simplifiedTypeName();
+#ifdef QDS_USE_PROJECTSTORAGE
+    return targetType.isVariant() || sourceType.isVariant() || targetType == sourceType
+           || (targetType.isNumber() && sourceType.isNumber())
+           || (targetType.isColor() && sourceType.isColor())
+           || (targetType.isString() && sourceType.isString());
+#else
+    const TypeName source = sourceType.simplifiedTypeName();
+    const TypeName target = targetType.simplifiedTypeName();
 
-        static constexpr auto variantTypes = std::make_tuple("alias", "unknown", "variant", "var");
+    static constexpr auto variantTypes = std::make_tuple("alias", "unknown", "variant", "var");
 
-        return isType(variantTypes, target) || isType(variantTypes, source) || target == source
-               || targetType == sourceType || isType(target, source, "double", "real", "int")
-               || isType(target, source, "QColor", "color")
-               || isType(target, source, "QString", "string");
-    }
+    return isType(variantTypes, target) || isType(variantTypes, source) || target == source
+           || targetType == sourceType || isType(target, source, "double", "real", "int")
+           || isType(target, source, "QColor", "color")
+           || isType(target, source, "QString", "string");
+#endif
 }
 } // namespace
 
@@ -287,8 +287,13 @@ void BindingEditor::updateWindowName()
                                + exportedTypeNames.front().name.toQString() + "]";
             }
         } else {
+#ifdef QDS_USE_PROJECTSTORAGE
+            targetString = " [" + (m_targetName.isEmpty() ? QString() : (m_targetName + ": "))
+                           + QString::fromUtf8(m_backendValueType.displayName()) + "]";
+#else
             targetString = " [" + (m_targetName.isEmpty() ? QString() : (m_targetName + ": "))
                            + QString::fromUtf8(m_backendValueType.simplifiedTypeName()) + "]";
+#endif
         }
 
         m_dialog->setWindowTitle(m_dialog->defaultTitle() + targetString);
diff --git a/src/plugins/qmldesigner/components/bindingeditor/signallist.cpp b/src/plugins/qmldesigner/components/bindingeditor/signallist.cpp
index 46470682519..12a605e58a0 100644
--- a/src/plugins/qmldesigner/components/bindingeditor/signallist.cpp
+++ b/src/plugins/qmldesigner/components/bindingeditor/signallist.cpp
@@ -218,14 +218,18 @@ void SignalList::addConnection(const QModelIndex &modelIndex)
     const ModelNode rootModelNode = view->rootModelNode();
 
     if (rootModelNode.isValid() && rootModelNode.metaInfo().isValid()) {
-        NodeMetaInfo nodeMetaInfo = view->model()->qtQuickConnectionsMetaInfo();
+#ifndef QDS_USE_PROJECTSTORAGE
+        NodeMetaInfo nodeMetaInfo = view->model()->qtQmlConnectionsMetaInfo();
         if (nodeMetaInfo.isValid()) {
-            view->executeInTransaction("ConnectionModel::addConnection",
-                                       [this, view, nodeMetaInfo, targetModelIndex, modelIndex,
-                                        buttonModelIndex, signalName, &rootModelNode] {
+#endif
+            view->executeInTransaction("ConnectionModel::addConnection", [&] {
+#ifdef QDS_USE_PROJECTSTORAGE
+                ModelNode newNode = view->createModelNode("Connections");
+#else
                 ModelNode newNode = view->createModelNode("QtQuick.Connections",
                                                           nodeMetaInfo.majorVersion(),
                                                           nodeMetaInfo.minorVersion());
+#endif
                 const QString source = m_modelNode.validId() + ".trigger()";
 
                 if (QmlItemNode::isValidQmlItemNode(m_modelNode))
@@ -240,7 +244,9 @@ void SignalList::addConnection(const QModelIndex &modelIndex)
                 m_model->setConnected(modelIndex.row(), true);
                 m_model->setData(buttonModelIndex, newNode.internalId(), SignalListModel::ConnectionsInternalIdRole);
             });
+#ifndef QDS_USE_PROJECTSTORAGE
         }
+#endif
     }
 }
 
diff --git a/src/plugins/qmldesigner/components/collectioneditor/collectionview.cpp b/src/plugins/qmldesigner/components/collectioneditor/collectionview.cpp
index 723d0beca88..93efc36a4fc 100644
--- a/src/plugins/qmldesigner/components/collectioneditor/collectionview.cpp
+++ b/src/plugins/qmldesigner/components/collectioneditor/collectionview.cpp
@@ -29,10 +29,9 @@
 
 namespace {
 
-inline bool isStudioCollectionModel(const QmlDesigner::ModelNode &node)
+bool isStudioCollectionModel(const QmlDesigner::ModelNode &node)
 {
-    using namespace QmlDesigner::CollectionEditorConstants;
-    return node.metaInfo().typeName() == JSONCOLLECTIONMODEL_TYPENAME;
+    return node.metaInfo().isQtQuickStudioUtilsJsonListModel();
 }
 
 inline void setVariantPropertyValue(const QmlDesigner::ModelNode &node,
@@ -201,11 +200,14 @@ void CollectionView::addResource(const QUrl &url, const QString &name)
         } else {
             sourceAddress = url.toString();
         }
-
+#ifdef QDS_USE_PROJECTSTORAGE
+        ModelNode resourceNode = createModelNode("JsonListModel");
+#else
         const NodeMetaInfo resourceMetaInfo = jsonCollectionMetaInfo();
         ModelNode resourceNode = createModelNode(resourceMetaInfo.typeName(),
                                                  resourceMetaInfo.majorVersion(),
                                                  resourceMetaInfo.minorVersion());
+#endif
         VariantProperty sourceProperty = resourceNode.variantProperty(
             CollectionEditorConstants::SOURCEFILE_PROPERTY);
         VariantProperty nameProperty = resourceNode.variantProperty("objectName");
diff --git a/src/plugins/qmldesigner/components/componentcore/designeractionmanager.cpp b/src/plugins/qmldesigner/components/componentcore/designeractionmanager.cpp
index eabe612fda3..27afaa08f2b 100644
--- a/src/plugins/qmldesigner/components/componentcore/designeractionmanager.cpp
+++ b/src/plugins/qmldesigner/components/componentcore/designeractionmanager.cpp
@@ -579,10 +579,14 @@ QList<SlotList> getSlotsLists(const ModelNode &node)
 //creates connection without signalHandlerProperty
 ModelNode createNewConnection(ModelNode targetNode)
 {
-    NodeMetaInfo connectionsMetaInfo = targetNode.view()->model()->qtQuickConnectionsMetaInfo();
+#ifdef QDS_USE_PROJECTSTORAGE
+    ModelNode newConnectionNode = targetNode.view()->createModelNode("Connections");
+#else
+    NodeMetaInfo connectionsMetaInfo = targetNode.view()->model()->qtQmlConnectionsMetaInfo();
     const auto typeName = useProjectStorage() ? "Connections" : "QtQuick.Connections";
     ModelNode newConnectionNode = targetNode.view()->createModelNode(
         typeName, connectionsMetaInfo.majorVersion(), connectionsMetaInfo.minorVersion());
+#endif
     if (QmlItemNode::isValidQmlItemNode(targetNode)) {
         targetNode.nodeAbstractProperty("data").reparentHere(newConnectionNode);
     } else {
@@ -874,20 +878,9 @@ public:
         NodeMetaInfo modelMetaInfo = view->model()->metaInfo("ListModel");
         NodeMetaInfo elementMetaInfo = view->model()->metaInfo("ListElement");
 
-        ListModelEditorModel model{[&] {
-                                       return view->createModelNode(useProjectStorage()
-                                                                        ? "ListModel"
-                                                                        : "QtQml.Models.ListModel",
-                                                                    modelMetaInfo.majorVersion(),
-                                                                    modelMetaInfo.minorVersion());
-                                   },
-                                   [&] {
-                                       return view->createModelNode(
-                                           useProjectStorage() ? "ListElement"
-                                                               : "QtQml.Models.ListElement",
-                                           elementMetaInfo.majorVersion(),
-                                           elementMetaInfo.minorVersion());
-                                   },
+#ifdef QDS_USE_PROJECTSTORAGE
+        ListModelEditorModel model{[&] { return view->createModelNode("ListModel"); },
+                                   [&] { return view->createModelNode("ListElement"); },
                                    [&](const ModelNode &node) {
                                        bool isNowInComponent = ModelNodeOperations::goIntoComponent(
                                            node);
@@ -906,6 +899,33 @@ public:
 
                                        return node;
                                    }};
+#else
+        ListModelEditorModel model{
+            [&] {
+                return view->createModelNode("QtQml.Models.ListModel",
+                                             modelMetaInfo.majorVersion(),
+                                             modelMetaInfo.minorVersion());
+            },
+            [&] {
+                return view->createModelNode("QtQml.Models.ListElement",
+                                             elementMetaInfo.majorVersion(),
+                                             elementMetaInfo.minorVersion());
+            },
+            [&](const ModelNode &node) {
+                bool isNowInComponent = ModelNodeOperations::goIntoComponent(node);
+
+                Model *currentModel = QmlDesignerPlugin::instance()->currentDesignDocument()->currentModel();
+
+                if (currentModel->rewriterView() && !currentModel->rewriterView()->errors().isEmpty()) {
+                    throw DocumentError{};
+                }
+
+                if (isNowInComponent)
+                    return view->rootModelNode();
+
+                return node;
+            }};
+#endif
 
         model.setListView(targetNode);
 
diff --git a/src/plugins/qmldesigner/components/componentcore/layoutingridlayout.cpp b/src/plugins/qmldesigner/components/componentcore/layoutingridlayout.cpp
index a323654b6b5..8d3412e0e85 100644
--- a/src/plugins/qmldesigner/components/componentcore/layoutingridlayout.cpp
+++ b/src/plugins/qmldesigner/components/componentcore/layoutingridlayout.cpp
@@ -169,9 +169,12 @@ void LayoutInGridLayout::doIt()
 
             m_selectionContext.view()->executeInTransaction("LayoutInGridLayout1",[this, &layoutNode, layoutType](){
                 QTC_ASSERT(m_selectionContext.view()->model()->hasNodeMetaInfo(layoutType), return);
-
+#ifdef QDS_USE_PROJECTSTORAGE
+                layoutNode = m_selectionContext.view()->createModelNode(layoutType);
+#else
                 NodeMetaInfo metaInfo = m_selectionContext.view()->model()->metaInfo(layoutType);
                 layoutNode = m_selectionContext.view()->createModelNode(layoutType, metaInfo.majorVersion(), metaInfo.minorVersion());
+#endif
                 reparentTo(layoutNode, m_parentNode);
             });
 
@@ -387,10 +390,13 @@ void LayoutInGridLayout::fillEmptyCells()
                 if (y > 0)
                     yPos = m_yTopOffsets.at(y-1);
 
+#ifdef QDS_USE_PROJECTSTORAGE
+                ModelNode newNode = m_selectionContext.view()->createModelNode("Item");
+#else
                 NodeMetaInfo metaInfo = m_selectionContext.view()->model()->metaInfo("QtQuick.Item");
 
                 ModelNode newNode = m_selectionContext.view()->createModelNode("QtQuick.Item", metaInfo.majorVersion(), metaInfo.minorVersion());
-
+#endif
                 reparentTo(newNode, m_parentNode);
 
                 m_spacerNodes.append(newNode);
diff --git a/src/plugins/qmldesigner/components/componentcore/modelnodeoperations.cpp b/src/plugins/qmldesigner/components/componentcore/modelnodeoperations.cpp
index ca7bd21689d..6ed1480d85c 100644
--- a/src/plugins/qmldesigner/components/componentcore/modelnodeoperations.cpp
+++ b/src/plugins/qmldesigner/components/componentcore/modelnodeoperations.cpp
@@ -484,11 +484,13 @@ static void layoutHelperFunction(const SelectionContext &selectionContext,
             selectionContext.view()->executeInTransaction("DesignerActionManager|layoutHelperFunction",[=](){
 
                 QmlItemNode parentNode = qmlItemNode.instanceParentItem();
-
+#ifdef QDS_USE_PROJECTSTORAGE
+                const ModelNode layoutNode = selectionContext.view()->createModelNode(layoutType);
+#else
                 NodeMetaInfo metaInfo = selectionContext.view()->model()->metaInfo(layoutType);
 
                 const ModelNode layoutNode = selectionContext.view()->createModelNode(layoutType, metaInfo.majorVersion(), metaInfo.minorVersion());
-
+#endif
                 reparentTo(layoutNode, parentNode);
 
                 QList<ModelNode> sortedSelectedNodes =  selectionContext.selectedModelNodes();
@@ -886,15 +888,26 @@ void addItemToStackedContainer(const SelectionContext &selectionContext)
 
         NodeMetaInfo itemMetaInfo = view->model()->metaInfo("QtQuick.Item", -1, -1);
         QTC_ASSERT(itemMetaInfo.isValid(), return);
-        QTC_ASSERT(itemMetaInfo.majorVersion() == 2, return);
-
+#ifdef QDS_USE_PROJECTSTORAGE
+        QmlDesigner::ModelNode itemNode = view->createModelNode("Item");
+#else
         QmlDesigner::ModelNode itemNode =
                 view->createModelNode("QtQuick.Item", itemMetaInfo.majorVersion(), itemMetaInfo.minorVersion());
-
+#endif
         container.defaultNodeListProperty().reparentHere(itemNode);
 
         if (potentialTabBar.isValid()) {// The stacked container is hooked up to a TabBar
-            NodeMetaInfo tabButtonMetaInfo = view->model()->metaInfo("QtQuick.Controls.TabButton", -1, -1);
+#ifdef QDS_USE_PROJECTSTORAGE
+            const int buttonIndex = potentialTabBar.directSubModelNodes().size();
+            ModelNode tabButtonNode = view->createModelNode("TabButton");
+
+            tabButtonNode.variantProperty("text").setValue(
+                QString::fromLatin1("Tab %1").arg(buttonIndex));
+            potentialTabBar.defaultNodeListProperty().reparentHere(tabButtonNode);
+#else
+            NodeMetaInfo tabButtonMetaInfo = view->model()->metaInfo("QtQuick.Controls.TabButton",
+                                                                     -1,
+                                                                     -1);
             if (tabButtonMetaInfo.isValid()) {
                 const int buttonIndex = potentialTabBar.directSubModelNodes().size();
                 ModelNode tabButtonNode =
@@ -906,6 +919,7 @@ void addItemToStackedContainer(const SelectionContext &selectionContext)
                 potentialTabBar.defaultNodeListProperty().reparentHere(tabButtonNode);
 
             }
+#endif
         }
     });
 }
@@ -1005,6 +1019,7 @@ void addTabBarToStackedContainer(const SelectionContext &selectionContext)
     QTC_ASSERT(container.isValid(), return);
     QTC_ASSERT(container.metaInfo().isValid(), return);
 
+#ifndef QDS_USE_PROJECTSTORAGE
     NodeMetaInfo tabBarMetaInfo = view->model()->metaInfo("QtQuick.Controls.TabBar", -1, -1);
     QTC_ASSERT(tabBarMetaInfo.isValid(), return);
     QTC_ASSERT(tabBarMetaInfo.majorVersion() == 2, return);
@@ -1012,6 +1027,7 @@ void addTabBarToStackedContainer(const SelectionContext &selectionContext)
     NodeMetaInfo tabButtonMetaInfo = view->model()->metaInfo("QtQuick.Controls.TabButton", -1, -1);
     QTC_ASSERT(tabButtonMetaInfo.isValid(), return);
     QTC_ASSERT(tabButtonMetaInfo.majorVersion() == 2, return);
+#endif
 
     QmlItemNode containerItemNode(container);
     QTC_ASSERT(containerItemNode.isValid(), return);
@@ -1019,14 +1035,15 @@ void addTabBarToStackedContainer(const SelectionContext &selectionContext)
     const PropertyName indexPropertyName = getIndexPropertyName(container);
     QTC_ASSERT(container.metaInfo().hasProperty(indexPropertyName), return);
 
-    view->executeInTransaction("DesignerActionManager:addItemToStackedContainer",
-                               [view, container, containerItemNode, tabBarMetaInfo, tabButtonMetaInfo, indexPropertyName](){
-
+    view->executeInTransaction("DesignerActionManager:addItemToStackedContainer", [&]() {
+#ifdef QDS_USE_PROJECTSTORAGE
+        ModelNode tabBarNode = view->createModelNode("TabBar");
+#else
         ModelNode tabBarNode =
                 view->createModelNode("QtQuick.Controls.TabBar",
                                       tabBarMetaInfo.majorVersion(),
                                       tabBarMetaInfo.minorVersion());
-
+#endif
         container.parentProperty().reparentHere(tabBarNode);
 
         const int maxValue = container.directSubModelNodes().size();
@@ -1038,11 +1055,14 @@ void addTabBarToStackedContainer(const SelectionContext &selectionContext)
         tabBarItem.anchors().setAnchor(AnchorLineBottom, containerItemNode, AnchorLineTop);
 
         for (int i = 0; i < maxValue; ++i) {
+#ifdef QDS_USE_PROJECTSTORAGE
+            ModelNode tabButtonNode = view->createModelNode("TabButton");
+#else
             ModelNode tabButtonNode =
                     view->createModelNode("QtQuick.Controls.TabButton",
                                           tabButtonMetaInfo.majorVersion(),
                                           tabButtonMetaInfo.minorVersion());
-
+#endif
             tabButtonNode.variantProperty("text").setValue(QString::fromLatin1("Tab %1").arg(i));
             tabBarNode.defaultNodeListProperty().reparentHere(tabButtonNode);
         }
@@ -1053,7 +1073,6 @@ void addTabBarToStackedContainer(const SelectionContext &selectionContext)
         const QString expression = id + "." + QString::fromLatin1(indexPropertyName);
         container.bindingProperty(indexPropertyName).setExpression(expression);
     });
-
 }
 
 AddFilesResult addFilesToProject(const QStringList &fileNames, const QString &defaultDir, bool showDialog)
@@ -1170,23 +1189,22 @@ void createFlowActionArea(const SelectionContext &selectionContext)
 
     const QPointF pos = selectionContext.scenePosition().isNull() ? QPointF() : selectionContext.scenePosition() - QmlItemNode(container).flowPosition();
 
-    view->executeInTransaction("DesignerActionManager:createFlowActionArea",
-                               [view, container, actionAreaMetaInfo, pos](){
-
-                                   ModelNode flowActionNode =
-                                       view->createModelNode("FlowView.FlowActionArea",
+    view->executeInTransaction("DesignerActionManager:createFlowActionArea", [&]() {
+#ifdef QDS_USE_PROJECTSTORAGE
+        ModelNode flowActionNode = view->createModelNode("FlowActionArea");
+#else
+            ModelNode flowActionNode = view->createModelNode("FlowView.FlowActionArea",
                                                              actionAreaMetaInfo.majorVersion(),
                                                              actionAreaMetaInfo.minorVersion());
+#endif
+        if (!pos.isNull()) {
+            flowActionNode.variantProperty("x").setValue(pos.x());
+            flowActionNode.variantProperty("y").setValue(pos.y());
+        }
 
-                                   if (!pos.isNull()) {
-                                       flowActionNode.variantProperty("x").setValue(pos.x());
-                                       flowActionNode.variantProperty("y").setValue(pos.y());
-                                   }
-
-                                   container.defaultNodeListProperty().reparentHere(flowActionNode);
-                                   view->setSelectedModelNode(flowActionNode);
-                               });
-
+        container.defaultNodeListProperty().reparentHere(flowActionNode);
+        view->setSelectedModelNode(flowActionNode);
+    });
 }
 
 void addTransition(const SelectionContext &selectionContext)
@@ -1221,17 +1239,18 @@ void addFlowEffect(const SelectionContext &selectionContext, const TypeName &typ
    NodeMetaInfo effectMetaInfo = view->model()->metaInfo("FlowView." + typeName, -1, -1);
    QTC_ASSERT(typeName == "None" || effectMetaInfo.isValid(), return);
 
-   view->executeInTransaction("DesignerActionManager:addFlowEffect", [=]() {
+   view->executeInTransaction("DesignerActionManager:addFlowEffect", [&]() {
        if (container.hasProperty("effect"))
            container.removeProperty("effect");
 
        if (effectMetaInfo.isQtObject()) {
-           ModelNode effectNode = view->createModelNode(useProjectStorage()
-                                                            ? typeName
-                                                            : effectMetaInfo.typeName(),
+#ifdef QDS_USE_PROJECTSTORAGE
+           ModelNode effectNode = view->createModelNode(typeName);
+#else
+           ModelNode effectNode = view->createModelNode(effectMetaInfo.typeName(),
                                                         effectMetaInfo.majorVersion(),
                                                         effectMetaInfo.minorVersion());
-
+#endif
            container.nodeProperty("effect").reparentHere(effectNode);
            view->setSelectedModelNode(effectNode);
        }
@@ -1299,7 +1318,6 @@ void reparentToNodeAndAdjustPosition(const ModelNode &parentModelNode,
 
 void addToGroupItem(const SelectionContext &selectionContext)
 {
-    const TypeName typeName = "QtQuick.Studio.Components.GroupItem";
 
     try {
         if (!hasStudioComponentsImport(selectionContext)) {
@@ -1315,20 +1333,28 @@ void addToGroupItem(const SelectionContext &selectionContext)
 
             if (qmlItemNode.hasInstanceParentItem()) {
                 ModelNode groupNode;
-                selectionContext.view()->executeInTransaction("DesignerActionManager|addToGroupItem1",[=, &groupNode](){
+                selectionContext.view()
+                    ->executeInTransaction("DesignerActionManager|addToGroupItem1", [&]() {
+                        QmlItemNode parentNode = qmlItemNode.instanceParentItem();
+#ifdef QDS_USE_PROJECTSTORAGE
+                        groupNode = selectionContext.view()->createModelNode("GroupItem");
+#else
+                        const TypeName typeName = "QtQuick.Studio.Components.GroupItem";
 
-                    QmlItemNode parentNode = qmlItemNode.instanceParentItem();
-                    NodeMetaInfo metaInfo = selectionContext.view()->model()->metaInfo(typeName);
-                    groupNode = selectionContext.view()->createModelNode(typeName, metaInfo.majorVersion(), metaInfo.minorVersion());
-                    reparentTo(groupNode, parentNode);
-                });
-                selectionContext.view()->executeInTransaction("DesignerActionManager|addToGroupItem2",[=](){
+                        NodeMetaInfo metaInfo = selectionContext.view()->model()->metaInfo(typeName);
+                        groupNode = selectionContext.view()->createModelNode(typeName,
+                                                                             metaInfo.majorVersion(),
+                                                                             metaInfo.minorVersion());
+#endif
+                        reparentTo(groupNode, parentNode);
+                    });
+                selectionContext.view()
+                    ->executeInTransaction("DesignerActionManager|addToGroupItem2", [&]() {
+                        QList<ModelNode> selectedNodes = selectionContext.selectedModelNodes();
+                        setUpperLeftPostionToNode(groupNode, selectedNodes);
 
-                    QList<ModelNode> selectedNodes = selectionContext.selectedModelNodes();
-                    setUpperLeftPostionToNode(groupNode, selectedNodes);
-
-                    reparentToNodeAndAdjustPosition(groupNode, selectedNodes);
-                });
+                        reparentToNodeAndAdjustPosition(groupNode, selectedNodes);
+                    });
             }
         }
     } catch (RewritingException &e) {
@@ -1387,7 +1413,6 @@ static void getTypeAndImport(const SelectionContext &selectionContext,
 
 void addCustomFlowEffect(const SelectionContext &selectionContext)
 {
-
     TypeName typeName;
 
     QString typeString;
@@ -1416,23 +1441,27 @@ void addCustomFlowEffect(const SelectionContext &selectionContext)
     QTC_ASSERT(container.metaInfo().isValid(), return);
     QTC_ASSERT(QmlItemNode::isFlowTransition(container), return);
 
+#ifndef QDS_USE_PROJECTSTORAGE
     NodeMetaInfo effectMetaInfo = view->model()->metaInfo(typeName, -1, -1);
     QTC_ASSERT(typeName == "None" || effectMetaInfo.isValid(), return);
-
-    view->executeInTransaction("DesignerActionManager:addFlowEffect", [=]() {
+#endif
+    view->executeInTransaction("DesignerActionManager:addFlowEffect", [&]() {
         if (container.hasProperty("effect"))
             container.removeProperty("effect");
 
+#ifdef QDS_USE_PROJECTSTORAGE
+        ModelNode effectNode = view->createModelNode(typeName);
+        container.nodeProperty("effect").reparentHere(effectNode);
+        view->setSelectedModelNode(effectNode);
+#else
         if (effectMetaInfo.isValid()) {
-            ModelNode effectNode = view->createModelNode(useProjectStorage()
-                                                             ? typeName
-                                                             : effectMetaInfo.typeName(),
+            ModelNode effectNode = view->createModelNode(effectMetaInfo.typeName(),
                                                          effectMetaInfo.majorVersion(),
                                                          effectMetaInfo.minorVersion());
-
             container.nodeProperty("effect").reparentHere(effectNode);
             view->setSelectedModelNode(effectNode);
         }
+#endif
     });
 }
 
@@ -1450,7 +1479,6 @@ static QString fromCamelCase(const QString &s)
 
 QString getTemplateDialog(const Utils::FilePath &projectPath)
 {
-
     const Utils::FilePath templatesPath = projectPath.pathAppended("templates");
 
     const QStringList templateFiles = QDir(templatesPath.toString()).entryList({"*.qml"});
@@ -1598,23 +1626,30 @@ void addMouseAreaFill(const SelectionContext &selectionContext)
         return;
     }
 
-    selectionContext.view()->executeInTransaction("DesignerActionManager|addMouseAreaFill", [selectionContext]() {
-        ModelNode modelNode = selectionContext.currentSingleSelectedNode();
-        if (modelNode.isValid()) {
-            NodeMetaInfo itemMetaInfo = selectionContext.view()->model()->metaInfo("QtQuick.MouseArea", -1, -1);
-            QTC_ASSERT(itemMetaInfo.isValid(), return);
+    selectionContext.view()
+        ->executeInTransaction("DesignerActionManager|addMouseAreaFill", [selectionContext]() {
+            ModelNode modelNode = selectionContext.currentSingleSelectedNode();
+            if (modelNode.isValid()) {
+#ifdef QDS_USE_PROJECTSTORAGE
+                QmlDesigner::ModelNode mouseAreaNode = selectionContext.view()->createModelNode(
+                    "MouseArea");
+#else
+                NodeMetaInfo itemMetaInfo = selectionContext.view()->model()->metaInfo(
+                    "QtQuick.MouseArea", -1, -1);
+                QTC_ASSERT(itemMetaInfo.isValid(), return);
 
-            QmlDesigner::ModelNode mouseAreaNode =
-                selectionContext.view()->createModelNode("QtQuick.MouseArea", itemMetaInfo.majorVersion(), itemMetaInfo.minorVersion());
-            mouseAreaNode.validId();
+                QmlDesigner::ModelNode mouseAreaNode = selectionContext.view()->createModelNode(
+                    "QtQuick.MouseArea", itemMetaInfo.majorVersion(), itemMetaInfo.minorVersion());
+#endif
+                mouseAreaNode.validId();
 
-            modelNode.defaultNodeListProperty().reparentHere(mouseAreaNode);
-            QmlItemNode mouseAreaItemNode(mouseAreaNode);
-            if (mouseAreaItemNode.isValid()) {
-                mouseAreaItemNode.anchors().fill();
+                modelNode.defaultNodeListProperty().reparentHere(mouseAreaNode);
+                QmlItemNode mouseAreaItemNode(mouseAreaNode);
+                if (mouseAreaItemNode.isValid()) {
+                    mouseAreaItemNode.anchors().fill();
+                }
             }
-        }
-    });
+        });
 }
 
 QVariant previewImageDataForGenericNode(const ModelNode &modelNode)
diff --git a/src/plugins/qmldesigner/components/connectioneditor/backendmodel.cpp b/src/plugins/qmldesigner/components/connectioneditor/backendmodel.cpp
index 5d9e9fe99c6..97c73205b29 100644
--- a/src/plugins/qmldesigner/components/connectioneditor/backendmodel.cpp
+++ b/src/plugins/qmldesigner/components/connectioneditor/backendmodel.cpp
@@ -228,16 +228,17 @@ void BackendModel::addNewBackend()
         if (!dialog.isSingleton()) {
             m_connectionView->executeInTransaction("BackendModel::addNewBackend",
                                                    [this, metaInfo, typeName, propertyName, &dialog] {
-                int minorVersion = metaInfo.minorVersion();
-                int majorVersion = metaInfo.majorVersion();
 
                 if (dialog.localDefinition()) {
-                    ModelNode newNode = m_connectionView->createModelNode(useProjectStorage()
-                                                                              ? typeName.toUtf8()
-                                                                              : metaInfo.typeName(),
+#ifdef QDS_USE_PROJECTSTORAGE
+                    ModelNode newNode = m_connectionView->createModelNode(typeName.toUtf8());
+#else
+                    int minorVersion = metaInfo.minorVersion();
+                    int majorVersion = metaInfo.majorVersion();
+                    ModelNode newNode = m_connectionView->createModelNode(metaInfo.typeName(),
                                                                           majorVersion,
                                                                           minorVersion);
-
+#endif
                     m_connectionView->rootModelNode().nodeProperty(propertyName.toUtf8()).setDynamicTypeNameAndsetModelNode(
                                 typeName.toUtf8(), newNode);
                 } else {
diff --git a/src/plugins/qmldesigner/components/connectioneditor/connectionmodel.cpp b/src/plugins/qmldesigner/components/connectioneditor/connectionmodel.cpp
index d3fcd019fbd..2047f7625c1 100644
--- a/src/plugins/qmldesigner/components/connectioneditor/connectionmodel.cpp
+++ b/src/plugins/qmldesigner/components/connectioneditor/connectionmodel.cpp
@@ -48,7 +48,7 @@ QStringList propertyNameListToStringList(const QmlDesigner::PropertyNameList &pr
 
 bool isConnection(const QmlDesigner::ModelNode &modelNode)
 {
-    return (modelNode.metaInfo().simplifiedTypeName() == "Connections");
+    return modelNode.metaInfo().isQtQmlConnections();
 }
 
 } //namespace
@@ -361,15 +361,14 @@ void ConnectionModel::addConnection(const PropertyName &signalName)
     ModelNode rootModelNode = connectionView()->rootModelNode();
 
     if (rootModelNode.isValid() && rootModelNode.metaInfo().isValid()) {
-
-        NodeMetaInfo nodeMetaInfo = connectionView()->model()->qtQuickConnectionsMetaInfo();
+#ifndef QDS_USE_PROJECTSTORAGE
+        NodeMetaInfo nodeMetaInfo = connectionView()->model()->qtQmlConnectionsMetaInfo();
 
         if (nodeMetaInfo.isValid()) {
-            ModelNode selectedNode;
-            if (connectionView()->selectedModelNodes().isEmpty())
+#endif
+            ModelNode selectedNode = connectionView()->firstSelectedModelNode();
+            if (!selectedNode)
                 selectedNode = connectionView()->rootModelNode();
-            else
-                selectedNode = connectionView()->selectedModelNodes().constFirst();
 
             PropertyName signalHandlerName = signalName;
             if (signalHandlerName.isEmpty())
@@ -378,12 +377,14 @@ void ConnectionModel::addConnection(const PropertyName &signalName)
             signalHandlerName = addOnToSignalName(QString::fromUtf8(signalHandlerName)).toUtf8();
 
             connectionView()
-                ->executeInTransaction("ConnectionModel::addConnection",
-                                       [this, nodeMetaInfo, signalHandlerName, &rootModelNode] {
-                    ModelNode newNode = connectionView()
-                                            ->createModelNode("QtQuick.Connections",
-                                                              nodeMetaInfo.majorVersion(),
-                                                              nodeMetaInfo.minorVersion());
+                ->executeInTransaction("ConnectionModel::addConnection", [&] {
+#ifdef QDS_USE_PROJECTSTORAGE
+                    ModelNode newNode = connectionView()->createModelNode("Connections");
+#else
+                    ModelNode newNode = connectionView()->createModelNode("QtQuick.Connections",
+                                                                          nodeMetaInfo.majorVersion(),
+                                                                          nodeMetaInfo.minorVersion());
+#endif
                     QString source = "console.log(\"clicked\")";
 
                     if (connectionView()->selectedModelNodes().size() == 1) {
@@ -411,7 +412,9 @@ void ConnectionModel::addConnection(const PropertyName &signalName)
 
                     selectProperty(newNode.signalHandlerProperty(signalHandlerName));
                 });
+#ifndef QDS_USE_PROJECTSTORAGE
         }
+#endif
     }
 }
 
diff --git a/src/plugins/qmldesigner/components/createtexture.cpp b/src/plugins/qmldesigner/components/createtexture.cpp
index 1363868f37f..b6e99ae972c 100644
--- a/src/plugins/qmldesigner/components/createtexture.cpp
+++ b/src/plugins/qmldesigner/components/createtexture.cpp
@@ -84,10 +84,13 @@ ModelNode CreateTexture::createTextureFromImage(const  Utils::FilePath &assetPat
 
     ModelNode newTexNode = Utils3D::getTextureDefaultInstance(textureSource, m_view);
     if (!newTexNode.isValid()) {
+#ifdef QDS_USE_PROJECTSTORAGE
+        newTexNode = m_view->createModelNode("Texture");
+#else
         newTexNode = m_view->createModelNode("QtQuick3D.Texture",
                                              metaInfo.majorVersion(),
                                              metaInfo.minorVersion());
-
+#endif
         newTexNode.setIdWithoutRefactoring(m_view->model()->generateNewId(assetPath.baseName()));
 
         VariantProperty sourceProp = newTexNode.variantProperty("source");
diff --git a/src/plugins/qmldesigner/components/debugview/debugview.cpp b/src/plugins/qmldesigner/components/debugview/debugview.cpp
index 64f85915f16..e05001e4774 100644
--- a/src/plugins/qmldesigner/components/debugview/debugview.cpp
+++ b/src/plugins/qmldesigner/components/debugview/debugview.cpp
@@ -95,7 +95,9 @@ void DebugView::nodeCreated(const ModelNode &createdNode)
         message << createdNode.nodeSource();
         message << "MetaInfo " << createdNode.metaInfo().isValid() << " ";
         if (auto metaInfo = createdNode.metaInfo()) {
+#ifndef QDS_USE_PROJECTSTORAGE
             message << metaInfo.majorVersion() << "." << metaInfo.minorVersion();
+#endif
             message << ModelUtils::componentFilePath(createdNode);
         }
         log("::nodeCreated:", message.readAll());
@@ -283,6 +285,7 @@ void DebugView::selectedNodesChanged(const QList<ModelNode> &selectedNodes /*sel
         message << lineBreak;
 
         if (selectedNode.metaInfo().isValid()) {
+#ifndef QDS_USE_PROJECTSTORAGE
             for (const NodeMetaInfo &metaInfo : selectedNode.metaInfo().selfAndPrototypes()) {
                 message << metaInfo.typeName() << " " << metaInfo.majorVersion() << "."
                         << metaInfo.minorVersion() << lineBreak;
@@ -290,6 +293,7 @@ void DebugView::selectedNodesChanged(const QList<ModelNode> &selectedNodes /*sel
 
             message << lineBreak;
             message << selectedNode.metaInfo().typeName();
+#endif
             message << lineBreak;
 
             message << "Node Source" << selectedNode.nodeSource();
@@ -323,10 +327,11 @@ void DebugView::selectedNodesChanged(const QList<ModelNode> &selectedNodes /*sel
         message << "Is valid object node: " << QmlItemNode::isValidQmlObjectNode(selectedNode);
         message << lineBreak;
 
+#ifndef QDS_USE_PROJECTSTORAGE
         message << "version: "
                 << QString::number(selectedNode.metaInfo().majorVersion()) + "."
                        + QString::number(selectedNode.metaInfo().minorVersion());
-
+#endif
         message << lineBreak;
 
         QmlItemNode itemNode(selectedNode);
diff --git a/src/plugins/qmldesigner/components/edit3d/bakelightsdatamodel.cpp b/src/plugins/qmldesigner/components/edit3d/bakelightsdatamodel.cpp
index e812bb6d00e..9657d564fb2 100644
--- a/src/plugins/qmldesigner/components/edit3d/bakelightsdatamodel.cpp
+++ b/src/plugins/qmldesigner/components/edit3d/bakelightsdatamodel.cpp
@@ -353,10 +353,14 @@ void BakeLightsDataModel::apply()
         if (node.hasBindingProperty(propName))
             blmNode = node.bindingProperty(propName).resolveToModelNode();
         if (!blmNode.isValid() && data.enabled) {
+#ifdef QDS_USE_PROJECTSTORAGE
+            blmNode = m_view->createModelNode("BakedLightmap");
+#else
             NodeMetaInfo metaInfo = m_view->model()->qtQuick3DBakedLightmapMetaInfo();
             blmNode = m_view->createModelNode("QtQuick3D.BakedLightmap",
                                           metaInfo.majorVersion(),
                                           metaInfo.minorVersion());
+#endif
             QString idPart;
             if (data.aliasProp.isEmpty())
                 idPart = data.id;
diff --git a/src/plugins/qmldesigner/components/itemlibrary/itemlibrarymodel.cpp b/src/plugins/qmldesigner/components/itemlibrary/itemlibrarymodel.cpp
index eaf6f89b14a..a0fec7e507a 100644
--- a/src/plugins/qmldesigner/components/itemlibrary/itemlibrarymodel.cpp
+++ b/src/plugins/qmldesigner/components/itemlibrary/itemlibrarymodel.cpp
@@ -371,10 +371,13 @@ void ItemLibraryModel::update([[maybe_unused]] ItemLibraryInfo *itemLibraryInfo,
         else
             metaInfo = model->metaInfo(entry.typeName());
 
+#ifdef QDS_USE_PROJECTSTORAGE
+        bool valid = metaInfo.isValid();
+#else
         bool valid = metaInfo.isValid()
                      && (metaInfo.majorVersion() >= entry.majorVersion()
                          || metaInfo.majorVersion() < 0);
-
+#endif
         bool isItem = valid && metaInfo.isQtQuickItem();
         bool forceVisibility = valid && NodeHints::fromItemLibraryEntry(entry).visibleInLibrary();
 
diff --git a/src/plugins/qmldesigner/components/materialbrowser/materialutils.cpp b/src/plugins/qmldesigner/components/materialbrowser/materialutils.cpp
index f22fdc030e4..1ee2e409f38 100644
--- a/src/plugins/qmldesigner/components/materialbrowser/materialutils.cpp
+++ b/src/plugins/qmldesigner/components/materialbrowser/materialutils.cpp
@@ -47,10 +47,14 @@ void MaterialUtils::assignMaterialTo3dModel(AbstractView *view, const ModelNode
 
         // if no valid material, create a new default material
         if (!newMaterialNode.isValid()) {
+#ifdef QDS_USE_PROJECTSTORAGE
+            newMaterialNode = view->createModelNode("PrincipledMaterial");
+#else
             NodeMetaInfo metaInfo = view->model()->qtQuick3DPrincipledMaterialMetaInfo();
             newMaterialNode = view->createModelNode("QtQuick3D.PrincipledMaterial",
                                                     metaInfo.majorVersion(),
                                                     metaInfo.minorVersion());
+#endif
             newMaterialNode.validId();
         }
     }
diff --git a/src/plugins/qmldesigner/components/materialeditor/materialeditorqmlbackend.cpp b/src/plugins/qmldesigner/components/materialeditor/materialeditorqmlbackend.cpp
index 661f1ad3788..ecc460ae510 100644
--- a/src/plugins/qmldesigner/components/materialeditor/materialeditorqmlbackend.cpp
+++ b/src/plugins/qmldesigner/components/materialeditor/materialeditorqmlbackend.cpp
@@ -287,8 +287,10 @@ void MaterialEditorQmlBackend::setup(const QmlObjectNode &selectedMaterialNode,
 
         contextObject()->setSelectionChanged(false);
 
+#ifndef QDS_USE_PROJECTSTORAGE
         NodeMetaInfo metaInfo = selectedMaterialNode.modelNode().metaInfo();
         contextObject()->setMajorVersion(metaInfo.isValid() ? metaInfo.majorVersion() : -1);
+#endif
     } else {
         context()->setContextProperty("hasMaterial", QVariant(false));
     }
diff --git a/src/plugins/qmldesigner/components/materialeditor/materialeditorview.cpp b/src/plugins/qmldesigner/components/materialeditor/materialeditorview.cpp
index ab43e992f7a..e083310cdbb 100644
--- a/src/plugins/qmldesigner/components/materialeditor/materialeditorview.cpp
+++ b/src/plugins/qmldesigner/components/materialeditor/materialeditorview.cpp
@@ -419,11 +419,14 @@ void MaterialEditorView::handleToolBarAction(int action)
             ModelNode matLib = Utils3D::materialLibraryNode(this);
             if (!matLib.isValid())
                 return;
-
+#ifdef QDS_USE_PROJECTSTORAGE
+            ModelNode newMatNode = createModelNode("PrincipledMaterial");
+#else
             NodeMetaInfo metaInfo = model()->qtQuick3DPrincipledMaterialMetaInfo();
             ModelNode newMatNode = createModelNode("QtQuick3D.PrincipledMaterial",
                                                    metaInfo.majorVersion(),
                                                    metaInfo.minorVersion());
+#endif
             renameMaterial(newMatNode, "New Material");
             matLib.defaultNodeListProperty().reparentHere(newMatNode);
         });
@@ -526,6 +529,10 @@ void MaterialEditorView::handlePreviewModelChanged(const QString &modelStr)
 
 void MaterialEditorView::setupQmlBackend()
 {
+#ifdef QDS_USE_PROJECTSTORAGE
+// TODO unify implementation with property editor view
+#else
+
     QUrl qmlPaneUrl;
     QUrl qmlSpecificsUrl;
     QString specificQmlData;
@@ -603,6 +610,7 @@ void MaterialEditorView::setupQmlBackend()
 
     m_stackedWidget->setCurrentWidget(m_qmlBackEnd->widget());
     m_stackedWidget->setMinimumSize({400, 300});
+#endif
 }
 
 void MaterialEditorView::commitVariantValueToModel(const PropertyName &propertyName, const QVariant &value)
@@ -1037,9 +1045,12 @@ void MaterialEditorView::duplicateMaterial(const ModelNode &material)
             return;
 
         // create the duplicate material
+#ifdef QDS_USE_PROJECTSTORAGE
+        QmlObjectNode duplicateMat = createModelNode(matType);
+#else
         NodeMetaInfo metaInfo = model()->metaInfo(matType);
         QmlObjectNode duplicateMat = createModelNode(matType, metaInfo.majorVersion(), metaInfo.minorVersion());
-
+#endif
         duplicateMatNode = duplicateMat.modelNode();
 
         // set name and id
diff --git a/src/plugins/qmldesigner/components/navigator/choosefrompropertylistdialog.cpp b/src/plugins/qmldesigner/components/navigator/choosefrompropertylistdialog.cpp
index 04c2ebd9e65..58b4c427499 100644
--- a/src/plugins/qmldesigner/components/navigator/choosefrompropertylistdialog.cpp
+++ b/src/plugins/qmldesigner/components/navigator/choosefrompropertylistdialog.cpp
@@ -97,9 +97,13 @@ ChooseFromPropertyListFilter::ChooseFromPropertyListFilter(const NodeMetaInfo &i
     } else if (insertInfo.isQtQuick3DMaterial()) {
         if (parentInfo.isQtQuick3DModel())
             propertyList.append("materials");
+#ifdef QDS_USE_PROJECTSTORAGE
+// TODO add the types here or use the module
+#else
     } else if (insertInfo.typeName().startsWith("ComponentBundles.MaterialBundle")) {
         if (parentInfo.isQtQuick3DModel())
             propertyList.append("materials");
+#endif
     } else if (insertInfo.isQtQuick3DBakedLightmap()) {
         if (parentInfo.isQtQuick3DModel())
             propertyList.append("bakedLightmap");
diff --git a/src/plugins/qmldesigner/components/navigator/navigatorview.cpp b/src/plugins/qmldesigner/components/navigator/navigatorview.cpp
index a3ad444e243..090beb64717 100644
--- a/src/plugins/qmldesigner/components/navigator/navigatorview.cpp
+++ b/src/plugins/qmldesigner/components/navigator/navigatorview.cpp
@@ -271,14 +271,20 @@ void NavigatorView::dragStarted(QMimeData *mimeData)
     } else if (mimeData->hasFormat(Constants::MIME_TYPE_TEXTURE)) {
         qint32 internalId = mimeData->data(Constants::MIME_TYPE_TEXTURE).toInt();
         ModelNode texNode = modelNodeForInternalId(internalId);
-
+#ifdef QDS_USE_PROJECTSTORAGE
+        m_widget->setDragType(texNode.type());
+#else
         m_widget->setDragType(texNode.metaInfo().typeName());
+#endif
         m_widget->update();
     } else if (mimeData->hasFormat(Constants::MIME_TYPE_MATERIAL)) {
         qint32 internalId = mimeData->data(Constants::MIME_TYPE_MATERIAL).toInt();
         ModelNode matNode = modelNodeForInternalId(internalId);
-
+#ifdef QDS_USE_PROJECTSTORAGE
+        m_widget->setDragType(matNode.type());
+#else
         m_widget->setDragType(matNode.metaInfo().typeName());
+#endif
         m_widget->update();
     } else if (mimeData->hasFormat(Constants::MIME_TYPE_BUNDLE_TEXTURE)) {
         m_widget->setDragType(Constants::MIME_TYPE_BUNDLE_TEXTURE);
diff --git a/src/plugins/qmldesigner/components/propertyeditor/gradientmodel.cpp b/src/plugins/qmldesigner/components/propertyeditor/gradientmodel.cpp
index 53af36c7ae1..8bedabd83a7 100644
--- a/src/plugins/qmldesigner/components/propertyeditor/gradientmodel.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/gradientmodel.cpp
@@ -695,6 +695,10 @@ void GradientModel::resetPuppet()
 
 QmlDesigner::ModelNode GradientModel::createGradientNode()
 {
+#ifdef QDS_USE_PROJECTSTORAGE
+    QmlDesigner::TypeName typeName = m_gradientTypeName.toUtf8();
+    auto gradientNode = view()->createModelNode(typeName);
+#else
     QmlDesigner::TypeName fullTypeName = m_gradientTypeName.toUtf8();
 
     if (m_gradientTypeName == "Gradient") {
@@ -709,7 +713,7 @@ QmlDesigner::ModelNode GradientModel::createGradientNode()
     int majorVersion = metaInfo.majorVersion();
 
     auto gradientNode = view()->createModelNode(fullTypeName, majorVersion, minorVersion);
-
+#endif
     setupGradientProperties(gradientNode);
 
     return gradientNode;
@@ -717,6 +721,9 @@ QmlDesigner::ModelNode GradientModel::createGradientNode()
 
 QmlDesigner::ModelNode GradientModel::createGradientStopNode()
 {
+#ifdef QDS_USE_PROJECTSTORAGE
+    return view()->createModelNode("GradientStop");
+#else
     QByteArray fullTypeName = "QtQuick.GradientStop";
     auto metaInfo = model()->metaInfo(fullTypeName);
 
@@ -724,6 +731,7 @@ QmlDesigner::ModelNode GradientModel::createGradientStopNode()
     int majorVersion = metaInfo.majorVersion();
 
     return view()->createModelNode(fullTypeName, majorVersion, minorVersion);
+#endif
 }
 
 void GradientModel::deleteGradientNode(bool saveTransaction)
diff --git a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorqmlbackend.cpp b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorqmlbackend.cpp
index 757777d656c..7f1ab00bb94 100644
--- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorqmlbackend.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorqmlbackend.cpp
@@ -10,11 +10,12 @@
 #include <auxiliarydataproperties.h>
 #include <bindingproperty.h>
 #include <nodemetainfo.h>
-#include <variantproperty.h>
+#include <projectstorage/sourcepathcache.h>
 #include <qmldesignerconstants.h>
 #include <qmldesignerplugin.h>
 #include <qmlobjectnode.h>
 #include <qmltimeline.h>
+#include <variantproperty.h>
 
 #include <theme.h>
 
@@ -514,6 +515,12 @@ void PropertyEditorQmlBackend::setup(const QmlObjectNode &qmlObjectNode, const Q
 
         NodeMetaInfo metaInfo = qmlObjectNode.modelNode().metaInfo();
 
+#ifdef QDS_USE_PROJECTSTORAGE
+        contextObject()->setMajorVersion(-1);
+        contextObject()->setMinorVersion(-1);
+        contextObject()->setMajorQtQuickVersion(-1);
+        contextObject()->setMinorQtQuickVersion(-1);
+#else
         if (metaInfo.isValid()) {
             contextObject()->setMajorVersion(metaInfo.majorVersion());
             contextObject()->setMinorVersion(metaInfo.minorVersion());
@@ -523,7 +530,7 @@ void PropertyEditorQmlBackend::setup(const QmlObjectNode &qmlObjectNode, const Q
             contextObject()->setMajorQtQuickVersion(-1);
             contextObject()->setMinorQtQuickVersion(-1);
         }
-
+#endif
         contextObject()->setMajorQtQuickVersion(qmlObjectNode.view()->majorQtQuickVersion());
         contextObject()->setMinorQtQuickVersion(qmlObjectNode.view()->minorQtQuickVersion());
 
@@ -619,6 +626,7 @@ inline bool dotPropertyHeuristic(const QmlObjectNode &node, const NodeMetaInfo &
     return true;
 }
 
+#ifndef QDS_USE_PROJECTSTORAGE
 QString PropertyEditorQmlBackend::templateGeneration(const NodeMetaInfo &metaType,
                                                      const NodeMetaInfo &superType,
                                                      const QmlObjectNode &node)
@@ -849,6 +857,7 @@ QUrl PropertyEditorQmlBackend::getQmlFileUrl(const TypeName &relativeTypeName, c
 {
     return fileToUrl(locateQmlFile(info, QString::fromUtf8(fixTypeNameForPanes(relativeTypeName) + ".qml")));
 }
+#endif // QDS_USE_PROJECTSTORAGE
 
 TypeName PropertyEditorQmlBackend::fixTypeNameForPanes(const TypeName &typeName)
 {
@@ -883,11 +892,13 @@ NodeMetaInfo PropertyEditorQmlBackend::findCommonAncestor(const ModelNode &node)
     return node.metaInfo();
 }
 
+#ifndef QDS_USE_PROJECTSTORAGE
 TypeName PropertyEditorQmlBackend::qmlFileName(const NodeMetaInfo &nodeInfo)
 {
     const TypeName fixedTypeName = fixTypeNameForPanes(nodeInfo.typeName());
     return fixedTypeName + "Pane.qml";
 }
+#endif
 
 QUrl PropertyEditorQmlBackend::fileToUrl(const QString &filePath)  {
     QUrl fileUrl;
@@ -963,6 +974,7 @@ void PropertyEditorQmlBackend::setValueforAuxiliaryProperties(const QmlObjectNod
     setValue(qmlObjectNode, propertyName, qmlObjectNode.modelNode().auxiliaryDataWithDefault(key));
 }
 
+#ifndef QDS_USE_PROJECTSTORAGE
 std::tuple<QUrl, NodeMetaInfo> PropertyEditorQmlBackend::getQmlUrlForMetaInfo(const NodeMetaInfo &metaInfo)
 {
     QString className;
@@ -1026,7 +1038,7 @@ QString PropertyEditorQmlBackend::locateQmlFile(const NodeMetaInfo &info, const
         return QFileInfo::exists(possibleFilePath);
     });
 }
-
+#endif // QDS_USE_PROJECTSTORAGE
 
 } //QmlDesigner
 
diff --git a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorqmlbackend.h b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorqmlbackend.h
index 64cca972071..b677258488b 100644
--- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorqmlbackend.h
+++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorqmlbackend.h
@@ -48,10 +48,13 @@ public:
     PropertyEditorValue *propertyValueForName(const QString &propertyName);
 
     static QString propertyEditorResourcesPath();
-    static QString templateGeneration(const NodeMetaInfo &type, const NodeMetaInfo &superType, const QmlObjectNode &node);
-
+#ifndef QDS_USE_PROJECTSTORAGE
+    static QString templateGeneration(const NodeMetaInfo &type,
+                                      const NodeMetaInfo &superType,
+                                      const QmlObjectNode &node);
     static QUrl getQmlFileUrl(const TypeName &relativeTypeName, const NodeMetaInfo &info);
     static std::tuple<QUrl, NodeMetaInfo> getQmlUrlForMetaInfo(const NodeMetaInfo &modelNode);
+#endif
 
     static bool checkIfUrlExists(const QUrl &url);
 
@@ -80,10 +83,12 @@ private:
                                   PropertyEditorView *propertyEditor,
                                   const NodeMetaInfo &type);
 
-    static TypeName qmlFileName(const NodeMetaInfo &nodeInfo);
     static QUrl fileToUrl(const QString &filePath);
     static QString fileFromUrl(const QUrl &url);
+#ifndef QDS_USE_PROJECTSTORAGE
+    static TypeName qmlFileName(const NodeMetaInfo &nodeInfo);
     static QString locateQmlFile(const NodeMetaInfo &info, const QString &relativePath);
+#endif
     static TypeName fixTypeNameForPanes(const TypeName &typeName);
 
 private:
diff --git a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorvalue.cpp b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorvalue.cpp
index f042df5241b..663ebafb659 100644
--- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorvalue.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorvalue.cpp
@@ -579,6 +579,15 @@ void PropertyEditorNodeWrapper::add(const QString &type)
     TypeName propertyType = type.toUtf8();
 
     if ((m_editorValue && m_editorValue->modelNode().isValid())) {
+#ifdef QDS_USE_PROJECTSTORAGE
+        if (propertyType.isEmpty()) {
+            auto node = m_editorValue->modelNode();
+            auto metaInfo = node.metaInfo().property(m_editorValue->name()).propertyType();
+            auto exportedTypeName = node.model()->exportedTypeNameForMetaInfo(metaInfo);
+            propertyType = exportedTypeName.name.toQByteArray();
+        }
+        m_modelNode = m_editorValue->modelNode().view()->createModelNode(propertyType);
+#else
         if (propertyType.isEmpty()) {
             propertyType = m_editorValue->modelNode()
                                .metaInfo()
@@ -589,6 +598,7 @@ void PropertyEditorNodeWrapper::add(const QString &type)
         while (propertyType.contains('*')) // strip star
             propertyType.chop(1);
         m_modelNode = m_editorValue->modelNode().view()->createModelNode(propertyType, 4, 7);
+#endif
         m_editorValue->modelNode().nodeAbstractProperty(m_editorValue->name()).reparentHere(m_modelNode);
         if (!m_modelNode.isValid())
             qWarning("PropertyEditorNodeWrapper::add failed");
diff --git a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorview.cpp b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorview.cpp
index 98901682a5e..1ff098f4eac 100644
--- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorview.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorview.cpp
@@ -96,8 +96,9 @@ PropertyEditorView::~PropertyEditorView()
     qDeleteAll(m_qmlBackendHash);
 }
 
-void PropertyEditorView::setupPane(const TypeName &typeName)
+void PropertyEditorView::setupPane([[maybe_unused]] const TypeName &typeName)
 {
+#ifndef QDS_USE_PROJECTSTORAGE
     NodeMetaInfo metaInfo = model()->metaInfo(typeName);
 
     QUrl qmlFile = PropertyEditorQmlBackend::getQmlFileUrl("Qt/ItemPane", metaInfo);
@@ -118,6 +119,7 @@ void PropertyEditorView::setupPane(const TypeName &typeName)
     } else {
         qmlBackend->initialSetup(typeName, qmlSpecificsFile, this);
     }
+#endif // QDS_USE_PROJECTSTORAGE
 }
 
 void PropertyEditorView::changeValue(const QString &name)
@@ -448,6 +450,7 @@ void PropertyEditorView::resetView()
 
 namespace {
 
+#ifndef QDS_USE_PROJECTSTORAGE
 [[maybe_unused]] std::tuple<NodeMetaInfo, QUrl> diffType(const NodeMetaInfo &commonAncestor,
                                                          const NodeMetaInfo &specificsClassMetaInfo)
 {
@@ -483,6 +486,7 @@ namespace {
 
     return {};
 }
+#endif // QDS_USE_PROJECTSTORAGE
 
 PropertyEditorQmlBackend *getQmlBackend(QHash<QString, PropertyEditorQmlBackend *> &qmlBackendHash,
                                         const QUrl &qmlFileUrl,
@@ -572,63 +576,56 @@ void setupWidget(PropertyEditorQmlBackend *currentQmlBackend,
 
 void PropertyEditorView::setupQmlBackend()
 {
-    if constexpr (useProjectStorage()) {
-        auto selfAndPrototypes = m_selectedNode.metaInfo().selfAndPrototypes();
-        bool isEditableComponent = m_selectedNode.isComponent()
-                                   && !QmlItemNode(m_selectedNode).isEffectItem();
-        auto specificQmlData = m_propertyEditorComponentGenerator.create(selfAndPrototypes,
-                                                                         isEditableComponent);
-        auto [panePath, specificsPath] = findPaneAndSpecificsPath(selfAndPrototypes,
-                                                                  model()->pathCache());
-        PropertyEditorQmlBackend *currentQmlBackend = getQmlBackend(m_qmlBackendHash,
-                                                                    QUrl::fromLocalFile(
-                                                                        QString{panePath}),
-                                                                    m_imageCache,
-                                                                    m_stackedWidget,
-                                                                    this);
+#ifdef QDS_USE_PROJECTSTORAGE
+    auto selfAndPrototypes = m_selectedNode.metaInfo().selfAndPrototypes();
+    bool isEditableComponent = m_selectedNode.isComponent()
+                               && !QmlItemNode(m_selectedNode).isEffectItem();
+    auto specificQmlData = m_propertyEditorComponentGenerator.create(selfAndPrototypes,
+                                                                     isEditableComponent);
+    auto [panePath, specificsPath] = findPaneAndSpecificsPath(selfAndPrototypes, model()->pathCache());
+    PropertyEditorQmlBackend *currentQmlBackend = getQmlBackend(m_qmlBackendHash,
+                                                                QUrl::fromLocalFile(QString{panePath}),
+                                                                m_imageCache,
+                                                                m_stackedWidget,
+                                                                this);
 
-        setupCurrentQmlBackend(currentQmlBackend,
-                               m_selectedNode,
-                               QUrl::fromLocalFile(QString{specificsPath}),
-                               currentState(),
-                               this,
-                               specificQmlData);
+    setupCurrentQmlBackend(currentQmlBackend,
+                           m_selectedNode,
+                           QUrl::fromLocalFile(QString{specificsPath}),
+                           currentState(),
+                           this,
+                           specificQmlData);
 
-        setupWidget(currentQmlBackend, this, m_stackedWidget);
+    setupWidget(currentQmlBackend, this, m_stackedWidget);
 
-        m_qmlBackEndForCurrentType = currentQmlBackend;
+    m_qmlBackEndForCurrentType = currentQmlBackend;
 
-        setupInsight(rootModelNode(), currentQmlBackend);
-    } else {
-        const NodeMetaInfo commonAncestor = PropertyEditorQmlBackend::findCommonAncestor(
-            m_selectedNode);
+    setupInsight(rootModelNode(), currentQmlBackend);
+#else
+    const NodeMetaInfo commonAncestor = PropertyEditorQmlBackend::findCommonAncestor(m_selectedNode);
 
-        const auto [qmlFileUrl, specificsClassMetaInfo] = PropertyEditorQmlBackend::getQmlUrlForMetaInfo(
-            commonAncestor);
+    const auto [qmlFileUrl, specificsClassMetaInfo] = PropertyEditorQmlBackend::getQmlUrlForMetaInfo(
+        commonAncestor);
 
-        auto [diffClassMetaInfo, qmlSpecificsFile] = diffType(commonAncestor, specificsClassMetaInfo);
+    auto [diffClassMetaInfo, qmlSpecificsFile] = diffType(commonAncestor, specificsClassMetaInfo);
 
-        QString specificQmlData = getSpecificQmlData(commonAncestor, m_selectedNode, diffClassMetaInfo);
+    QString specificQmlData = getSpecificQmlData(commonAncestor, m_selectedNode, diffClassMetaInfo);
 
-        PropertyEditorQmlBackend *currentQmlBackend = getQmlBackend(m_qmlBackendHash,
-                                                                    qmlFileUrl,
-                                                                    m_imageCache,
-                                                                    m_stackedWidget,
-                                                                    this);
+    PropertyEditorQmlBackend *currentQmlBackend = getQmlBackend(m_qmlBackendHash,
+                                                                qmlFileUrl,
+                                                                m_imageCache,
+                                                                m_stackedWidget,
+                                                                this);
 
-        setupCurrentQmlBackend(currentQmlBackend,
-                               m_selectedNode,
-                               qmlSpecificsFile,
-                               currentState(),
-                               this,
-                               specificQmlData);
+    setupCurrentQmlBackend(
+        currentQmlBackend, m_selectedNode, qmlSpecificsFile, currentState(), this, specificQmlData);
 
-        setupWidget(currentQmlBackend, this, m_stackedWidget);
+    setupWidget(currentQmlBackend, this, m_stackedWidget);
 
-        m_qmlBackEndForCurrentType = currentQmlBackend;
+    m_qmlBackEndForCurrentType = currentQmlBackend;
 
-        setupInsight(rootModelNode(), currentQmlBackend);
-    }
+    setupInsight(rootModelNode(), currentQmlBackend);
+#endif // QDS_USE_PROJECTSTORAGE
 }
 
 void PropertyEditorView::commitVariantValueToModel(const PropertyName &propertyName, const QVariant &value)
diff --git a/src/plugins/qmldesigner/components/stateseditor/propertymodel.cpp b/src/plugins/qmldesigner/components/stateseditor/propertymodel.cpp
index 0a72d60ef7a..db07dd22080 100644
--- a/src/plugins/qmldesigner/components/stateseditor/propertymodel.cpp
+++ b/src/plugins/qmldesigner/components/stateseditor/propertymodel.cpp
@@ -64,12 +64,19 @@ QVariant PropertyModel::data(const QModelIndex &index, int role) const
 
         if (!propertyChanges.target().isValid())
             return {};
-
+#ifdef QDS_USE_PROJECTSTORAGE
+        return propertyChanges.target()
+            .metaInfo()
+            .property(m_properties.at(index.row()).name())
+            .propertyType()
+            .displayName();
+#else
         return propertyChanges.target()
             .metaInfo()
             .property(m_properties.at(index.row()).name())
             .propertyType()
             .typeName();
+#endif
     }
     }
     return {};
diff --git a/src/plugins/qmldesigner/components/stateseditor/stateseditormodel.cpp b/src/plugins/qmldesigner/components/stateseditor/stateseditormodel.cpp
index 2ff5adedbe7..33351baf5ea 100644
--- a/src/plugins/qmldesigner/components/stateseditor/stateseditormodel.cpp
+++ b/src/plugins/qmldesigner/components/stateseditor/stateseditormodel.cpp
@@ -343,6 +343,9 @@ bool StatesEditorModel::renameActiveStateGroup(const QString &name)
 void StatesEditorModel::addStateGroup(const QString &name)
 {
     m_statesEditorView->executeInTransaction("createStateGroup", [this, name]() {
+#ifdef QDS_USE_PROJECTSTORAGE
+        auto stateGroupNode = m_statesEditorView->createModelNode("StateGroup");
+#else
         const TypeName typeName = "QtQuick.StateGroup";
         auto metaInfo = m_statesEditorView->model()->metaInfo(typeName);
         int minorVersion = metaInfo.minorVersion();
@@ -350,6 +353,7 @@ void StatesEditorModel::addStateGroup(const QString &name)
         auto stateGroupNode = m_statesEditorView->createModelNode(typeName,
                                                                   majorVersion,
                                                                   minorVersion);
+#endif
         stateGroupNode.setIdWithoutRefactoring(m_statesEditorView->model()->generateNewId(name));
 
         m_statesEditorView->rootModelNode().defaultNodeAbstractProperty().reparentHere(
diff --git a/src/plugins/qmldesigner/components/textureeditor/textureeditorqmlbackend.cpp b/src/plugins/qmldesigner/components/textureeditor/textureeditorqmlbackend.cpp
index 0cf01cf6209..80cf5693d28 100644
--- a/src/plugins/qmldesigner/components/textureeditor/textureeditorqmlbackend.cpp
+++ b/src/plugins/qmldesigner/components/textureeditor/textureeditorqmlbackend.cpp
@@ -247,8 +247,10 @@ void TextureEditorQmlBackend::setup(const QmlObjectNode &selectedTextureNode, co
 
         contextObject()->setSelectionChanged(false);
 
+#ifndef QDS_USE_PROJECTSTORAGE
         NodeMetaInfo metaInfo = selectedTextureNode.modelNode().metaInfo();
         contextObject()->setMajorVersion(metaInfo.isValid() ? metaInfo.majorVersion() : -1);
+#endif
     } else {
         context()->setContextProperty("hasTexture", QVariant(false));
     }
diff --git a/src/plugins/qmldesigner/components/textureeditor/textureeditorview.cpp b/src/plugins/qmldesigner/components/textureeditor/textureeditorview.cpp
index 5cdd788ab7b..5de3730c97b 100644
--- a/src/plugins/qmldesigner/components/textureeditor/textureeditorview.cpp
+++ b/src/plugins/qmldesigner/components/textureeditor/textureeditorview.cpp
@@ -380,10 +380,14 @@ void TextureEditorView::handleToolBarAction(int action)
             ModelNode matLib = Utils3D::materialLibraryNode(this);
             if (!matLib.isValid())
                 return;
-
+#ifdef QDS_USE_PROJECTSTORAGE
+            ModelNode newTextureNode = createModelNode("Texture");
+#else
             NodeMetaInfo metaInfo = model()->metaInfo("QtQuick3D.Texture");
-            ModelNode newTextureNode = createModelNode("QtQuick3D.Texture", metaInfo.majorVersion(),
-                                                                            metaInfo.minorVersion());
+            ModelNode newTextureNode = createModelNode("QtQuick3D.Texture",
+                                                       metaInfo.majorVersion(),
+                                                       metaInfo.minorVersion());
+#endif
             newTextureNode.validId();
             matLib.defaultNodeListProperty().reparentHere(newTextureNode);
         });
@@ -408,6 +412,9 @@ void TextureEditorView::handleToolBarAction(int action)
 
 void TextureEditorView::setupQmlBackend()
 {
+#ifdef QDS_USE_PROJECTSTORAGE
+// This is an copy of the property editor code which is already rewritten. Please reuse that code.
+#else
     QUrl qmlPaneUrl;
     QUrl qmlSpecificsUrl;
     QString specificQmlData;
@@ -475,6 +482,7 @@ void TextureEditorView::setupQmlBackend()
         m_dynamicPropertiesModel->reset();
 
     m_stackedWidget->setCurrentWidget(m_qmlBackEnd->widget());
+#endif
 }
 
 void TextureEditorView::commitVariantValueToModel(const PropertyName &propertyName, const QVariant &value)
@@ -754,9 +762,12 @@ void TextureEditorView::duplicateTexture(const ModelNode &texture)
             return;
 
         // create the duplicate texture
+#ifdef QDS_USE_PROJECTSTORAGE
+        QmlObjectNode duplicateTex = createModelNode(matType);
+#else
         NodeMetaInfo metaInfo = model()->metaInfo(matType);
         QmlObjectNode duplicateTex = createModelNode(matType, metaInfo.majorVersion(), metaInfo.minorVersion());
-
+#endif
         duplicateTextureNode = duplicateTex .modelNode();
         duplicateTextureNode.validId();
 
diff --git a/src/plugins/qmldesigner/components/timelineeditor/timelineview.cpp b/src/plugins/qmldesigner/components/timelineeditor/timelineview.cpp
index c363f944099..7905df68e91 100644
--- a/src/plugins/qmldesigner/components/timelineeditor/timelineview.cpp
+++ b/src/plugins/qmldesigner/components/timelineeditor/timelineview.cpp
@@ -278,6 +278,7 @@ TimelineWidget *TimelineView::widget() const
     return m_timelineWidget;
 }
 
+namespace {
 QList<QmlModelState> getAllStates(TimelineView* view)
 {
     QmlVisualNode visNode(view->rootModelNode());
@@ -315,6 +316,7 @@ void enableInCurrentState(
         }
     }
 }
+} // namespace
 
 const QmlTimeline TimelineView::addNewTimeline()
 {
@@ -329,21 +331,24 @@ const QmlTimeline TimelineView::addNewTimeline()
     } catch (const Exception &e) {
         e.showException();
     }
-
+#ifndef QDS_USE_PROJECTSTORAGE
     NodeMetaInfo metaInfo = model()->metaInfo(timelineType);
 
     QTC_ASSERT(metaInfo.isValid(), return QmlTimeline());
-
+#endif
     ModelNode timelineNode;
 
-    executeInTransaction("TimelineView::addNewTimeline",
-                         [this, timelineType, metaInfo, &timelineNode] {
+    executeInTransaction("TimelineView::addNewTimeline", [&] {
         bool hasTimelines = getTimelines().isEmpty();
         QString currentStateName = getStateName(this, hasTimelines);
 
+#ifdef QDS_USE_PROJECTSTORAGE
+        timelineNode = createModelNode("Timeline");
+#else
         timelineNode = createModelNode(timelineType,
                                        metaInfo.majorVersion(),
                                        metaInfo.minorVersion());
+#endif
         timelineNode.validId();
 
         timelineNode.variantProperty("startFrame").setValue(0);
@@ -366,21 +371,25 @@ ModelNode TimelineView::addAnimation(QmlTimeline timeline)
 
     QTC_ASSERT(isAttached(), return ModelNode());
 
+#ifndef QDS_USE_PROJECTSTORAGE
     NodeMetaInfo metaInfo = model()->metaInfo(animationType);
 
     QTC_ASSERT(metaInfo.isValid(), return ModelNode());
-
+#endif
     ModelNode animationNode;
 
-    executeInTransaction("TimelineView::addAnimation",
-                         [this, timeline, animationType, metaInfo, &animationNode] {
+    executeInTransaction("TimelineView::addAnimation", [&] {
         bool hasAnimations = getAnimations(timeline).isEmpty();
         QString currentStateName = getStateName(this, hasAnimations);
 
+#ifdef QDS_USE_PROJECTSTORAGE
+        animationNode = createModelNode("TimelineAnimation");
+#else
         animationNode = createModelNode(animationType,
                                         metaInfo.majorVersion(),
                                         metaInfo.minorVersion());
         animationNode.variantProperty("duration").setValue(timeline.duration());
+#endif
         animationNode.validId();
 
         animationNode.variantProperty("from").setValue(timeline.startKeyframe());
diff --git a/src/plugins/qmldesigner/components/transitioneditor/transitioneditorview.cpp b/src/plugins/qmldesigner/components/transitioneditor/transitioneditorview.cpp
index c24ebc1ce32..104127bd49d 100644
--- a/src/plugins/qmldesigner/components/transitioneditor/transitioneditorview.cpp
+++ b/src/plugins/qmldesigner/components/transitioneditor/transitioneditorview.cpp
@@ -225,8 +225,19 @@ ModelNode TransitionEditorView::addNewTransition()
 
     if (!idPropertyList.isEmpty()) {
         executeInTransaction(
-                    " TransitionEditorView::addNewTransition", [&transition, idPropertyList, root, this]() {
+            " TransitionEditorView::addNewTransition", [&transition, idPropertyList, root, this]() {
 
+#ifdef QDS_USE_PROJECTSTORAGE
+                transition = createModelNode("Transition",
+                                             {{
+                                                  "from",
+                                                  "*",
+                                              },
+                                              {
+                                                  "to",
+                                                  "*",
+                                              }});
+#else
             const NodeMetaInfo transitionMetaInfo = model()->metaInfo("QtQuick.Transition");
             transition = createModelNode("QtQuick.Transition",
                                          transitionMetaInfo.majorVersion(),
@@ -239,28 +250,38 @@ ModelNode TransitionEditorView::addNewTransition()
                                               "to",
                                               "*",
                                           }});
-            transition.setAuxiliaryData(transitionDurationProperty, 2000);
-            transition.validId();
-            root.nodeListProperty("transitions").reparentHere(transition);
+#endif
+                transition.setAuxiliaryData(transitionDurationProperty, 2000);
+                transition.validId();
+                root.nodeListProperty("transitions").reparentHere(transition);
 
-            for (auto it = idPropertyList.cbegin(); it != idPropertyList.cend(); ++it) {
-                ModelNode parallelAnimation = createModelNode("QtQuick.ParallelAnimation");
-                transition.defaultNodeAbstractProperty().reparentHere(parallelAnimation);
-                for (const QString &property : it.value()) {
-                    ModelNode sequentialAnimation
-                            = createModelNode("QtQuick.SequentialAnimation");
-                    parallelAnimation.defaultNodeAbstractProperty().reparentHere(
-                                sequentialAnimation);
+                for (auto it = idPropertyList.cbegin(); it != idPropertyList.cend(); ++it) {
+                    ModelNode parallelAnimation = createModelNode("QtQuick.ParallelAnimation");
+                    transition.defaultNodeAbstractProperty().reparentHere(parallelAnimation);
+                    for (const QString &property : it.value()) {
+                        ModelNode sequentialAnimation = createModelNode(
+                            "QtQuick.SequentialAnimation");
+                        parallelAnimation.defaultNodeAbstractProperty().reparentHere(
+                            sequentialAnimation);
 
+#ifdef QDS_USE_PROJECTSTORAGE
+                        ModelNode pauseAnimation = createModelNode("PauseAnimation",
+                                                                   {{"duration", 50}});
+#else
                     const NodeMetaInfo pauseMetaInfo = model()->metaInfo("QtQuick.PauseAnimation");
 
                     ModelNode pauseAnimation = createModelNode("QtQuick.PauseAnimation",
                                                                pauseMetaInfo.majorVersion(),
                                                                pauseMetaInfo.minorVersion(),
                                                                {{"duration", 50}});
-                    sequentialAnimation.defaultNodeAbstractProperty().reparentHere(
-                                pauseAnimation);
+#endif
+                        sequentialAnimation.defaultNodeAbstractProperty().reparentHere(pauseAnimation);
 
+#ifdef QDS_USE_PROJECTSTORAGE
+                        ModelNode propertyAnimation = createModelNode("PropertyAnimation",
+                                                                      {{"property", property},
+                                                                       {"duration", 150}});
+#else
                     const NodeMetaInfo propertyMetaInfo = model()->metaInfo("QtQuick.PauseAnimation");
 
                     ModelNode propertyAnimation = createModelNode("QtQuick.PropertyAnimation",
@@ -268,11 +289,12 @@ ModelNode TransitionEditorView::addNewTransition()
                                                                   propertyMetaInfo.minorVersion(),
                                                                   {{"property", property},
                                                                    {"duration", 150}});
-                    propertyAnimation.bindingProperty("target").setExpression(it.key());
-                    sequentialAnimation.defaultNodeAbstractProperty().reparentHere(
-                                propertyAnimation);
+#endif
+                        propertyAnimation.bindingProperty("target").setExpression(it.key());
+                        sequentialAnimation.defaultNodeAbstractProperty().reparentHere(
+                            propertyAnimation);
+                    }
                 }
-            }
             });
     } else {
         QString properties;
diff --git a/src/plugins/qmldesigner/designercore/include/abstractview.h b/src/plugins/qmldesigner/designercore/include/abstractview.h
index 385739aa829..f4565633482 100644
--- a/src/plugins/qmldesigner/designercore/include/abstractview.h
+++ b/src/plugins/qmldesigner/designercore/include/abstractview.h
@@ -95,6 +95,13 @@ public:
                               ModelNode::NodeSourceType nodeSourceType = ModelNode::NodeWithoutSource,
                               const QString &behaviorPropertyName = {});
 
+    ModelNode createModelNode(const TypeName &typeName,
+                              const PropertyListType &propertyList,
+                              const AuxiliaryDatas &auxPropertyList = {},
+                              const QString &nodeSource = {},
+                              ModelNode::NodeSourceType nodeSourceType = ModelNode::NodeWithoutSource,
+                              const QString &behaviorPropertyName = {});
+
     ModelNode rootModelNode() const;
     ModelNode rootModelNode();
 
diff --git a/src/plugins/qmldesigner/designercore/include/model.h b/src/plugins/qmldesigner/designercore/include/model.h
index 67179efede3..1f6f6dbcad8 100644
--- a/src/plugins/qmldesigner/designercore/include/model.h
+++ b/src/plugins/qmldesigner/designercore/include/model.h
@@ -110,13 +110,14 @@ public:
                                       fileUrl,
                                       std::move(resourceManagement)));
     }
-    static ModelPointer create(ProjectStorageDependencies m_projectStorageDependencies,
+
+    static ModelPointer create(ProjectStorageDependencies projectStorageDependencies,
                                const TypeName &typeName,
                                int major = 1,
                                int minor = 1,
                                std::unique_ptr<ModelResourceManagementInterface> resourceManagement = {})
     {
-        return ModelPointer(new Model(m_projectStorageDependencies,
+        return ModelPointer(new Model(projectStorageDependencies,
                                       typeName,
                                       major,
                                       minor,
@@ -124,6 +125,9 @@ public:
                                       std::move(resourceManagement)));
     }
 
+    ModelPointer createModel(const TypeName &typeName,
+                             std::unique_ptr<ModelResourceManagementInterface> resourceManagement = {});
+
     QUrl fileUrl() const;
     SourceId fileUrlSourceId() const;
     void setFileUrl(const QUrl &url);
@@ -150,6 +154,7 @@ public:
     NodeMetaInfo flowViewFlowWildcardMetaInfo() const;
     NodeMetaInfo fontMetaInfo() const;
     NodeMetaInfo qmlQtObjectMetaInfo() const;
+    NodeMetaInfo qtQmlConnectionsMetaInfo() const;
     NodeMetaInfo qtQmlModelsListModelMetaInfo() const;
     NodeMetaInfo qtQmlModelsListElementMetaInfo() const;
     NodeMetaInfo qtQuick3DBakedLightmapMetaInfo() const;
@@ -164,7 +169,6 @@ public:
     NodeMetaInfo qtQuick3DPrincipledMaterialMetaInfo() const;
     NodeMetaInfo qtQuick3DSpotLightMetaInfo() const;
     NodeMetaInfo qtQuick3DTextureMetaInfo() const;
-    NodeMetaInfo qtQuickConnectionsMetaInfo() const;
     NodeMetaInfo qtQuickControlsTextAreaMetaInfo() const;
     NodeMetaInfo qtQuickImageMetaInfo() const;
     NodeMetaInfo qtQuickItemMetaInfo() const;
@@ -216,6 +220,10 @@ public:
     QStringList importPaths() const;
     Import highestPossibleImport(const QString &importPath);
 
+    ModuleIds moduleIds() const;
+
+    Storage::Info::ExportedTypeName exportedTypeNameForMetaInfo(const NodeMetaInfo &metaInfo) const;
+
     RewriterView *rewriterView() const;
     void setRewriterView(RewriterView *rewriterView);
 
diff --git a/src/plugins/qmldesigner/designercore/include/nodemetainfo.h b/src/plugins/qmldesigner/designercore/include/nodemetainfo.h
index 7e171c54450..53c755ddc88 100644
--- a/src/plugins/qmldesigner/designercore/include/nodemetainfo.h
+++ b/src/plugins/qmldesigner/designercore/include/nodemetainfo.h
@@ -22,6 +22,16 @@ QT_BEGIN_NAMESPACE
 class QDeclarativeContext;
 QT_END_NAMESPACE
 
+#ifdef QDS_USE_PROJECTSTORAGE
+#  define DEPRECATED_TYPENAME [[deprecated("Don't use string based types anymore!")]]
+#  define DEPRECATED_VERSION_NUMBER \
+      [[deprecated( \
+          "In most cases you don't need them anymore because the import is setting them!")]]
+#else
+#  define DEPRECATED_TYPENAME
+#  define DEPRECATED_VERSION_NUMBER
+#endif
+
 namespace QmlDesigner {
 
 class MetaInfo;
@@ -92,10 +102,11 @@ public:
 
     bool defaultPropertyIsComponent() const;
 
-    TypeName typeName() const;
-    TypeName simplifiedTypeName() const;
-    int majorVersion() const;
-    int minorVersion() const;
+    TypeName displayName() const;
+    DEPRECATED_TYPENAME TypeName typeName() const;
+    DEPRECATED_TYPENAME TypeName simplifiedTypeName() const;
+    DEPRECATED_VERSION_NUMBER int majorVersion() const;
+    DEPRECATED_VERSION_NUMBER int minorVersion() const;
 
     Storage::Info::ExportedTypeNames allExportedTypeNames() const;
     Storage::Info::ExportedTypeNames exportedTypeNamesForSourceId(SourceId sourceId) const;
@@ -155,6 +166,7 @@ public:
     bool isQmlComponent() const;
     bool isQtMultimediaSoundEffect() const;
     bool isQtObject() const;
+    bool isQtQmlConnections() const;
     bool isQtQuick3DBakedLightmap() const;
     bool isQtQuick3DBuffer() const;
     bool isQtQuick3DCamera() const;
@@ -202,6 +214,7 @@ public:
     bool isQtQuickState() const;
     bool isQtQuickStateOperation() const;
     bool isQtQuickStudioComponentsGroupItem() const;
+    bool isQtQuickStudioUtilsJsonListModel() const;
     bool isQtQuickText() const;
     bool isQtQuickTimelineKeyframe() const;
     bool isQtQuickTimelineKeyframeGroup() const;
diff --git a/src/plugins/qmldesigner/designercore/metainfo/nodemetainfo.cpp b/src/plugins/qmldesigner/designercore/metainfo/nodemetainfo.cpp
index bc405057340..3002f4d8de8 100644
--- a/src/plugins/qmldesigner/designercore/metainfo/nodemetainfo.cpp
+++ b/src/plugins/qmldesigner/designercore/metainfo/nodemetainfo.cpp
@@ -26,6 +26,12 @@
 #include <utils/qtcassert.h>
 #include <utils/algorithm.h>
 
+// remove that if the old code model is removed
+QT_WARNING_PUSH
+QT_WARNING_DISABLE_GCC("-Wdeprecated-declarations")
+QT_WARNING_DISABLE_CLANG("-Wdeprecated-declarations")
+QT_WARNING_DISABLE_MSVC(4996)
+
 namespace QmlDesigner {
 
 /*!
@@ -1924,6 +1930,11 @@ bool NodeMetaInfo::defaultPropertyIsComponent() const
     return false;
 }
 
+TypeName NodeMetaInfo::displayName() const
+{
+    return {};
+}
+
 TypeName NodeMetaInfo::typeName() const
 {
     if (isValid())
@@ -2365,6 +2376,16 @@ bool NodeMetaInfo::isQtObject() const
     }
 }
 
+bool NodeMetaInfo::isQtQmlConnections() const
+{
+    if constexpr (useProjectStorage()) {
+        using namespace Storage::Info;
+        return isBasedOnCommonType<QtQml, Connections>(m_projectStorage, m_typeId);
+    } else {
+        return isValid() && simplifiedTypeName() == "Connections";
+    }
+}
+
 bool NodeMetaInfo::isLayoutable() const
 {
     if constexpr (useProjectStorage()) {
@@ -3014,6 +3035,17 @@ bool NodeMetaInfo::isQtQuickStudioComponentsGroupItem() const
     }
 }
 
+bool NodeMetaInfo::isQtQuickStudioUtilsJsonListModel() const
+{
+    if constexpr (useProjectStorage()) {
+        using namespace Storage::Info;
+        return isBasedOnCommonType<QtQuick_Studio_Components, JsonListModel>(m_projectStorage,
+                                                                             m_typeId);
+    } else {
+        return isValid() && isSubclassOf("QtQuick.Studio.Utils.JsonListModel");
+    }
+}
+
 bool NodeMetaInfo::isQmlComponent() const
 {
     if constexpr (useProjectStorage()) {
@@ -3689,3 +3721,5 @@ CompoundPropertyMetaInfos MetaInfoUtils::inflateValueAndReadOnlyProperties(Prope
 }
 
 } // namespace QmlDesigner
+
+QT_WARNING_POP
diff --git a/src/plugins/qmldesigner/designercore/model/abstractview.cpp b/src/plugins/qmldesigner/designercore/model/abstractview.cpp
index aa9422d5c49..061ab8ae2b0 100644
--- a/src/plugins/qmldesigner/designercore/model/abstractview.cpp
+++ b/src/plugins/qmldesigner/designercore/model/abstractview.cpp
@@ -68,12 +68,12 @@ RewriterTransaction AbstractView::beginRewriterTransaction(const QByteArray &ide
 
 ModelNode AbstractView::createModelNode(const TypeName &typeName)
 {
-    if constexpr (useProjectStorage()) {
-        return createModelNode(typeName, -1, -1);
-    } else {
-        const NodeMetaInfo metaInfo = model()->metaInfo(typeName);
-        return createModelNode(typeName, metaInfo.majorVersion(), metaInfo.minorVersion());
-    }
+#ifdef QDS_USE_PROJECTSTORAGE
+    return createModelNode(typeName, -1, -1);
+#else
+    const NodeMetaInfo metaInfo = model()->metaInfo(typeName);
+    return createModelNode(typeName, metaInfo.majorVersion(), metaInfo.minorVersion());
+#endif
 }
 
 ModelNode AbstractView::createModelNode(const TypeName &typeName,
@@ -90,6 +90,24 @@ ModelNode AbstractView::createModelNode(const TypeName &typeName,
                                             behaviorPropertyName), model(), this);
 }
 
+ModelNode AbstractView::createModelNode(const TypeName &typeName,
+                                        const QList<QPair<PropertyName, QVariant>> &propertyList,
+                                        const AuxiliaryDatas &auxPropertyList,
+                                        const QString &nodeSource,
+                                        ModelNode::NodeSourceType nodeSourceType,
+                                        const QString &behaviorPropertyName)
+{
+    return ModelNode(model()->d->createNode(typeName,
+                                            -1,
+                                            -1,
+                                            propertyList,
+                                            auxPropertyList,
+                                            nodeSource,
+                                            nodeSourceType,
+                                            behaviorPropertyName),
+                     model(),
+                     this);
+}
 
 // Returns the constant root model node.
 ModelNode AbstractView::rootModelNode() const
@@ -824,6 +842,7 @@ static int getMajorVersionFromImport(const Model *model)
     return -1;
 }
 
+#ifndef QDS_USE_PROJECTSTORAGE
 static int getMajorVersionFromNode(const ModelNode &modelNode)
 {
     if (modelNode.metaInfo().isValid()) {
@@ -848,6 +867,7 @@ static int getMinorVersionFromNode(const ModelNode &modelNode)
 
     return 1; // default
 }
+#endif
 
 int AbstractView::majorQtQuickVersion() const
 {
@@ -855,7 +875,11 @@ int AbstractView::majorQtQuickVersion() const
     if (majorVersionFromImport >= 0)
         return majorVersionFromImport;
 
+#ifdef QDS_USE_PROJECTSTORAGE
+    return -1;
+#else
     return getMajorVersionFromNode(rootModelNode());
+#endif
 }
 
 int AbstractView::minorQtQuickVersion() const
@@ -864,7 +888,11 @@ int AbstractView::minorQtQuickVersion() const
     if (minorVersionFromImport >= 0)
         return minorVersionFromImport;
 
+#ifdef QDS_USE_PROJECTSTORAGE
+    return -1;
+#else
     return getMinorVersionFromNode(rootModelNode());
+#endif
 }
 
 } // namespace QmlDesigner
diff --git a/src/plugins/qmldesigner/designercore/model/model.cpp b/src/plugins/qmldesigner/designercore/model/model.cpp
index 9f38819dee8..a4cd31b2a89 100644
--- a/src/plugins/qmldesigner/designercore/model/model.cpp
+++ b/src/plugins/qmldesigner/designercore/model/model.cpp
@@ -1731,6 +1731,16 @@ Model::Model(const TypeName &typeName,
         this, typeName, major, minor, metaInfoProxyModel, std::move(resourceManagement)))
 {}
 
+ModelPointer Model::createModel(const TypeName &typeName,
+                                std::unique_ptr<ModelResourceManagementInterface> resourceManagement)
+{
+    return Model::create({*d->projectStorage, *d->pathCache},
+                         typeName,
+                         imports(),
+                         fileUrl(),
+                         std::move(resourceManagement));
+}
+
 Model::~Model() = default;
 
 const Imports &Model::imports() const
@@ -1738,6 +1748,16 @@ const Imports &Model::imports() const
     return d->imports();
 }
 
+ModuleIds Model::moduleIds() const
+{
+    return {};
+}
+
+Storage::Info::ExportedTypeName Model::exportedTypeNameForMetaInfo(const NodeMetaInfo &) const
+{
+    return {};
+}
+
 const Imports &Model::possibleImports() const
 {
     return d->m_possibleImportList;
@@ -1938,7 +1958,6 @@ void Model::setCurrentStateNode(const ModelNode &node)
     d->notifyCurrentStateChanged(node);
 }
 
-// QTC_TEMP
 ModelNode Model::currentStateNode(AbstractView *view)
 {
     return ModelNode(d->currentStateNode(), this, view);
@@ -2455,13 +2474,13 @@ NodeMetaInfo Model::qtQuickTransistionMetaInfo() const
     }
 }
 
-NodeMetaInfo Model::qtQuickConnectionsMetaInfo() const
+NodeMetaInfo Model::qtQmlConnectionsMetaInfo() const
 {
     if constexpr (useProjectStorage()) {
         using namespace Storage::Info;
-        return createNodeMetaInfo<QtQuick, Connections>();
+        return createNodeMetaInfo<QtQml, Connections>();
     } else {
-        return metaInfo("QtQuick.Connections");
+        return metaInfo("QtQml.Connections");
     }
 }
 
@@ -2714,12 +2733,12 @@ ModelNode createNode(Model *model,
 
 ModelNode Model::createModelNode(const TypeName &typeName)
 {
-    if constexpr (useProjectStorage()) {
-        return createNode(this, d.get(), typeName, -1, -1);
-    } else {
-        const NodeMetaInfo m = metaInfo(typeName);
-        return createNode(this, d.get(), typeName, m.majorVersion(), m.minorVersion());
-    }
+#ifdef QDS_USE_PROJECTSTORAGE
+    return createNode(this, d.get(), typeName, -1, -1);
+#else
+    const NodeMetaInfo m = metaInfo(typeName);
+    return createNode(this, d.get(), typeName, m.majorVersion(), m.minorVersion());
+#endif
 }
 
 void Model::changeRootNodeType(const TypeName &type)
diff --git a/src/plugins/qmldesigner/designercore/model/modelmerger.cpp b/src/plugins/qmldesigner/designercore/model/modelmerger.cpp
index a9fa1ebd19b..24873bb141f 100644
--- a/src/plugins/qmldesigner/designercore/model/modelmerger.cpp
+++ b/src/plugins/qmldesigner/designercore/model/modelmerger.cpp
@@ -152,9 +152,17 @@ static ModelNode createNodeFromNode(const ModelNode &modelNode,
                                     const QHash<QString, QString> &idRenamingHash,
                                     AbstractView *view, const MergePredicate &mergePredicate)
 {
+#ifdef QDS_USE_PROJECTSTORAGE
+    ModelNode newNode = view->createModelNode(modelNode.type(),
+                                              {},
+                                              {},
+                                              modelNode.nodeSource(),
+                                              modelNode.nodeSourceType());
+#else
     NodeMetaInfo nodeMetaInfo = view->model()->metaInfo(modelNode.type());
     ModelNode newNode(view->createModelNode(modelNode.type(), nodeMetaInfo.majorVersion(), nodeMetaInfo.minorVersion(),
                                             {}, {}, modelNode.nodeSource(), modelNode.nodeSourceType()));
+#endif
     syncVariantProperties(newNode, modelNode);
     syncAuxiliaryProperties(newNode, modelNode);
     syncBindingProperties(newNode, modelNode, idRenamingHash);
diff --git a/src/plugins/qmldesigner/designercore/model/qmlconnections.cpp b/src/plugins/qmldesigner/designercore/model/qmlconnections.cpp
index 7a63e73d629..b7d04f3f387 100644
--- a/src/plugins/qmldesigner/designercore/model/qmlconnections.cpp
+++ b/src/plugins/qmldesigner/designercore/model/qmlconnections.cpp
@@ -98,10 +98,15 @@ QList<SignalHandlerProperty> QmlConnections::signalProperties() const
 
 ModelNode QmlConnections::createQmlConnections(AbstractView *view)
 {
-    NodeMetaInfo nodeMetaInfo = view->model()->qtQuickConnectionsMetaInfo();
+#ifdef QDS_USE_PROJECTSTORAGE
+    return view->createModelNode("Connections");
+#else
+    NodeMetaInfo nodeMetaInfo = view->model()->qtQmlConnectionsMetaInfo();
+
     return view->createModelNode("QtQuick.Connections",
                                  nodeMetaInfo.majorVersion(),
                                  nodeMetaInfo.minorVersion());
+#endif
 }
 
 } // QmlDesigner
diff --git a/src/plugins/qmldesigner/designercore/model/qmlitemnode.cpp b/src/plugins/qmldesigner/designercore/model/qmlitemnode.cpp
index 59295e6ae76..826856428bf 100644
--- a/src/plugins/qmldesigner/designercore/model/qmlitemnode.cpp
+++ b/src/plugins/qmldesigner/designercore/model/qmlitemnode.cpp
@@ -81,12 +81,25 @@ QmlItemNode QmlItemNode::createQmlItemNodeFromImage(AbstractView *view, const QS
             propertyPairList.append({PropertyName("source"), QVariant(relativeImageName)});
         }
 
+#ifdef QDS_USE_PROJECTSTORAGE
+        TypeName type("Image");
+        QImageReader reader(imageName);
+        if (reader.supportsAnimation())
+            type = "AnimatedImage";
+
+        newQmlItemNode = QmlItemNode(view->createModelNode(type, propertyPairList));
+#else
+
         TypeName type("QtQuick.Image");
         QImageReader reader(imageName);
         if (reader.supportsAnimation())
             type = "QtQuick.AnimatedImage";
 
-        newQmlItemNode = QmlItemNode(view->createModelNode(type, metaInfo.majorVersion(), metaInfo.minorVersion(), propertyPairList));
+        newQmlItemNode = QmlItemNode(view->createModelNode(type,
+                                                           metaInfo.majorVersion(),
+                                                           metaInfo.minorVersion(),
+                                                           propertyPairList));
+#endif
         parentproperty.reparentHere(newQmlItemNode);
 
         QFileInfo fi(relativeImageName);
@@ -129,7 +142,6 @@ QmlItemNode QmlItemNode::createQmlItemNodeFromFont(AbstractView *view,
     QmlItemNode newQmlItemNode;
 
     auto doCreateQmlItemNodeFromFont = [=, &newQmlItemNode, &parentproperty]() {
-        NodeMetaInfo metaInfo = view->model()->metaInfo("QtQuick.Text");
         QList<QPair<PropertyName, QVariant>> propertyPairList;
         if (const int intX = qRound(position.x()))
             propertyPairList.append({PropertyName("x"), QVariant(intX)});
@@ -138,9 +150,13 @@ QmlItemNode QmlItemNode::createQmlItemNodeFromFont(AbstractView *view,
         propertyPairList.append({PropertyName("font.family"), QVariant(fontFamily)});
         propertyPairList.append({PropertyName("font.pointSize"), 20});
         propertyPairList.append({PropertyName("text"), QVariant(fontFamily)});
-
+#ifdef QDS_USE_PROJECTSTORAGE
+        newQmlItemNode = QmlItemNode(view->createModelNode("Text", propertyPairList));
+#else
+        NodeMetaInfo metaInfo = view->model()->metaInfo("QtQuick.Text");
         newQmlItemNode = QmlItemNode(view->createModelNode("QtQuick.Text", metaInfo.majorVersion(),
                                                            metaInfo.minorVersion(), propertyPairList));
+#endif
         parentproperty.reparentHere(newQmlItemNode);
 
         newQmlItemNode.setId(view->model()->generateNewId("text", "text"));
diff --git a/src/plugins/qmldesigner/designercore/model/qmlobjectnode.cpp b/src/plugins/qmldesigner/designercore/model/qmlobjectnode.cpp
index 55e56512e63..8e1d130295d 100644
--- a/src/plugins/qmldesigner/designercore/model/qmlobjectnode.cpp
+++ b/src/plugins/qmldesigner/designercore/model/qmlobjectnode.cpp
@@ -475,7 +475,7 @@ QList<ModelNode> QmlObjectNode::getAllConnections() const
     if (!isValid())
         return {};
 
-    auto list = view()->allModelNodesOfType(model()->qtQuickConnectionsMetaInfo());
+    auto list = view()->allModelNodesOfType(model()->qtQmlConnectionsMetaInfo());
     return Utils::filtered(list, [this](const ModelNode &connection) {
         return connection.hasBindingProperty("target")
                && connection.bindingProperty("target").resolveToModelNode() == modelNode();
diff --git a/src/plugins/qmldesigner/designercore/model/qmlstate.cpp b/src/plugins/qmldesigner/designercore/model/qmlstate.cpp
index 55864745a96..60ac06f2881 100644
--- a/src/plugins/qmldesigner/designercore/model/qmlstate.cpp
+++ b/src/plugins/qmldesigner/designercore/model/qmlstate.cpp
@@ -141,6 +141,9 @@ void QmlModelState::addChangeSetIfNotExists(const ModelNode &node)
     if (!hasPropertyChanges(node)) {
         ModelNode newChangeSet;
 
+#ifdef QDS_USE_PROJECTSTORAGE
+        newChangeSet = modelNode().view()->createModelNode("PropertyChanges");
+#else
         const QByteArray typeName = "QtQuick.PropertyChanges";
         NodeMetaInfo metaInfo = modelNode().model()->metaInfo(typeName);
 
@@ -148,6 +151,7 @@ void QmlModelState::addChangeSetIfNotExists(const ModelNode &node)
         int minor = metaInfo.minorVersion();
 
         newChangeSet = modelNode().view()->createModelNode(typeName, major, minor);
+#endif
 
         modelNode().nodeListProperty("changes").reparentHere(newChangeSet);
 
@@ -296,6 +300,9 @@ ModelNode QmlModelState::createQmlState(AbstractView *view, const PropertyListTy
 {
     QTC_ASSERT(view, return {});
 
+#ifdef QDS_USE_PROJECTSTORAGE
+    return view->createModelNode("State", propertyList);
+#else
     const QByteArray typeName = "QtQuick.State";
     NodeMetaInfo metaInfo = view->model()->metaInfo(typeName);
 
@@ -303,6 +310,7 @@ ModelNode QmlModelState::createQmlState(AbstractView *view, const PropertyListTy
     int minor = metaInfo.minorVersion();
 
     return view->createModelNode(typeName, major, minor, propertyList);
+#endif
 }
 
 void QmlModelState::setAsDefault()
diff --git a/src/plugins/qmldesigner/designercore/model/qmlvisualnode.cpp b/src/plugins/qmldesigner/designercore/model/qmlvisualnode.cpp
index 75db18b5a22..c84f2342576 100644
--- a/src/plugins/qmldesigner/designercore/model/qmlvisualnode.cpp
+++ b/src/plugins/qmldesigner/designercore/model/qmlvisualnode.cpp
@@ -278,7 +278,11 @@ static QmlObjectNode createQmlObjectNodeFromSource(AbstractView *view,
                                                    const QString &source,
                                                    const QmlVisualNode::Position &position)
 {
+#ifdef QDS_USE_PROJECTSTORAGE
+    auto inputModel = view->model()->createModel("Item");
+#else
     auto inputModel = Model::create("QtQuick.Item", 1, 0, view->model());
+#endif
     inputModel->setFileUrl(view->model()->fileUrl());
     QPlainTextEdit textEdit;
 
@@ -328,11 +332,12 @@ QmlObjectNode QmlVisualNode::createQmlObjectNode(AbstractView *view,
     NodeHints hints = NodeHints::fromItemLibraryEntry(itemLibraryEntry);
 
     auto createNodeFunc = [=, &newQmlObjectNode, &parentProperty]() {
+#ifndef QDS_USE_PROJECTSTORAGE
         NodeMetaInfo metaInfo = view->model()->metaInfo(itemLibraryEntry.typeName());
 
         int minorVersion = metaInfo.minorVersion();
         int majorVersion = metaInfo.majorVersion();
-
+#endif
         using PropertyBindingEntry = QPair<PropertyName, QString>;
         QList<PropertyBindingEntry> propertyBindingList;
         QList<PropertyBindingEntry> propertyEnumList;
@@ -359,7 +364,18 @@ QmlObjectNode QmlVisualNode::createQmlObjectNode(AbstractView *view,
             if (itemLibraryEntry.typeName() == "QtQml.Component")
                 nodeSourceType = ModelNode::NodeWithComponentSource;
 
-            newQmlObjectNode = QmlObjectNode(view->createModelNode(itemLibraryEntry.typeName(), majorVersion, minorVersion, propertyPairList, {}, {}, nodeSourceType));
+#ifdef QDS_USE_PROJECTSTORAGE
+            newQmlObjectNode = QmlObjectNode(view->createModelNode(
+                itemLibraryEntry.typeName(), propertyPairList, {}, {}, nodeSourceType));
+#else
+            newQmlObjectNode = QmlObjectNode(view->createModelNode(itemLibraryEntry.typeName(),
+                                                                   majorVersion,
+                                                                   minorVersion,
+                                                                   propertyPairList,
+                                                                   {},
+                                                                   {},
+                                                                   nodeSourceType));
+#endif
         } else {
             newQmlObjectNode = createQmlObjectNodeFromSource(view, itemLibraryEntry.qmlSource(), position);
         }
diff --git a/src/plugins/qmldesigner/designercore/model/stylesheetmerger.cpp b/src/plugins/qmldesigner/designercore/model/stylesheetmerger.cpp
index c4b4eb8c09c..8e0416b68aa 100644
--- a/src/plugins/qmldesigner/designercore/model/stylesheetmerger.cpp
+++ b/src/plugins/qmldesigner/designercore/model/stylesheetmerger.cpp
@@ -169,6 +169,11 @@ ModelNode StylesheetMerger::createReplacementNode(const ModelNode& styleNode, Mo
             continue;
         propertyList.append(QPair<PropertyName, QVariant>(variantProperty.name(), variantProperty.value()));
     }
+
+#ifdef QDS_USE_PROJECTSTORAGE
+    ModelNode newNode(m_templateView->createModelNode(
+        styleNode.type(), propertyList, {}, styleNode.nodeSource(), styleNode.nodeSourceType()));
+#else
     ModelNode newNode(m_templateView->createModelNode(styleNode.type(),
                                                       nodeMetaInfo.majorVersion(),
                                                       nodeMetaInfo.minorVersion(),
@@ -176,6 +181,7 @@ ModelNode StylesheetMerger::createReplacementNode(const ModelNode& styleNode, Mo
                                                       {},
                                                       styleNode.nodeSource(),
                                                       styleNode.nodeSourceType()));
+#endif
 
     syncAuxiliaryProperties(newNode, modelNode);
     syncBindingProperties(newNode, modelNode);
@@ -436,10 +442,14 @@ void StylesheetMerger::syncStateNode(ModelNode &outputState, const ModelNode &in
             changeSet = itr->second;
         } else {
             const QByteArray typeName = inputChangeset.type();
+#ifdef QDS_USE_PROJECTSTORAGE
+            changeSet = m_templateView->createModelNode(typeName);
+#else
             NodeMetaInfo metaInfo = m_templateView->model()->metaInfo(typeName);
             int major = metaInfo.majorVersion();
             int minor = metaInfo.minorVersion();
             changeSet = m_templateView->createModelNode(typeName, major, minor);
+#endif
             outputState.nodeListProperty("changes").reparentHere(changeSet);
             outputChangeSets.insert({key, changeSet});
         }
diff --git a/src/plugins/qmldesigner/designercore/model/texttomodelmerger.cpp b/src/plugins/qmldesigner/designercore/model/texttomodelmerger.cpp
index 942289f865e..f7be6cf5e46 100644
--- a/src/plugins/qmldesigner/designercore/model/texttomodelmerger.cpp
+++ b/src/plugins/qmldesigner/designercore/model/texttomodelmerger.cpp
@@ -1192,11 +1192,11 @@ void TextToModelMerger::syncNode(ModelNode &modelNode,
     int majorVersion = -1;
     int minorVersion = -1;
 
-    if constexpr (!useProjectStorage()) {
-        typeName = info.typeName();
-        majorVersion = info.majorVersion();
-        minorVersion = info.minorVersion();
-    }
+#ifndef QDS_USE_PROJECTSTORAGE
+    typeName = info.typeName();
+    majorVersion = info.majorVersion();
+    minorVersion = info.minorVersion();
+#endif
 
     if (modelNode.isRootNode() && !m_rewriterView->allowComponentRoot() && info.isQmlComponent()) {
         for (AST::UiObjectMemberList *iter = astInitializer->members; iter; iter = iter->next) {
@@ -1563,11 +1563,12 @@ void TextToModelMerger::syncNodeProperty(AbstractProperty &modelProperty,
 
     int majorVersion = -1;
     int minorVersion = -1;
-    if constexpr (!useProjectStorage()) {
-        typeName = info.typeName();
-        majorVersion = info.majorVersion();
-        minorVersion = info.minorVersion();
-    }
+
+#ifndef QDS_USE_PROJECTSTORAGE
+    typeName = info.typeName();
+    majorVersion = info.majorVersion();
+    minorVersion = info.minorVersion();
+#endif
 
     if (modelProperty.isNodeProperty() && dynamicPropertyType == modelProperty.dynamicTypeName()) {
         ModelNode nodePropertyNode = modelProperty.toNodeProperty().modelNode();
@@ -2104,11 +2105,11 @@ ModelNode ModelAmender::listPropertyMissingModelNode(NodeListProperty &modelProp
 
     int majorVersion = -1;
     int minorVersion = -1;
-    if constexpr (!useProjectStorage()) {
-        typeName = info.typeName();
-        majorVersion = info.majorVersion();
-        minorVersion = info.minorVersion();
-    }
+#ifndef QDS_USE_PROJECTSTORAGE
+    typeName = info.typeName();
+    majorVersion = info.majorVersion();
+    minorVersion = info.minorVersion();
+#endif
 
     const bool propertyTakesComponent = propertyHasImplicitComponentType(modelProperty, info);
 
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/commontypecache.h b/src/plugins/qmldesigner/designercore/projectstorage/commontypecache.h
index 41f894356ab..03c25dfac79 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/commontypecache.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/commontypecache.h
@@ -55,6 +55,7 @@ inline constexpr char InstanceListEntry[] = "InstanceListEntry";
 inline constexpr char InstanceList[] = "InstanceList";
 inline constexpr char IntType[] = "int";
 inline constexpr char Item[] = "Item";
+inline constexpr char JsonListModel[] = "JsonListModel";
 inline constexpr char KeyframeGroup[] = "KeyframeGroup";
 inline constexpr char Keyframe[] = "Keyframe";
 inline constexpr char Layout[] = "Layout";
@@ -171,11 +172,11 @@ class CommonTypeCache
                                    CacheType<QML, var>,
                                    CacheType<QML_cppnative, FloatType>,
                                    CacheType<QML_cppnative, UIntType>,
+                                   CacheType<QtQml, Connections>,
                                    CacheType<QtMultimedia, SoundEffect>,
                                    CacheType<QtQml_Models, ListElement>,
                                    CacheType<QtQml_Models, ListModel>,
                                    CacheType<QtQuick, BorderImage>,
-                                   CacheType<QtQuick, Connections>,
                                    CacheType<QtQuick, GridView>,
                                    CacheType<QtQuick, Image>,
                                    CacheType<QtQuick, Item>,
@@ -243,6 +244,7 @@ class CommonTypeCache
                                    CacheType<QtQuick_Extras, Picture>,
                                    CacheType<QtQuick_Layouts, Layout>,
                                    CacheType<QtQuick_Studio_Components, GroupItem>,
+                                   CacheType<QtQuick_Studio_Components, JsonListModel>,
                                    CacheType<QtQuick_Templates, Control>,
                                    CacheType<QtQuick_Timeline, Keyframe>,
                                    CacheType<QtQuick_Timeline, KeyframeGroup>,
diff --git a/src/plugins/qmldesigner/qmldesignerprojectmanager.cpp b/src/plugins/qmldesigner/qmldesignerprojectmanager.cpp
index 2f229985960..7e28849fbb3 100644
--- a/src/plugins/qmldesigner/qmldesignerprojectmanager.cpp
+++ b/src/plugins/qmldesigner/qmldesignerprojectmanager.cpp
@@ -281,12 +281,12 @@ AsynchronousImageCache &QmlDesignerProjectManager::asynchronousImageCache()
 }
 
 namespace {
-ProjectStorage<Sqlite::Database> *dummyProjectStorage()
+[[maybe_unused]] ProjectStorage<Sqlite::Database> *dummyProjectStorage()
 {
     return nullptr;
 }
 
-ProjectStorageUpdater::PathCache *dummyPathCache()
+[[maybe_unused]] ProjectStorageUpdater::PathCache *dummyPathCache()
 {
     return nullptr;
 }
@@ -383,7 +383,7 @@ void collectQmldirPaths(const QString &path, QStringList &qmldirPaths)
     }
 }
 
-void projectQmldirPaths(::ProjectExplorer::Target *target, QStringList &qmldirPaths)
+[[maybe_unused]] void projectQmldirPaths(::ProjectExplorer::Target *target, QStringList &qmldirPaths)
 {
     ::QmlProjectManager::QmlBuildSystem *buildSystem = getQmlBuildSystem(target);
 
@@ -395,12 +395,22 @@ void projectQmldirPaths(::ProjectExplorer::Target *target, QStringList &qmldirPa
         collectQmldirPaths(importPath, qmldirPaths);
 }
 
-void qtQmldirPaths(::ProjectExplorer::Target *target, QStringList &qmldirPaths)
+[[maybe_unused]] void qtQmldirPaths(::ProjectExplorer::Target *target, QStringList &qmldirPaths)
 {
     if constexpr (useProjectStorage())
         collectQmldirPaths(qmlPath(target).toString(), qmldirPaths);
 }
 
+[[maybe_unused]] void qtQmldirPathsForLiteDesigner(::ProjectExplorer::Target *target,
+                                                   QStringList &qmldirPaths)
+{
+    if constexpr (useProjectStorage()) {
+        auto qmlRootPath = qmlPath(target).toString();
+        collectQmldirPaths(qmlRootPath + "/QtQml", qmldirPaths);
+        collectQmldirPaths(qmlRootPath + "/QtQuick", qmldirPaths);
+    }
+}
+
 QStringList directories(::ProjectExplorer::Target *target)
 {
     if (!target)
@@ -409,8 +419,12 @@ QStringList directories(::ProjectExplorer::Target *target)
     QStringList qmldirPaths;
     qmldirPaths.reserve(100);
 
-    qtQmldirPaths(target, qmldirPaths);
-    projectQmldirPaths(target, qmldirPaths);
+    if constexpr (isUsingQmlDesignerLite()) {
+        qtQmldirPathsForLiteDesigner(target, qmldirPaths);
+    } else {
+        qtQmldirPaths(target, qmldirPaths);
+        projectQmldirPaths(target, qmldirPaths);
+    }
 
     std::sort(qmldirPaths.begin(), qmldirPaths.end());
     qmldirPaths.erase(std::unique(qmldirPaths.begin(), qmldirPaths.end()), qmldirPaths.end());
diff --git a/tests/auto/qml/qmldesigner/coretests/tst_testcore.cpp b/tests/auto/qml/qmldesigner/coretests/tst_testcore.cpp
index 9be03d22612..ca82e95b8c1 100644
--- a/tests/auto/qml/qmldesigner/coretests/tst_testcore.cpp
+++ b/tests/auto/qml/qmldesigner/coretests/tst_testcore.cpp
@@ -1365,6 +1365,14 @@ void tst_TestCore::testRewriterBehaivours()
 
     QVERIFY(metaInfo.isValid());
 
+#ifdef QDS_USE_PROJECTSTORAGE
+    ModelNode newBehavior = testRewriterView->createModelNode("Behavior",
+                                                              {},
+                                                              {},
+                                                              {},
+                                                              ModelNode::NodeWithoutSource,
+                                                              "height");
+#else
     ModelNode newBehavior = testRewriterView->createModelNode("QtQuick.Behavior",
                                                               metaInfo.majorVersion(),
                                                               metaInfo.minorVersion(),
@@ -1373,17 +1381,20 @@ void tst_TestCore::testRewriterBehaivours()
                                                               {},
                                                               ModelNode::NodeWithoutSource,
                                                               "height");
-
+#endif
     rootModelNode.defaultNodeListProperty().reparentHere(newBehavior);
 
     QCOMPARE(newBehavior.behaviorPropertyName(), "height");
 
     metaInfo = animation.metaInfo();
     QVERIFY(metaInfo.isValid());
+#ifdef QDS_USE_PROJECTSTORAGE
+    ModelNode newAnimation = testRewriterView->createModelNode(model->exportedTypeNameForMetaInfo(metaInfo).name.toQByteArray());
+#else
     ModelNode newAnimation = testRewriterView->createModelNode(metaInfo.typeName(),
                                                                metaInfo.majorVersion(),
                                                                metaInfo.minorVersion());
-
+#endif
     newBehavior.defaultNodeListProperty().reparentHere(newAnimation);
 
     newAnimation.variantProperty("duration").setValue(500);
@@ -1666,8 +1677,10 @@ void tst_TestCore::testStatesVersionFailing()
 
     QCOMPARE(QmlItemNode(rootModelNode).states().state("state2"), newState);
 
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(stateInfo.majorVersion(), newState.modelNode().majorVersion());
     QCOMPARE(stateInfo.minorVersion(), newState.modelNode().minorVersion());
+#endif
 
     ModelNode rect1Node = view->modelNodeForId("rect1");
     QVERIFY(rect1Node.isValid());
@@ -1708,8 +1721,10 @@ void tst_TestCore::testStatesVersionFailing()
     QVERIFY(changes2.modelNode().hasProperty("x"));
     QVERIFY(oldText != textEdit.toPlainText());
 
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(changeInfo.majorVersion(), changes2.modelNode().majorVersion());
     QCOMPARE(changeInfo.minorVersion(), changes2.modelNode().minorVersion());
+#endif
 }
 
 void tst_TestCore::loadSubItems()
@@ -1987,8 +2002,10 @@ void tst_TestCore::testBasicStatesQtQuick20()
     QCOMPARE(rootModelNode.majorVersion(), 2);
     //QCOMPARE(rootModelNode.majorQtQuickVersion(), 2);
 
+#ifndef QDS_USE_PROJECTSTORAGE
     qDebug() << rootModelNode.nodeListProperty("states").toModelNodeList().first().metaInfo().majorVersion();
     qDebug() << rootModelNode.nodeListProperty("states").toModelNodeList().first().metaInfo().typeName();
+#endif
 
     QSKIP("No qml2puppet");
 
@@ -4833,9 +4850,11 @@ void tst_TestCore::testMetaInfoSimpleType()
     NodeMetaInfo itemMetaInfo = model->metaInfo("QtQuick.Item", 2, 1);
 
     QVERIFY(itemMetaInfo.isValid());
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(itemMetaInfo.typeName(), QmlDesigner::TypeName("QtQuick.Item"));
     QCOMPARE(itemMetaInfo.majorVersion(), 2);
     QCOMPARE(itemMetaInfo.minorVersion(), 1);
+#endif
 
     // super classes
     NodeMetaInfo qobject = itemMetaInfo.prototypes()[1];
@@ -4857,13 +4876,17 @@ void tst_TestCore::testMetaInfoUncreatableType()
     QVERIFY(animationTypeInfo.isValid());
 
     QVERIFY(animationTypeInfo.isValid());
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(animationTypeInfo.typeName(), QmlDesigner::TypeName("QtQuick.Animation"));
     QCOMPARE(animationTypeInfo.majorVersion(), 2);
     QCOMPARE(animationTypeInfo.minorVersion(), 1);
+#endif
 
     NodeMetaInfo qObjectTypeInfo = animationTypeInfo.prototypes()[1];
     QVERIFY(qObjectTypeInfo.isValid());
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(qObjectTypeInfo.simplifiedTypeName(), QmlDesigner::TypeName("QtObject"));
+#endif
 
     QCOMPARE(animationTypeInfo.prototypes().size(), 2);
 }
@@ -4903,9 +4926,11 @@ void tst_TestCore::testMetaInfoCustomType()
 
     NodeMetaInfo stateOperationInfo = propertyChangesInfo.prototypes()[1];
     QVERIFY(stateOperationInfo.isValid());
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(stateOperationInfo.typeName(), QmlDesigner::TypeName("QtQuick.QQuickStateOperation"));
     QCOMPARE(stateOperationInfo.majorVersion(), -1);
     QCOMPARE(stateOperationInfo.minorVersion(), -1);
+#endif
     QCOMPARE(propertyChangesInfo.prototypes().size(), 3);
 
     // DeclarativePropertyChanges just has 3 properties
@@ -4923,25 +4948,31 @@ void tst_TestCore::testMetaInfoEnums()
     QVERIFY(view.data());
     model->attachView(view.data());
 
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(view->rootModelNode().metaInfo().typeName(), QmlDesigner::TypeName("QtQuick.Text"));
+#endif
 
     QVERIFY(view->rootModelNode().metaInfo().hasProperty("transformOrigin"));
 
     QVERIFY(view->rootModelNode().metaInfo().property("transformOrigin").isEnumType());
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(view->rootModelNode()
                  .metaInfo()
                  .property("transformOrigin")
                  .propertyType()
                  .simplifiedTypeName(),
              QmlDesigner::TypeName("TransformOrigin"));
+#endif
 
     QVERIFY(view->rootModelNode().metaInfo().property("horizontalAlignment").isEnumType());
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(view->rootModelNode()
                  .metaInfo()
                  .property("horizontalAlignment")
                  .propertyType()
                  .simplifiedTypeName(),
              QmlDesigner::TypeName("HAlignment"));
+#endif
 
     QApplication::processEvents();
 }
@@ -5038,10 +5069,12 @@ void tst_TestCore::testMetaInfoDotProperties()
     QVERIFY(model->hasNodeMetaInfo("QtQuick.Text"));
 
     QVERIFY(model->metaInfo("QtQuick.Rectangle").hasProperty("border"));
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(model->metaInfo("QtQuick.Rectangle").property("border").propertyType().typeName(),
              QmlDesigner::TypeName("<cpp>.QQuickPen"));
 
     QCOMPARE(view->rootModelNode().metaInfo().typeName(), QmlDesigner::TypeName("QtQuick.Text"));
+#endif
     QVERIFY(view->rootModelNode().metaInfo().hasProperty("font"));
 
     QVERIFY(view->rootModelNode().metaInfo().hasProperty("font.bold"));
@@ -5071,7 +5104,9 @@ void tst_TestCore::testMetaInfoListProperties()
     model->attachView(view.data());
 
     QVERIFY(model->hasNodeMetaInfo("QtQuick.Item"));
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(view->rootModelNode().metaInfo().typeName(), QmlDesigner::TypeName("QtQuick.Item"));
+#endif
 
     QVERIFY(view->rootModelNode().metaInfo().hasProperty("states"));
     QVERIFY(view->rootModelNode().metaInfo().property("states").isListProperty());
@@ -5108,10 +5143,12 @@ void tst_TestCore::testQtQuick20Basic()
     QVERIFY(testRewriterView->errors().isEmpty());
     ModelNode rootModelNode(testRewriterView->rootModelNode());
     QVERIFY(rootModelNode.isValid());
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(rootModelNode.metaInfo().majorVersion(), 2);
     QCOMPARE(rootModelNode.metaInfo().minorVersion(), 0);
     //QCOMPARE(rootModelNode.majorQtQuickVersion(), 2);
     QCOMPARE(rootModelNode.majorVersion(), 2);
+#endif
 }
 
 void tst_TestCore::testQtQuick20BasicRectangle()
@@ -5133,11 +5170,13 @@ void tst_TestCore::testQtQuick20BasicRectangle()
     QVERIFY(testRewriterView->errors().isEmpty());
     ModelNode rootModelNode(testRewriterView->rootModelNode());
     QVERIFY(rootModelNode.isValid());
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(rootModelNode.type(), QmlDesigner::TypeName("QtQuick.Rectangle"));
     QCOMPARE(rootModelNode.metaInfo().majorVersion(), 2);
     QCOMPARE(rootModelNode.metaInfo().minorVersion(), 0);
     //QCOMPARE(rootModelNode.majorQtQuickVersion(), 2);
     QCOMPARE(rootModelNode.majorVersion(), 2);
+#endif
 }
 
 void tst_TestCore::testQtQuickControls2()