diff --git a/src/analysis/interpolation/qgstriangulation.cpp b/src/analysis/interpolation/qgstriangulation.cpp
index c0f55844bd1..a46d98a0e7b 100644
--- a/src/analysis/interpolation/qgstriangulation.cpp
+++ b/src/analysis/interpolation/qgstriangulation.cpp
@@ -18,6 +18,6 @@
 QgsFields QgsTriangulation::triangulationFields()
 {
   QgsFields fields;
-  fields.append( QgsField( QStringLiteral( "type" ), QVariant::String, QStringLiteral( "String" ) ) );
+  fields.append( QgsField( QStringLiteral( "type" ), QMetaType::Type::QString, QStringLiteral( "String" ) ) );
   return fields;
 }
diff --git a/src/analysis/processing/qgsalgorithmaddincrementalfield.cpp b/src/analysis/processing/qgsalgorithmaddincrementalfield.cpp
index 0c7e79fef61..93a39198ba5 100644
--- a/src/analysis/processing/qgsalgorithmaddincrementalfield.cpp
+++ b/src/analysis/processing/qgsalgorithmaddincrementalfield.cpp
@@ -103,7 +103,7 @@ void QgsAddIncrementalFieldAlgorithm::initParameters( const QVariantMap & )
 QgsFields QgsAddIncrementalFieldAlgorithm::outputFields( const QgsFields &inputFields ) const
 {
   QgsFields outFields = inputFields;
-  outFields.append( QgsField( mFieldName, QVariant::LongLong ) );
+  outFields.append( QgsField( mFieldName, QMetaType::Type::LongLong ) );
   mFields = outFields;
   return outFields;
 }
diff --git a/src/analysis/processing/qgsalgorithmaddtablefield.cpp b/src/analysis/processing/qgsalgorithmaddtablefield.cpp
index 0ffda54b3c7..fadd4b1ebb1 100644
--- a/src/analysis/processing/qgsalgorithmaddtablefield.cpp
+++ b/src/analysis/processing/qgsalgorithmaddtablefield.cpp
@@ -81,19 +81,19 @@ void QgsAddTableFieldAlgorithm::initParameters( const QVariantMap & )
   typeStrings.reserve( 11 );
   icons.reserve( 11 );
   for ( const auto &type :
-        std::vector < std::pair< QVariant::Type, QVariant::Type > >
+        std::vector < std::pair< QMetaType::Type, QMetaType::Type > >
 {
-  {QVariant::Int, QVariant::Invalid },
-  {QVariant::Double, QVariant::Invalid },
-  {QVariant::String, QVariant::Invalid },
-  {QVariant::Bool, QVariant::Invalid },
-  {QVariant::Date, QVariant::Invalid },
-  {QVariant::Time, QVariant::Invalid },
-  {QVariant::DateTime, QVariant::Invalid },
-  {QVariant::ByteArray, QVariant::Invalid },
-  {QVariant::StringList, QVariant::Invalid },
-  {QVariant::List, QVariant::Int },
-  {QVariant::List, QVariant::Double }
+  {QMetaType::Type::Int, QMetaType::Type::UnknownType },
+  {QMetaType::Type::Double, QMetaType::Type::UnknownType },
+  {QMetaType::Type::QString, QMetaType::Type::UnknownType },
+  {QMetaType::Type::Bool, QMetaType::Type::UnknownType },
+  {QMetaType::Type::QDate, QMetaType::Type::UnknownType },
+  {QMetaType::Type::QTime, QMetaType::Type::UnknownType },
+  {QMetaType::Type::QDateTime, QMetaType::Type::UnknownType },
+  {QMetaType::Type::QByteArray, QMetaType::Type::UnknownType },
+  {QMetaType::Type::QStringList, QMetaType::Type::UnknownType },
+  {QMetaType::Type::QVariantList, QMetaType::Type::Int },
+  {QMetaType::Type::QVariantList, QMetaType::Type::Double }
 } )
   {
     typeStrings << QgsVariantUtils::typeToDisplayString( type.first, type.second );
@@ -148,40 +148,40 @@ bool QgsAddTableFieldAlgorithm::prepareAlgorithm( const QVariantMap &parameters,
   switch ( type )
   {
     case 0: // Integer
-      mField.setType( QVariant::Int );
+      mField.setType( QMetaType::Type::Int );
       break;
     case 1: // Float
-      mField.setType( QVariant::Double );
+      mField.setType( QMetaType::Type::Double );
       break;
     case 2: // String
-      mField.setType( QVariant::String );
+      mField.setType( QMetaType::Type::QString );
       break;
     case 3: // Boolean
-      mField.setType( QVariant::Bool );
+      mField.setType( QMetaType::Type::Bool );
       break;
     case 4: // Date
-      mField.setType( QVariant::Date );
+      mField.setType( QMetaType::Type::QDate );
       break;
     case 5: // Time
-      mField.setType( QVariant::Time );
+      mField.setType( QMetaType::Type::QTime );
       break;
     case 6: // DateTime
-      mField.setType( QVariant::DateTime );
+      mField.setType( QMetaType::Type::QDateTime );
       break;
     case 7: // Binary
-      mField.setType( QVariant::ByteArray );
+      mField.setType( QMetaType::Type::QByteArray );
       break;
     case 8: // StringList
-      mField.setType( QVariant::StringList );
-      mField.setSubType( QVariant::String );
+      mField.setType( QMetaType::Type::QStringList );
+      mField.setSubType( QMetaType::Type::QString );
       break;
     case 9: // IntegerList
-      mField.setType( QVariant::List );
-      mField.setSubType( QVariant::Int );
+      mField.setType( QMetaType::Type::QVariantList );
+      mField.setSubType( QMetaType::Type::Int );
       break;
     case 10: // DoubleList
-      mField.setType( QVariant::List );
-      mField.setSubType( QVariant::Double );
+      mField.setType( QMetaType::Type::QVariantList );
+      mField.setSubType( QMetaType::Type::Double );
       break;
   }
 
diff --git a/src/analysis/processing/qgsalgorithmaddxyfields.cpp b/src/analysis/processing/qgsalgorithmaddxyfields.cpp
index ea30c6a98ce..47c7b101316 100644
--- a/src/analysis/processing/qgsalgorithmaddxyfields.cpp
+++ b/src/analysis/processing/qgsalgorithmaddxyfields.cpp
@@ -104,8 +104,8 @@ QgsFields QgsAddXYFieldsAlgorithm::outputFields( const QgsFields &inputFields )
     const QString yFieldName = mPrefix + 'y';
 
     QgsFields outFields = inputFields;
-    outFields.append( QgsField( xFieldName, QVariant::Double, QString(), 20, 10 ) );
-    outFields.append( QgsField( yFieldName, QVariant::Double, QString(), 20, 10 ) );
+    outFields.append( QgsField( xFieldName, QMetaType::Type::Double, QString(), 20, 10 ) );
+    outFields.append( QgsField( yFieldName, QMetaType::Type::Double, QString(), 20, 10 ) );
     return outFields;
   }
 }
diff --git a/src/analysis/processing/qgsalgorithmaggregate.cpp b/src/analysis/processing/qgsalgorithmaggregate.cpp
index 8c603dab25c..9fd36bac619 100644
--- a/src/analysis/processing/qgsalgorithmaggregate.cpp
+++ b/src/analysis/processing/qgsalgorithmaggregate.cpp
@@ -92,9 +92,9 @@ bool QgsAggregateAlgorithm::prepareAlgorithm( const QVariantMap &parameters, Qgs
     if ( name.isEmpty() )
       throw QgsProcessingException( QObject::tr( "Field name cannot be empty" ) );
 
-    const QVariant::Type type = static_cast< QVariant::Type >( aggregateDef.value( QStringLiteral( "type" ) ).toInt() );
+    const QMetaType::Type type = static_cast< QMetaType::Type >( aggregateDef.value( QStringLiteral( "type" ) ).toInt() );
     const QString typeName = aggregateDef.value( QStringLiteral( "type_name" ) ).toString();
-    const QVariant::Type subType = static_cast< QVariant::Type >( aggregateDef.value( QStringLiteral( "sub_type" ) ).toInt() );
+    const QMetaType::Type subType = static_cast< QMetaType::Type >( aggregateDef.value( QStringLiteral( "sub_type" ) ).toInt() );
 
     const int length = aggregateDef.value( QStringLiteral( "length" ), 0 ).toInt();
     const int precision = aggregateDef.value( QStringLiteral( "precision" ), 0 ).toInt();
@@ -163,7 +163,7 @@ QVariantMap QgsAggregateAlgorithm::processAlgorithm( const QVariantMap &paramete
     }
 
     // upgrade group by value to a list, so that we get correct behavior with the QHash
-    const QVariantList key = groupByValue.type() == QVariant::List ? groupByValue.toList() : ( QVariantList() << groupByValue );
+    const QVariantList key = groupByValue.userType() == QMetaType::Type::QVariantList ? groupByValue.toList() : ( QVariantList() << groupByValue );
 
     const auto groupIt = groups.find( key );
     if ( groupIt == groups.end() )
diff --git a/src/analysis/processing/qgsalgorithmangletonearest.cpp b/src/analysis/processing/qgsalgorithmangletonearest.cpp
index 2f12342abee..d322569b3de 100644
--- a/src/analysis/processing/qgsalgorithmangletonearest.cpp
+++ b/src/analysis/processing/qgsalgorithmangletonearest.cpp
@@ -196,7 +196,7 @@ QVariantMap QgsAngleToNearestAlgorithm::processAlgorithm( const QVariantMap &par
   }
   else
   {
-    outFields.append( QgsField( fieldName, QVariant::Double ) );
+    outFields.append( QgsField( fieldName, QMetaType::Type::Double ) );
   }
 
   QString dest;
diff --git a/src/analysis/processing/qgsalgorithmarrayoffsetlines.cpp b/src/analysis/processing/qgsalgorithmarrayoffsetlines.cpp
index e99cd4f80df..3d468464ef1 100644
--- a/src/analysis/processing/qgsalgorithmarrayoffsetlines.cpp
+++ b/src/analysis/processing/qgsalgorithmarrayoffsetlines.cpp
@@ -172,8 +172,8 @@ QgsFeatureList QgsCreateArrayOffsetLinesAlgorithm::processFeature( const QgsFeat
 QgsFields QgsCreateArrayOffsetLinesAlgorithm::outputFields( const QgsFields &inputFields ) const
 {
   QgsFields output = inputFields;
-  output.append( QgsField( QStringLiteral( "instance" ), QVariant::Int ) );
-  output.append( QgsField( QStringLiteral( "offset" ), QVariant::Double ) );
+  output.append( QgsField( QStringLiteral( "instance" ), QMetaType::Type::Int ) );
+  output.append( QgsField( QStringLiteral( "offset" ), QMetaType::Type::Double ) );
   return output;
 }
 
diff --git a/src/analysis/processing/qgsalgorithmarraytranslatedfeatures.cpp b/src/analysis/processing/qgsalgorithmarraytranslatedfeatures.cpp
index 212ca4474e2..da9c8b8a0fb 100644
--- a/src/analysis/processing/qgsalgorithmarraytranslatedfeatures.cpp
+++ b/src/analysis/processing/qgsalgorithmarraytranslatedfeatures.cpp
@@ -212,7 +212,7 @@ Qgis::WkbType QgsArrayTranslatedFeaturesAlgorithm::outputWkbType( Qgis::WkbType
 QgsFields QgsArrayTranslatedFeaturesAlgorithm::outputFields( const QgsFields &inputFields ) const
 {
   QgsFields output;
-  output.append( QgsField( QStringLiteral( "instance" ), QVariant::Int ) );
+  output.append( QgsField( QStringLiteral( "instance" ), QMetaType::Type::Int ) );
   return QgsProcessingUtils::combineFields( inputFields, output );
 }
 
diff --git a/src/analysis/processing/qgsalgorithmboundingbox.cpp b/src/analysis/processing/qgsalgorithmboundingbox.cpp
index a425a2cc09c..445d9ef4b95 100644
--- a/src/analysis/processing/qgsalgorithmboundingbox.cpp
+++ b/src/analysis/processing/qgsalgorithmboundingbox.cpp
@@ -64,10 +64,10 @@ QgsBoundingBoxAlgorithm *QgsBoundingBoxAlgorithm::createInstance() const
 QgsFields QgsBoundingBoxAlgorithm::outputFields( const QgsFields &inputFields ) const
 {
   QgsFields fields = inputFields;
-  fields.append( QgsField( QStringLiteral( "width" ), QVariant::Double, QString(), 20, 6 ) );
-  fields.append( QgsField( QStringLiteral( "height" ), QVariant::Double, QString(), 20, 6 ) );
-  fields.append( QgsField( QStringLiteral( "area" ), QVariant::Double, QString(), 20, 6 ) );
-  fields.append( QgsField( QStringLiteral( "perimeter" ), QVariant::Double, QString(), 20, 6 ) );
+  fields.append( QgsField( QStringLiteral( "width" ), QMetaType::Type::Double, QString(), 20, 6 ) );
+  fields.append( QgsField( QStringLiteral( "height" ), QMetaType::Type::Double, QString(), 20, 6 ) );
+  fields.append( QgsField( QStringLiteral( "area" ), QMetaType::Type::Double, QString(), 20, 6 ) );
+  fields.append( QgsField( QStringLiteral( "perimeter" ), QMetaType::Type::Double, QString(), 20, 6 ) );
   return fields;
 }
 
diff --git a/src/analysis/processing/qgsalgorithmcalculateoverlaps.cpp b/src/analysis/processing/qgsalgorithmcalculateoverlaps.cpp
index cec697eecf2..9ab6f14ca4c 100644
--- a/src/analysis/processing/qgsalgorithmcalculateoverlaps.cpp
+++ b/src/analysis/processing/qgsalgorithmcalculateoverlaps.cpp
@@ -100,8 +100,8 @@ bool QgsCalculateVectorOverlapsAlgorithm::prepareAlgorithm( const QVariantMap &p
     {
       mLayerNames << layer->name();
       mOverlayerSources.emplace_back( std::make_unique< QgsVectorLayerFeatureSource >( vl ) );
-      mOutputFields.append( QgsField( QStringLiteral( "%1_area" ).arg( vl->name() ), QVariant::Double ) );
-      mOutputFields.append( QgsField( QStringLiteral( "%1_pc" ).arg( vl->name() ), QVariant::Double ) );
+      mOutputFields.append( QgsField( QStringLiteral( "%1_area" ).arg( vl->name() ), QMetaType::Type::Double ) );
+      mOutputFields.append( QgsField( QStringLiteral( "%1_pc" ).arg( vl->name() ), QMetaType::Type::Double ) );
     }
   }
 
diff --git a/src/analysis/processing/qgsalgorithmcategorizeusingstyle.cpp b/src/analysis/processing/qgsalgorithmcategorizeusingstyle.cpp
index 5e4b874ba0c..c4d05e8b17f 100644
--- a/src/analysis/processing/qgsalgorithmcategorizeusingstyle.cpp
+++ b/src/analysis/processing/qgsalgorithmcategorizeusingstyle.cpp
@@ -187,14 +187,14 @@ QVariantMap QgsCategorizeUsingStyleAlgorithm::processAlgorithm( const QVariantMa
   }
 
   QgsFields nonMatchingCategoryFields;
-  nonMatchingCategoryFields.append( QgsField( QStringLiteral( "category" ), QVariant::String ) );
+  nonMatchingCategoryFields.append( QgsField( QStringLiteral( "category" ), QMetaType::Type::QString ) );
   QString nonMatchingCategoriesDest;
   std::unique_ptr< QgsFeatureSink > nonMatchingCategoriesSink( parameterAsSink( parameters, QStringLiteral( "NON_MATCHING_CATEGORIES" ), context, nonMatchingCategoriesDest, nonMatchingCategoryFields, Qgis::WkbType::NoGeometry ) );
   if ( !nonMatchingCategoriesSink && parameters.contains( QStringLiteral( "NON_MATCHING_CATEGORIES" ) ) && parameters.value( QStringLiteral( "NON_MATCHING_CATEGORIES" ) ).isValid() )
     throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "NON_MATCHING_CATEGORIES" ) ) );
 
   QgsFields nonMatchingSymbolFields;
