diff --git a/src/PythonQtClassInfo.cpp b/src/PythonQtClassInfo.cpp
index 5e17f0d11..9e4524a6a 100644
--- a/src/PythonQtClassInfo.cpp
+++ b/src/PythonQtClassInfo.cpp
@@ -102,7 +102,7 @@ void PythonQtClassInfo::setupCPPObject(const QByteArray& classname)
 {
   _isQObject = false;
   _wrappedClassName = classname;
-  _metaTypeId = QMetaType::type(classname);
+  _metaTypeId = PythonQtUtils::metaTypeIdFromTypeName(classname);
   if (_metaTypeId == 0) {
     _metaTypeId = -1;
   }
diff --git a/src/PythonQtConversion.cpp b/src/PythonQtConversion.cpp
index ca1313743..455a0d2dc 100644
--- a/src/PythonQtConversion.cpp
+++ b/src/PythonQtConversion.cpp
@@ -270,7 +270,7 @@ PyObject* PythonQtConv::convertQtValueToPythonInternal(int type, const void* dat
      default:
        // check if we have a QList of pointers, which we can circumvent with a QList<void*>
        if (info.isQList && (info.innerNamePointerCount == 1)) {
-         static int id = QMetaType::type("QList<void*>");
+         static int id = PythonQtUtils::metaTypeIdFromTypeName("QList<void*>");
          PythonQtArgumentFrame_ADD_VARIANT_VALUE_BY_ID(frame, id, ptr);
          // return the constData pointer that will be filled with the result value later on
          ptr = (void*)((QVariant*)ptr)->constData();
@@ -311,10 +311,10 @@ void* PythonQtConv::handlePythonToQtAutoConversion(int typeId, PyObject* obj, vo
 {
   void* ptr = alreadyAllocatedCPPObject;
 
-  static int penId = QMetaType::type("QPen");
-  static int brushId = QMetaType::type("QBrush");
-  static int cursorId = QMetaType::type("QCursor");
-  static int colorId = QMetaType::type("QColor");
+  static int penId = PythonQtUtils::metaTypeIdFromTypeName("QPen");
+  static int brushId = PythonQtUtils::metaTypeIdFromTypeName("QBrush");
+  static int cursorId = PythonQtUtils::metaTypeIdFromTypeName("QCursor");
+  static int colorId = PythonQtUtils::metaTypeIdFromTypeName("QColor");
   static PyObject* qtGlobalColorEnum = PythonQtClassInfo::findEnumWrapper("Qt::GlobalColor", nullptr);
   if (typeId == cursorId) {
     static PyObject* qtCursorShapeEnum = PythonQtClassInfo::findEnumWrapper("Qt::CursorShape", nullptr);
@@ -728,7 +728,7 @@ void* PythonQtConv::ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& i
          if (info.typeId == PythonQtMethodInfo::Unknown || info.typeId >= QMetaType::User) {
            // check for QList<AnyPtr*> case, where we will use a QList<void*> QVariant
            if (info.isQList && (info.innerNamePointerCount == 1)) {
-             static int id = QMetaType::type("QList<void*>");
+             static int id = PythonQtUtils::metaTypeIdFromTypeName("QList<void*>");
              if (!alreadyAllocatedCPPObject) {
                PythonQtArgumentFrame_ADD_VARIANT_VALUE_BY_ID_IF_NEEDED(alreadyAllocatedCPPObject, frame, id, ptr);
                ptr = (void*)((QVariant*)ptr)->constData();
@@ -1094,22 +1094,22 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
     ) {
     // no special type requested
     if (val == nullptr) {
-      type = QVariant::Invalid;
+      type = QMetaType::UnknownType; // Equivalent to QVariant::Invalid or unregistered type
     } else if (PyBytes_Check(val)) {
 #ifdef PY3K
       // In Python 3, it is a ByteArray
-      type = QVariant::ByteArray;
+      type = QMetaType::QByteArray;
 #else
       // In Python 2, we need to use String, since it might be a string
-      type = QVariant::String;
+      type = QMetaType::QString;
 #endif
     } else if (PyUnicode_Check(val)) {
-      type = QVariant::String;
+      type = QMetaType::QString;
     } else if (val == Py_False || val == Py_True) {
-      type = QVariant::Bool;
+      type = QMetaType::Bool;
 #ifndef PY3K
     } else if (PyObject_TypeCheck(val, &PyInt_Type)) {
-      type = QVariant::Int;
+      type = QMetaType::Int;
 #endif
     } else if (PyLong_Check(val)) {
       // return int if the value fits into that range,
@@ -1117,12 +1117,12 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
       qint64 d = PyLong_AsLongLong(val);
       if (d > std::numeric_limits<int>::max() ||
           d < std::numeric_limits<int>::min()) {
-        type = QVariant::LongLong;
+        type = QMetaType::LongLong;
       } else {
-        type = QVariant::Int;
+        type = QMetaType::Int;
       }
     } else if (PyFloat_Check(val)) {
-      type = QVariant::Double;
+      type = QMetaType::Double;
     } else if (PyObject_TypeCheck(val, &PythonQtInstanceWrapper_Type)) {
       PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)val;
       // c++ wrapper, check if the class names of the c++ objects match
@@ -1144,11 +1144,11 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
       return v;
     } else if (val == Py_None) {
       // none is invalid
-      type = QVariant::Invalid;
+      type = QMetaType::UnknownType; // Equivalent to QVariant::Invalid or unregistered type
     } else if (PyDict_Check(val)) {
-      type = QVariant::Map;
+      type = QMetaType::QVariantMap;
     } else if (PyList_Check(val) || PyTuple_Check(val) || PySequence_Check(val)) {
-      type = QVariant::List;
+      type = QMetaType::QVariantList;
     } else {
       // transport the Python objects directly inside of QVariant:
       v = PythonQtObjectPtr(val).toVariant();
@@ -1157,28 +1157,28 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
   }
   // special type request:
   switch (type) {
-  case QVariant::Invalid:
+  case QMetaType::UnknownType: // Equivalent to QVariant::Invalid or unregistered type
     return v;
     break;
-  case QVariant::Int:
+  case QMetaType::Int:
     {
       int d = PyObjGetInt(val, false, ok);
       if (ok) return QVariant(d);
     }
     break;
-  case QVariant::UInt:
+  case QMetaType::UInt:
     {
       int d = PyObjGetInt(val, false,ok);
       if (ok) v = QVariant((unsigned int)d);
     }
     break;
-  case QVariant::Bool:
+  case QMetaType::Bool:
     {
       int d = PyObjGetBool(val,false,ok);
       if (ok) v =  QVariant((bool)(d!=0));
     }
     break;
-  case QVariant::Double:
+  case QMetaType::Double:
     {
       double d = PyObjGetDouble(val,false,ok);
       if (ok) v =  QVariant(d);
@@ -1239,7 +1239,7 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
     }
     break;
 
-  case QVariant::ByteArray:
+  case QMetaType::QByteArray:
     {
       bool ok;
 #ifdef PY3K
@@ -1249,20 +1249,20 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
 #endif
     }
     break;
-  case QVariant::String:
+  case QMetaType::QString:
     {
       bool ok;
       v = QVariant(PyObjGetString(val, false, ok));
     }
     break;
 
-  case QVariant::Map:
+  case QMetaType::QVariantMap:
     pythonToMapVariant<QVariantMap>(val, v);
     break;
-  case QVariant::Hash:
+  case QMetaType::QVariantHash:
     pythonToMapVariant<QVariantHash>(val, v);
     break;
-  case QVariant::List:
+  case QMetaType::QVariantList:
   {
     bool isListOrTuple = PyList_Check(val) || PyTuple_Check(val);
     if (isListOrTuple || PySequence_Check(val)) {
@@ -1288,7 +1288,7 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
     }
   }
     break;
-  case QVariant::StringList:
+  case QMetaType::QStringList:
     {
       bool ok;
       QStringList l = PyObjToStringList(val, false, ok);
@@ -1308,7 +1308,7 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
         // Try to convert the object to a QVariant based on the typeName
         bool ok;
         bool isPtr = false;
-        QByteArray typeName = QMetaType::typeName(type);
+        QByteArray typeName = QByteArray(PythonQtUtils::typeNameFromMetaTypeId(type));
         if (typeName.endsWith("*")) {
           isPtr = true;
           typeName.truncate(typeName.length() - 1);
@@ -1323,7 +1323,7 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
           }
         }
       }
-    } else if (static_cast<std::uint32_t>(type) >= QVariant::UserType) {
+    } else if (static_cast<std::uint32_t>(type) >= QMetaType::User) {
       // not an instance wrapper, but there might be other converters 
       // Maybe we have a special converter that is registered for that type:
       PythonQtConvertPythonToMetaTypeCB* converter = _pythonToMetaTypeConverters.value(type);
@@ -1505,66 +1505,66 @@ bool PythonQtConv::ConvertPythonListToQListOfPointerType(PyObject* obj, QList<vo
 QString PythonQtConv::CPPObjectToString(int type, const void* data) {
   QString r;
   switch (type) {
-    case QVariant::Size: {
+    case QMetaType::QSize: {
       const QSize* s = static_cast<const QSize*>(data);
       r = QString::number(s->width()) + ", " + QString::number(s->height());
       }
       break;
-    case QVariant::SizeF: {
+    case QMetaType::QSizeF: {
       const QSizeF* s = static_cast<const QSizeF*>(data);
       r = QString::number(s->width()) + ", " + QString::number(s->height());
       }
       break;
-    case QVariant::Point: {
+    case QMetaType::QPoint: {
       const QPoint* s = static_cast<const QPoint*>(data);
       r = QString::number(s->x()) + ", " + QString::number(s->y());
       }
       break;
-    case QVariant::PointF: {
+    case QMetaType::QPointF: {
       const QPointF* s = static_cast<const QPointF*>(data);
       r = QString::number(s->x()) + ", " + QString::number(s->y());
       }
       break;
-    case QVariant::Rect: {
+    case QMetaType::QRect: {
       const QRect* s = static_cast<const QRect*>(data);
       r = QString::number(s->x()) + ", " + QString::number(s->y());
       r += ", " + QString::number(s->width()) + ", " + QString::number(s->height());
       }
       break;
-    case QVariant::RectF: {
+    case QMetaType::QRectF: {
       const QRectF* s = static_cast<const QRectF*>(data);
       r = QString::number(s->x()) + ", " + QString::number(s->y());
       r += ", " + QString::number(s->width()) + ", " + QString::number(s->height());
       }
       break;
-    case QVariant::Date: {
+    case QMetaType::QDate: {
       const QDate* s = static_cast<const QDate*>(data);
       r = s->toString(Qt::ISODate);
       }
       break;
-    case QVariant::DateTime: {
+    case QMetaType::QDateTime: {
       const QDateTime* s = static_cast<const QDateTime*>(data);
       r = s->toString(Qt::ISODate);
       }
       break;
-    case QVariant::Time: {
+    case QMetaType::QTime: {
       const QTime* s = static_cast<const QTime*>(data);
       r = s->toString(Qt::ISODate);
     }
       break;
-    case QVariant::Pixmap:
+    case QMetaType::QPixmap:
     {
       const QPixmap* s = static_cast<const QPixmap*>(data);
       r = QString("Pixmap ") + QString::number(s->width()) + ", " + QString::number(s->height());
     }
       break;
-    case QVariant::Image:
+    case QMetaType::QImage:
     {
       const QImage* s = static_cast<const QImage*>(data);
       r = QString("Image ") + QString::number(s->width()) + ", " + QString::number(s->height());
     }
       break;
-    case QVariant::Url:
+    case QMetaType::QUrl:
       {
         const QUrl* s = static_cast<const QUrl*>(data);
         r = s->toString();
@@ -1574,7 +1574,7 @@ QString PythonQtConv::CPPObjectToString(int type, const void* data) {
     default:
       // this creates a copy, but that should not be expensive for typical simple variants
       // (but we do not want to do this for our own user types!)
-      if (type>0 && type < (int)QVariant::UserType) {
+      if (type>0 && type < (int)QMetaType::User) {
         r = variantFromType(type, data).toString();
       }
   }
@@ -1584,13 +1584,15 @@ QString PythonQtConv::CPPObjectToString(int type, const void* data) {
 PyObject* PythonQtConv::createCopyFromMetaType( int type, const void* data )
 {
   // if the type is known, we can construct it via QMetaType::construct
-#if( QT_VERSION >= QT_VERSION_CHECK(5,0,0) )
+#if QT_VERSION >= QT_VERSION_CHECK(6,0,0)
+  void* newCPPObject = QMetaType(type).create(data);
+#elif QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
   void* newCPPObject = QMetaType::create(type, data);
 #else
   void* newCPPObject = QMetaType::construct(type, data);
 #endif
   // XXX this could be optimized by using metatypeid directly
-  PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)PythonQt::priv()->wrapPtr(newCPPObject, QMetaType::typeName(type));
+  PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)PythonQt::priv()->wrapPtr(newCPPObject, QByteArray(PythonQtUtils::typeNameFromMetaTypeId(type)));
   wrap->_ownedByPythonQt = true;
   wrap->_useQMetaTypeDestroy = true;
   return (PyObject*)wrap;
diff --git a/src/PythonQtConversion.h b/src/PythonQtConversion.h
index d0f0eeb16..56fc11471 100644
--- a/src/PythonQtConversion.h
+++ b/src/PythonQtConversion.h
@@ -237,9 +237,9 @@ template<class ListType, class T>
 PyObject* PythonQtConvertListOfValueTypeToPythonList(const void* /*QList<T>* */ inList, int metaTypeId)
 {
   ListType* list = (ListType*)inList;
-  static const int innerType = PythonQtMethodInfo::getInnerTemplateMetaType(QByteArray(QMetaType::typeName(metaTypeId)));
-  if (innerType == QVariant::Invalid) {
-    std::cerr << "PythonQtConvertListOfValueTypeToPythonList: unknown inner type " << QMetaType::typeName(metaTypeId) << std::endl;
+  static const int innerType = PythonQtMethodInfo::getInnerTemplateMetaType(QByteArray(PythonQtUtils::typeNameFromMetaTypeId(metaTypeId)));
+  if (innerType == QMetaType::UnknownType) {
+    std::cerr << "PythonQtConvertListOfValueTypeToPythonList: unknown inner type " << PythonQtUtils::typeNameFromMetaTypeId(metaTypeId) << std::endl;
   }
   PyObject* result = PyTuple_New(list->size());
   int i = 0;
@@ -254,9 +254,9 @@ template<class ListType, class T>
 bool PythonQtConvertPythonListToListOfValueType(PyObject* obj, void* /*QList<T>* */ outList, int metaTypeId, bool /*strict*/)
 {
   ListType* list = (ListType*)outList;
-  static const int innerType = PythonQtMethodInfo::getInnerTemplateMetaType(QByteArray(QMetaType::typeName(metaTypeId)));
-  if (innerType == QVariant::Invalid) {
-    std::cerr << "PythonQtConvertPythonListToListOfValueType: unknown inner type " << QMetaType::typeName(metaTypeId) << std::endl;
+  static const int innerType = PythonQtMethodInfo::getInnerTemplateMetaType(QByteArray(PythonQtUtils::typeNameFromMetaTypeId(metaTypeId)));
+  if (innerType == QMetaType::UnknownType) {
+    std::cerr << "PythonQtConvertPythonListToListOfValueType: unknown inner type " << PythonQtUtils::typeNameFromMetaTypeId(metaTypeId) << std::endl;
   }
   bool result = false;
   if (PySequence_Check(obj)) {
@@ -287,9 +287,9 @@ template<class ListType, class T>
 PyObject* PythonQtConvertListOfKnownClassToPythonList(const void* /*QList<T>* */ inList, int metaTypeId)
 {
   ListType* list = (ListType*)inList;
-  static PythonQtClassInfo* innerType = PythonQt::priv()->getClassInfo(PythonQtMethodInfo::getInnerListTypeName(QByteArray(QMetaType::typeName(metaTypeId))));
+  static PythonQtClassInfo* innerType = PythonQt::priv()->getClassInfo(PythonQtMethodInfo::getInnerListTypeName(QByteArray(PythonQtUtils::typeNameFromMetaTypeId(metaTypeId))));
   if (innerType == nullptr) {
-    std::cerr << "PythonQtConvertListOfKnownClassToPythonList: unknown inner type for " << QMetaType::typeName(metaTypeId) << std::endl;
+    std::cerr << "PythonQtConvertListOfKnownClassToPythonList: unknown inner type for " << PythonQtUtils::typeNameFromMetaTypeId(metaTypeId) << std::endl;
   }
   PyObject* result = PyTuple_New(list->size());
   int i = 0;
@@ -307,9 +307,9 @@ template<class ListType, class T>
 bool PythonQtConvertPythonListToListOfKnownClass(PyObject* obj, void* /*QList<T>* */ outList, int metaTypeId, bool /*strict*/)
 {
   ListType* list = (ListType*)outList;
-  static PythonQtClassInfo* innerType = PythonQt::priv()->getClassInfo(PythonQtMethodInfo::getInnerListTypeName(QByteArray(QMetaType::typeName(metaTypeId))));
+  static PythonQtClassInfo* innerType = PythonQt::priv()->getClassInfo(PythonQtMethodInfo::getInnerListTypeName(QByteArray(PythonQtUtils::typeNameFromMetaTypeId(metaTypeId))));
   if (innerType == nullptr) {
-    std::cerr << "PythonQtConvertListOfKnownClassToPythonList: unknown inner type for " << QMetaType::typeName(metaTypeId) << std::endl;
+    std::cerr << "PythonQtConvertListOfKnownClassToPythonList: unknown inner type for " << PythonQtUtils::typeNameFromMetaTypeId(metaTypeId) << std::endl;
   }
   bool result = false;
   if (PySequence_Check(obj)) {
@@ -350,13 +350,13 @@ PyObject* PythonQtConvertPairToPython(const void* /*QPair<T1,T2>* */ inPair, int
   static int innerType1 = -1;
   static int innerType2 = -1;
   if (innerType1==-1) {
-    QByteArray innerTypes = PythonQtMethodInfo::getInnerTemplateTypeName(QByteArray(QMetaType::typeName(metaTypeId)));
+    QByteArray innerTypes = PythonQtMethodInfo::getInnerTemplateTypeName(QByteArray(PythonQtUtils::typeNameFromMetaTypeId(metaTypeId)));
     QList<QByteArray> names = innerTypes.split(',');
-    innerType1 = QMetaType::type(names.at(0).trimmed());
-    innerType2 = QMetaType::type(names.at(1).trimmed());
+    innerType1 = PythonQtUtils::metaTypeIdFromTypeName(names.at(0).trimmed());
+    innerType2 = PythonQtUtils::metaTypeIdFromTypeName(names.at(1).trimmed());
   }
-  if (innerType1 == QVariant::Invalid || innerType2 == QVariant::Invalid) {
-    std::cerr << "PythonQtConvertPairToPython: unknown inner type " << QMetaType::typeName(metaTypeId) << std::endl;
+  if (innerType1 == QMetaType::UnknownType || innerType2 == QMetaType::UnknownType) {
+    std::cerr << "PythonQtConvertPairToPython: unknown inner type " << PythonQtUtils::typeNameFromMetaTypeId(metaTypeId) << std::endl;
   }
   PyObject* result = PyTuple_New(2);
   PyTuple_SET_ITEM(result, 0, PythonQtConv::convertQtValueToPythonInternal(innerType1, &pair->first));
@@ -371,13 +371,13 @@ bool PythonQtConvertPythonToPair(PyObject* obj, void* /*QPair<T1,T2>* */ outPair
   static int innerType1 = -1;
   static int innerType2 = -1;
   if (innerType1 == -1) {
-    QByteArray innerTypes = PythonQtMethodInfo::getInnerTemplateTypeName(QByteArray(QMetaType::typeName(metaTypeId)));
+    QByteArray innerTypes = PythonQtMethodInfo::getInnerTemplateTypeName(QByteArray(PythonQtUtils::typeNameFromMetaTypeId(metaTypeId)));
     QList<QByteArray> names = innerTypes.split(',');
-    innerType1 = QMetaType::type(names.at(0).trimmed());
-    innerType2 = QMetaType::type(names.at(1).trimmed());
+    innerType1 = PythonQtUtils::metaTypeIdFromTypeName(names.at(0).trimmed());
+    innerType2 = PythonQtUtils::metaTypeIdFromTypeName(names.at(1).trimmed());
   }
-  if (innerType1 == QVariant::Invalid || innerType2 == QVariant::Invalid) {
-    std::cerr << "PythonQtConvertPythonToPair: unknown inner type " << QMetaType::typeName(metaTypeId) << std::endl;
+  if (innerType1 == QMetaType::UnknownType || innerType2 == QMetaType::UnknownType) {
+    std::cerr << "PythonQtConvertPythonToPair: unknown inner type " << PythonQtUtils::typeNameFromMetaTypeId(metaTypeId) << std::endl;
   }
   bool result = false;
   if (PySequence_Check(obj)) {
@@ -416,9 +416,9 @@ template<class ListType, class T1, class T2>
 PyObject* PythonQtConvertListOfPairToPythonList(const void* /*QList<QPair<T1,T2> >* */ inList, int metaTypeId)
 {
   ListType* list = (ListType*)inList;
-  static int innerType = PythonQtMethodInfo::getInnerTemplateMetaType(QByteArray(QMetaType::typeName(metaTypeId)));
-  if (innerType == QVariant::Invalid) {
-    std::cerr << "PythonQtConvertListOfPairToPythonList: unknown inner type " << QMetaType::typeName(metaTypeId) << std::endl;
+  static int innerType = PythonQtMethodInfo::getInnerTemplateMetaType(QByteArray(PythonQtUtils::typeNameFromMetaTypeId(metaTypeId)));
+  if (innerType == QMetaType::UnknownType) {
+    std::cerr << "PythonQtConvertListOfPairToPythonList: unknown inner type " << PythonQtUtils::typeNameFromMetaTypeId(metaTypeId) << std::endl;
   }
   PyObject* result = PyTuple_New(list->size());
   int i = 0;
@@ -435,9 +435,9 @@ template<class ListType, class T1, class T2>
 bool PythonQtConvertPythonListToListOfPair(PyObject* obj, void* /*QList<QPair<T1,T2> >* */ outList, int metaTypeId, bool /*strict*/)
 {
   ListType* list = (ListType*)outList;
-  static int innerType = PythonQtMethodInfo::getInnerTemplateMetaType(QByteArray(QMetaType::typeName(metaTypeId)));
-  if (innerType == QVariant::Invalid) {
-    std::cerr << "PythonQtConvertPythonListToListOfPair: unknown inner type " << QMetaType::typeName(metaTypeId) << std::endl;
+  static int innerType = PythonQtMethodInfo::getInnerTemplateMetaType(QByteArray(PythonQtUtils::typeNameFromMetaTypeId(metaTypeId)));
+  if (innerType == QMetaType::UnknownType) {
+    std::cerr << "PythonQtConvertPythonListToListOfPair: unknown inner type " << PythonQtUtils::typeNameFromMetaTypeId(metaTypeId) << std::endl;
   }
   bool result = false;
   if (PySequence_Check(obj)) {
@@ -470,12 +470,12 @@ PyObject* PythonQtConvertIntegerMapToPython(const void* /*QMap<int, T>* */ inMap
   MapType* map = (MapType*)inMap;
   static int innerType = -1;
   if (innerType == -1) {
-    QByteArray innerTypes = PythonQtMethodInfo::getInnerTemplateTypeName(QByteArray(QMetaType::typeName(metaTypeId)));
+    QByteArray innerTypes = PythonQtMethodInfo::getInnerTemplateTypeName(QByteArray(PythonQtUtils::typeNameFromMetaTypeId(metaTypeId)));
     QList<QByteArray> names = innerTypes.split(',');
-    innerType = QMetaType::type(names.at(1).trimmed());
+    innerType = PythonQtUtils::metaTypeIdFromTypeName(names.at(1).trimmed());
   }
-  if (innerType == QVariant::Invalid) {
-    std::cerr << "PythonQtConvertIntegerMapToPython: unknown inner type " << QMetaType::typeName(metaTypeId) << std::endl;
+  if (innerType == QMetaType::UnknownType) {
+    std::cerr << "PythonQtConvertIntegerMapToPython: unknown inner type " << PythonQtUtils::typeNameFromMetaTypeId(metaTypeId) << std::endl;
   }
 
   PyObject* result = PyDict_New();
@@ -498,12 +498,12 @@ bool PythonQtConvertPythonToIntegerMap(PyObject* val, void* /*QMap<int, T>* */ o
   MapType* map = (MapType*)outMap;
   static int innerType = -1;
   if (innerType == -1) {
-    QByteArray innerTypes = PythonQtMethodInfo::getInnerTemplateTypeName(QByteArray(QMetaType::typeName(metaTypeId)));
+    QByteArray innerTypes = PythonQtMethodInfo::getInnerTemplateTypeName(QByteArray(PythonQtUtils::typeNameFromMetaTypeId(metaTypeId)));
     QList<QByteArray> names = innerTypes.split(',');
-    innerType = QMetaType::type(names.at(1).trimmed());
+    innerType = PythonQtUtils::metaTypeIdFromTypeName(names.at(1).trimmed());
   }
-  if (innerType == QVariant::Invalid) {
-    std::cerr << "PythonQtConvertPythonToIntegerMap: unknown inner type " << QMetaType::typeName(metaTypeId) << std::endl;
+  if (innerType == QMetaType::UnknownType) {
+    std::cerr << "PythonQtConvertPythonToIntegerMap: unknown inner type " << PythonQtUtils::typeNameFromMetaTypeId(metaTypeId) << std::endl;
   }
   bool result = false;
   if (PyMapping_Check(val)) {
diff --git a/src/PythonQtInstanceWrapper.cpp b/src/PythonQtInstanceWrapper.cpp
index c560810ab..11ca09d64 100644
--- a/src/PythonQtInstanceWrapper.cpp
+++ b/src/PythonQtInstanceWrapper.cpp
@@ -70,7 +70,11 @@ static void PythonQtInstanceWrapper_deleteObject(PythonQtInstanceWrapper* self,
       int type = self->classInfo()->metaTypeId();
       if (self->_useQMetaTypeDestroy && type>=0) {
         // use QMetaType to destroy the object
+#if QT_VERSION >= QT_VERSION_CHECK(6,0,0)
+        QMetaType(type).destroy(self->_wrappedPtr);
+#else
         QMetaType::destroy(type, self->_wrappedPtr);
+#endif
       } else {
         PythonQtSlotInfo* slot = self->classInfo()->destructor();
         if (slot) {
@@ -82,7 +86,11 @@ static void PythonQtInstanceWrapper_deleteObject(PythonQtInstanceWrapper* self,
         } else {
           if (type>=0) {
             // use QMetaType to destroy the object
+#if QT_VERSION >= QT_VERSION_CHECK(6,0,0)
+            QMetaType(type).destroy(self->_wrappedPtr);
+#else
             QMetaType::destroy(type, self->_wrappedPtr);
+#endif
           } else {
             // TODO: warn about not being able to destroy the object?
           }
@@ -482,7 +490,7 @@ static PyObject *PythonQtInstanceWrapper_getattro(PyObject *obj,PyObject *name)
   switch (member._type) {
   case PythonQtMemberInfo::Property:
     if (wrapper->_obj) {
-      if (member._property.userType() != QVariant::Invalid) {
+      if (member._property.userType() != QMetaType::UnknownType) {
 
         PythonQt::ProfilingCB* profilingCB = PythonQt::priv()->profilingCB();
         if (profilingCB) {
@@ -762,7 +770,7 @@ static PyObject * PythonQtInstanceWrapper_str(PyObject * obj)
   PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
 
   // QByteArray should be directly returned as a str
-  if (wrapper->classInfo()->metaTypeId()==QVariant::ByteArray) {
+  if (wrapper->classInfo()->metaTypeId() == QMetaType::QByteArray) {
     QByteArray* b = (QByteArray*) wrapper->_wrappedPtr;
 #ifdef PY3K
     // Note: In Python 2, this was used to access the data() of a byte array.
diff --git a/src/PythonQtMethodInfo.cpp b/src/PythonQtMethodInfo.cpp
index f428ce5f2..0653fee94 100644
--- a/src/PythonQtMethodInfo.cpp
+++ b/src/PythonQtMethodInfo.cpp
@@ -191,7 +191,7 @@ void PythonQtMethodInfo::fillParameterInfo(ParameterInfo& type, const QByteArray
 
     type.typeId = nameToType(name);
     if (type.typeId == Unknown) {
-      type.typeId = QMetaType::type(name.constData());
+      type.typeId = PythonQtUtils::metaTypeIdFromTypeName(name.constData());
 #if( QT_VERSION >= QT_VERSION_CHECK(5,0,0) )
       if (type.typeId == QMetaType::UnknownType) {
 #else
@@ -234,7 +234,7 @@ int PythonQtMethodInfo::getInnerTemplateMetaType(const QByteArray& typeName)
     int idx2 = typeName.lastIndexOf(">");
     if (idx2 > 0) {
       QByteArray innerType = typeName.mid(idx + 1, idx2 - idx - 1).trimmed();
-      return QMetaType::type(innerType.constData());
+      return PythonQtUtils::metaTypeIdFromTypeName(innerType.constData());
     }
   }
   return QMetaType::Void;
@@ -442,7 +442,7 @@ const PythonQtMethodInfo::ParameterInfo& PythonQtMethodInfo::getParameterInfoFor
     return it.value();
   }
   ParameterInfo info;
-  fillParameterInfo(info, QMetaType::typeName(type));
+  fillParameterInfo(info, QByteArray(PythonQtUtils::typeNameFromMetaTypeId(type)));
   _cachedParameterInfos.insert(type, info);
   return _cachedParameterInfos[type];
 }
diff --git a/src/PythonQtSlot.cpp b/src/PythonQtSlot.cpp
index 084df8706..a502be4b6 100644
--- a/src/PythonQtSlot.cpp
+++ b/src/PythonQtSlot.cpp
@@ -553,7 +553,7 @@ meth_get__doc__(PythonQtSlotFunctionObject * m, void * /*closure*/)
   } else if (returnType.startsWith("QHash<") || returnType.startsWith("QMap<") ||
     returnType == "QVariantMap" || returnType == "QVariantHash") {
     pyReturnType = "dict";
-  } else if (returnTypeId == QVariant::Bool) {
+  } else if (returnTypeId == QMetaType::Bool) {
     pyReturnType = "bool";
   } else if (returnTypeId == PythonQtMethodInfo::Variant) {
     pyReturnType = "object";
diff --git a/src/PythonQtUtils.h b/src/PythonQtUtils.h
index 50692d47b..4c908bd72 100644
--- a/src/PythonQtUtils.h
+++ b/src/PythonQtUtils.h
@@ -47,6 +47,7 @@
 
 #include <QByteArray>
 #include <QMetaMethod>
+#include <QMetaType>
 
 namespace PythonQtUtils
 {
@@ -89,6 +90,24 @@ namespace PythonQtUtils
 #else
     // support old-style classes and new style classes
     return (obj->ob_type == &PyClass_Type || obj->ob_type == &PyType_Type);
+#endif
+  }
+
+  //! Returns the meta type ID from a type name
+  inline int metaTypeIdFromTypeName(const QByteArray& className) {
+#if QT_VERSION >= QT_VERSION_CHECK(6,0,0)
+    return QMetaType::fromName(className.constData()).id();
+#else
+    return QMetaType::type(className.constData());
+#endif
+  }
+
+  //! Returns the type name from a meta type ID
+  inline const char * typeNameFromMetaTypeId(int metaTypeId) {
+#if QT_VERSION >= QT_VERSION_CHECK(6,0,0)
+    return QMetaType(metaTypeId).name();
+#else
+    return QMetaType::typeName(metaTypeId);
 #endif
   }
 }