-  nonMatchingSymbolFields.append( QgsField( QStringLiteral( "name" ), QVariant::String ) );
+  nonMatchingSymbolFields.append( QgsField( QStringLiteral( "name" ), QMetaType::Type::QString ) );
   QString nonMatchingSymbolsDest;
   std::unique_ptr< QgsFeatureSink > nonMatchingSymbolsSink( parameterAsSink( parameters, QStringLiteral( "NON_MATCHING_SYMBOLS" ), context, nonMatchingSymbolsDest, nonMatchingSymbolFields, Qgis::WkbType::NoGeometry ) );
   if ( !nonMatchingSymbolsSink && parameters.contains( QStringLiteral( "NON_MATCHING_SYMBOLS" ) ) && parameters.value( QStringLiteral( "NON_MATCHING_SYMBOLS" ) ).isValid() )
diff --git a/src/analysis/processing/qgsalgorithmconvexhull.cpp b/src/analysis/processing/qgsalgorithmconvexhull.cpp
index e4909eaecac..8e592c59768 100644
--- a/src/analysis/processing/qgsalgorithmconvexhull.cpp
+++ b/src/analysis/processing/qgsalgorithmconvexhull.cpp
@@ -64,8 +64,8 @@ QgsConvexHullAlgorithm *QgsConvexHullAlgorithm::createInstance() const
 QgsFields QgsConvexHullAlgorithm::outputFields( const QgsFields &inputFields ) const
 {
   QgsFields fields = inputFields;
-  fields.append( QgsField( QStringLiteral( "area" ), QVariant::Double, QString(), 20, 6 ) );
-  fields.append( QgsField( QStringLiteral( "perimeter" ), QVariant::Double, QString(), 20, 6 ) );
+  fields.append( QgsField( QStringLiteral( "area" ), QMetaType::Type::Double, QString(), 20, 6 ) );
+  fields.append( QgsField( QStringLiteral( "perimeter" ), QMetaType::Type::Double, QString(), 20, 6 ) );
   return fields;
 }
 
diff --git a/src/analysis/processing/qgsalgorithmdbscanclustering.cpp b/src/analysis/processing/qgsalgorithmdbscanclustering.cpp
index 9e2c3d1bad8..206f3319e39 100644
--- a/src/analysis/processing/qgsalgorithmdbscanclustering.cpp
+++ b/src/analysis/processing/qgsalgorithmdbscanclustering.cpp
@@ -120,9 +120,9 @@ QVariantMap QgsDbscanClusteringAlgorithm::processAlgorithm( const QVariantMap &p
   QgsFields outputFields = source->fields();
   QgsFields newFields;
   const QString clusterFieldName = parameterAsString( parameters, QStringLiteral( "FIELD_NAME" ), context );
-  newFields.append( QgsField( clusterFieldName, QVariant::Int ) );
+  newFields.append( QgsField( clusterFieldName, QMetaType::Type::Int ) );
   const QString clusterSizeFieldName = parameterAsString( parameters, QStringLiteral( "SIZE_FIELD_NAME" ), context );
-  newFields.append( QgsField( clusterSizeFieldName, QVariant::Int ) );
+  newFields.append( QgsField( clusterSizeFieldName, QMetaType::Type::Int ) );
   outputFields = QgsProcessingUtils::combineFields( outputFields, newFields );
 
   QString dest;
diff --git a/src/analysis/processing/qgsalgorithmdelaunaytriangulation.cpp b/src/analysis/processing/qgsalgorithmdelaunaytriangulation.cpp
index 3ff9c4570b1..a27e2a2dd45 100644
--- a/src/analysis/processing/qgsalgorithmdelaunaytriangulation.cpp
+++ b/src/analysis/processing/qgsalgorithmdelaunaytriangulation.cpp
@@ -82,13 +82,13 @@ QVariantMap QgsDelaunayTriangulationAlgorithm::processAlgorithm( const QVariantM
   QgsFields fields;
   if ( addAttributes )
   {
-    fields.append( QgsField( QStringLiteral( "POINTA" ), QVariant::LongLong ) );
-    fields.append( QgsField( QStringLiteral( "POINTB" ), QVariant::LongLong ) );
-    fields.append( QgsField( QStringLiteral( "POINTC" ), QVariant::LongLong ) );
+    fields.append( QgsField( QStringLiteral( "POINTA" ), QMetaType::Type::LongLong ) );
+    fields.append( QgsField( QStringLiteral( "POINTB" ), QMetaType::Type::LongLong ) );
+    fields.append( QgsField( QStringLiteral( "POINTC" ), QMetaType::Type::LongLong ) );
   }
   else
   {
-    fields.append( QgsField( QStringLiteral( "id" ), QVariant::LongLong ) );
+    fields.append( QgsField( QStringLiteral( "id" ), QMetaType::Type::LongLong ) );
   }
 
   QString dest;
diff --git a/src/analysis/processing/qgsalgorithmexplodehstore.cpp b/src/analysis/processing/qgsalgorithmexplodehstore.cpp
index 7f305ec8779..45a59e5aa3f 100644
--- a/src/analysis/processing/qgsalgorithmexplodehstore.cpp
+++ b/src/analysis/processing/qgsalgorithmexplodehstore.cpp
@@ -125,7 +125,7 @@ QVariantMap QgsExplodeHstoreAlgorithm::processAlgorithm( const QVariantMap &para
   QgsFields hstoreFields;
   for ( const QString &fieldName : fieldsToAdd )
   {
-    hstoreFields.append( QgsField( fieldName, QVariant::String ) );
+    hstoreFields.append( QgsField( fieldName, QMetaType::Type::QString ) );
   }
 
   QgsFields outFields = QgsProcessingUtils::combineFields( source->fields(), hstoreFields );
diff --git a/src/analysis/processing/qgsalgorithmexportlayersinformation.cpp b/src/analysis/processing/qgsalgorithmexportlayersinformation.cpp
index 7cabe380c7f..94f868083b2 100644
--- a/src/analysis/processing/qgsalgorithmexportlayersinformation.cpp
+++ b/src/analysis/processing/qgsalgorithmexportlayersinformation.cpp
@@ -94,15 +94,15 @@ bool QgsExportLayersInformationAlgorithm::prepareAlgorithm( const QVariantMap &p
 QVariantMap QgsExportLayersInformationAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
 {
   QgsFields outFields;
-  outFields.append( QgsField( QStringLiteral( "name" ), QVariant::String ) );
-  outFields.append( QgsField( QStringLiteral( "source" ), QVariant::String ) );
-  outFields.append( QgsField( QStringLiteral( "crs" ), QVariant::String ) );
-  outFields.append( QgsField( QStringLiteral( "provider" ), QVariant::String ) );
-  outFields.append( QgsField( QStringLiteral( "file_path" ), QVariant::String ) );
-  outFields.append( QgsField( QStringLiteral( "layer_name" ), QVariant::String ) );
-  outFields.append( QgsField( QStringLiteral( "subset" ), QVariant::String ) );
-  outFields.append( QgsField( QStringLiteral( "abstract" ), QVariant::String ) );
-  outFields.append( QgsField( QStringLiteral( "attribution" ), QVariant::String ) );
+  outFields.append( QgsField( QStringLiteral( "name" ), QMetaType::Type::QString ) );
+  outFields.append( QgsField( QStringLiteral( "source" ), QMetaType::Type::QString ) );
+  outFields.append( QgsField( QStringLiteral( "crs" ), QMetaType::Type::QString ) );
+  outFields.append( QgsField( QStringLiteral( "provider" ), QMetaType::Type::QString ) );
+  outFields.append( QgsField( QStringLiteral( "file_path" ), QMetaType::Type::QString ) );
+  outFields.append( QgsField( QStringLiteral( "layer_name" ), QMetaType::Type::QString ) );
+  outFields.append( QgsField( QStringLiteral( "subset" ), QMetaType::Type::QString ) );
+  outFields.append( QgsField( QStringLiteral( "abstract" ), QMetaType::Type::QString ) );
+  outFields.append( QgsField( QStringLiteral( "attribution" ), QMetaType::Type::QString ) );
 
   QString outputDest;
   std::unique_ptr< QgsFeatureSink > outputSink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, outputDest, outFields,
diff --git a/src/analysis/processing/qgsalgorithmexportmesh.cpp b/src/analysis/processing/qgsalgorithmexportmesh.cpp
index 20d364276e6..8c15f37d265 100644
--- a/src/analysis/processing/qgsalgorithmexportmesh.cpp
+++ b/src/analysis/processing/qgsalgorithmexportmesh.cpp
@@ -41,18 +41,18 @@ static QgsFields createFields( const QList<QgsMeshDatasetGroupMetadata> &groupMe
     {
       if ( vectorOption == 0 || vectorOption == 2 )
       {
-        fields.append( QgsField( QStringLiteral( "%1_x" ).arg( meta.name() ), QVariant::Double ) );
-        fields.append( QgsField( QStringLiteral( "%1_y" ).arg( meta.name() ), QVariant::Double ) );
+        fields.append( QgsField( QStringLiteral( "%1_x" ).arg( meta.name() ), QMetaType::Type::Double ) );
+        fields.append( QgsField( QStringLiteral( "%1_y" ).arg( meta.name() ), QMetaType::Type::Double ) );
       }
 
       if ( vectorOption == 1 || vectorOption == 2 )
       {
-        fields.append( QgsField( QStringLiteral( "%1_mag" ).arg( meta.name() ), QVariant::Double ) );
-        fields.append( QgsField( QStringLiteral( "%1_dir" ).arg( meta.name() ), QVariant::Double ) );
+        fields.append( QgsField( QStringLiteral( "%1_mag" ).arg( meta.name() ), QMetaType::Type::Double ) );
+        fields.append( QgsField( QStringLiteral( "%1_dir" ).arg( meta.name() ), QMetaType::Type::Double ) );
       }
     }
     else
-      fields.append( QgsField( meta.name(), QVariant::Double ) );
+      fields.append( QgsField( meta.name(), QMetaType::Type::Double ) );
   }
   return fields;
 }
@@ -1083,13 +1083,13 @@ QVariantMap QgsMeshContoursAlgorithm::processAlgorithm( const QVariantMap &param
   // Create vector layers
   QgsFields polygonFields;
   QgsFields lineFields;
-  polygonFields.append( QgsField( QObject::tr( "group" ), QVariant::String ) );
-  polygonFields.append( QgsField( QObject::tr( "time" ), QVariant::String ) );
-  polygonFields.append( QgsField( QObject::tr( "min_value" ), QVariant::Double ) );
-  polygonFields.append( QgsField( QObject::tr( "max_value" ), QVariant::Double ) );
-  lineFields.append( QgsField( QObject::tr( "group" ), QVariant::String ) );
-  lineFields.append( QgsField( QObject::tr( "time" ), QVariant::String ) );
-  lineFields.append( QgsField( QObject::tr( "value" ), QVariant::Double ) );
+  polygonFields.append( QgsField( QObject::tr( "group" ), QMetaType::Type::QString ) );
+  polygonFields.append( QgsField( QObject::tr( "time" ), QMetaType::Type::QString ) );
+  polygonFields.append( QgsField( QObject::tr( "min_value" ), QMetaType::Type::Double ) );
+  polygonFields.append( QgsField( QObject::tr( "max_value" ), QMetaType::Type::Double ) );
+  lineFields.append( QgsField( QObject::tr( "group" ), QMetaType::Type::QString ) );
+  lineFields.append( QgsField( QObject::tr( "time" ), QMetaType::Type::QString ) );
+  lineFields.append( QgsField( QObject::tr( "value" ), QMetaType::Type::Double ) );
 
   QgsCoordinateReferenceSystem outputCrs = parameterAsCrs( parameters, QStringLiteral( "CRS_OUTPUT" ), context );
 
diff --git a/src/analysis/processing/qgsalgorithmexporttospreadsheet.cpp b/src/analysis/processing/qgsalgorithmexporttospreadsheet.cpp
index a55fa5e9864..6da97148619 100644
--- a/src/analysis/processing/qgsalgorithmexporttospreadsheet.cpp
+++ b/src/analysis/processing/qgsalgorithmexporttospreadsheet.cpp
@@ -56,7 +56,7 @@ class FieldValueConverter : public QgsVectorFileWriter::FieldValueConverter
       const int idx = mLayer->fields().indexFromName( field.name() );
       if ( mFormatters.contains( idx ) )
       {
-        return QgsField( field.name(), QVariant::String );
+        return QgsField( field.name(), QMetaType::Type::QString );
       }
       return field;
     }
diff --git a/src/analysis/processing/qgsalgorithmextentfromlayer.cpp b/src/analysis/processing/qgsalgorithmextentfromlayer.cpp
index 77f6325ee1d..f210456269d 100644
--- a/src/analysis/processing/qgsalgorithmextentfromlayer.cpp
+++ b/src/analysis/processing/qgsalgorithmextentfromlayer.cpp
@@ -90,16 +90,16 @@ QVariantMap QgsExtentFromLayerAlgorithm::processAlgorithm( const QVariantMap &pa
   const double roundTo = parameterAsDouble( parameters, QStringLiteral( "ROUND_TO" ), context );
 
   QgsFields fields;
-  fields.append( QgsField( QStringLiteral( "MINX" ), QVariant::Double ) );
-  fields.append( QgsField( QStringLiteral( "MINY" ), QVariant::Double ) );
-  fields.append( QgsField( QStringLiteral( "MAXX" ), QVariant::Double ) );
-  fields.append( QgsField( QStringLiteral( "MAXY" ), QVariant::Double ) );
-  fields.append( QgsField( QStringLiteral( "CNTX" ), QVariant::Double ) );
-  fields.append( QgsField( QStringLiteral( "CNTY" ), QVariant::Double ) );
-  fields.append( QgsField( QStringLiteral( "AREA" ), QVariant::Double ) );
-  fields.append( QgsField( QStringLiteral( "PERIM" ), QVariant::Double ) );
-  fields.append( QgsField( QStringLiteral( "HEIGHT" ), QVariant::Double ) );
-  fields.append( QgsField( QStringLiteral( "WIDTH" ), QVariant::Double ) );
+  fields.append( QgsField( QStringLiteral( "MINX" ), QMetaType::Type::Double ) );
+  fields.append( QgsField( QStringLiteral( "MINY" ), QMetaType::Type::Double ) );
+  fields.append( QgsField( QStringLiteral( "MAXX" ), QMetaType::Type::Double ) );
+  fields.append( QgsField( QStringLiteral( "MAXY" ), QMetaType::Type::Double ) );
+  fields.append( QgsField( QStringLiteral( "CNTX" ), QMetaType::Type::Double ) );
+  fields.append( QgsField( QStringLiteral( "CNTY" ), QMetaType::Type::Double ) );
+  fields.append( QgsField( QStringLiteral( "AREA" ), QMetaType::Type::Double ) );
+  fields.append( QgsField( QStringLiteral( "PERIM" ), QMetaType::Type::Double ) );
+  fields.append( QgsField( QStringLiteral( "HEIGHT" ), QMetaType::Type::Double ) );
+  fields.append( QgsField( QStringLiteral( "WIDTH" ), QMetaType::Type::Double ) );
 
   QString dest;
   std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Polygon, layer->crs() ) );
diff --git a/src/analysis/processing/qgsalgorithmextenttolayer.cpp b/src/analysis/processing/qgsalgorithmextenttolayer.cpp
index e4bce689f61..e1aeab336c3 100644
--- a/src/analysis/processing/qgsalgorithmextenttolayer.cpp
+++ b/src/analysis/processing/qgsalgorithmextenttolayer.cpp
@@ -48,7 +48,7 @@ QVariantMap QgsExtentToLayerAlgorithm::processAlgorithm( const QVariantMap &para
   const QgsGeometry geom = parameterAsExtentGeometry( parameters, QStringLiteral( "INPUT" ), context );
 
   QgsFields fields;
-  fields.append( QgsField( QStringLiteral( "id" ), QVariant::Int ) );
+  fields.append( QgsField( QStringLiteral( "id" ), QMetaType::Type::Int ) );
 
   QString dest;
   std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Polygon, crs ) );
diff --git a/src/analysis/processing/qgsalgorithmextractbyattribute.cpp b/src/analysis/processing/qgsalgorithmextractbyattribute.cpp
index 1377c55c076..ad278bc44bc 100644
--- a/src/analysis/processing/qgsalgorithmextractbyattribute.cpp
+++ b/src/analysis/processing/qgsalgorithmextractbyattribute.cpp
@@ -106,9 +106,9 @@ QVariantMap QgsExtractByAttributeAlgorithm::processAlgorithm( const QVariantMap
   if ( idx < 0 )
     throw QgsProcessingException( QObject::tr( "Field '%1' was not found in INPUT source" ).arg( fieldName ) );
 
-  const QVariant::Type fieldType = source->fields().at( idx ).type();
+  const QMetaType::Type fieldType = source->fields().at( idx ).type();
 
-  if ( fieldType != QVariant::String && ( op == BeginsWith || op == Contains || op == DoesNotContain ) )
+  if ( fieldType != QMetaType::Type::QString && ( op == BeginsWith || op == Contains || op == DoesNotContain ) )
   {
     QString method;
     switch ( op )
diff --git a/src/analysis/processing/qgsalgorithmextractlabels.cpp b/src/analysis/processing/qgsalgorithmextractlabels.cpp
index 8653f9c5563..94fd5124dfb 100644
--- a/src/analysis/processing/qgsalgorithmextractlabels.cpp
+++ b/src/analysis/processing/qgsalgorithmextractlabels.cpp
@@ -351,29 +351,29 @@ QVariantMap QgsExtractLabelsAlgorithm::processAlgorithm( const QVariantMap &para
   const QSize imageSize = calculator.calculateImageSize( extent, scale ).toSize();
 
   QgsFields fields;
-  fields.append( QgsField( QStringLiteral( "Layer" ), QVariant::String, QString(), 0, 0 ) );
-  fields.append( QgsField( QStringLiteral( "FeatureID" ), QVariant::LongLong, QString(), 20 ) );
-  fields.append( QgsField( QStringLiteral( "LabelText" ), QVariant::String, QString(), 0, 0 ) );
-  fields.append( QgsField( QStringLiteral( "LabelWidth" ), QVariant::Double, QString(), 20, 8 ) );
-  fields.append( QgsField( QStringLiteral( "LabelHeight" ), QVariant::Double, QString(), 20, 8 ) );
-  fields.append( QgsField( QStringLiteral( "LabelRotation" ), QVariant::Double, QString(), 20, 2 ) );
-  fields.append( QgsField( QStringLiteral( "LabelUnplaced" ), QVariant::Bool, QString(), 1, 0 ) );
-  fields.append( QgsField( QStringLiteral( "Family" ), QVariant::String, QString(), 0, 0 ) );
-  fields.append( QgsField( QStringLiteral( "Size" ), QVariant::Double, QString(), 20, 4 ) );
-  fields.append( QgsField( QStringLiteral( "Italic" ), QVariant::Bool, QString(), 1, 0 ) );
-  fields.append( QgsField( QStringLiteral( "Bold" ), QVariant::Bool, QString(), 1, 0 ) );
-  fields.append( QgsField( QStringLiteral( "Underline" ), QVariant::Bool, QString(), 1, 0 ) );
-  fields.append( QgsField( QStringLiteral( "FontStyle" ), QVariant::String, QString(), 0, 0 ) );
-  fields.append( QgsField( QStringLiteral( "FontLetterSpacing" ), QVariant::Double, QString(), 20, 4 ) );
-  fields.append( QgsField( QStringLiteral( "FontWordSpacing" ), QVariant::Double, QString(), 20, 4 ) );
-  fields.append( QgsField( QStringLiteral( "MultiLineAlignment" ), QVariant::String, QString(), 0, 0 ) );
-  fields.append( QgsField( QStringLiteral( "MultiLineHeight" ), QVariant::Double, QString(), 20, 2 ) );
-  fields.append( QgsField( QStringLiteral( "Color" ), QVariant::String, QString(), 7, 0 ) );
-  fields.append( QgsField( QStringLiteral( "FontOpacity" ), QVariant::Double, QString(), 20, 1 ) );
-  fields.append( QgsField( QStringLiteral( "BufferDraw" ), QVariant::Bool, QString(), 1, 0 ) );
-  fields.append( QgsField( QStringLiteral( "BufferSize" ), QVariant::Double, QString(), 20, 4 ) );
-  fields.append( QgsField( QStringLiteral( "BufferColor" ), QVariant::String, QString(), 7, 0 ) );
-  fields.append( QgsField( QStringLiteral( "BufferOpacity" ), QVariant::Double, QString(), 20, 1 ) );
+  fields.append( QgsField( QStringLiteral( "Layer" ), QMetaType::Type::QString, QString(), 0, 0 ) );
+  fields.append( QgsField( QStringLiteral( "FeatureID" ), QMetaType::Type::LongLong, QString(), 20 ) );
+  fields.append( QgsField( QStringLiteral( "LabelText" ), QMetaType::Type::QString, QString(), 0, 0 ) );
+  fields.append( QgsField( QStringLiteral( "LabelWidth" ), QMetaType::Type::Double, QString(), 20, 8 ) );
+  fields.append( QgsField( QStringLiteral( "LabelHeight" ), QMetaType::Type::Double, QString(), 20, 8 ) );
+  fields.append( QgsField( QStringLiteral( "LabelRotation" ), QMetaType::Type::Double, QString(), 20, 2 ) );
+  fields.append( QgsField( QStringLiteral( "LabelUnplaced" ), QMetaType::Type::Bool, QString(), 1, 0 ) );
+  fields.append( QgsField( QStringLiteral( "Family" ), QMetaType::Type::QString, QString(), 0, 0 ) );
+  fields.append( QgsField( QStringLiteral( "Size" ), QMetaType::Type::Double, QString(), 20, 4 ) );
+  fields.append( QgsField( QStringLiteral( "Italic" ), QMetaType::Type::Bool, QString(), 1, 0 ) );
+  fields.append( QgsField( QStringLiteral( "Bold" ), QMetaType::Type::Bool, QString(), 1, 0 ) );
+  fields.append( QgsField( QStringLiteral( "Underline" ), QMetaType::Type::Bool, QString(), 1, 0 ) );
+  fields.append( QgsField( QStringLiteral( "FontStyle" ), QMetaType::Type::QString, QString(), 0, 0 ) );
+  fields.append( QgsField( QStringLiteral( "FontLetterSpacing" ), QMetaType::Type::Double, QString(), 20, 4 ) );
+  fields.append( QgsField( QStringLiteral( "FontWordSpacing" ), QMetaType::Type::Double, QString(), 20, 4 ) );
+  fields.append( QgsField( QStringLiteral( "MultiLineAlignment" ), QMetaType::Type::QString, QString(), 0, 0 ) );
+  fields.append( QgsField( QStringLiteral( "MultiLineHeight" ), QMetaType::Type::Double, QString(), 20, 2 ) );
+  fields.append( QgsField( QStringLiteral( "Color" ), QMetaType::Type::QString, QString(), 7, 0 ) );
+  fields.append( QgsField( QStringLiteral( "FontOpacity" ), QMetaType::Type::Double, QString(), 20, 1 ) );
+  fields.append( QgsField( QStringLiteral( "BufferDraw" ), QMetaType::Type::Bool, QString(), 1, 0 ) );
+  fields.append( QgsField( QStringLiteral( "BufferSize" ), QMetaType::Type::Double, QString(), 20, 4 ) );
+  fields.append( QgsField( QStringLiteral( "BufferColor" ), QMetaType::Type::QString, QString(), 7, 0 ) );
+  fields.append( QgsField( QStringLiteral( "BufferOpacity" ), QMetaType::Type::Double, QString(), 20, 1 ) );
 
   QString dest;
   std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Point, mCrs, QgsFeatureSink::RegeneratePrimaryKey ) );
diff --git a/src/analysis/processing/qgsalgorithmextractlayoutmapextent.cpp b/src/analysis/processing/qgsalgorithmextractlayoutmapextent.cpp
index 8e16a429f9f..026ce8a834d 100644
--- a/src/analysis/processing/qgsalgorithmextractlayoutmapextent.cpp
+++ b/src/analysis/processing/qgsalgorithmextractlayoutmapextent.cpp
@@ -144,11 +144,11 @@ bool QgsLayoutMapExtentToLayerAlgorithm::prepareAlgorithm( const QVariantMap &pa
 QVariantMap QgsLayoutMapExtentToLayerAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
 {
   QgsFields fields;
-  fields.append( QgsField( QStringLiteral( "map" ), QVariant::String ) );
-  fields.append( QgsField( QStringLiteral( "width" ), QVariant::Double ) );
-  fields.append( QgsField( QStringLiteral( "height" ), QVariant::Double ) );
-  fields.append( QgsField( QStringLiteral( "scale" ), QVariant::Double ) );
-  fields.append( QgsField( QStringLiteral( "rotation" ), QVariant::Double ) );
+  fields.append( QgsField( QStringLiteral( "map" ), QMetaType::Type::QString ) );
+  fields.append( QgsField( QStringLiteral( "width" ), QMetaType::Type::Double ) );
+  fields.append( QgsField( QStringLiteral( "height" ), QMetaType::Type::Double ) );
+  fields.append( QgsField( QStringLiteral( "scale" ), QMetaType::Type::Double ) );
+  fields.append( QgsField( QStringLiteral( "rotation" ), QMetaType::Type::Double ) );
 
   QString dest;
   std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Polygon, mCrs ) );
diff --git a/src/analysis/processing/qgsalgorithmextractspecificvertices.cpp b/src/analysis/processing/qgsalgorithmextractspecificvertices.cpp
index 6c72a8fbd81..c6e581a51c4 100644
--- a/src/analysis/processing/qgsalgorithmextractspecificvertices.cpp
+++ b/src/analysis/processing/qgsalgorithmextractspecificvertices.cpp
@@ -82,16 +82,16 @@ Qgis::ProcessingSourceType QgsExtractSpecificVerticesAlgorithm::outputLayerType(
 QgsFields QgsExtractSpecificVerticesAlgorithm::outputFields( const QgsFields &inputFields ) const
 {
   QgsFields outputFields = inputFields;
-  outputFields.append( QgsField( QStringLiteral( "vertex_pos" ), QVariant::Int ) );
-  outputFields.append( QgsField( QStringLiteral( "vertex_index" ), QVariant::Int ) );
-  outputFields.append( QgsField( QStringLiteral( "vertex_part" ), QVariant::Int ) );
+  outputFields.append( QgsField( QStringLiteral( "vertex_pos" ), QMetaType::Type::Int ) );
+  outputFields.append( QgsField( QStringLiteral( "vertex_index" ), QMetaType::Type::Int ) );
+  outputFields.append( QgsField( QStringLiteral( "vertex_part" ), QMetaType::Type::Int ) );
   if ( mGeometryType == Qgis::GeometryType::Polygon )
   {
-    outputFields.append( QgsField( QStringLiteral( "vertex_part_ring" ), QVariant::Int ) );
+    outputFields.append( QgsField( QStringLiteral( "vertex_part_ring" ), QMetaType::Type::Int ) );
   }
-  outputFields.append( QgsField( QStringLiteral( "vertex_part_index" ), QVariant::Int ) );
-  outputFields.append( QgsField( QStringLiteral( "distance" ), QVariant::Double ) );
-  outputFields.append( QgsField( QStringLiteral( "angle" ), QVariant::Double ) );
+  outputFields.append( QgsField( QStringLiteral( "vertex_part_index" ), QMetaType::Type::Int ) );
+  outputFields.append( QgsField( QStringLiteral( "distance" ), QMetaType::Type::Double ) );
+  outputFields.append( QgsField( QStringLiteral( "angle" ), QMetaType::Type::Double ) );
 
   return outputFields;
 }
diff --git a/src/analysis/processing/qgsalgorithmextractvertices.cpp b/src/analysis/processing/qgsalgorithmextractvertices.cpp
index 3b1ebf166f6..f3ea571df56 100644
--- a/src/analysis/processing/qgsalgorithmextractvertices.cpp
+++ b/src/analysis/processing/qgsalgorithmextractvertices.cpp
@@ -72,15 +72,15 @@ Qgis::ProcessingSourceType QgsExtractVerticesAlgorithm::outputLayerType() const
 QgsFields QgsExtractVerticesAlgorithm::outputFields( const QgsFields &inputFields ) const
 {
   QgsFields outputFields = inputFields;
-  outputFields.append( QgsField( QStringLiteral( "vertex_index" ), QVariant::Int, QString(), 10, 0 ) );
-  outputFields.append( QgsField( QStringLiteral( "vertex_part" ), QVariant::Int, QString(), 10, 0 ) );
+  outputFields.append( QgsField( QStringLiteral( "vertex_index" ), QMetaType::Type::Int, QString(), 10, 0 ) );
+  outputFields.append( QgsField( QStringLiteral( "vertex_part" ), QMetaType::Type::Int, QString(), 10, 0 ) );
   if ( mGeometryType == Qgis::GeometryType::Polygon )
   {
-    outputFields.append( QgsField( QStringLiteral( "vertex_part_ring" ), QVariant::Int, QString(), 10, 0 ) );
+    outputFields.append( QgsField( QStringLiteral( "vertex_part_ring" ), QMetaType::Type::Int, QString(), 10, 0 ) );
   }
-  outputFields.append( QgsField( QStringLiteral( "vertex_part_index" ), QVariant::Int, QString(), 10, 0 ) );
-  outputFields.append( QgsField( QStringLiteral( "distance" ), QVariant::Double, QString(), 20, 14 ) );
-  outputFields.append( QgsField( QStringLiteral( "angle" ), QVariant::Double, QString(), 20, 14 ) );
+  outputFields.append( QgsField( QStringLiteral( "vertex_part_index" ), QMetaType::Type::Int, QString(), 10, 0 ) );
+  outputFields.append( QgsField( QStringLiteral( "distance" ), QMetaType::Type::Double, QString(), 20, 14 ) );
+  outputFields.append( QgsField( QStringLiteral( "angle" ), QMetaType::Type::Double, QString(), 20, 14 ) );
 
   return outputFields;
 }
diff --git a/src/analysis/processing/qgsalgorithmextractzmvalues.cpp b/src/analysis/processing/qgsalgorithmextractzmvalues.cpp
index 0f6a31d1972..9f075750ea7 100644
--- a/src/analysis/processing/qgsalgorithmextractzmvalues.cpp
+++ b/src/analysis/processing/qgsalgorithmextractzmvalues.cpp
@@ -96,7 +96,7 @@ bool QgsExtractZMValuesAlgorithmBase::prepareAlgorithm( const QVariantMap &param
   {
     mStats |= STATS.at( s );
     mSelectedStats << STATS.at( s );
-    mNewFields.append( QgsField( mPrefix + QgsStatisticalSummary::shortName( STATS.at( s ) ), STATS.at( s ) == Qgis::Statistic::Count || STATS.at( s ) == Qgis::Statistic::Variety ? QVariant::Int : QVariant::Double ) );
+    mNewFields.append( QgsField( mPrefix + QgsStatisticalSummary::shortName( STATS.at( s ) ), STATS.at( s ) == Qgis::Statistic::Count || STATS.at( s ) == Qgis::Statistic::Variety ? QMetaType::Type::Int : QMetaType::Type::Double ) );
   }
 
   return true;
diff --git a/src/analysis/processing/qgsalgorithmfieldcalculator.cpp b/src/analysis/processing/qgsalgorithmfieldcalculator.cpp
index 2a108347148..1dda274580f 100644
--- a/src/analysis/processing/qgsalgorithmfieldcalculator.cpp
+++ b/src/analysis/processing/qgsalgorithmfieldcalculator.cpp
@@ -71,19 +71,19 @@ void QgsFieldCalculatorAlgorithm::initParameters( const QVariantMap &configurati
   fieldTypes.reserve( 11 );
   icons.reserve( 11 );
   for ( const auto &type :
-        std::vector < std::pair< QVariant::Type, QVariant::Type > >
+        std::vector < std::pair< QMetaType::Type, QMetaType::Type > >
 {
-  {QVariant::Double, QVariant::Invalid },
-  {QVariant::Int, QVariant::Invalid },
-  {QVariant::String, QVariant::Invalid },
-  {QVariant::Date, QVariant::Invalid },
-  {QVariant::Time, QVariant::Invalid },
-  {QVariant::DateTime, QVariant::Invalid },
-  {QVariant::Bool, QVariant::Invalid },
-  {QVariant::ByteArray, QVariant::Invalid },
-  {QVariant::StringList, QVariant::Invalid },
-  {QVariant::List, QVariant::Int },
-  {QVariant::List, QVariant::Double }
+  {QMetaType::Type::Double, QMetaType::Type::UnknownType },
+  {QMetaType::Type::Int, QMetaType::Type::UnknownType },
+  {QMetaType::Type::QString, QMetaType::Type::UnknownType },
+  {QMetaType::Type::QDate, QMetaType::Type::UnknownType },
+  {QMetaType::Type::QTime, QMetaType::Type::UnknownType },
+  {QMetaType::Type::QDateTime, QMetaType::Type::UnknownType },
+  {QMetaType::Type::Bool, QMetaType::Type::UnknownType },
+  {QMetaType::Type::QByteArray, QMetaType::Type::UnknownType },
+  {QMetaType::Type::QStringList, QMetaType::Type::UnknownType },
+  {QMetaType::Type::QVariantList, QMetaType::Type::Int },
+  {QMetaType::Type::QVariantList, QMetaType::Type::Double }
 } )
   {
     fieldTypes << QgsVariantUtils::typeToDisplayString( type.first, type.second );
@@ -149,45 +149,45 @@ bool QgsFieldCalculatorAlgorithm::prepareAlgorithm( const QVariantMap &parameter
   const int fieldPrecision = parameterAsInt( parameters, QStringLiteral( "FIELD_PRECISION" ), context );
   const QString fieldName = parameterAsString( parameters, QStringLiteral( "FIELD_NAME" ), context );
 
-  QVariant::Type fieldType = QVariant::Type::String;
-  QVariant::Type fieldSubType = QVariant::Type::Invalid;
+  QMetaType::Type fieldType = QMetaType::Type::QString;
+  QMetaType::Type fieldSubType = QMetaType::Type::UnknownType;
   switch ( fieldTypeIdx )
   {
     case 0: // Float
-      fieldType = QVariant::Double;
+      fieldType = QMetaType::Type::Double;
       break;
     case 1: // Integer
-      fieldType = QVariant::Int;
+      fieldType = QMetaType::Type::Int;
       break;
     case 2: // String
-      fieldType = QVariant::String;
+      fieldType = QMetaType::Type::QString;
       break;
     case 3: // Date
-      fieldType = QVariant::Date;
+      fieldType = QMetaType::Type::QDate;
       break;
     case 4: // Time
-      fieldType = QVariant::Time;
+      fieldType = QMetaType::Type::QTime;
       break;
     case 5: // DateTime
-      fieldType = QVariant::DateTime;
+      fieldType = QMetaType::Type::QDateTime;
       break;
     case 6: // Boolean
-      fieldType = QVariant::Bool;
+      fieldType = QMetaType::Type::Bool;
       break;
     case 7: // Binary
-      fieldType = QVariant::ByteArray;
+      fieldType = QMetaType::Type::QByteArray;
       break;
     case 8: // StringList
-      fieldType = QVariant::StringList;
-      fieldSubType = QVariant::String;
+      fieldType = QMetaType::Type::QStringList;
+      fieldSubType = QMetaType::Type::QString;
       break;
     case 9: // IntegerList
-      fieldType = QVariant::List;
-      fieldSubType = QVariant::Int;
+      fieldType = QMetaType::Type::QVariantList;
+      fieldSubType = QMetaType::Type::Int;
       break;
     case 10: // DoubleList
-      fieldType = QVariant::List;
-      fieldSubType = QVariant::Double;
+      fieldType = QMetaType::Type::QVariantList;
+      fieldSubType = QMetaType::Type::Double;
       break;
   }
 
diff --git a/src/analysis/processing/qgsalgorithmgrid.cpp b/src/analysis/processing/qgsalgorithmgrid.cpp
index 13ba030504c..5862f5b608d 100644
--- a/src/analysis/processing/qgsalgorithmgrid.cpp
+++ b/src/analysis/processing/qgsalgorithmgrid.cpp
@@ -114,19 +114,19 @@ QVariantMap QgsGridAlgorithm::processAlgorithm( const QVariantMap &parameters, Q
     throw QgsProcessingException( QObject::tr( "Invalid overlay: horizontal: '%1', vertical: '%2'" ).arg( mHOverlay ).arg( mVOverlay ) );
 
   QgsFields fields = QgsFields();
-  fields.append( QgsField( QStringLiteral( "id" ), QVariant::LongLong ) );
-  fields.append( QgsField( QStringLiteral( "left" ), QVariant::Double ) );
-  fields.append( QgsField( QStringLiteral( "top" ), QVariant::Double ) );
-  fields.append( QgsField( QStringLiteral( "right" ), QVariant::Double ) );
-  fields.append( QgsField( QStringLiteral( "bottom" ), QVariant::Double ) );
+  fields.append( QgsField( QStringLiteral( "id" ), QMetaType::Type::LongLong ) );
+  fields.append( QgsField( QStringLiteral( "left" ), QMetaType::Type::Double ) );
+  fields.append( QgsField( QStringLiteral( "top" ), QMetaType::Type::Double ) );
+  fields.append( QgsField( QStringLiteral( "right" ), QMetaType::Type::Double ) );
+  fields.append( QgsField( QStringLiteral( "bottom" ), QMetaType::Type::Double ) );
 
   switch ( mIdx )
   {
     case 0: //point
     case 2: //rectangle
     case 4: //hexagon
-      fields.append( QgsField( QStringLiteral( "row_index" ), QVariant::LongLong ) );
-      fields.append( QgsField( QStringLiteral( "col_index" ), QVariant::LongLong ) );
+      fields.append( QgsField( QStringLiteral( "row_index" ), QMetaType::Type::LongLong ) );
+      fields.append( QgsField( QStringLiteral( "col_index" ), QMetaType::Type::LongLong ) );
       break;
     default:
       break;
diff --git a/src/analysis/processing/qgsalgorithmimportphotos.cpp b/src/analysis/processing/qgsalgorithmimportphotos.cpp
index efe24de027f..8abc1eedf21 100644
--- a/src/analysis/processing/qgsalgorithmimportphotos.cpp
+++ b/src/analysis/processing/qgsalgorithmimportphotos.cpp
@@ -148,7 +148,7 @@ QVariant QgsImportPhotosAlgorithm::extractAltitudeFromMetadata( const QVariantMa
   {
     double alt = metadata.value( QStringLiteral( "EXIF_GPSAltitude" ) ).toDouble();
     if ( metadata.contains( QStringLiteral( "EXIF_GPSAltitudeRef" ) ) &&
-         ( ( metadata.value( QStringLiteral( "EXIF_GPSAltitudeRef" ) ).type() == QVariant::String && metadata.value( QStringLiteral( "EXIF_GPSAltitudeRef" ) ).toString().right( 1 ) == QLatin1String( "1" ) )
+         ( ( metadata.value( QStringLiteral( "EXIF_GPSAltitudeRef" ) ).userType() == QMetaType::Type::QString && metadata.value( QStringLiteral( "EXIF_GPSAltitudeRef" ) ).toString().right( 1 ) == QLatin1String( "1" ) )
            || metadata.value( QStringLiteral( "EXIF_GPSAltitudeRef" ) ).toDouble() < 0 ) )
       alt = -alt;
     altitude = alt;
@@ -317,24 +317,24 @@ QVariantMap QgsImportPhotosAlgorithm::processAlgorithm( const QVariantMap &param
   const bool recurse = parameterAsBoolean( parameters, QStringLiteral( "RECURSIVE" ), context );
 
   QgsFields outFields;
-  outFields.append( QgsField( QStringLiteral( "photo" ), QVariant::String ) );
-  outFields.append( QgsField( QStringLiteral( "filename" ), QVariant::String ) );
-  outFields.append( QgsField( QStringLiteral( "directory" ), QVariant::String ) );
-  outFields.append( QgsField( QStringLiteral( "altitude" ), QVariant::Double ) );
-  outFields.append( QgsField( QStringLiteral( "direction" ), QVariant::Double ) );
-  outFields.append( QgsField( QStringLiteral( "rotation" ), QVariant::Int ) );
-  outFields.append( QgsField( QStringLiteral( "longitude" ), QVariant::String ) );
-  outFields.append( QgsField( QStringLiteral( "latitude" ), QVariant::String ) );
-  outFields.append( QgsField( QStringLiteral( "timestamp" ), QVariant::DateTime ) );
+  outFields.append( QgsField( QStringLiteral( "photo" ), QMetaType::Type::QString ) );
+  outFields.append( QgsField( QStringLiteral( "filename" ), QMetaType::Type::QString ) );
+  outFields.append( QgsField( QStringLiteral( "directory" ), QMetaType::Type::QString ) );
+  outFields.append( QgsField( QStringLiteral( "altitude" ), QMetaType::Type::Double ) );
+  outFields.append( QgsField( QStringLiteral( "direction" ), QMetaType::Type::Double ) );
+  outFields.append( QgsField( QStringLiteral( "rotation" ), QMetaType::Type::Int ) );
+  outFields.append( QgsField( QStringLiteral( "longitude" ), QMetaType::Type::QString ) );
+  outFields.append( QgsField( QStringLiteral( "latitude" ), QMetaType::Type::QString ) );
+  outFields.append( QgsField( QStringLiteral( "timestamp" ), QMetaType::Type::QDateTime ) );
   QString outputDest;
   std::unique_ptr< QgsFeatureSink > outputSink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, outputDest, outFields,
       Qgis::WkbType::PointZ, QgsCoordinateReferenceSystem( QStringLiteral( "EPSG:4326" ) ) ) );
 
   QgsFields invalidFields;
-  invalidFields.append( QgsField( QStringLiteral( "photo" ), QVariant::String ) );
-  invalidFields.append( QgsField( QStringLiteral( "filename" ), QVariant::String ) );
-  invalidFields.append( QgsField( QStringLiteral( "directory" ), QVariant::String ) );
-  invalidFields.append( QgsField( QStringLiteral( "readable" ), QVariant::Bool ) );
+  invalidFields.append( QgsField( QStringLiteral( "photo" ), QMetaType::Type::QString ) );
+  invalidFields.append( QgsField( QStringLiteral( "filename" ), QMetaType::Type::QString ) );
+  invalidFields.append( QgsField( QStringLiteral( "directory" ), QMetaType::Type::QString ) );
+  invalidFields.append( QgsField( QStringLiteral( "readable" ), QMetaType::Type::Bool ) );
   QString invalidDest;
   std::unique_ptr< QgsFeatureSink > invalidSink( parameterAsSink( parameters, QStringLiteral( "INVALID" ), context, invalidDest, invalidFields ) );
 
diff --git a/src/analysis/processing/qgsalgorithmjoinbylocationsummary.cpp b/src/analysis/processing/qgsalgorithmjoinbylocationsummary.cpp
index 1b753f43d55..d114b57dcdb 100644
--- a/src/analysis/processing/qgsalgorithmjoinbylocationsummary.cpp
+++ b/src/analysis/processing/qgsalgorithmjoinbylocationsummary.cpp
@@ -179,12 +179,12 @@ QVariantMap QgsJoinByLocationSummaryAlgorithm::processAlgorithm( const QVariantM
   };
 
   // Adds a field to the output, with a specified type
-  auto addFieldWithType = [&fieldsToJoin]( const QgsField & original, const QString & statistic, QVariant::Type type )
+  auto addFieldWithType = [&fieldsToJoin]( const QgsField & original, const QString & statistic, QMetaType::Type type )
   {
     QgsField field = QgsField( original );
     field.setName( field.name() + '_' + statistic );
     field.setType( type );
-    if ( type == QVariant::Double )
+    if ( type == QMetaType::Type::Double )
     {
       field.setLength( 20 );
       field.setPrecision( 6 );
@@ -202,7 +202,7 @@ QVariantMap QgsJoinByLocationSummaryAlgorithm::processAlgorithm( const QVariantM
 
   struct FieldStatistic
   {
-    FieldStatistic( int enumIndex, const QString &name, QVariant::Type type )
+    FieldStatistic( int enumIndex, const QString &name, QMetaType::Type type )
       : enumIndex( enumIndex )
       , name( name )
       , type( type )
@@ -210,45 +210,45 @@ QVariantMap QgsJoinByLocationSummaryAlgorithm::processAlgorithm( const QVariantM
 
     int enumIndex = 0;
     QString name;
-    QVariant::Type type;
+    QMetaType::Type type;
   };
   static const QVector< FieldStatistic > sNumericStats
   {
-    FieldStatistic( 0, QStringLiteral( "count" ), QVariant::LongLong ),
-    FieldStatistic( 1, QStringLiteral( "unique" ), QVariant::LongLong ),
-    FieldStatistic( 2, QStringLiteral( "min" ), QVariant::Double ),
-    FieldStatistic( 3, QStringLiteral( "max" ), QVariant::Double ),
-    FieldStatistic( 4, QStringLiteral( "range" ), QVariant::Double ),
-    FieldStatistic( 5, QStringLiteral( "sum" ), QVariant::Double ),
-    FieldStatistic( 6, QStringLiteral( "mean" ), QVariant::Double ),
-    FieldStatistic( 7, QStringLiteral( "median" ), QVariant::Double ),
-    FieldStatistic( 8, QStringLiteral( "stddev" ), QVariant::Double ),
-    FieldStatistic( 9, QStringLiteral( "minority" ), QVariant::Double ),
-    FieldStatistic( 10, QStringLiteral( "majority" ), QVariant::Double ),
-    FieldStatistic( 11, QStringLiteral( "q1" ), QVariant::Double ),
-    FieldStatistic( 12, QStringLiteral( "q3" ), QVariant::Double ),
-    FieldStatistic( 13, QStringLiteral( "iqr" ), QVariant::Double ),
+    FieldStatistic( 0, QStringLiteral( "count" ), QMetaType::Type::LongLong ),
+    FieldStatistic( 1, QStringLiteral( "unique" ), QMetaType::Type::LongLong ),
+    FieldStatistic( 2, QStringLiteral( "min" ), QMetaType::Type::Double ),
+    FieldStatistic( 3, QStringLiteral( "max" ), QMetaType::Type::Double ),
+    FieldStatistic( 4, QStringLiteral( "range" ), QMetaType::Type::Double ),
+    FieldStatistic( 5, QStringLiteral( "sum" ), QMetaType::Type::Double ),
+    FieldStatistic( 6, QStringLiteral( "mean" ), QMetaType::Type::Double ),
+    FieldStatistic( 7, QStringLiteral( "median" ), QMetaType::Type::Double ),
+    FieldStatistic( 8, QStringLiteral( "stddev" ), QMetaType::Type::Double ),
+    FieldStatistic( 9, QStringLiteral( "minority" ), QMetaType::Type::Double ),
+    FieldStatistic( 10, QStringLiteral( "majority" ), QMetaType::Type::Double ),
+    FieldStatistic( 11, QStringLiteral( "q1" ), QMetaType::Type::Double ),
+    FieldStatistic( 12, QStringLiteral( "q3" ), QMetaType::Type::Double ),
+    FieldStatistic( 13, QStringLiteral( "iqr" ), QMetaType::Type::Double ),
   };
   static const QVector< FieldStatistic > sDateTimeStats
   {
-    FieldStatistic( 0, QStringLiteral( "count" ), QVariant::LongLong ),
-    FieldStatistic( 1, QStringLiteral( "unique" ), QVariant::LongLong ),
-    FieldStatistic( 14, QStringLiteral( "empty" ), QVariant::LongLong ),
-    FieldStatistic( 15, QStringLiteral( "filled" ), QVariant::LongLong ),
-    FieldStatistic( 2, QStringLiteral( "min" ), QVariant::Invalid ),
-    FieldStatistic( 3, QStringLiteral( "max" ), QVariant::Invalid ),
+    FieldStatistic( 0, QStringLiteral( "count" ), QMetaType::Type::LongLong ),
+    FieldStatistic( 1, QStringLiteral( "unique" ), QMetaType::Type::LongLong ),
+    FieldStatistic( 14, QStringLiteral( "empty" ), QMetaType::Type::LongLong ),
+    FieldStatistic( 15, QStringLiteral( "filled" ), QMetaType::Type::LongLong ),
+    FieldStatistic( 2, QStringLiteral( "min" ), QMetaType::Type::UnknownType ),
+    FieldStatistic( 3, QStringLiteral( "max" ), QMetaType::Type::UnknownType ),
   };
   static const QVector< FieldStatistic > sStringStats
   {
-    FieldStatistic( 0, QStringLiteral( "count" ), QVariant::LongLong ),
-    FieldStatistic( 1, QStringLiteral( "unique" ), QVariant::LongLong ),
-    FieldStatistic( 14, QStringLiteral( "empty" ), QVariant::LongLong ),
-    FieldStatistic( 15, QStringLiteral( "filled" ), QVariant::LongLong ),
-    FieldStatistic( 2, QStringLiteral( "min" ), QVariant::Invalid ),
-    FieldStatistic( 3, QStringLiteral( "max" ), QVariant::Invalid ),
-    FieldStatistic( 16, QStringLiteral( "min_length" ), QVariant::Int ),
-    FieldStatistic( 17, QStringLiteral( "max_length" ), QVariant::Int ),
-    FieldStatistic( 18, QStringLiteral( "mean_length" ), QVariant::Double ),
+    FieldStatistic( 0, QStringLiteral( "count" ), QMetaType::Type::LongLong ),
+    FieldStatistic( 1, QStringLiteral( "unique" ), QMetaType::Type::LongLong ),
+    FieldStatistic( 14, QStringLiteral( "empty" ), QMetaType::Type::LongLong ),
+    FieldStatistic( 15, QStringLiteral( "filled" ), QMetaType::Type::LongLong ),
+    FieldStatistic( 2, QStringLiteral( "min" ), QMetaType::Type::UnknownType ),
+    FieldStatistic( 3, QStringLiteral( "max" ), QMetaType::Type::UnknownType ),
+    FieldStatistic( 16, QStringLiteral( "min_length" ), QMetaType::Type::Int ),
+    FieldStatistic( 17, QStringLiteral( "max_length" ), QMetaType::Type::Int ),
+    FieldStatistic( 18, QStringLiteral( "mean_length" ), QMetaType::Type::Double ),
   };
 
   for ( const QString &field : std::as_const( joinedFieldNames ) )
@@ -265,9 +265,9 @@ QVariantMap QgsJoinByLocationSummaryAlgorithm::processAlgorithm( const QVariantM
         fieldTypes.append( FieldType::Numeric );
         statisticList = sNumericStats;
       }
-      else if ( joinField.type() == QVariant::Date
-                || joinField.type() == QVariant::Time
-                || joinField.type() == QVariant::DateTime )
+      else if ( joinField.type() == QMetaType::Type::QDate
+                || joinField.type() == QMetaType::Type::QTime
+                || joinField.type() == QMetaType::Type::QDateTime )
       {
         fieldTypes.append( FieldType::DateTime );
         statisticList = sDateTimeStats;
@@ -282,7 +282,7 @@ QVariantMap QgsJoinByLocationSummaryAlgorithm::processAlgorithm( const QVariantM
       {
         if ( summaries.contains( statistic.enumIndex ) )
         {
-          if ( statistic.type != QVariant::Invalid )
+          if ( statistic.type != QMetaType::Type::UnknownType )
             addFieldWithType( joinField, statistic.name, statistic.type );
           else
             addFieldKeepType( joinField, statistic.name );
diff --git a/src/analysis/processing/qgsalgorithmjoinbynearest.cpp b/src/analysis/processing/qgsalgorithmjoinbynearest.cpp
index 2ca1c0616cb..96fd6236098 100644
--- a/src/analysis/processing/qgsalgorithmjoinbynearest.cpp
+++ b/src/analysis/processing/qgsalgorithmjoinbynearest.cpp
@@ -171,12 +171,12 @@ QVariantMap QgsJoinByNearestAlgorithm::processAlgorithm( const QVariantMap &para
   QgsFields outFields = QgsProcessingUtils::combineFields( input->fields(), outFields2 );
 
   QgsFields resultFields;
-  resultFields.append( QgsField( QStringLiteral( "n" ), QVariant::Int ) );
-  resultFields.append( QgsField( QStringLiteral( "distance" ), QVariant::Double ) );
-  resultFields.append( QgsField( QStringLiteral( "feature_x" ), QVariant::Double ) );
-  resultFields.append( QgsField( QStringLiteral( "feature_y" ), QVariant::Double ) );
-  resultFields.append( QgsField( QStringLiteral( "nearest_x" ), QVariant::Double ) );
-  resultFields.append( QgsField( QStringLiteral( "nearest_y" ), QVariant::Double ) );
+  resultFields.append( QgsField( QStringLiteral( "n" ), QMetaType::Type::Int ) );
+  resultFields.append( QgsField( QStringLiteral( "distance" ), QMetaType::Type::Double ) );
+  resultFields.append( QgsField( QStringLiteral( "feature_x" ), QMetaType::Type::Double ) );
+  resultFields.append( QgsField( QStringLiteral( "feature_y" ), QMetaType::Type::Double ) );
+  resultFields.append( QgsField( QStringLiteral( "nearest_x" ), QMetaType::Type::Double ) );
+  resultFields.append( QgsField( QStringLiteral( "nearest_y" ), QMetaType::Type::Double ) );
   outFields = QgsProcessingUtils::combineFields( outFields, resultFields );
 
   QString dest;
diff --git a/src/analysis/processing/qgsalgorithmkmeansclustering.cpp b/src/analysis/processing/qgsalgorithmkmeansclustering.cpp
index 9b35c914301..ae0d4264b3e 100644
--- a/src/analysis/processing/qgsalgorithmkmeansclustering.cpp
+++ b/src/analysis/processing/qgsalgorithmkmeansclustering.cpp
@@ -88,9 +88,9 @@ QVariantMap QgsKMeansClusteringAlgorithm::processAlgorithm( const QVariantMap &p
   QgsFields outputFields = source->fields();
   QgsFields newFields;
   const QString clusterFieldName = parameterAsString( parameters, QStringLiteral( "FIELD_NAME" ), context );
-  newFields.append( QgsField( clusterFieldName, QVariant::Int ) );
+  newFields.append( QgsField( clusterFieldName, QMetaType::Type::Int ) );
   const QString clusterSizeFieldName = parameterAsString( parameters, QStringLiteral( "SIZE_FIELD_NAME" ), context );
-  newFields.append( QgsField( clusterSizeFieldName, QVariant::Int ) );
+  newFields.append( QgsField( clusterSizeFieldName, QMetaType::Type::Int ) );
   outputFields = QgsProcessingUtils::combineFields( outputFields, newFields );
 
   QString dest;
diff --git a/src/analysis/processing/qgsalgorithmmeancoordinates.cpp b/src/analysis/processing/qgsalgorithmmeancoordinates.cpp
index 52d2035cb25..80316c7ade3 100644
--- a/src/analysis/processing/qgsalgorithmmeancoordinates.cpp
+++ b/src/analysis/processing/qgsalgorithmmeancoordinates.cpp
@@ -98,8 +98,8 @@ QVariantMap QgsMeanCoordinatesAlgorithm::processAlgorithm( const QVariantMap &pa
   }
 
   QgsFields fields;
-  fields.append( QgsField( QStringLiteral( "MEAN_X" ), QVariant::Double, QString(), 24, 15 ) );
-  fields.append( QgsField( QStringLiteral( "MEAN_Y" ), QVariant::Double, QString(), 24, 15 ) );
+  fields.append( QgsField( QStringLiteral( "MEAN_X" ), QMetaType::Type::Double, QString(), 24, 15 ) );
+  fields.append( QgsField( QStringLiteral( "MEAN_Y" ), QMetaType::Type::Double, QString(), 24, 15 ) );
   if ( uniqueFieldIndex >= 0 )
   {
     const QgsField uniqueField = source->fields().at( uniqueFieldIndex );
diff --git a/src/analysis/processing/qgsalgorithmmergevector.cpp b/src/analysis/processing/qgsalgorithmmergevector.cpp
index 9bce67ad3a5..1be37b84eb1 100644
--- a/src/analysis/processing/qgsalgorithmmergevector.cpp
+++ b/src/analysis/processing/qgsalgorithmmergevector.cpp
@@ -165,8 +165,8 @@ QVariantMap QgsMergeVectorAlgorithm::processAlgorithm( const QVariantMap &parame
             feedback->pushWarning( QObject::tr( "%1 field in layer %2 has different data type than the destination layer (%3 instead of %4). "
                                                 "%1 field will be converted to string type." )
                                    .arg( sourceField.name(), layerName, sourceField.typeName(), destField.typeName() ) );
-            destField.setType( QVariant::String );
-            destField.setSubType( QVariant::Invalid );
+            destField.setType( QMetaType::Type::QString );
+            destField.setSubType( QMetaType::Type::UnknownType );
             destField.setLength( 0 );
             destField.setPrecision( 0 );
           }
@@ -182,13 +182,13 @@ QVariantMap QgsMergeVectorAlgorithm::processAlgorithm( const QVariantMap &parame
   bool addLayerField = false;
   if ( outputFields.lookupField( QStringLiteral( "layer" ) ) < 0 )
   {
-    outputFields.append( QgsField( QStringLiteral( "layer" ), QVariant::String, QString() ) );
+    outputFields.append( QgsField( QStringLiteral( "layer" ), QMetaType::Type::QString, QString() ) );
     addLayerField = true;
   }
   bool addPathField = false;
   if ( outputFields.lookupField( QStringLiteral( "path" ) ) < 0 )
   {
-    outputFields.append( QgsField( QStringLiteral( "path" ), QVariant::String, QString() ) );
+    outputFields.append( QgsField( QStringLiteral( "path" ), QMetaType::Type::QString, QString() ) );
     addPathField = true;
   }
 
diff --git a/src/analysis/processing/qgsalgorithmminimumenclosingcircle.cpp b/src/analysis/processing/qgsalgorithmminimumenclosingcircle.cpp
index 291bfbd02d6..65617bc71d3 100644
--- a/src/analysis/processing/qgsalgorithmminimumenclosingcircle.cpp
+++ b/src/analysis/processing/qgsalgorithmminimumenclosingcircle.cpp
@@ -88,8 +88,8 @@ bool QgsMinimumEnclosingCircleAlgorithm::supportInPlaceEdit( const QgsMapLayer *
 QgsFields QgsMinimumEnclosingCircleAlgorithm::outputFields( const QgsFields &inputFields ) const
 {
   QgsFields fields = inputFields;
-  fields.append( QgsField( QStringLiteral( "radius" ), QVariant::Double, QString(), 20, 6 ) );
-  fields.append( QgsField( QStringLiteral( "area" ), QVariant::Double, QString(), 20, 6 ) );
+  fields.append( QgsField( QStringLiteral( "radius" ), QMetaType::Type::Double, QString(), 20, 6 ) );
+  fields.append( QgsField( QStringLiteral( "area" ), QMetaType::Type::Double, QString(), 20, 6 ) );
   return fields;
 }
 
diff --git a/src/analysis/processing/qgsalgorithmmultiringconstantbuffer.cpp b/src/analysis/processing/qgsalgorithmmultiringconstantbuffer.cpp
index e4b1ccc1201..dced13d73f9 100644
--- a/src/analysis/processing/qgsalgorithmmultiringconstantbuffer.cpp
+++ b/src/analysis/processing/qgsalgorithmmultiringconstantbuffer.cpp
@@ -108,8 +108,8 @@ bool QgsMultiRingConstantBufferAlgorithm::prepareAlgorithm( const QVariantMap &p
 QgsFields QgsMultiRingConstantBufferAlgorithm::outputFields( const QgsFields &inputFields ) const
 {
   QgsFields fields = inputFields;
-  fields.append( QgsField( QStringLiteral( "ringId" ), QVariant::Int, QString(), 10, 0 ) );
-  fields.append( QgsField( QStringLiteral( "distance" ), QVariant::Double, QString(), 20, 6 ) );
+  fields.append( QgsField( QStringLiteral( "ringId" ), QMetaType::Type::Int, QString(), 10, 0 ) );
+  fields.append( QgsField( QStringLiteral( "distance" ), QMetaType::Type::Double, QString(), 20, 6 ) );
   return fields;
 }
 
diff --git a/src/analysis/processing/qgsalgorithmorientedminimumboundingbox.cpp b/src/analysis/processing/qgsalgorithmorientedminimumboundingbox.cpp
index 1902f879570..41b253e5f5a 100644
--- a/src/analysis/processing/qgsalgorithmorientedminimumboundingbox.cpp
+++ b/src/analysis/processing/qgsalgorithmorientedminimumboundingbox.cpp
@@ -82,11 +82,11 @@ bool QgsOrientedMinimumBoundingBoxAlgorithm::supportInPlaceEdit( const QgsMapLay
 QgsFields QgsOrientedMinimumBoundingBoxAlgorithm::outputFields( const QgsFields &inputFields ) const
 {
   QgsFields fields = inputFields;
-  fields.append( QgsField( QStringLiteral( "width" ), QVariant::Double, QString(), 20, 6 ) );
-  fields.append( QgsField( QStringLiteral( "height" ), QVariant::Double, QString(), 20, 6 ) );
-  fields.append( QgsField( QStringLiteral( "angle" ), QVariant::Double, QString(), 20, 6 ) );
-  fields.append( QgsField( QStringLiteral( "area" ), QVariant::Double, QString(), 20, 6 ) );
-  fields.append( QgsField( QStringLiteral( "perimeter" ), QVariant::Double, QString(), 20, 6 ) );
+  fields.append( QgsField( QStringLiteral( "width" ), QMetaType::Type::Double, QString(), 20, 6 ) );
+  fields.append( QgsField( QStringLiteral( "height" ), QMetaType::Type::Double, QString(), 20, 6 ) );
+  fields.append( QgsField( QStringLiteral( "angle" ), QMetaType::Type::Double, QString(), 20, 6 ) );
+  fields.append( QgsField( QStringLiteral( "area" ), QMetaType::Type::Double, QString(), 20, 6 ) );
+  fields.append( QgsField( QStringLiteral( "perimeter" ), QMetaType::Type::Double, QString(), 20, 6 ) );
   return fields;
 }
 
diff --git a/src/analysis/processing/qgsalgorithmpackage.cpp b/src/analysis/processing/qgsalgorithmpackage.cpp
index 0aaf3d7fc62..7216e6aa10c 100644
--- a/src/analysis/processing/qgsalgorithmpackage.cpp
+++ b/src/analysis/processing/qgsalgorithmpackage.cpp
@@ -437,13 +437,13 @@ bool QgsPackageAlgorithm::packageVectorLayer( QgsVectorLayer *layer, const QStri
   options.attributes = fields.allAttributesList();
   if ( fidIndex >= 0 )
   {
-    const QVariant::Type fidType { layer->fields().field( fidIndex ).type() };
+    const QMetaType::Type fidType { layer->fields().field( fidIndex ).type() };
     if ( ! layer->fieldConstraints( fidIndex ).testFlag( QgsFieldConstraints::Constraint::ConstraintUnique )
          && ! layer->fieldConstraints( fidIndex ).testFlag( QgsFieldConstraints::Constraint::ConstraintNotNull )
-         && fidType != QVariant::Int
-         && fidType != QVariant::UInt
-         && fidType != QVariant::LongLong
-         && fidType != QVariant::ULongLong )
+         && fidType != QMetaType::Type::Int
+         && fidType != QMetaType::Type::UInt
+         && fidType != QMetaType::Type::LongLong
+         && fidType != QMetaType::Type::ULongLong )
     {
       options.attributes.removeAll( fidIndex );
     }
diff --git a/src/analysis/processing/qgsalgorithmpixelcentroidsfrompolygons.cpp b/src/analysis/processing/qgsalgorithmpixelcentroidsfrompolygons.cpp
index a5bf8f520d6..63eaeb6fee7 100644
--- a/src/analysis/processing/qgsalgorithmpixelcentroidsfrompolygons.cpp
+++ b/src/analysis/processing/qgsalgorithmpixelcentroidsfrompolygons.cpp
@@ -77,9 +77,9 @@ QVariantMap QgsPixelCentroidsFromPolygonsAlgorithm::processAlgorithm( const QVar
     throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT_VECTOR" ) ) );
 
   QgsFields fields;
-  fields.append( QgsField( QStringLiteral( "id" ), QVariant::LongLong ) );
-  fields.append( QgsField( QStringLiteral( "poly_id" ), QVariant::Int ) );
-  fields.append( QgsField( QStringLiteral( "point_id" ), QVariant::Int ) );
+  fields.append( QgsField( QStringLiteral( "id" ), QMetaType::Type::LongLong ) );
+  fields.append( QgsField( QStringLiteral( "poly_id" ), QMetaType::Type::Int ) );
+  fields.append( QgsField( QStringLiteral( "point_id" ), QMetaType::Type::Int ) );
 
   QString dest;
   std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Point, rasterLayer->crs(), QgsFeatureSink::RegeneratePrimaryKey ) );
diff --git a/src/analysis/processing/qgsalgorithmpointsalonggeometry.cpp b/src/analysis/processing/qgsalgorithmpointsalonggeometry.cpp
index 5488084e1f7..eeb4e063749 100644
--- a/src/analysis/processing/qgsalgorithmpointsalonggeometry.cpp
+++ b/src/analysis/processing/qgsalgorithmpointsalonggeometry.cpp
@@ -89,8 +89,8 @@ Qgis::WkbType QgsPointsAlongGeometryAlgorithm::outputWkbType( Qgis::WkbType inpu
 QgsFields QgsPointsAlongGeometryAlgorithm::outputFields( const QgsFields &inputFields ) const
 {
   QgsFields output = inputFields;
-  output.append( QgsField( QStringLiteral( "distance" ), QVariant::Double ) );
-  output.append( QgsField( QStringLiteral( "angle" ), QVariant::Double ) );
+  output.append( QgsField( QStringLiteral( "distance" ), QMetaType::Type::Double ) );
+  output.append( QgsField( QStringLiteral( "angle" ), QMetaType::Type::Double ) );
   return output;
 }
 
diff --git a/src/analysis/processing/qgsalgorithmpointsinpolygon.cpp b/src/analysis/processing/qgsalgorithmpointsinpolygon.cpp
index 23ad1a82ba6..e751ad19066 100644
--- a/src/analysis/processing/qgsalgorithmpointsinpolygon.cpp
+++ b/src/analysis/processing/qgsalgorithmpointsinpolygon.cpp
@@ -255,7 +255,7 @@ QgsFields QgsPointsInPolygonAlgorithm::outputFields( const QgsFields &inputField
     QgsFields outFields = inputFields;
     mDestFieldIndex = inputFields.lookupField( mFieldName );
     if ( mDestFieldIndex < 0 )
-      outFields.append( QgsField( mFieldName, QVariant::Double ) );
+      outFields.append( QgsField( mFieldName, QMetaType::Type::Double ) );
 
     mFields = outFields;
     return outFields;
diff --git a/src/analysis/processing/qgsalgorithmpointstopaths.cpp b/src/analysis/processing/qgsalgorithmpointstopaths.cpp
index 31dcc4a5480..0c52e11fdd9 100644
--- a/src/analysis/processing/qgsalgorithmpointstopaths.cpp
+++ b/src/analysis/processing/qgsalgorithmpointstopaths.cpp
@@ -166,7 +166,7 @@ QVariantMap QgsPointsToPathsAlgorithm::processAlgorithm( const QVariantMap &para
   QStringList requiredFields = QStringList( orderExpression.referencedColumns().values() );
   orderExpression.prepare( &expressionContext );
 
-  QVariant::Type orderFieldType = QVariant::String;
+  QMetaType::Type orderFieldType = QMetaType::Type::QString;
   if ( orderExpression.isField() )
   {
     const int orderFieldIndex = source->fields().indexFromName( orderExpression.referencedColumns().values().first() );
diff --git a/src/analysis/processing/qgsalgorithmpointtolayer.cpp b/src/analysis/processing/qgsalgorithmpointtolayer.cpp
index 311f57370c1..6b1244f0108 100644
--- a/src/analysis/processing/qgsalgorithmpointtolayer.cpp
+++ b/src/analysis/processing/qgsalgorithmpointtolayer.cpp
@@ -48,7 +48,7 @@ QVariantMap QgsPointToLayerAlgorithm::processAlgorithm( const QVariantMap &param
   const QgsGeometry geom = QgsGeometry::fromPointXY( parameterAsPoint( parameters, QStringLiteral( "INPUT" ), context ) );
 
   QgsFields fields;
-  fields.append( QgsField( QStringLiteral( "id" ), QVariant::Int ) );
+  fields.append( QgsField( QStringLiteral( "id" ), QMetaType::Type::Int ) );
 
   QString dest;
   std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Point, crs ) );
diff --git a/src/analysis/processing/qgsalgorithmpoleofinaccessibility.cpp b/src/analysis/processing/qgsalgorithmpoleofinaccessibility.cpp
index fd3b15eb239..1bb03f3a3e7 100644
--- a/src/analysis/processing/qgsalgorithmpoleofinaccessibility.cpp
+++ b/src/analysis/processing/qgsalgorithmpoleofinaccessibility.cpp
@@ -92,7 +92,7 @@ Qgis::WkbType QgsPoleOfInaccessibilityAlgorithm::outputWkbType( Qgis::WkbType in
 QgsFields QgsPoleOfInaccessibilityAlgorithm::outputFields( const QgsFields &inputFields ) const
 {
   QgsFields outputFields = inputFields;
-  outputFields.append( QgsField( QStringLiteral( "dist_pole" ), QVariant::Double ) );
+  outputFields.append( QgsField( QStringLiteral( "dist_pole" ), QMetaType::Type::Double ) );
 
   return outputFields;
 }
diff --git a/src/analysis/processing/qgsalgorithmrandompointsextent.cpp b/src/analysis/processing/qgsalgorithmrandompointsextent.cpp
index b953168067f..f79e4540e09 100644
--- a/src/analysis/processing/qgsalgorithmrandompointsextent.cpp
+++ b/src/analysis/processing/qgsalgorithmrandompointsextent.cpp
@@ -96,7 +96,7 @@ QVariantMap QgsRandomPointsExtentAlgorithm::processAlgorithm( const QVariantMap
 {
 
   QgsFields fields = QgsFields();
-  fields.append( QgsField( QStringLiteral( "id" ), QVariant::LongLong ) );
+  fields.append( QgsField( QStringLiteral( "id" ), QMetaType::Type::LongLong ) );
 
   QString dest;
   std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Point, mCrs ) );
diff --git a/src/analysis/processing/qgsalgorithmrandompointsinpolygons.cpp b/src/analysis/processing/qgsalgorithmrandompointsinpolygons.cpp
index 147fb11decb..d2be17f358c 100644
--- a/src/analysis/processing/qgsalgorithmrandompointsinpolygons.cpp
+++ b/src/analysis/processing/qgsalgorithmrandompointsinpolygons.cpp
@@ -185,7 +185,7 @@ QVariantMap QgsRandomPointsInPolygonsAlgorithm::processAlgorithm( const QVariant
     throw QgsProcessingException( invalidSourceError( parameters, INPUT ) );
 
   QgsFields fields;
-  fields.append( QgsField( QStringLiteral( "rand_point_id" ), QVariant::LongLong ) );
+  fields.append( QgsField( QStringLiteral( "rand_point_id" ), QMetaType::Type::LongLong ) );
   if ( mIncludePolygonAttr )
     fields.extend( polygonSource->fields() );
 
diff --git a/src/analysis/processing/qgsalgorithmrandompointsonlines.cpp b/src/analysis/processing/qgsalgorithmrandompointsonlines.cpp
index df56466d000..297f90a152e 100644
--- a/src/analysis/processing/qgsalgorithmrandompointsonlines.cpp
+++ b/src/analysis/processing/qgsalgorithmrandompointsonlines.cpp
@@ -192,7 +192,7 @@ QVariantMap QgsRandomPointsOnLinesAlgorithm::processAlgorithm( const QVariantMap
     throw QgsProcessingException( invalidSourceError( parameters, INPUT ) );
 
   QgsFields fields;
-  fields.append( QgsField( QStringLiteral( "rand_point_id" ), QVariant::LongLong ) );
+  fields.append( QgsField( QStringLiteral( "rand_point_id" ), QMetaType::Type::LongLong ) );
   if ( mIncludeLineAttr )
     fields.extend( lineSource->fields() );
 
diff --git a/src/analysis/processing/qgsalgorithmrasterlayeruniquevalues.cpp b/src/analysis/processing/qgsalgorithmrasterlayeruniquevalues.cpp
index 097cb2821b8..41fd306620d 100644
--- a/src/analysis/processing/qgsalgorithmrasterlayeruniquevalues.cpp
+++ b/src/analysis/processing/qgsalgorithmrasterlayeruniquevalues.cpp
@@ -114,9 +114,9 @@ QVariantMap QgsRasterLayerUniqueValuesReportAlgorithm::processAlgorithm( const Q
   if ( parameters.contains( QStringLiteral( "OUTPUT_TABLE" ) ) && parameters.value( QStringLiteral( "OUTPUT_TABLE" ) ).isValid() )
   {
     QgsFields outFields;
-    outFields.append( QgsField( QStringLiteral( "value" ), QVariant::Double, QString(), 20, 8 ) );
-    outFields.append( QgsField( QStringLiteral( "count" ), QVariant::LongLong, QString(), 20 ) );
-    outFields.append( QgsField( areaUnit.replace( QStringLiteral( "²" ), QStringLiteral( "2" ) ), QVariant::Double, QString(), 20, 8 ) );
+    outFields.append( QgsField( QStringLiteral( "value" ), QMetaType::Type::Double, QString(), 20, 8 ) );
+    outFields.append( QgsField( QStringLiteral( "count" ), QMetaType::Type::LongLong, QString(), 20 ) );
+    outFields.append( QgsField( areaUnit.replace( QStringLiteral( "²" ), QStringLiteral( "2" ) ), QQMetaType::Type::Double QString(), 20, 8 ) );
     sink.reset( parameterAsSink( parameters, QStringLiteral( "OUTPUT_TABLE" ), context, tableDest, outFields, Qgis::WkbType::NoGeometry, QgsCoordinateReferenceSystem() ) );
     if ( !sink )
       throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT_TABLE" ) ) );
diff --git a/src/analysis/processing/qgsalgorithmrastersampling.cpp b/src/analysis/processing/qgsalgorithmrastersampling.cpp
index 36cd11cc643..c532ca04ecb 100644
--- a/src/analysis/processing/qgsalgorithmrastersampling.cpp
+++ b/src/analysis/processing/qgsalgorithmrastersampling.cpp
@@ -98,7 +98,7 @@ QVariantMap QgsRasterSamplingAlgorithm::processAlgorithm( const QVariantMap &par
     const bool intSafe = ( dataType == Qgis::DataType::Byte || dataType == Qgis::DataType::UInt16 || dataType == Qgis::DataType::Int16 || dataType == Qgis::DataType::UInt32 ||
                            dataType == Qgis::DataType::Int32 || dataType == Qgis::DataType::CInt16 || dataType == Qgis::DataType::CInt32 );
 
-    newFields.append( QgsField( QStringLiteral( "%1%2" ).arg( fieldPrefix, QString::number( band ) ), intSafe ? QVariant::Int : QVariant::Double ) );
+    newFields.append( QgsField( QStringLiteral( "%1%2" ).arg( fieldPrefix, QString::number( band ) ), intSafe ? QMetaType::Type::Int : QMetaType::Type::Double ) );
     emptySampleAttributes += QVariant();
   }
   const QgsFields fields = QgsProcessingUtils::combineFields( source->fields(), newFields );
diff --git a/src/analysis/processing/qgsalgorithmrastersurfacevolume.cpp b/src/analysis/processing/qgsalgorithmrastersurfacevolume.cpp
index fc0e5e330ef..84b3e48b225 100644
--- a/src/analysis/processing/qgsalgorithmrastersurfacevolume.cpp
+++ b/src/analysis/processing/qgsalgorithmrastersurfacevolume.cpp
@@ -138,9 +138,9 @@ QVariantMap QgsRasterSurfaceVolumeAlgorithm::processAlgorithm( const QVariantMap
   if ( parameters.contains( QStringLiteral( "OUTPUT_TABLE" ) ) && parameters.value( QStringLiteral( "OUTPUT_TABLE" ) ).isValid() )
   {
     QgsFields outFields;
-    outFields.append( QgsField( QStringLiteral( "volume" ), QVariant::Double, QString(), 20, 8 ) );
-    outFields.append( QgsField( areaUnit.replace( QStringLiteral( "²" ), QStringLiteral( "2" ) ), QVariant::Double, QString(), 20, 8 ) );
-    outFields.append( QgsField( QStringLiteral( "pixel_count" ), QVariant::LongLong ) );
+    outFields.append( QgsField( QStringLiteral( "volume" ), QMetaType::Type::Double, QString(), 20, 8 ) );
+    outFields.append( QgsField( areaUnit.replace( QStringLiteral( "²" ), QStringLiteral( "2" ) ), QQMetaType::Type::Double QString(), 20, 8 ) );
+    outFields.append( QgsField( QStringLiteral( "pixel_count" ), QMetaType::Type::LongLong ) );
     sink.reset( parameterAsSink( parameters, QStringLiteral( "OUTPUT_TABLE" ), context, tableDest, outFields, Qgis::WkbType::NoGeometry, QgsCoordinateReferenceSystem() ) );
     if ( !sink )
       throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT_TABLE" ) ) );
diff --git a/src/analysis/processing/qgsalgorithmrasterzonalstats.cpp b/src/analysis/processing/qgsalgorithmrasterzonalstats.cpp
index 67490202925..674d8c01333 100644
--- a/src/analysis/processing/qgsalgorithmrasterzonalstats.cpp
+++ b/src/analysis/processing/qgsalgorithmrasterzonalstats.cpp
@@ -177,13 +177,13 @@ QVariantMap QgsRasterLayerZonalStatsAlgorithm::processAlgorithm( const QVariantM
   if ( parameters.contains( QStringLiteral( "OUTPUT_TABLE" ) ) && parameters.value( QStringLiteral( "OUTPUT_TABLE" ) ).isValid() )
   {
     QgsFields outFields;
-    outFields.append( QgsField( QStringLiteral( "zone" ), QVariant::Double, QString(), 20, 8 ) );
-    outFields.append( QgsField( areaUnit.isEmpty() ? "area" : areaUnit.replace( QStringLiteral( "²" ), QStringLiteral( "2" ) ), QVariant::Double, QString(), 20, 8 ) );
-    outFields.append( QgsField( QStringLiteral( "sum" ), QVariant::Double, QString(), 20, 8 ) );
-    outFields.append( QgsField( QStringLiteral( "count" ), QVariant::LongLong, QString(), 20 ) );
-    outFields.append( QgsField( QStringLiteral( "min" ), QVariant::Double, QString(), 20, 8 ) );
-    outFields.append( QgsField( QStringLiteral( "max" ), QVariant::Double, QString(), 20, 8 ) );
-    outFields.append( QgsField( QStringLiteral( "mean" ), QVariant::Double, QString(), 20, 8 ) );
+    outFields.append( QgsField( QStringLiteral( "zone" ), QMetaType::Type::Double, QString(), 20, 8 ) );
+    outFields.append( QgsField( areaUnit.isEmpty() ? "area" : areaUnit.replace( QStringLiteral( "²" ), QStringLiteral( "2" ) ), QQMetaType::Type::Double QString(), 20, 8 ) );
+    outFields.append( QgsField( QStringLiteral( "sum" ), QMetaType::Type::Double, QString(), 20, 8 ) );
+    outFields.append( QgsField( QStringLiteral( "count" ), QMetaType::Type::LongLong, QString(), 20 ) );
+    outFields.append( QgsField( QStringLiteral( "min" ), QMetaType::Type::Double, QString(), 20, 8 ) );
+    outFields.append( QgsField( QStringLiteral( "max" ), QMetaType::Type::Double, QString(), 20, 8 ) );
+    outFields.append( QgsField( QStringLiteral( "mean" ), QMetaType::Type::Double, QString(), 20, 8 ) );
 
     sink.reset( parameterAsSink( parameters, QStringLiteral( "OUTPUT_TABLE" ), context, tableDest, outFields, Qgis::WkbType::NoGeometry, QgsCoordinateReferenceSystem() ) );
     if ( !sink )
diff --git a/src/analysis/processing/qgsalgorithmrefactorfields.cpp b/src/analysis/processing/qgsalgorithmrefactorfields.cpp
index d59191d0928..3431b644cf8 100644
--- a/src/analysis/processing/qgsalgorithmrefactorfields.cpp
+++ b/src/analysis/processing/qgsalgorithmrefactorfields.cpp
@@ -106,9 +106,9 @@ bool QgsRefactorFieldsAlgorithm::prepareAlgorithm( const QVariantMap &parameters
     if ( name.isEmpty() )
       throw QgsProcessingException( QObject::tr( "Field name cannot be empty" ) );
 
-    const QVariant::Type type = static_cast< QVariant::Type >( fieldDef.value( QStringLiteral( "type" ) ).toInt() );
+    const QMetaType::Type type = static_cast< QMetaType::Type >( fieldDef.value( QStringLiteral( "type" ) ).toInt() );
     const QString typeName = fieldDef.value( QStringLiteral( "sub_name" ) ).toString();
-    const QVariant::Type subType = static_cast< QVariant::Type >( fieldDef.value( QStringLiteral( "sub_type" ) ).toInt() );
+    const QMetaType::Type subType = static_cast< QMetaType::Type >( fieldDef.value( QStringLiteral( "sub_type" ) ).toInt() );
 
     const int length = fieldDef.value( QStringLiteral( "length" ), 0 ).toInt();
     const int precision = fieldDef.value( QStringLiteral( "precision" ), 0 ).toInt();
diff --git a/src/analysis/processing/qgsalgorithmroundness.cpp b/src/analysis/processing/qgsalgorithmroundness.cpp
index de205ef466f..e0c8ccb8d9b 100644
--- a/src/analysis/processing/qgsalgorithmroundness.cpp
+++ b/src/analysis/processing/qgsalgorithmroundness.cpp
@@ -79,7 +79,7 @@ Qgis::ProcessingSourceType QgsRoundnessAlgorithm::outputLayerType() const
 QgsFields QgsRoundnessAlgorithm::outputFields( const QgsFields &inputFields ) const
 {
   QgsFields outputFields = inputFields;
-  outputFields.append( QgsField( QStringLiteral( "roundness" ), QVariant::Double ) );
+  outputFields.append( QgsField( QStringLiteral( "roundness" ), QMetaType::Type::Double ) );
   return outputFields;
 }
 
diff --git a/src/analysis/processing/qgsalgorithmserviceareafromlayer.cpp b/src/analysis/processing/qgsalgorithmserviceareafromlayer.cpp
index faaa5ead4b1..29559a6b2bf 100644
--- a/src/analysis/processing/qgsalgorithmserviceareafromlayer.cpp
+++ b/src/analysis/processing/qgsalgorithmserviceareafromlayer.cpp
@@ -123,8 +123,8 @@ QVariantMap QgsServiceAreaFromLayerAlgorithm::processAlgorithm( const QVariantMa
   std::unique_ptr< QgsGraph > graph( mBuilder->takeGraph() );
 
   QgsFields fields = startPoints->fields();
-  fields.append( QgsField( QStringLiteral( "type" ), QVariant::String ) );
-  fields.append( QgsField( QStringLiteral( "start" ), QVariant::String ) );
+  fields.append( QgsField( QStringLiteral( "type" ), QMetaType::Type::QString ) );
+  fields.append( QgsField( QStringLiteral( "start" ), QMetaType::Type::QString ) );
 
   QString pointsSinkId;
   std::unique_ptr< QgsFeatureSink > pointsSink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, pointsSinkId, fields,
diff --git a/src/analysis/processing/qgsalgorithmserviceareafrompoint.cpp b/src/analysis/processing/qgsalgorithmserviceareafrompoint.cpp
index 7bca638bcca..3e15af80d1a 100644
--- a/src/analysis/processing/qgsalgorithmserviceareafrompoint.cpp
+++ b/src/analysis/processing/qgsalgorithmserviceareafrompoint.cpp
@@ -195,8 +195,8 @@ QVariantMap QgsServiceAreaFromPointAlgorithm::processAlgorithm( const QVariantMa
   QVariantMap outputs;
 
   QgsFields fields;
-  fields.append( QgsField( QStringLiteral( "type" ), QVariant::String ) );
-  fields.append( QgsField( QStringLiteral( "start" ), QVariant::String ) );
+  fields.append( QgsField( QStringLiteral( "type" ), QMetaType::Type::QString ) );
+  fields.append( QgsField( QStringLiteral( "start" ), QMetaType::Type::QString ) );
 
   QgsFeature feat;
   feat.setFields( fields );
diff --git a/src/analysis/processing/qgsalgorithmshortestline.cpp b/src/analysis/processing/qgsalgorithmshortestline.cpp
index 84a0ff3c2bc..0f36750a4dc 100644
--- a/src/analysis/processing/qgsalgorithmshortestline.cpp
+++ b/src/analysis/processing/qgsalgorithmshortestline.cpp
@@ -107,7 +107,7 @@ QVariantMap QgsShortestLineAlgorithm::processAlgorithm( const QVariantMap &param
     mKNeighbors = mDestination->featureCount();
 
   QgsFields fields = QgsProcessingUtils::combineFields( mSource->fields(), mDestination->fields() );
-  fields.append( QgsField( QStringLiteral( "distance" ), QVariant::Double ) );
+  fields.append( QgsField( QStringLiteral( "distance" ), QMetaType::Type::Double ) );
 
   QString dest;
   std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::MultiLineString, mSource->sourceCrs() ) );
diff --git a/src/analysis/processing/qgsalgorithmshortestpathlayertopoint.cpp b/src/analysis/processing/qgsalgorithmshortestpathlayertopoint.cpp
index 44170593cf2..35e32a417a1 100644
--- a/src/analysis/processing/qgsalgorithmshortestpathlayertopoint.cpp
+++ b/src/analysis/processing/qgsalgorithmshortestpathlayertopoint.cpp
@@ -79,9 +79,9 @@ QVariantMap QgsShortestPathLayerToPointAlgorithm::processAlgorithm( const QVaria
     throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "START_POINTS" ) ) );
 
   QgsFields fields = startPoints->fields();
-  fields.append( QgsField( QStringLiteral( "start" ), QVariant::String ) );
-  fields.append( QgsField( QStringLiteral( "end" ), QVariant::String ) );
-  fields.append( QgsField( QStringLiteral( "cost" ), QVariant::Double ) );
+  fields.append( QgsField( QStringLiteral( "start" ), QMetaType::Type::QString ) );
+  fields.append( QgsField( QStringLiteral( "end" ), QMetaType::Type::QString ) );
+  fields.append( QgsField( QStringLiteral( "cost" ), QMetaType::Type::Double ) );
 
   QString dest;
   std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::LineString, mNetwork->sourceCrs() ) );
diff --git a/src/analysis/processing/qgsalgorithmshortestpathpointtolayer.cpp b/src/analysis/processing/qgsalgorithmshortestpathpointtolayer.cpp
index e6b2e902a06..dc2662bbca8 100644
--- a/src/analysis/processing/qgsalgorithmshortestpathpointtolayer.cpp
+++ b/src/analysis/processing/qgsalgorithmshortestpathpointtolayer.cpp
@@ -79,9 +79,9 @@ QVariantMap QgsShortestPathPointToLayerAlgorithm::processAlgorithm( const QVaria
     throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "END_POINTS" ) ) );
 
   QgsFields fields = endPoints->fields();
-  fields.append( QgsField( QStringLiteral( "start" ), QVariant::String ) );
-  fields.append( QgsField( QStringLiteral( "end" ), QVariant::String ) );
-  fields.append( QgsField( QStringLiteral( "cost" ), QVariant::Double ) );
+  fields.append( QgsField( QStringLiteral( "start" ), QMetaType::Type::QString ) );
+  fields.append( QgsField( QStringLiteral( "end" ), QMetaType::Type::QString ) );
+  fields.append( QgsField( QStringLiteral( "cost" ), QMetaType::Type::Double ) );
 
   QString dest;
   std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::LineString, mNetwork->sourceCrs(), QgsFeatureSink::RegeneratePrimaryKey ) );
diff --git a/src/analysis/processing/qgsalgorithmshortestpathpointtopoint.cpp b/src/analysis/processing/qgsalgorithmshortestpathpointtopoint.cpp
index 11939b34405..a79911ec7ca 100644
--- a/src/analysis/processing/qgsalgorithmshortestpathpointtopoint.cpp
+++ b/src/analysis/processing/qgsalgorithmshortestpathpointtopoint.cpp
@@ -67,9 +67,9 @@ QVariantMap QgsShortestPathPointToPointAlgorithm::processAlgorithm( const QVaria
   loadCommonParams( parameters, context, feedback );
 
   QgsFields fields;
-  fields.append( QgsField( QStringLiteral( "start" ), QVariant::String ) );
-  fields.append( QgsField( QStringLiteral( "end" ), QVariant::String ) );
-  fields.append( QgsField( QStringLiteral( "cost" ), QVariant::Double ) );
+  fields.append( QgsField( QStringLiteral( "start" ), QMetaType::Type::QString ) );
+  fields.append( QgsField( QStringLiteral( "end" ), QMetaType::Type::QString ) );
+  fields.append( QgsField( QStringLiteral( "cost" ), QMetaType::Type::Double ) );
 
   QString dest;
   std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::LineString, mNetwork->sourceCrs() ) );
diff --git a/src/analysis/processing/qgsalgorithmsplitfeaturesbyattributecharacter.cpp b/src/analysis/processing/qgsalgorithmsplitfeaturesbyattributecharacter.cpp
index ede3c0b04fd..ea582b8460d 100644
--- a/src/analysis/processing/qgsalgorithmsplitfeaturesbyattributecharacter.cpp
+++ b/src/analysis/processing/qgsalgorithmsplitfeaturesbyattributecharacter.cpp
@@ -101,7 +101,7 @@ QgsFields QgsSplitFeaturesByAttributeCharacterAlgorithm::outputFields( const Qgs
     else
     {
       // we need to convert the split field to a string field
-      outputFields.append( QgsField( inputFields.at( i ).name(), QVariant::String ) );
+      outputFields.append( QgsField( inputFields.at( i ).name(), QMetaType::Type::QString ) );
     }
   }
   return outputFields;
diff --git a/src/analysis/processing/qgsalgorithmsumlinelength.cpp b/src/analysis/processing/qgsalgorithmsumlinelength.cpp
index 6df45b11244..c75cb21bfe1 100644
--- a/src/analysis/processing/qgsalgorithmsumlinelength.cpp
+++ b/src/analysis/processing/qgsalgorithmsumlinelength.cpp
@@ -159,11 +159,11 @@ QgsFields QgsSumLineLengthAlgorithm::outputFields( const QgsFields &inputFields
     QgsFields outFields = inputFields;
     mLengthFieldIndex = inputFields.lookupField( mLengthFieldName );
     if ( mLengthFieldIndex < 0 )
-      outFields.append( QgsField( mLengthFieldName, QVariant::Double ) );
+      outFields.append( QgsField( mLengthFieldName, QMetaType::Type::Double ) );
 
     mCountFieldIndex = inputFields.lookupField( mCountFieldName );
     if ( mCountFieldIndex < 0 )
-      outFields.append( QgsField( mCountFieldName, QVariant::Double ) );
+      outFields.append( QgsField( mCountFieldName, QMetaType::Type::Double ) );
 
     mFields = outFields;
     return outFields;
diff --git a/src/analysis/processing/qgsalgorithmtinmeshcreation.cpp b/src/analysis/processing/qgsalgorithmtinmeshcreation.cpp
index 2826f8358a3..a053d571e50 100644
--- a/src/analysis/processing/qgsalgorithmtinmeshcreation.cpp
+++ b/src/analysis/processing/qgsalgorithmtinmeshcreation.cpp
@@ -88,7 +88,7 @@ void QgsTinMeshCreationAlgorithm::initAlgorithm( const QVariantMap &configuratio
 bool QgsTinMeshCreationAlgorithm::prepareAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
 {
   const QVariant layersVariant = parameters.value( parameterDefinition( QStringLiteral( "SOURCE_DATA" ) )->name() );
-  if ( layersVariant.type() != QVariant::List )
+  if ( layersVariant.userType() != QMetaType::Type::QVariantList )
     return false;
 
   const QVariantList layersList = layersVariant.toList();
@@ -102,7 +102,7 @@ bool QgsTinMeshCreationAlgorithm::prepareAlgorithm( const QVariantMap &parameter
     if ( feedback && feedback->isCanceled() )
       return false;
 
-    if ( layer.type() != QVariant::Map )
+    if ( layer.userType() != QMetaType::Type::QVariantMap )
       continue;
     const QVariantMap layerMap = layer.toMap();
     const QString layerSource = layerMap.value( QStringLiteral( "source" ) ).toString();
diff --git a/src/analysis/processing/qgsalgorithmtransect.cpp b/src/analysis/processing/qgsalgorithmtransect.cpp
index d2cb70d41de..cf6a35b8346 100644
--- a/src/analysis/processing/qgsalgorithmtransect.cpp
+++ b/src/analysis/processing/qgsalgorithmtransect.cpp
@@ -116,12 +116,12 @@ QVariantMap QgsTransectAlgorithm::processAlgorithm( const QVariantMap &parameter
 
   QgsFields fields = source->fields();
 
-  fields.append( QgsField( QStringLiteral( "TR_FID" ), QVariant::Int, QString(), 20 ) );
-  fields.append( QgsField( QStringLiteral( "TR_ID" ), QVariant::Int, QString(), 20 ) );
-  fields.append( QgsField( QStringLiteral( "TR_SEGMENT" ), QVariant::Int, QString(), 20 ) );
-  fields.append( QgsField( QStringLiteral( "TR_ANGLE" ), QVariant::Double, QString(), 5, 2 ) );
-  fields.append( QgsField( QStringLiteral( "TR_LENGTH" ), QVariant::Double, QString(), 20, 6 ) );
-  fields.append( QgsField( QStringLiteral( "TR_ORIENT" ), QVariant::Int, QString(), 1 ) );
+  fields.append( QgsField( QStringLiteral( "TR_FID" ), QMetaType::Type::Int, QString(), 20 ) );
+  fields.append( QgsField( QStringLiteral( "TR_ID" ), QMetaType::Type::Int, QString(), 20 ) );
+  fields.append( QgsField( QStringLiteral( "TR_SEGMENT" ), QMetaType::Type::Int, QString(), 20 ) );
+  fields.append( QgsField( QStringLiteral( "TR_ANGLE" ), QMetaType::Type::Double, QString(), 5, 2 ) );
+  fields.append( QgsField( QStringLiteral( "TR_LENGTH" ), QMetaType::Type::Double, QString(), 20, 6 ) );
+  fields.append( QgsField( QStringLiteral( "TR_ORIENT" ), QMetaType::Type::Int, QString(), 1 ) );
 
   Qgis::WkbType outputWkb = Qgis::WkbType::LineString;
   if ( QgsWkbTypes::hasZ( source->wkbType() ) )
diff --git a/src/analysis/processing/qgsalgorithmuniquevalueindex.cpp b/src/analysis/processing/qgsalgorithmuniquevalueindex.cpp
index b94361ee18d..c28e3125b9a 100644
--- a/src/analysis/processing/qgsalgorithmuniquevalueindex.cpp
+++ b/src/analysis/processing/qgsalgorithmuniquevalueindex.cpp
@@ -84,7 +84,7 @@ QVariantMap QgsAddUniqueValueIndexAlgorithm::processAlgorithm( const QVariantMap
 
   const QString newFieldName = parameterAsString( parameters, QStringLiteral( "FIELD_NAME" ), context );
   QgsFields fields = source->fields();
-  const QgsField newField = QgsField( newFieldName, QVariant::Int );
+  const QgsField newField = QgsField( newFieldName, QMetaType::Type::Int );
   fields.append( newField );
 
   QString dest;
diff --git a/src/analysis/processing/qgsalgorithmvectorize.cpp b/src/analysis/processing/qgsalgorithmvectorize.cpp
index 59f20f6869d..aeb8f1bff40 100644
--- a/src/analysis/processing/qgsalgorithmvectorize.cpp
+++ b/src/analysis/processing/qgsalgorithmvectorize.cpp
@@ -69,7 +69,7 @@ QVariantMap QgsVectorizeAlgorithmBase::processAlgorithm( const QVariantMap &para
 {
   const QString fieldName = parameterAsString( parameters, QStringLiteral( "FIELD_NAME" ), context );
   QgsFields fields;
-  fields.append( QgsField( fieldName, QVariant::Double, QString(), 20, 8 ) );
+  fields.append( QgsField( fieldName, QMetaType::Type::Double, QString(), 20, 8 ) );
 
   QString dest;
   std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, sinkType(), mCrs ) );
diff --git a/src/analysis/processing/qgsalgorithmvoronoipolygons.cpp b/src/analysis/processing/qgsalgorithmvoronoipolygons.cpp
index 5d5da6bb822..ffd95e63225 100644
--- a/src/analysis/processing/qgsalgorithmvoronoipolygons.cpp
+++ b/src/analysis/processing/qgsalgorithmvoronoipolygons.cpp
@@ -197,7 +197,7 @@ QString QgsVoronoiPolygonsAlgorithm::voronoiWithAttributes( const QVariantMap &p
 QString QgsVoronoiPolygonsAlgorithm::voronoiWithoutAttributes( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
 {
   QgsFields fields;
-  fields.append( QgsField( QStringLiteral( "id" ), QVariant::LongLong ) );
+  fields.append( QgsField( QStringLiteral( "id" ), QMetaType::Type::LongLong ) );
 
   QString dest;
   std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Polygon, mSource->sourceCrs() ) );
diff --git a/src/analysis/processing/qgsalgorithmzonalhistogram.cpp b/src/analysis/processing/qgsalgorithmzonalhistogram.cpp
index 959bff6a578..11a965925b3 100644
--- a/src/analysis/processing/qgsalgorithmzonalhistogram.cpp
+++ b/src/analysis/processing/qgsalgorithmzonalhistogram.cpp
@@ -170,7 +170,7 @@ QVariantMap QgsZonalHistogramAlgorithm::processAlgorithm( const QVariantMap &par
   QgsFields newFields;
   for ( auto it = uniqueValues.constBegin(); it != uniqueValues.constEnd(); ++it )
   {
-    newFields.append( QgsField( QStringLiteral( "%1%2" ).arg( fieldPrefix, mHasNoDataValue && *it == mNodataValue ? QStringLiteral( "NODATA" ) : QString::number( *it ) ), QVariant::LongLong, QString(), -1, 0 ) );
+    newFields.append( QgsField( QStringLiteral( "%1%2" ).arg( fieldPrefix, mHasNoDataValue && *it == mNodataValue ? QStringLiteral( "NODATA" ) : QString::number( *it ) ), QMetaType::Type::LongLong, QString(), -1, 0 ) );
   }
   const QgsFields fields = QgsProcessingUtils::combineFields( zones->fields(), newFields );
 
diff --git a/src/analysis/processing/qgsalgorithmzonalstatisticsfeaturebased.cpp b/src/analysis/processing/qgsalgorithmzonalstatisticsfeaturebased.cpp
index 0968213ad84..7171e57763e 100644
--- a/src/analysis/processing/qgsalgorithmzonalstatisticsfeaturebased.cpp
+++ b/src/analysis/processing/qgsalgorithmzonalstatisticsfeaturebased.cpp
@@ -144,7 +144,7 @@ bool QgsZonalStatisticsFeatureBasedAlgorithm::prepareAlgorithm( const QVariantMa
   {
     if ( mStats & stat )
     {
-      const QgsField field = QgsField( mPrefix + QgsZonalStatistics::shortName( stat ), QVariant::Double, QStringLiteral( "double precision" ) );
+      const QgsField field = QgsField( mPrefix + QgsZonalStatistics::shortName( stat ), QMetaType::Type::Double, QStringLiteral( "double precision" ) );
       if ( mOutputFields.names().contains( field.name() ) )
       {
         throw QgsProcessingException( QObject::tr( "Field %1 already exists" ).arg( field.name() ) );
diff --git a/src/analysis/processing/qgsbookmarkalgorithms.cpp b/src/analysis/processing/qgsbookmarkalgorithms.cpp
index b883bdc9947..a70ed1dd054 100644
--- a/src/analysis/processing/qgsbookmarkalgorithms.cpp
+++ b/src/analysis/processing/qgsbookmarkalgorithms.cpp
@@ -108,8 +108,8 @@ QVariantMap QgsBookmarksToLayerAlgorithm::processAlgorithm( const QVariantMap &p
 {
   const QgsCoordinateReferenceSystem crs = parameterAsCrs( parameters, QStringLiteral( "CRS" ), context );
   QgsFields fields;
-  fields.append( QgsField( QStringLiteral( "name" ), QVariant::String ) );
-  fields.append( QgsField( QStringLiteral( "group" ), QVariant::String ) );
+  fields.append( QgsField( QStringLiteral( "name" ), QMetaType::Type::QString ) );
+  fields.append( QgsField( QStringLiteral( "group" ), QMetaType::Type::QString ) );
   QString dest;
   std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Polygon, crs ) );
   if ( !sink )
diff --git a/src/analysis/vector/qgszonalstatistics.cpp b/src/analysis/vector/qgszonalstatistics.cpp
index 6e9b43213d9..a30ffe8f9c3 100644
--- a/src/analysis/vector/qgszonalstatistics.cpp
+++ b/src/analysis/vector/qgszonalstatistics.cpp
@@ -100,7 +100,7 @@ Qgis::ZonalStatisticResult QgsZonalStatistics::calculateStatistics( QgsFeedback
     if ( mStatistics & stat )
     {
       QString fieldName = getUniqueFieldName( mAttributePrefix + QgsZonalStatistics::shortName( stat ), newFieldList );
-      QgsField field( fieldName, QVariant::Double, QStringLiteral( "double precision" ) );
+      QgsField field( fieldName, QMetaType::Type::Double, QStringLiteral( "double precision" ) );
       newFieldList.push_back( field );
       statFieldIndexes.insert( stat, oldFieldCount + newFieldList.count() - 1 );
     }