diff --git a/scripts/mkqtdecl_common/produce.rb b/scripts/mkqtdecl_common/produce.rb
index 44e249175..0dbfb6a09 100755
--- a/scripts/mkqtdecl_common/produce.rb
+++ b/scripts/mkqtdecl_common/produce.rb
@@ -1784,6 +1784,9 @@ END
       m.find { |bd| bd.virtual && bd.type.init == "0" } != nil
     end
 
+    # gets the operator= if there is one
+    eq_op = (all_methods_by_name["operator="] || [])[0]
+
     # collect used enums in order to generate forward converter declarations
     # ("used" implies argument types and defined enums)
     used_ed = {}
@@ -2306,8 +2309,27 @@ END
     end
 
     if !is_child_class
+
+      # forward decl
+      @ext_decls << "#{struct.kind.to_s} #{cls};\n\n"
+
+      # type traits included ...
+      tt = "namespace tl { template <> struct type_traits<#{cls}> : public type_traits<void> {\n"
+      if !conf.has_copy_ctor?(cls) || is_abstract || (eq_op && eq_op.visibility == :private)
+        tt += "  typedef tl::false_tag has_copy_constructor;\n"
+      end
+      if !conf.has_default_ctor?(cls) || is_abstract
+        tt += "  typedef tl::false_tag has_default_constructor;\n"
+      end
+      if (dtor = struct.get_dtor) && dtor.visibility != :public
+        tt += "  typedef tl::false_tag has_public_destructor;\n"
+      end
+      tt += "}; }\n\n"
+      @ext_decls << tt
+
       # only for top-level classes external declarations are produced currently
-      @ext_decls << "#{struct.kind.to_s} #{cls};\nnamespace gsi { GSI_#{modn.upcase}_PUBLIC gsi::Class<#{cls}> &qtdecl_#{clsn} (); }\n\n"
+      @ext_decls << "namespace gsi { GSI_#{modn.upcase}_PUBLIC gsi::Class<#{cls}> &qtdecl_#{clsn} (); }\n\n"
+
     end
 
     ofile.puts("")
@@ -3170,6 +3192,7 @@ l.each_with_index do |decl_obj,i|
 end
 
 puts("Producing ..")
+
 if cls_list
   cls_list.split(",").each do |cs|
     bp.produce_cpp(conf, cs)
diff --git a/src/gsiqt/qt4/QtCore/gsiQtExternals.h b/src/gsiqt/qt4/QtCore/gsiQtExternals.h
index 0a84e8d8d..83b85324c 100644
--- a/src/gsiqt/qt4/QtCore/gsiQtExternals.h
+++ b/src/gsiqt/qt4/QtCore/gsiQtExternals.h
@@ -34,222 +34,569 @@
 #include "gsiQtCoreCommon.h"
 
 class QAbstractItemModel;
+
+namespace tl { template <> struct type_traits<QAbstractItemModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAbstractItemModel> &qtdecl_QAbstractItemModel (); }
 
 class QAbstractListModel;
+
+namespace tl { template <> struct type_traits<QAbstractListModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAbstractListModel> &qtdecl_QAbstractListModel (); }
 
 class QAbstractTableModel;
+
+namespace tl { template <> struct type_traits<QAbstractTableModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAbstractTableModel> &qtdecl_QAbstractTableModel (); }
 
 class QBasicTimer;
+
+namespace tl { template <> struct type_traits<QBasicTimer> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QBasicTimer> &qtdecl_QBasicTimer (); }
 
 class QBuffer;
+
+namespace tl { template <> struct type_traits<QBuffer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QBuffer> &qtdecl_QBuffer (); }
 
 class QByteArrayMatcher;
+
+namespace tl { template <> struct type_traits<QByteArrayMatcher> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QByteArrayMatcher> &qtdecl_QByteArrayMatcher (); }
 
 class QChildEvent;
+
+namespace tl { template <> struct type_traits<QChildEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QChildEvent> &qtdecl_QChildEvent (); }
 
 class QCoreApplication;
+
+namespace tl { template <> struct type_traits<QCoreApplication> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QCoreApplication> &qtdecl_QCoreApplication (); }
 
 class QCryptographicHash;
+
+namespace tl { template <> struct type_traits<QCryptographicHash> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QCryptographicHash> &qtdecl_QCryptographicHash (); }
 
 class QDataStream;
+
+namespace tl { template <> struct type_traits<QDataStream> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDataStream> &qtdecl_QDataStream (); }
 
 class QDate;
+
+namespace tl { template <> struct type_traits<QDate> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDate> &qtdecl_QDate (); }
 
 class QDateTime;
+
+namespace tl { template <> struct type_traits<QDateTime> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDateTime> &qtdecl_QDateTime (); }
 
 class QDir;
+
+namespace tl { template <> struct type_traits<QDir> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDir> &qtdecl_QDir (); }
 
 class QDynamicPropertyChangeEvent;
+
+namespace tl { template <> struct type_traits<QDynamicPropertyChangeEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDynamicPropertyChangeEvent> &qtdecl_QDynamicPropertyChangeEvent (); }
 
 class QEasingCurve;
+
+namespace tl { template <> struct type_traits<QEasingCurve> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QEasingCurve> &qtdecl_QEasingCurve (); }
 
 class QEvent;
+
+namespace tl { template <> struct type_traits<QEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QEvent> &qtdecl_QEvent (); }
 
 class QEventLoop;
+
+namespace tl { template <> struct type_traits<QEventLoop> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QEventLoop> &qtdecl_QEventLoop (); }
 
 struct QFactoryInterface;
+
+namespace tl { template <> struct type_traits<QFactoryInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QFactoryInterface> &qtdecl_QFactoryInterface (); }
 
 class QFile;
+
+namespace tl { template <> struct type_traits<QFile> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QFile> &qtdecl_QFile (); }
 
 class QFileInfo;
+
+namespace tl { template <> struct type_traits<QFileInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QFileInfo> &qtdecl_QFileInfo (); }
 
 class QFileSystemWatcher;
+
+namespace tl { template <> struct type_traits<QFileSystemWatcher> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QFileSystemWatcher> &qtdecl_QFileSystemWatcher (); }
 
 class QIODevice;
+
+namespace tl { template <> struct type_traits<QIODevice> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QIODevice> &qtdecl_QIODevice (); }
 
 class QLibrary;
+
+namespace tl { template <> struct type_traits<QLibrary> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QLibrary> &qtdecl_QLibrary (); }
 
 class QLibraryInfo;
+
+namespace tl { template <> struct type_traits<QLibraryInfo> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QLibraryInfo> &qtdecl_QLibraryInfo (); }
 
 class QLine;
+
+namespace tl { template <> struct type_traits<QLine> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QLine> &qtdecl_QLine (); }
 
 class QLineF;
+
+namespace tl { template <> struct type_traits<QLineF> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QLineF> &qtdecl_QLineF (); }
 
 class QLocale;
+
+namespace tl { template <> struct type_traits<QLocale> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QLocale> &qtdecl_QLocale (); }
 
 class QMargins;
+
+namespace tl { template <> struct type_traits<QMargins> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMargins> &qtdecl_QMargins (); }
 
 class QMetaClassInfo;
+
+namespace tl { template <> struct type_traits<QMetaClassInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMetaClassInfo> &qtdecl_QMetaClassInfo (); }
 
 class QMetaEnum;
+
+namespace tl { template <> struct type_traits<QMetaEnum> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMetaEnum> &qtdecl_QMetaEnum (); }
 
 class QMetaMethod;
+
+namespace tl { template <> struct type_traits<QMetaMethod> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMetaMethod> &qtdecl_QMetaMethod (); }
 
 struct QMetaObject;
+
+namespace tl { template <> struct type_traits<QMetaObject> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMetaObject> &qtdecl_QMetaObject (); }
 
 class QMetaProperty;
+
+namespace tl { template <> struct type_traits<QMetaProperty> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMetaProperty> &qtdecl_QMetaProperty (); }
 
 class QMetaType;
+
+namespace tl { template <> struct type_traits<QMetaType> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMetaType> &qtdecl_QMetaType (); }
 
 class QMimeData;
+
+namespace tl { template <> struct type_traits<QMimeData> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMimeData> &qtdecl_QMimeData (); }
 
 class QModelIndex;
+
+namespace tl { template <> struct type_traits<QModelIndex> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QModelIndex> &qtdecl_QModelIndex (); }
 
 class QMutex;
+
+namespace tl { template <> struct type_traits<QMutex> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMutex> &qtdecl_QMutex (); }
 
 class QObject;
+
+namespace tl { template <> struct type_traits<QObject> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QObject> &qtdecl_QObject (); }
 
 class QPersistentModelIndex;
+
+namespace tl { template <> struct type_traits<QPersistentModelIndex> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QPersistentModelIndex> &qtdecl_QPersistentModelIndex (); }
 
 class QPluginLoader;
+
+namespace tl { template <> struct type_traits<QPluginLoader> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QPluginLoader> &qtdecl_QPluginLoader (); }
 
 class QPoint;
+
+namespace tl { template <> struct type_traits<QPoint> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QPoint> &qtdecl_QPoint (); }
 
 class QPointF;
+
+namespace tl { template <> struct type_traits<QPointF> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QPointF> &qtdecl_QPointF (); }
 
 class QProcess;
+
+namespace tl { template <> struct type_traits<QProcess> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QProcess> &qtdecl_QProcess (); }
 
 class QProcessEnvironment;
+
+namespace tl { template <> struct type_traits<QProcessEnvironment> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QProcessEnvironment> &qtdecl_QProcessEnvironment (); }
 
 class QReadLocker;
+
+namespace tl { template <> struct type_traits<QReadLocker> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QReadLocker> &qtdecl_QReadLocker (); }
 
 class QReadWriteLock;
+
+namespace tl { template <> struct type_traits<QReadWriteLock> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QReadWriteLock> &qtdecl_QReadWriteLock (); }
 
 class QRect;
+
+namespace tl { template <> struct type_traits<QRect> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QRect> &qtdecl_QRect (); }
 
 class QRectF;
+
+namespace tl { template <> struct type_traits<QRectF> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QRectF> &qtdecl_QRectF (); }
 
 class QRegExp;
+
+namespace tl { template <> struct type_traits<QRegExp> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QRegExp> &qtdecl_QRegExp (); }
 
 class QResource;
+
+namespace tl { template <> struct type_traits<QResource> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QResource> &qtdecl_QResource (); }
 
 class QSemaphore;
+
+namespace tl { template <> struct type_traits<QSemaphore> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSemaphore> &qtdecl_QSemaphore (); }
 
 class QSettings;
+
+namespace tl { template <> struct type_traits<QSettings> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSettings> &qtdecl_QSettings (); }
 
 class QSignalMapper;
+
+namespace tl { template <> struct type_traits<QSignalMapper> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSignalMapper> &qtdecl_QSignalMapper (); }
 
 class QSize;
+
+namespace tl { template <> struct type_traits<QSize> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSize> &qtdecl_QSize (); }
 
 class QSizeF;
+
+namespace tl { template <> struct type_traits<QSizeF> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSizeF> &qtdecl_QSizeF (); }
 
 class QSocketNotifier;
+
+namespace tl { template <> struct type_traits<QSocketNotifier> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSocketNotifier> &qtdecl_QSocketNotifier (); }
 
 class QStringMatcher;
+
+namespace tl { template <> struct type_traits<QStringMatcher> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QStringMatcher> &qtdecl_QStringMatcher (); }
 
 class QSysInfo;
+
+namespace tl { template <> struct type_traits<QSysInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSysInfo> &qtdecl_QSysInfo (); }
 
 class QSystemLocale;
+
+namespace tl { template <> struct type_traits<QSystemLocale> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSystemLocale> &qtdecl_QSystemLocale (); }
 
 class QTemporaryFile;
+
+namespace tl { template <> struct type_traits<QTemporaryFile> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTemporaryFile> &qtdecl_QTemporaryFile (); }
 
 class QTextCodec;
+
+namespace tl { template <> struct type_traits<QTextCodec> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTextCodec> &qtdecl_QTextCodec (); }
 
 class QTextDecoder;
+
+namespace tl { template <> struct type_traits<QTextDecoder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTextDecoder> &qtdecl_QTextDecoder (); }
 
 class QTextEncoder;
+
+namespace tl { template <> struct type_traits<QTextEncoder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTextEncoder> &qtdecl_QTextEncoder (); }
 
 class QTextStream;
+
+namespace tl { template <> struct type_traits<QTextStream> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTextStream> &qtdecl_QTextStream (); }
 
 class QThread;
+
+namespace tl { template <> struct type_traits<QThread> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QThread> &qtdecl_QThread (); }
 
 class QTime;
+
+namespace tl { template <> struct type_traits<QTime> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTime> &qtdecl_QTime (); }
 
 class QTimeLine;
+
+namespace tl { template <> struct type_traits<QTimeLine> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTimeLine> &qtdecl_QTimeLine (); }
 
 class QTimer;
+
+namespace tl { template <> struct type_traits<QTimer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTimer> &qtdecl_QTimer (); }
 
 class QTimerEvent;
+
+namespace tl { template <> struct type_traits<QTimerEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTimerEvent> &qtdecl_QTimerEvent (); }
 
 class QTranslator;
+
+namespace tl { template <> struct type_traits<QTranslator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTranslator> &qtdecl_QTranslator (); }
 
 class QUrl;
+
+namespace tl { template <> struct type_traits<QUrl> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QUrl> &qtdecl_QUrl (); }
 
 class QWaitCondition;
+
+namespace tl { template <> struct type_traits<QWaitCondition> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QWaitCondition> &qtdecl_QWaitCondition (); }
 
 class QWriteLocker;
+
+namespace tl { template <> struct type_traits<QWriteLocker> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QWriteLocker> &qtdecl_QWriteLocker (); }
 
 
diff --git a/src/gsiqt/qt4/QtDesigner/gsiQtExternals.h b/src/gsiqt/qt4/QtDesigner/gsiQtExternals.h
index 57bef5200..26b07bd2c 100644
--- a/src/gsiqt/qt4/QtDesigner/gsiQtExternals.h
+++ b/src/gsiqt/qt4/QtDesigner/gsiQtExternals.h
@@ -34,9 +34,19 @@
 #include "gsiQtDesignerCommon.h"
 
 class QAbstractFormBuilder;
+
+namespace tl { template <> struct type_traits<QAbstractFormBuilder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTDESIGNER_PUBLIC gsi::Class<QAbstractFormBuilder> &qtdecl_QAbstractFormBuilder (); }
 
 class QFormBuilder;
+
+namespace tl { template <> struct type_traits<QFormBuilder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTDESIGNER_PUBLIC gsi::Class<QFormBuilder> &qtdecl_QFormBuilder (); }
 
 
diff --git a/src/gsiqt/qt4/QtGui/gsiQtExternals.h b/src/gsiqt/qt4/QtGui/gsiQtExternals.h
index 4512bb893..17bf60c09 100644
--- a/src/gsiqt/qt4/QtGui/gsiQtExternals.h
+++ b/src/gsiqt/qt4/QtGui/gsiQtExternals.h
@@ -34,1068 +34,2805 @@
 #include "gsiQtGuiCommon.h"
 
 class QAbstractButton;
+
+namespace tl { template <> struct type_traits<QAbstractButton> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAbstractButton> &qtdecl_QAbstractButton (); }
 
 class QAbstractGraphicsShapeItem;
+
+namespace tl { template <> struct type_traits<QAbstractGraphicsShapeItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAbstractGraphicsShapeItem> &qtdecl_QAbstractGraphicsShapeItem (); }
 
 class QAbstractItemDelegate;
+
+namespace tl { template <> struct type_traits<QAbstractItemDelegate> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAbstractItemDelegate> &qtdecl_QAbstractItemDelegate (); }
 
 class QAbstractItemView;
+
+namespace tl { template <> struct type_traits<QAbstractItemView> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAbstractItemView> &qtdecl_QAbstractItemView (); }
 
 class QAbstractPageSetupDialog;
+
+namespace tl { template <> struct type_traits<QAbstractPageSetupDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAbstractPageSetupDialog> &qtdecl_QAbstractPageSetupDialog (); }
 
 class QAbstractPrintDialog;
+
+namespace tl { template <> struct type_traits<QAbstractPrintDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAbstractPrintDialog> &qtdecl_QAbstractPrintDialog (); }
 
 class QAbstractProxyModel;
+
+namespace tl { template <> struct type_traits<QAbstractProxyModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAbstractProxyModel> &qtdecl_QAbstractProxyModel (); }
 
 class QAbstractScrollArea;
+
+namespace tl { template <> struct type_traits<QAbstractScrollArea> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAbstractScrollArea> &qtdecl_QAbstractScrollArea (); }
 
 class QAbstractSlider;
+
+namespace tl { template <> struct type_traits<QAbstractSlider> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAbstractSlider> &qtdecl_QAbstractSlider (); }
 
 class QAbstractSpinBox;
+
+namespace tl { template <> struct type_traits<QAbstractSpinBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAbstractSpinBox> &qtdecl_QAbstractSpinBox (); }
 
 class QAbstractTextDocumentLayout;
+
+namespace tl { template <> struct type_traits<QAbstractTextDocumentLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAbstractTextDocumentLayout> &qtdecl_QAbstractTextDocumentLayout (); }
 
 class QAbstractUndoItem;
+
+namespace tl { template <> struct type_traits<QAbstractUndoItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAbstractUndoItem> &qtdecl_QAbstractUndoItem (); }
 
 class QAccessible;
+
+namespace tl { template <> struct type_traits<QAccessible> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessible> &qtdecl_QAccessible (); }
 
 class QAccessibleApplication;
+
+namespace tl { template <> struct type_traits<QAccessibleApplication> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleApplication> &qtdecl_QAccessibleApplication (); }
 
 class QAccessibleEvent;
+
+namespace tl { template <> struct type_traits<QAccessibleEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleEvent> &qtdecl_QAccessibleEvent (); }
 
 class QAccessibleInterface;
+
+namespace tl { template <> struct type_traits<QAccessibleInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleInterface> &qtdecl_QAccessibleInterface (); }
 
 class QAccessibleObject;
+
+namespace tl { template <> struct type_traits<QAccessibleObject> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleObject> &qtdecl_QAccessibleObject (); }
 
 class QAccessibleWidget;
+
+namespace tl { template <> struct type_traits<QAccessibleWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleWidget> &qtdecl_QAccessibleWidget (); }
 
 class QAction;
+
+namespace tl { template <> struct type_traits<QAction> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAction> &qtdecl_QAction (); }
 
 class QActionEvent;
+
+namespace tl { template <> struct type_traits<QActionEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QActionEvent> &qtdecl_QActionEvent (); }
 
 class QActionGroup;
+
+namespace tl { template <> struct type_traits<QActionGroup> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QActionGroup> &qtdecl_QActionGroup (); }
 
 class QApplication;
+
+namespace tl { template <> struct type_traits<QApplication> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QApplication> &qtdecl_QApplication (); }
 
 class QBitmap;
+
+namespace tl { template <> struct type_traits<QBitmap> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QBitmap> &qtdecl_QBitmap (); }
 
 class QBoxLayout;
+
+namespace tl { template <> struct type_traits<QBoxLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QBoxLayout> &qtdecl_QBoxLayout (); }
 
 class QBrush;
+
+namespace tl { template <> struct type_traits<QBrush> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QBrush> &qtdecl_QBrush (); }
 
 class QButtonGroup;
+
+namespace tl { template <> struct type_traits<QButtonGroup> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QButtonGroup> &qtdecl_QButtonGroup (); }
 
 class QCDEStyle;
+
+namespace tl { template <> struct type_traits<QCDEStyle> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QCDEStyle> &qtdecl_QCDEStyle (); }
 
 class QCalendarWidget;
+
+namespace tl { template <> struct type_traits<QCalendarWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QCalendarWidget> &qtdecl_QCalendarWidget (); }
 
 class QCheckBox;
+
+namespace tl { template <> struct type_traits<QCheckBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QCheckBox> &qtdecl_QCheckBox (); }
 
 class QCleanlooksStyle;
+
+namespace tl { template <> struct type_traits<QCleanlooksStyle> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QCleanlooksStyle> &qtdecl_QCleanlooksStyle (); }
 
 class QClipboard;
+
+namespace tl { template <> struct type_traits<QClipboard> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QClipboard> &qtdecl_QClipboard (); }
 
 class QClipboardEvent;
+
+namespace tl { template <> struct type_traits<QClipboardEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QClipboardEvent> &qtdecl_QClipboardEvent (); }
 
 class QCloseEvent;
+
+namespace tl { template <> struct type_traits<QCloseEvent> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QCloseEvent> &qtdecl_QCloseEvent (); }
 
 class QColor;
+
+namespace tl { template <> struct type_traits<QColor> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QColor> &qtdecl_QColor (); }
 
 class QColorDialog;
+
+namespace tl { template <> struct type_traits<QColorDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QColorDialog> &qtdecl_QColorDialog (); }
 
 class QColormap;
+
+namespace tl { template <> struct type_traits<QColormap> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QColormap> &qtdecl_QColormap (); }
 
 class QColumnView;
+
+namespace tl { template <> struct type_traits<QColumnView> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QColumnView> &qtdecl_QColumnView (); }
 
 class QComboBox;
+
+namespace tl { template <> struct type_traits<QComboBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QComboBox> &qtdecl_QComboBox (); }
 
 class QCommandLinkButton;
+
+namespace tl { template <> struct type_traits<QCommandLinkButton> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QCommandLinkButton> &qtdecl_QCommandLinkButton (); }
 
 class QCommonStyle;
+
+namespace tl { template <> struct type_traits<QCommonStyle> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QCommonStyle> &qtdecl_QCommonStyle (); }
 
 class QCompleter;
+
+namespace tl { template <> struct type_traits<QCompleter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QCompleter> &qtdecl_QCompleter (); }
 
 class QConicalGradient;
+
+namespace tl { template <> struct type_traits<QConicalGradient> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QConicalGradient> &qtdecl_QConicalGradient (); }
 
 class QContextMenuEvent;
+
+namespace tl { template <> struct type_traits<QContextMenuEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QContextMenuEvent> &qtdecl_QContextMenuEvent (); }
 
 class QCursor;
+
+namespace tl { template <> struct type_traits<QCursor> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QCursor> &qtdecl_QCursor (); }
 
 class QDataWidgetMapper;
+
+namespace tl { template <> struct type_traits<QDataWidgetMapper> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDataWidgetMapper> &qtdecl_QDataWidgetMapper (); }
 
 class QDateEdit;
+
+namespace tl { template <> struct type_traits<QDateEdit> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDateEdit> &qtdecl_QDateEdit (); }
 
 class QDateTimeEdit;
+
+namespace tl { template <> struct type_traits<QDateTimeEdit> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDateTimeEdit> &qtdecl_QDateTimeEdit (); }
 
 class QDesktopServices;
+
+namespace tl { template <> struct type_traits<QDesktopServices> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDesktopServices> &qtdecl_QDesktopServices (); }
 
 class QDesktopWidget;
+
+namespace tl { template <> struct type_traits<QDesktopWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDesktopWidget> &qtdecl_QDesktopWidget (); }
 
 class QDial;
+
+namespace tl { template <> struct type_traits<QDial> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDial> &qtdecl_QDial (); }
 
 class QDialog;
+
+namespace tl { template <> struct type_traits<QDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDialog> &qtdecl_QDialog (); }
 
 class QDialogButtonBox;
+
+namespace tl { template <> struct type_traits<QDialogButtonBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDialogButtonBox> &qtdecl_QDialogButtonBox (); }
 
 class QDirIterator;
+
+namespace tl { template <> struct type_traits<QDirIterator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDirIterator> &qtdecl_QDirIterator (); }
 
 class QDirModel;
+
+namespace tl { template <> struct type_traits<QDirModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDirModel> &qtdecl_QDirModel (); }
 
 class QDockWidget;
+
+namespace tl { template <> struct type_traits<QDockWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDockWidget> &qtdecl_QDockWidget (); }
 
 class QDoubleSpinBox;
+
+namespace tl { template <> struct type_traits<QDoubleSpinBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDoubleSpinBox> &qtdecl_QDoubleSpinBox (); }
 
 class QDoubleValidator;
+
+namespace tl { template <> struct type_traits<QDoubleValidator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDoubleValidator> &qtdecl_QDoubleValidator (); }
 
 class QDrag;
+
+namespace tl { template <> struct type_traits<QDrag> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDrag> &qtdecl_QDrag (); }
 
 class QDragEnterEvent;
+
+namespace tl { template <> struct type_traits<QDragEnterEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDragEnterEvent> &qtdecl_QDragEnterEvent (); }
 
 class QDragLeaveEvent;
+
+namespace tl { template <> struct type_traits<QDragLeaveEvent> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDragLeaveEvent> &qtdecl_QDragLeaveEvent (); }
 
 class QDragMoveEvent;
+
+namespace tl { template <> struct type_traits<QDragMoveEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDragMoveEvent> &qtdecl_QDragMoveEvent (); }
 
 class QDragResponseEvent;
+
+namespace tl { template <> struct type_traits<QDragResponseEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDragResponseEvent> &qtdecl_QDragResponseEvent (); }
 
 class QDropEvent;
+
+namespace tl { template <> struct type_traits<QDropEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDropEvent> &qtdecl_QDropEvent (); }
 
 class QErrorMessage;
+
+namespace tl { template <> struct type_traits<QErrorMessage> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QErrorMessage> &qtdecl_QErrorMessage (); }
 
 class QFileDialog;
+
+namespace tl { template <> struct type_traits<QFileDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFileDialog> &qtdecl_QFileDialog (); }
 
 class QFileIconProvider;
+
+namespace tl { template <> struct type_traits<QFileIconProvider> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFileIconProvider> &qtdecl_QFileIconProvider (); }
 
 class QFileOpenEvent;
+
+namespace tl { template <> struct type_traits<QFileOpenEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFileOpenEvent> &qtdecl_QFileOpenEvent (); }
 
 class QFileSystemModel;
+
+namespace tl { template <> struct type_traits<QFileSystemModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFileSystemModel> &qtdecl_QFileSystemModel (); }
 
 class QFocusEvent;
+
+namespace tl { template <> struct type_traits<QFocusEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFocusEvent> &qtdecl_QFocusEvent (); }
 
 class QFocusFrame;
+
+namespace tl { template <> struct type_traits<QFocusFrame> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFocusFrame> &qtdecl_QFocusFrame (); }
 
 class QFont;
+
+namespace tl { template <> struct type_traits<QFont> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFont> &qtdecl_QFont (); }
 
 class QFontComboBox;
+
+namespace tl { template <> struct type_traits<QFontComboBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFontComboBox> &qtdecl_QFontComboBox (); }
 
 class QFontDatabase;
+
+namespace tl { template <> struct type_traits<QFontDatabase> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFontDatabase> &qtdecl_QFontDatabase (); }
 
 class QFontDialog;
+
+namespace tl { template <> struct type_traits<QFontDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFontDialog> &qtdecl_QFontDialog (); }
 
 class QFontInfo;
+
+namespace tl { template <> struct type_traits<QFontInfo> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFontInfo> &qtdecl_QFontInfo (); }
 
 class QFontMetrics;
+
+namespace tl { template <> struct type_traits<QFontMetrics> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFontMetrics> &qtdecl_QFontMetrics (); }
 
 class QFontMetricsF;
+
+namespace tl { template <> struct type_traits<QFontMetricsF> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFontMetricsF> &qtdecl_QFontMetricsF (); }
 
 class QFormLayout;
+
+namespace tl { template <> struct type_traits<QFormLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFormLayout> &qtdecl_QFormLayout (); }
 
 class QFrame;
+
+namespace tl { template <> struct type_traits<QFrame> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFrame> &qtdecl_QFrame (); }
 
 class QGesture;
+
+namespace tl { template <> struct type_traits<QGesture> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGesture> &qtdecl_QGesture (); }
 
 class QGestureEvent;
+
+namespace tl { template <> struct type_traits<QGestureEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGestureEvent> &qtdecl_QGestureEvent (); }
 
 class QGestureRecognizer;
+
+namespace tl { template <> struct type_traits<QGestureRecognizer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGestureRecognizer> &qtdecl_QGestureRecognizer (); }
 
 class QGradient;
+
+namespace tl { template <> struct type_traits<QGradient> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGradient> &qtdecl_QGradient (); }
 
 class QGraphicsAnchor;
+
+namespace tl { template <> struct type_traits<QGraphicsAnchor> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsAnchor> &qtdecl_QGraphicsAnchor (); }
 
 class QGraphicsAnchorLayout;
+
+namespace tl { template <> struct type_traits<QGraphicsAnchorLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsAnchorLayout> &qtdecl_QGraphicsAnchorLayout (); }
 
 class QGraphicsBlurEffect;
+
+namespace tl { template <> struct type_traits<QGraphicsBlurEffect> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsBlurEffect> &qtdecl_QGraphicsBlurEffect (); }
 
 class QGraphicsColorizeEffect;
+
+namespace tl { template <> struct type_traits<QGraphicsColorizeEffect> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsColorizeEffect> &qtdecl_QGraphicsColorizeEffect (); }
 
 class QGraphicsDropShadowEffect;
+
+namespace tl { template <> struct type_traits<QGraphicsDropShadowEffect> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsDropShadowEffect> &qtdecl_QGraphicsDropShadowEffect (); }
 
 class QGraphicsEffect;
+
+namespace tl { template <> struct type_traits<QGraphicsEffect> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsEffect> &qtdecl_QGraphicsEffect (); }
 
 class QGraphicsEllipseItem;
+
+namespace tl { template <> struct type_traits<QGraphicsEllipseItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsEllipseItem> &qtdecl_QGraphicsEllipseItem (); }
 
 class QGraphicsGridLayout;
+
+namespace tl { template <> struct type_traits<QGraphicsGridLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsGridLayout> &qtdecl_QGraphicsGridLayout (); }
 
 class QGraphicsItem;
+
+namespace tl { template <> struct type_traits<QGraphicsItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsItem> &qtdecl_QGraphicsItem (); }
 
 class QGraphicsItemAnimation;
+
+namespace tl { template <> struct type_traits<QGraphicsItemAnimation> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsItemAnimation> &qtdecl_QGraphicsItemAnimation (); }
 
 class QGraphicsItemGroup;
+
+namespace tl { template <> struct type_traits<QGraphicsItemGroup> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsItemGroup> &qtdecl_QGraphicsItemGroup (); }
 
 class QGraphicsLayout;
+
+namespace tl { template <> struct type_traits<QGraphicsLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsLayout> &qtdecl_QGraphicsLayout (); }
 
 class QGraphicsLayoutItem;
+
+namespace tl { template <> struct type_traits<QGraphicsLayoutItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsLayoutItem> &qtdecl_QGraphicsLayoutItem (); }
 
 class QGraphicsLineItem;
+
+namespace tl { template <> struct type_traits<QGraphicsLineItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsLineItem> &qtdecl_QGraphicsLineItem (); }
 
 class QGraphicsLinearLayout;
+
+namespace tl { template <> struct type_traits<QGraphicsLinearLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsLinearLayout> &qtdecl_QGraphicsLinearLayout (); }
 
 class QGraphicsObject;
+
+namespace tl { template <> struct type_traits<QGraphicsObject> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsObject> &qtdecl_QGraphicsObject (); }
 
 class QGraphicsOpacityEffect;
+
+namespace tl { template <> struct type_traits<QGraphicsOpacityEffect> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsOpacityEffect> &qtdecl_QGraphicsOpacityEffect (); }
 
 class QGraphicsPathItem;
+
+namespace tl { template <> struct type_traits<QGraphicsPathItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsPathItem> &qtdecl_QGraphicsPathItem (); }
 
 class QGraphicsPixmapItem;
+
+namespace tl { template <> struct type_traits<QGraphicsPixmapItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsPixmapItem> &qtdecl_QGraphicsPixmapItem (); }
 
 class QGraphicsPolygonItem;
+
+namespace tl { template <> struct type_traits<QGraphicsPolygonItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsPolygonItem> &qtdecl_QGraphicsPolygonItem (); }
 
 class QGraphicsProxyWidget;
+
+namespace tl { template <> struct type_traits<QGraphicsProxyWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsProxyWidget> &qtdecl_QGraphicsProxyWidget (); }
 
 class QGraphicsRectItem;
+
+namespace tl { template <> struct type_traits<QGraphicsRectItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsRectItem> &qtdecl_QGraphicsRectItem (); }
 
 class QGraphicsRotation;
+
+namespace tl { template <> struct type_traits<QGraphicsRotation> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsRotation> &qtdecl_QGraphicsRotation (); }
 
 class QGraphicsScale;
+
+namespace tl { template <> struct type_traits<QGraphicsScale> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsScale> &qtdecl_QGraphicsScale (); }
 
 class QGraphicsScene;
+
+namespace tl { template <> struct type_traits<QGraphicsScene> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsScene> &qtdecl_QGraphicsScene (); }
 
 class QGraphicsSceneContextMenuEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneContextMenuEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsSceneContextMenuEvent> &qtdecl_QGraphicsSceneContextMenuEvent (); }
 
 class QGraphicsSceneDragDropEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneDragDropEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsSceneDragDropEvent> &qtdecl_QGraphicsSceneDragDropEvent (); }
 
 class QGraphicsSceneEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsSceneEvent> &qtdecl_QGraphicsSceneEvent (); }
 
 class QGraphicsSceneHelpEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneHelpEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsSceneHelpEvent> &qtdecl_QGraphicsSceneHelpEvent (); }
 
 class QGraphicsSceneHoverEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneHoverEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsSceneHoverEvent> &qtdecl_QGraphicsSceneHoverEvent (); }
 
 class QGraphicsSceneMouseEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneMouseEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsSceneMouseEvent> &qtdecl_QGraphicsSceneMouseEvent (); }
 
 class QGraphicsSceneMoveEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneMoveEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsSceneMoveEvent> &qtdecl_QGraphicsSceneMoveEvent (); }
 
 class QGraphicsSceneResizeEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneResizeEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsSceneResizeEvent> &qtdecl_QGraphicsSceneResizeEvent (); }
 
 class QGraphicsSceneWheelEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneWheelEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsSceneWheelEvent> &qtdecl_QGraphicsSceneWheelEvent (); }
 
 class QGraphicsSimpleTextItem;
+
+namespace tl { template <> struct type_traits<QGraphicsSimpleTextItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsSimpleTextItem> &qtdecl_QGraphicsSimpleTextItem (); }
 
 class QGraphicsTextItem;
+
+namespace tl { template <> struct type_traits<QGraphicsTextItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsTextItem> &qtdecl_QGraphicsTextItem (); }
 
 class QGraphicsTransform;
+
+namespace tl { template <> struct type_traits<QGraphicsTransform> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsTransform> &qtdecl_QGraphicsTransform (); }
 
 class QGraphicsView;
+
+namespace tl { template <> struct type_traits<QGraphicsView> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsView> &qtdecl_QGraphicsView (); }
 
 class QGraphicsWidget;
+
+namespace tl { template <> struct type_traits<QGraphicsWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGraphicsWidget> &qtdecl_QGraphicsWidget (); }
 
 class QGridLayout;
+
+namespace tl { template <> struct type_traits<QGridLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGridLayout> &qtdecl_QGridLayout (); }
 
 class QGroupBox;
+
+namespace tl { template <> struct type_traits<QGroupBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGroupBox> &qtdecl_QGroupBox (); }
 
 class QHBoxLayout;
+
+namespace tl { template <> struct type_traits<QHBoxLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QHBoxLayout> &qtdecl_QHBoxLayout (); }
 
 class QHeaderView;
+
+namespace tl { template <> struct type_traits<QHeaderView> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QHeaderView> &qtdecl_QHeaderView (); }
 
 class QHelpEvent;
+
+namespace tl { template <> struct type_traits<QHelpEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QHelpEvent> &qtdecl_QHelpEvent (); }
 
 class QHideEvent;
+
+namespace tl { template <> struct type_traits<QHideEvent> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QHideEvent> &qtdecl_QHideEvent (); }
 
 class QHoverEvent;
+
+namespace tl { template <> struct type_traits<QHoverEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QHoverEvent> &qtdecl_QHoverEvent (); }
 
 class QIcon;
+
+namespace tl { template <> struct type_traits<QIcon> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QIcon> &qtdecl_QIcon (); }
 
 class QIconDragEvent;
+
+namespace tl { template <> struct type_traits<QIconDragEvent> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QIconDragEvent> &qtdecl_QIconDragEvent (); }
 
 class QIconEngine;
+
+namespace tl { template <> struct type_traits<QIconEngine> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QIconEngine> &qtdecl_QIconEngine (); }
 
 class QIconEnginePlugin;
+
+namespace tl { template <> struct type_traits<QIconEnginePlugin> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QIconEnginePlugin> &qtdecl_QIconEnginePlugin (); }
 
 class QIconEnginePluginV2;
+
+namespace tl { template <> struct type_traits<QIconEnginePluginV2> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QIconEnginePluginV2> &qtdecl_QIconEnginePluginV2 (); }
 
 class QIconEngineV2;
+
+namespace tl { template <> struct type_traits<QIconEngineV2> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QIconEngineV2> &qtdecl_QIconEngineV2 (); }
 
 class QImage;
+
+namespace tl { template <> struct type_traits<QImage> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QImage> &qtdecl_QImage (); }
 
 class QImageIOHandler;
+
+namespace tl { template <> struct type_traits<QImageIOHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QImageIOHandler> &qtdecl_QImageIOHandler (); }
 
 class QImageIOPlugin;
+
+namespace tl { template <> struct type_traits<QImageIOPlugin> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QImageIOPlugin> &qtdecl_QImageIOPlugin (); }
 
 class QImageReader;
+
+namespace tl { template <> struct type_traits<QImageReader> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QImageReader> &qtdecl_QImageReader (); }
 
 class QImageTextKeyLang;
+
+namespace tl { template <> struct type_traits<QImageTextKeyLang> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QImageTextKeyLang> &qtdecl_QImageTextKeyLang (); }
 
 class QImageWriter;
+
+namespace tl { template <> struct type_traits<QImageWriter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QImageWriter> &qtdecl_QImageWriter (); }
 
 class QInputContext;
+
+namespace tl { template <> struct type_traits<QInputContext> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QInputContext> &qtdecl_QInputContext (); }
 
 class QInputContextFactory;
+
+namespace tl { template <> struct type_traits<QInputContextFactory> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QInputContextFactory> &qtdecl_QInputContextFactory (); }
 
 class QInputContextPlugin;
+
+namespace tl { template <> struct type_traits<QInputContextPlugin> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QInputContextPlugin> &qtdecl_QInputContextPlugin (); }
 
 class QInputDialog;
+
+namespace tl { template <> struct type_traits<QInputDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QInputDialog> &qtdecl_QInputDialog (); }
 
 class QInputEvent;
+
+namespace tl { template <> struct type_traits<QInputEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QInputEvent> &qtdecl_QInputEvent (); }
 
 class QInputMethodEvent;
+
+namespace tl { template <> struct type_traits<QInputMethodEvent> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QInputMethodEvent> &qtdecl_QInputMethodEvent (); }
 
 class QIntValidator;
+
+namespace tl { template <> struct type_traits<QIntValidator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QIntValidator> &qtdecl_QIntValidator (); }
 
 class QItemDelegate;
+
+namespace tl { template <> struct type_traits<QItemDelegate> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QItemDelegate> &qtdecl_QItemDelegate (); }
 
 class QItemEditorCreatorBase;
+
+namespace tl { template <> struct type_traits<QItemEditorCreatorBase> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QItemEditorCreatorBase> &qtdecl_QItemEditorCreatorBase (); }
 
 class QItemEditorFactory;
+
+namespace tl { template <> struct type_traits<QItemEditorFactory> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QItemEditorFactory> &qtdecl_QItemEditorFactory (); }
 
 class QItemSelection;
+
+namespace tl { template <> struct type_traits<QItemSelection> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QItemSelection> &qtdecl_QItemSelection (); }
 
 class QItemSelectionModel;
+
+namespace tl { template <> struct type_traits<QItemSelectionModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QItemSelectionModel> &qtdecl_QItemSelectionModel (); }
 
 class QItemSelectionRange;
+
+namespace tl { template <> struct type_traits<QItemSelectionRange> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QItemSelectionRange> &qtdecl_QItemSelectionRange (); }
 
 class QKeyEvent;
+
+namespace tl { template <> struct type_traits<QKeyEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QKeyEvent> &qtdecl_QKeyEvent (); }
 
 class QKeySequence;
+
+namespace tl { template <> struct type_traits<QKeySequence> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QKeySequence> &qtdecl_QKeySequence (); }
 
 class QLCDNumber;
+
+namespace tl { template <> struct type_traits<QLCDNumber> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QLCDNumber> &qtdecl_QLCDNumber (); }
 
 class QLabel;
+
+namespace tl { template <> struct type_traits<QLabel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QLabel> &qtdecl_QLabel (); }
 
 class QLayout;
+
+namespace tl { template <> struct type_traits<QLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QLayout> &qtdecl_QLayout (); }
 
 class QLayoutItem;
+
+namespace tl { template <> struct type_traits<QLayoutItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QLayoutItem> &qtdecl_QLayoutItem (); }
 
 class QLineEdit;
+
+namespace tl { template <> struct type_traits<QLineEdit> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QLineEdit> &qtdecl_QLineEdit (); }
 
 class QLinearGradient;
+
+namespace tl { template <> struct type_traits<QLinearGradient> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QLinearGradient> &qtdecl_QLinearGradient (); }
 
 class QListView;
+
+namespace tl { template <> struct type_traits<QListView> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QListView> &qtdecl_QListView (); }
 
 class QListWidget;
+
+namespace tl { template <> struct type_traits<QListWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QListWidget> &qtdecl_QListWidget (); }
 
 class QListWidgetItem;
+
+namespace tl { template <> struct type_traits<QListWidgetItem> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QListWidgetItem> &qtdecl_QListWidgetItem (); }
 
 class QMainWindow;
+
+namespace tl { template <> struct type_traits<QMainWindow> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMainWindow> &qtdecl_QMainWindow (); }
 
 class QMatrix;
+
+namespace tl { template <> struct type_traits<QMatrix> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMatrix> &qtdecl_QMatrix (); }
 
 class QMatrix4x4;
+
+namespace tl { template <> struct type_traits<QMatrix4x4> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMatrix4x4> &qtdecl_QMatrix4x4 (); }
 
 class QMdiArea;
+
+namespace tl { template <> struct type_traits<QMdiArea> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMdiArea> &qtdecl_QMdiArea (); }
 
 class QMdiSubWindow;
+
+namespace tl { template <> struct type_traits<QMdiSubWindow> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMdiSubWindow> &qtdecl_QMdiSubWindow (); }
 
 class QMenu;
+
+namespace tl { template <> struct type_traits<QMenu> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMenu> &qtdecl_QMenu (); }
 
 class QMenuBar;
+
+namespace tl { template <> struct type_traits<QMenuBar> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMenuBar> &qtdecl_QMenuBar (); }
 
 class QMessageBox;
+
+namespace tl { template <> struct type_traits<QMessageBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMessageBox> &qtdecl_QMessageBox (); }
 
 class QMimeSource;
+
+namespace tl { template <> struct type_traits<QMimeSource> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMimeSource> &qtdecl_QMimeSource (); }
 
 class QMotifStyle;
+
+namespace tl { template <> struct type_traits<QMotifStyle> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMotifStyle> &qtdecl_QMotifStyle (); }
 
 class QMouseEvent;
+
+namespace tl { template <> struct type_traits<QMouseEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMouseEvent> &qtdecl_QMouseEvent (); }
 
 class QMoveEvent;
+
+namespace tl { template <> struct type_traits<QMoveEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMoveEvent> &qtdecl_QMoveEvent (); }
 
 class QMovie;
+
+namespace tl { template <> struct type_traits<QMovie> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMovie> &qtdecl_QMovie (); }
 
 class QPageSetupDialog;
+
+namespace tl { template <> struct type_traits<QPageSetupDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPageSetupDialog> &qtdecl_QPageSetupDialog (); }
 
 class QPaintDevice;
+
+namespace tl { template <> struct type_traits<QPaintDevice> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPaintDevice> &qtdecl_QPaintDevice (); }
 
 class QPaintEngine;
+
+namespace tl { template <> struct type_traits<QPaintEngine> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPaintEngine> &qtdecl_QPaintEngine (); }
 
 class QPaintEngineState;
+
+namespace tl { template <> struct type_traits<QPaintEngineState> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPaintEngineState> &qtdecl_QPaintEngineState (); }
 
 class QPaintEvent;
+
+namespace tl { template <> struct type_traits<QPaintEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPaintEvent> &qtdecl_QPaintEvent (); }
 
 class QPainter;
+
+namespace tl { template <> struct type_traits<QPainter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPainter> &qtdecl_QPainter (); }
 
 class QPainterPath;
+
+namespace tl { template <> struct type_traits<QPainterPath> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPainterPath> &qtdecl_QPainterPath (); }
 
 class QPainterPathStroker;
+
+namespace tl { template <> struct type_traits<QPainterPathStroker> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPainterPathStroker> &qtdecl_QPainterPathStroker (); }
 
 class QPalette;
+
+namespace tl { template <> struct type_traits<QPalette> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPalette> &qtdecl_QPalette (); }
 
 class QPanGesture;
+
+namespace tl { template <> struct type_traits<QPanGesture> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPanGesture> &qtdecl_QPanGesture (); }
 
 class QPen;
+
+namespace tl { template <> struct type_traits<QPen> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPen> &qtdecl_QPen (); }
 
 class QPicture;
+
+namespace tl { template <> struct type_traits<QPicture> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPicture> &qtdecl_QPicture (); }
 
 class QPinchGesture;
+
+namespace tl { template <> struct type_traits<QPinchGesture> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPinchGesture> &qtdecl_QPinchGesture (); }
 
 class QPixmap;
+
+namespace tl { template <> struct type_traits<QPixmap> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPixmap> &qtdecl_QPixmap (); }
 
 class QPixmapCache;
+
+namespace tl { template <> struct type_traits<QPixmapCache> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPixmapCache> &qtdecl_QPixmapCache (); }
 
 class QPlainTextDocumentLayout;
+
+namespace tl { template <> struct type_traits<QPlainTextDocumentLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPlainTextDocumentLayout> &qtdecl_QPlainTextDocumentLayout (); }
 
 class QPlainTextEdit;
+
+namespace tl { template <> struct type_traits<QPlainTextEdit> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPlainTextEdit> &qtdecl_QPlainTextEdit (); }
 
 class QPlastiqueStyle;
+
+namespace tl { template <> struct type_traits<QPlastiqueStyle> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPlastiqueStyle> &qtdecl_QPlastiqueStyle (); }
 
 class QPolygon;
+
+namespace tl { template <> struct type_traits<QPolygon> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPolygon> &qtdecl_QPolygon (); }
 
 class QPolygonF;
+
+namespace tl { template <> struct type_traits<QPolygonF> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPolygonF> &qtdecl_QPolygonF (); }
 
 class QPrintDialog;
+
+namespace tl { template <> struct type_traits<QPrintDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPrintDialog> &qtdecl_QPrintDialog (); }
 
 class QPrintEngine;
+
+namespace tl { template <> struct type_traits<QPrintEngine> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPrintEngine> &qtdecl_QPrintEngine (); }
 
 class QPrintPreviewDialog;
+
+namespace tl { template <> struct type_traits<QPrintPreviewDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPrintPreviewDialog> &qtdecl_QPrintPreviewDialog (); }
 
 class QPrintPreviewWidget;
+
+namespace tl { template <> struct type_traits<QPrintPreviewWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPrintPreviewWidget> &qtdecl_QPrintPreviewWidget (); }
 
 class QPrinter;
+
+namespace tl { template <> struct type_traits<QPrinter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPrinter> &qtdecl_QPrinter (); }
 
 class QPrinterInfo;
+
+namespace tl { template <> struct type_traits<QPrinterInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPrinterInfo> &qtdecl_QPrinterInfo (); }
 
 class QProgressBar;
+
+namespace tl { template <> struct type_traits<QProgressBar> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QProgressBar> &qtdecl_QProgressBar (); }
 
 class QProgressDialog;
+
+namespace tl { template <> struct type_traits<QProgressDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QProgressDialog> &qtdecl_QProgressDialog (); }
 
 class QPushButton;
+
+namespace tl { template <> struct type_traits<QPushButton> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPushButton> &qtdecl_QPushButton (); }
 
 class QQuaternion;
+
+namespace tl { template <> struct type_traits<QQuaternion> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QQuaternion> &qtdecl_QQuaternion (); }
 
 class QRadialGradient;
+
+namespace tl { template <> struct type_traits<QRadialGradient> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QRadialGradient> &qtdecl_QRadialGradient (); }
 
 class QRadioButton;
+
+namespace tl { template <> struct type_traits<QRadioButton> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QRadioButton> &qtdecl_QRadioButton (); }
 
 class QRegExpValidator;
+
+namespace tl { template <> struct type_traits<QRegExpValidator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QRegExpValidator> &qtdecl_QRegExpValidator (); }
 
 class QRegion;
+
+namespace tl { template <> struct type_traits<QRegion> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QRegion> &qtdecl_QRegion (); }
 
 class QResizeEvent;
+
+namespace tl { template <> struct type_traits<QResizeEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QResizeEvent> &qtdecl_QResizeEvent (); }
 
 class QRubberBand;
+
+namespace tl { template <> struct type_traits<QRubberBand> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QRubberBand> &qtdecl_QRubberBand (); }
 
 class QScrollArea;
+
+namespace tl { template <> struct type_traits<QScrollArea> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QScrollArea> &qtdecl_QScrollArea (); }
 
 class QScrollBar;
+
+namespace tl { template <> struct type_traits<QScrollBar> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QScrollBar> &qtdecl_QScrollBar (); }
 
 class QShortcut;
+
+namespace tl { template <> struct type_traits<QShortcut> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QShortcut> &qtdecl_QShortcut (); }
 
 class QShortcutEvent;
+
+namespace tl { template <> struct type_traits<QShortcutEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QShortcutEvent> &qtdecl_QShortcutEvent (); }
 
 class QShowEvent;
+
+namespace tl { template <> struct type_traits<QShowEvent> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QShowEvent> &qtdecl_QShowEvent (); }
 
 class QSizeGrip;
+
+namespace tl { template <> struct type_traits<QSizeGrip> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QSizeGrip> &qtdecl_QSizeGrip (); }
 
 class QSizePolicy;
+
+namespace tl { template <> struct type_traits<QSizePolicy> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QSizePolicy> &qtdecl_QSizePolicy (); }
 
 class QSlider;
+
+namespace tl { template <> struct type_traits<QSlider> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QSlider> &qtdecl_QSlider (); }
 
 class QSortFilterProxyModel;
+
+namespace tl { template <> struct type_traits<QSortFilterProxyModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QSortFilterProxyModel> &qtdecl_QSortFilterProxyModel (); }
 
 class QSound;
+
+namespace tl { template <> struct type_traits<QSound> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QSound> &qtdecl_QSound (); }
 
 class QSpacerItem;
+
+namespace tl { template <> struct type_traits<QSpacerItem> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QSpacerItem> &qtdecl_QSpacerItem (); }
 
 class QSpinBox;
+
+namespace tl { template <> struct type_traits<QSpinBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QSpinBox> &qtdecl_QSpinBox (); }
 
 class QSplashScreen;
+
+namespace tl { template <> struct type_traits<QSplashScreen> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QSplashScreen> &qtdecl_QSplashScreen (); }
 
 class QSplitter;
+
+namespace tl { template <> struct type_traits<QSplitter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QSplitter> &qtdecl_QSplitter (); }
 
 class QSplitterHandle;
+
+namespace tl { template <> struct type_traits<QSplitterHandle> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QSplitterHandle> &qtdecl_QSplitterHandle (); }
 
 class QStackedLayout;
+
+namespace tl { template <> struct type_traits<QStackedLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStackedLayout> &qtdecl_QStackedLayout (); }
 
 class QStackedWidget;
+
+namespace tl { template <> struct type_traits<QStackedWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStackedWidget> &qtdecl_QStackedWidget (); }
 
 class QStandardItem;
+
+namespace tl { template <> struct type_traits<QStandardItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStandardItem> &qtdecl_QStandardItem (); }
 
 class QStandardItemModel;
+
+namespace tl { template <> struct type_traits<QStandardItemModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStandardItemModel> &qtdecl_QStandardItemModel (); }
 
 class QStatusBar;
+
+namespace tl { template <> struct type_traits<QStatusBar> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStatusBar> &qtdecl_QStatusBar (); }
 
 class QStatusTipEvent;
+
+namespace tl { template <> struct type_traits<QStatusTipEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStatusTipEvent> &qtdecl_QStatusTipEvent (); }
 
 class QStringListModel;
+
+namespace tl { template <> struct type_traits<QStringListModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStringListModel> &qtdecl_QStringListModel (); }
 
 class QStyle;
+
+namespace tl { template <> struct type_traits<QStyle> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyle> &qtdecl_QStyle (); }
 
 class QStyleFactory;
+
+namespace tl { template <> struct type_traits<QStyleFactory> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleFactory> &qtdecl_QStyleFactory (); }
 
 class QStyleHintReturn;
+
+namespace tl { template <> struct type_traits<QStyleHintReturn> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleHintReturn> &qtdecl_QStyleHintReturn (); }
 
 class QStyleHintReturnMask;
+
+namespace tl { template <> struct type_traits<QStyleHintReturnMask> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleHintReturnMask> &qtdecl_QStyleHintReturnMask (); }
 
 class QStyleHintReturnVariant;
+
+namespace tl { template <> struct type_traits<QStyleHintReturnVariant> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleHintReturnVariant> &qtdecl_QStyleHintReturnVariant (); }
 
 class QStyleOption;
+
+namespace tl { template <> struct type_traits<QStyleOption> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOption> &qtdecl_QStyleOption (); }
 
 class QStyleOptionButton;
+
+namespace tl { template <> struct type_traits<QStyleOptionButton> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionButton> &qtdecl_QStyleOptionButton (); }
 
 class QStyleOptionComboBox;
+
+namespace tl { template <> struct type_traits<QStyleOptionComboBox> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionComboBox> &qtdecl_QStyleOptionComboBox (); }
 
 class QStyleOptionComplex;
+
+namespace tl { template <> struct type_traits<QStyleOptionComplex> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionComplex> &qtdecl_QStyleOptionComplex (); }
 
 class QStyleOptionDockWidget;
+
+namespace tl { template <> struct type_traits<QStyleOptionDockWidget> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionDockWidget> &qtdecl_QStyleOptionDockWidget (); }
 
 class QStyleOptionFocusRect;
+
+namespace tl { template <> struct type_traits<QStyleOptionFocusRect> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionFocusRect> &qtdecl_QStyleOptionFocusRect (); }
 
 class QStyleOptionFrame;
+
+namespace tl { template <> struct type_traits<QStyleOptionFrame> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionFrame> &qtdecl_QStyleOptionFrame (); }
 
 class QStyleOptionFrameV2;
+
+namespace tl { template <> struct type_traits<QStyleOptionFrameV2> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionFrameV2> &qtdecl_QStyleOptionFrameV2 (); }
 
 class QStyleOptionFrameV3;
+
+namespace tl { template <> struct type_traits<QStyleOptionFrameV3> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionFrameV3> &qtdecl_QStyleOptionFrameV3 (); }
 
 class QStyleOptionGraphicsItem;
+
+namespace tl { template <> struct type_traits<QStyleOptionGraphicsItem> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionGraphicsItem> &qtdecl_QStyleOptionGraphicsItem (); }
 
 class QStyleOptionGroupBox;
+
+namespace tl { template <> struct type_traits<QStyleOptionGroupBox> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionGroupBox> &qtdecl_QStyleOptionGroupBox (); }
 
 class QStyleOptionHeader;
+
+namespace tl { template <> struct type_traits<QStyleOptionHeader> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionHeader> &qtdecl_QStyleOptionHeader (); }
 
 class QStyleOptionMenuItem;
+
+namespace tl { template <> struct type_traits<QStyleOptionMenuItem> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionMenuItem> &qtdecl_QStyleOptionMenuItem (); }
 
 class QStyleOptionProgressBar;
+
+namespace tl { template <> struct type_traits<QStyleOptionProgressBar> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionProgressBar> &qtdecl_QStyleOptionProgressBar (); }
 
 class QStyleOptionProgressBarV2;
+
+namespace tl { template <> struct type_traits<QStyleOptionProgressBarV2> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionProgressBarV2> &qtdecl_QStyleOptionProgressBarV2 (); }
 
 class QStyleOptionQ3DockWindow;
+
+namespace tl { template <> struct type_traits<QStyleOptionQ3DockWindow> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionQ3DockWindow> &qtdecl_QStyleOptionQ3DockWindow (); }
 
 class QStyleOptionQ3ListView;
+
+namespace tl { template <> struct type_traits<QStyleOptionQ3ListView> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionQ3ListView> &qtdecl_QStyleOptionQ3ListView (); }
 
 class QStyleOptionQ3ListViewItem;
+
+namespace tl { template <> struct type_traits<QStyleOptionQ3ListViewItem> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionQ3ListViewItem> &qtdecl_QStyleOptionQ3ListViewItem (); }
 
 class QStyleOptionRubberBand;
+
+namespace tl { template <> struct type_traits<QStyleOptionRubberBand> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionRubberBand> &qtdecl_QStyleOptionRubberBand (); }
 
 class QStyleOptionSizeGrip;
+
+namespace tl { template <> struct type_traits<QStyleOptionSizeGrip> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionSizeGrip> &qtdecl_QStyleOptionSizeGrip (); }
 
 class QStyleOptionSlider;
+
+namespace tl { template <> struct type_traits<QStyleOptionSlider> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionSlider> &qtdecl_QStyleOptionSlider (); }
 
 class QStyleOptionSpinBox;
+
+namespace tl { template <> struct type_traits<QStyleOptionSpinBox> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionSpinBox> &qtdecl_QStyleOptionSpinBox (); }
 
 class QStyleOptionTab;
+
+namespace tl { template <> struct type_traits<QStyleOptionTab> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionTab> &qtdecl_QStyleOptionTab (); }
 
 class QStyleOptionTabBarBase;
+
+namespace tl { template <> struct type_traits<QStyleOptionTabBarBase> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionTabBarBase> &qtdecl_QStyleOptionTabBarBase (); }
 
 class QStyleOptionTabBarBaseV2;
+
+namespace tl { template <> struct type_traits<QStyleOptionTabBarBaseV2> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionTabBarBaseV2> &qtdecl_QStyleOptionTabBarBaseV2 (); }
 
 class QStyleOptionTabV2;
+
+namespace tl { template <> struct type_traits<QStyleOptionTabV2> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionTabV2> &qtdecl_QStyleOptionTabV2 (); }
 
 class QStyleOptionTabV3;
+
+namespace tl { template <> struct type_traits<QStyleOptionTabV3> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionTabV3> &qtdecl_QStyleOptionTabV3 (); }
 
 class QStyleOptionTabWidgetFrame;
+
+namespace tl { template <> struct type_traits<QStyleOptionTabWidgetFrame> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionTabWidgetFrame> &qtdecl_QStyleOptionTabWidgetFrame (); }
 
 class QStyleOptionTitleBar;
+
+namespace tl { template <> struct type_traits<QStyleOptionTitleBar> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionTitleBar> &qtdecl_QStyleOptionTitleBar (); }
 
 class QStyleOptionToolBar;
+
+namespace tl { template <> struct type_traits<QStyleOptionToolBar> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionToolBar> &qtdecl_QStyleOptionToolBar (); }
 
 class QStyleOptionToolBox;
+
+namespace tl { template <> struct type_traits<QStyleOptionToolBox> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionToolBox> &qtdecl_QStyleOptionToolBox (); }
 
 class QStyleOptionToolBoxV2;
+
+namespace tl { template <> struct type_traits<QStyleOptionToolBoxV2> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionToolBoxV2> &qtdecl_QStyleOptionToolBoxV2 (); }
 
 class QStyleOptionToolButton;
+
+namespace tl { template <> struct type_traits<QStyleOptionToolButton> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionToolButton> &qtdecl_QStyleOptionToolButton (); }
 
 class QStyleOptionViewItem;
+
+namespace tl { template <> struct type_traits<QStyleOptionViewItem> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionViewItem> &qtdecl_QStyleOptionViewItem (); }
 
 class QStyleOptionViewItemV2;
+
+namespace tl { template <> struct type_traits<QStyleOptionViewItemV2> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionViewItemV2> &qtdecl_QStyleOptionViewItemV2 (); }
 
 class QStyleOptionViewItemV3;
+
+namespace tl { template <> struct type_traits<QStyleOptionViewItemV3> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionViewItemV3> &qtdecl_QStyleOptionViewItemV3 (); }
 
 class QStyleOptionViewItemV4;
+
+namespace tl { template <> struct type_traits<QStyleOptionViewItemV4> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleOptionViewItemV4> &qtdecl_QStyleOptionViewItemV4 (); }
 
 class QStylePainter;
+
+namespace tl { template <> struct type_traits<QStylePainter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStylePainter> &qtdecl_QStylePainter (); }
 
 class QStylePlugin;
+
+namespace tl { template <> struct type_traits<QStylePlugin> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStylePlugin> &qtdecl_QStylePlugin (); }
 
 class QStyledItemDelegate;
+
+namespace tl { template <> struct type_traits<QStyledItemDelegate> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyledItemDelegate> &qtdecl_QStyledItemDelegate (); }
 
 class QSwipeGesture;
+
+namespace tl { template <> struct type_traits<QSwipeGesture> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QSwipeGesture> &qtdecl_QSwipeGesture (); }
 
 class QSyntaxHighlighter;
+
+namespace tl { template <> struct type_traits<QSyntaxHighlighter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QSyntaxHighlighter> &qtdecl_QSyntaxHighlighter (); }
 
 class QSystemTrayIcon;
+
+namespace tl { template <> struct type_traits<QSystemTrayIcon> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QSystemTrayIcon> &qtdecl_QSystemTrayIcon (); }
 
 class QTabBar;
+
+namespace tl { template <> struct type_traits<QTabBar> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTabBar> &qtdecl_QTabBar (); }
 
 class QTabWidget;
+
+namespace tl { template <> struct type_traits<QTabWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTabWidget> &qtdecl_QTabWidget (); }
 
 class QTableView;
+
+namespace tl { template <> struct type_traits<QTableView> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTableView> &qtdecl_QTableView (); }
 
 class QTableWidget;
+
+namespace tl { template <> struct type_traits<QTableWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTableWidget> &qtdecl_QTableWidget (); }
 
 class QTableWidgetItem;
+
+namespace tl { template <> struct type_traits<QTableWidgetItem> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTableWidgetItem> &qtdecl_QTableWidgetItem (); }
 
 class QTableWidgetSelectionRange;
+
+namespace tl { template <> struct type_traits<QTableWidgetSelectionRange> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTableWidgetSelectionRange> &qtdecl_QTableWidgetSelectionRange (); }
 
 class QTabletEvent;
+
+namespace tl { template <> struct type_traits<QTabletEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTabletEvent> &qtdecl_QTabletEvent (); }
 
 class QTapAndHoldGesture;
+
+namespace tl { template <> struct type_traits<QTapAndHoldGesture> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTapAndHoldGesture> &qtdecl_QTapAndHoldGesture (); }
 
 class QTapGesture;
+
+namespace tl { template <> struct type_traits<QTapGesture> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTapGesture> &qtdecl_QTapGesture (); }
 
 class QTextBlock;
+
+namespace tl { template <> struct type_traits<QTextBlock> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextBlock> &qtdecl_QTextBlock (); }
 
 class QTextBlockFormat;
+
+namespace tl { template <> struct type_traits<QTextBlockFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextBlockFormat> &qtdecl_QTextBlockFormat (); }
 
 class QTextBlockGroup;
+
+namespace tl { template <> struct type_traits<QTextBlockGroup> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextBlockGroup> &qtdecl_QTextBlockGroup (); }
 
 class QTextBlockUserData;
+
+namespace tl { template <> struct type_traits<QTextBlockUserData> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextBlockUserData> &qtdecl_QTextBlockUserData (); }
 
 class QTextBrowser;
+
+namespace tl { template <> struct type_traits<QTextBrowser> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextBrowser> &qtdecl_QTextBrowser (); }
 
 class QTextCharFormat;
+
+namespace tl { template <> struct type_traits<QTextCharFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextCharFormat> &qtdecl_QTextCharFormat (); }
 
 class QTextCursor;
+
+namespace tl { template <> struct type_traits<QTextCursor> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextCursor> &qtdecl_QTextCursor (); }
 
 class QTextDocument;
+
+namespace tl { template <> struct type_traits<QTextDocument> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextDocument> &qtdecl_QTextDocument (); }
 
 class QTextDocumentFragment;
+
+namespace tl { template <> struct type_traits<QTextDocumentFragment> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextDocumentFragment> &qtdecl_QTextDocumentFragment (); }
 
 class QTextDocumentWriter;
+
+namespace tl { template <> struct type_traits<QTextDocumentWriter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextDocumentWriter> &qtdecl_QTextDocumentWriter (); }
 
 class QTextEdit;
+
+namespace tl { template <> struct type_traits<QTextEdit> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextEdit> &qtdecl_QTextEdit (); }
 
 class QTextFormat;
+
+namespace tl { template <> struct type_traits<QTextFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextFormat> &qtdecl_QTextFormat (); }
 
 class QTextFragment;
+
+namespace tl { template <> struct type_traits<QTextFragment> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextFragment> &qtdecl_QTextFragment (); }
 
 class QTextFrame;
+
+namespace tl { template <> struct type_traits<QTextFrame> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextFrame> &qtdecl_QTextFrame (); }
 
 class QTextFrameFormat;
+
+namespace tl { template <> struct type_traits<QTextFrameFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextFrameFormat> &qtdecl_QTextFrameFormat (); }
 
 class QTextImageFormat;
+
+namespace tl { template <> struct type_traits<QTextImageFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextImageFormat> &qtdecl_QTextImageFormat (); }
 
 class QTextInlineObject;
+
+namespace tl { template <> struct type_traits<QTextInlineObject> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextInlineObject> &qtdecl_QTextInlineObject (); }
 
 class QTextItem;
+
+namespace tl { template <> struct type_traits<QTextItem> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextItem> &qtdecl_QTextItem (); }
 
 class QTextLayout;
+
+namespace tl { template <> struct type_traits<QTextLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextLayout> &qtdecl_QTextLayout (); }
 
 class QTextLength;
+
+namespace tl { template <> struct type_traits<QTextLength> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextLength> &qtdecl_QTextLength (); }
 
 class QTextLine;
+
+namespace tl { template <> struct type_traits<QTextLine> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextLine> &qtdecl_QTextLine (); }
 
 class QTextList;
+
+namespace tl { template <> struct type_traits<QTextList> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextList> &qtdecl_QTextList (); }
 
 class QTextListFormat;
+
+namespace tl { template <> struct type_traits<QTextListFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextListFormat> &qtdecl_QTextListFormat (); }
 
 class QTextObject;
+
+namespace tl { template <> struct type_traits<QTextObject> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextObject> &qtdecl_QTextObject (); }
 
 class QTextObjectInterface;
+
+namespace tl { template <> struct type_traits<QTextObjectInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextObjectInterface> &qtdecl_QTextObjectInterface (); }
 
 class QTextOption;
+
+namespace tl { template <> struct type_traits<QTextOption> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextOption> &qtdecl_QTextOption (); }
 
 class QTextTable;
+
+namespace tl { template <> struct type_traits<QTextTable> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextTable> &qtdecl_QTextTable (); }
 
 class QTextTableCell;
+
+namespace tl { template <> struct type_traits<QTextTableCell> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextTableCell> &qtdecl_QTextTableCell (); }
 
 class QTextTableCellFormat;
+
+namespace tl { template <> struct type_traits<QTextTableCellFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextTableCellFormat> &qtdecl_QTextTableCellFormat (); }
 
 class QTextTableFormat;
+
+namespace tl { template <> struct type_traits<QTextTableFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextTableFormat> &qtdecl_QTextTableFormat (); }
 
 class QTimeEdit;
+
+namespace tl { template <> struct type_traits<QTimeEdit> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTimeEdit> &qtdecl_QTimeEdit (); }
 
 class QToolBar;
+
+namespace tl { template <> struct type_traits<QToolBar> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QToolBar> &qtdecl_QToolBar (); }
 
 class QToolBarChangeEvent;
+
+namespace tl { template <> struct type_traits<QToolBarChangeEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QToolBarChangeEvent> &qtdecl_QToolBarChangeEvent (); }
 
 class QToolBox;
+
+namespace tl { template <> struct type_traits<QToolBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QToolBox> &qtdecl_QToolBox (); }
 
 class QToolButton;
+
+namespace tl { template <> struct type_traits<QToolButton> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QToolButton> &qtdecl_QToolButton (); }
 
 class QToolTip;
+
+namespace tl { template <> struct type_traits<QToolTip> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QToolTip> &qtdecl_QToolTip (); }
 
 class QTouchEvent;
+
+namespace tl { template <> struct type_traits<QTouchEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTouchEvent> &qtdecl_QTouchEvent (); }
 
 class QTransform;
+
+namespace tl { template <> struct type_traits<QTransform> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTransform> &qtdecl_QTransform (); }
 
 class QTreeView;
+
+namespace tl { template <> struct type_traits<QTreeView> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTreeView> &qtdecl_QTreeView (); }
 
 class QTreeWidget;
+
+namespace tl { template <> struct type_traits<QTreeWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTreeWidget> &qtdecl_QTreeWidget (); }
 
 class QTreeWidgetItem;
+
+namespace tl { template <> struct type_traits<QTreeWidgetItem> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTreeWidgetItem> &qtdecl_QTreeWidgetItem (); }
 
 class QTreeWidgetItemIterator;
+
+namespace tl { template <> struct type_traits<QTreeWidgetItemIterator> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTreeWidgetItemIterator> &qtdecl_QTreeWidgetItemIterator (); }
 
 class QUndoCommand;
+
+namespace tl { template <> struct type_traits<QUndoCommand> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QUndoCommand> &qtdecl_QUndoCommand (); }
 
 class QUndoGroup;
+
+namespace tl { template <> struct type_traits<QUndoGroup> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QUndoGroup> &qtdecl_QUndoGroup (); }
 
 class QUndoStack;
+
+namespace tl { template <> struct type_traits<QUndoStack> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QUndoStack> &qtdecl_QUndoStack (); }
 
 class QUndoView;
+
+namespace tl { template <> struct type_traits<QUndoView> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QUndoView> &qtdecl_QUndoView (); }
 
 class QUnixPrintWidget;
+
+namespace tl { template <> struct type_traits<QUnixPrintWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QUnixPrintWidget> &qtdecl_QUnixPrintWidget (); }
 
 class QVBoxLayout;
+
+namespace tl { template <> struct type_traits<QVBoxLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QVBoxLayout> &qtdecl_QVBoxLayout (); }
 
 class QValidator;
+
+namespace tl { template <> struct type_traits<QValidator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QValidator> &qtdecl_QValidator (); }
 
 class QVector2D;
+
+namespace tl { template <> struct type_traits<QVector2D> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QVector2D> &qtdecl_QVector2D (); }
 
 class QVector3D;
+
+namespace tl { template <> struct type_traits<QVector3D> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QVector3D> &qtdecl_QVector3D (); }
 
 class QVector4D;
+
+namespace tl { template <> struct type_traits<QVector4D> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QVector4D> &qtdecl_QVector4D (); }
 
 class QWhatsThis;
+
+namespace tl { template <> struct type_traits<QWhatsThis> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QWhatsThis> &qtdecl_QWhatsThis (); }
 
 class QWhatsThisClickedEvent;
+
+namespace tl { template <> struct type_traits<QWhatsThisClickedEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QWhatsThisClickedEvent> &qtdecl_QWhatsThisClickedEvent (); }
 
 class QWheelEvent;
+
+namespace tl { template <> struct type_traits<QWheelEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QWheelEvent> &qtdecl_QWheelEvent (); }
 
 class QWidget;
+
+namespace tl { template <> struct type_traits<QWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QWidget> &qtdecl_QWidget (); }
 
 class QWidgetAction;
+
+namespace tl { template <> struct type_traits<QWidgetAction> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QWidgetAction> &qtdecl_QWidgetAction (); }
 
 class QWidgetItem;
+
+namespace tl { template <> struct type_traits<QWidgetItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QWidgetItem> &qtdecl_QWidgetItem (); }
 
 class QWindowStateChangeEvent;
+
+namespace tl { template <> struct type_traits<QWindowStateChangeEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QWindowStateChangeEvent> &qtdecl_QWindowStateChangeEvent (); }
 
 class QWindowsStyle;
+
+namespace tl { template <> struct type_traits<QWindowsStyle> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QWindowsStyle> &qtdecl_QWindowsStyle (); }
 
 class QWizard;
+
+namespace tl { template <> struct type_traits<QWizard> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QWizard> &qtdecl_QWizard (); }
 
 class QWizardPage;
+
+namespace tl { template <> struct type_traits<QWizardPage> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QWizardPage> &qtdecl_QWizardPage (); }
 
 
diff --git a/src/gsiqt/qt4/QtNetwork/gsiQtExternals.h b/src/gsiqt/qt4/QtNetwork/gsiQtExternals.h
index 8def8e459..704560384 100644
--- a/src/gsiqt/qt4/QtNetwork/gsiQtExternals.h
+++ b/src/gsiqt/qt4/QtNetwork/gsiQtExternals.h
@@ -34,96 +34,238 @@
 #include "gsiQtNetworkCommon.h"
 
 class QAbstractNetworkCache;
+
+namespace tl { template <> struct type_traits<QAbstractNetworkCache> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QAbstractNetworkCache> &qtdecl_QAbstractNetworkCache (); }
 
 class QAbstractSocket;
+
+namespace tl { template <> struct type_traits<QAbstractSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QAbstractSocket> &qtdecl_QAbstractSocket (); }
 
 class QAuthenticator;
+
+namespace tl { template <> struct type_traits<QAuthenticator> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QAuthenticator> &qtdecl_QAuthenticator (); }
 
 class QFtp;
+
+namespace tl { template <> struct type_traits<QFtp> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QFtp> &qtdecl_QFtp (); }
 
 class QHostAddress;
+
+namespace tl { template <> struct type_traits<QHostAddress> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QHostAddress> &qtdecl_QHostAddress (); }
 
 class QHostInfo;
+
+namespace tl { template <> struct type_traits<QHostInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QHostInfo> &qtdecl_QHostInfo (); }
 
 class QIPv6Address;
+
+namespace tl { template <> struct type_traits<QIPv6Address> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QIPv6Address> &qtdecl_QIPv6Address (); }
 
 class QLocalServer;
+
+namespace tl { template <> struct type_traits<QLocalServer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QLocalServer> &qtdecl_QLocalServer (); }
 
 class QLocalSocket;
+
+namespace tl { template <> struct type_traits<QLocalSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QLocalSocket> &qtdecl_QLocalSocket (); }
 
 class QNetworkAccessManager;
+
+namespace tl { template <> struct type_traits<QNetworkAccessManager> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkAccessManager> &qtdecl_QNetworkAccessManager (); }
 
 class QNetworkAddressEntry;
+
+namespace tl { template <> struct type_traits<QNetworkAddressEntry> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkAddressEntry> &qtdecl_QNetworkAddressEntry (); }
 
 class QNetworkCacheMetaData;
+
+namespace tl { template <> struct type_traits<QNetworkCacheMetaData> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkCacheMetaData> &qtdecl_QNetworkCacheMetaData (); }
 
 class QNetworkCookie;
+
+namespace tl { template <> struct type_traits<QNetworkCookie> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkCookie> &qtdecl_QNetworkCookie (); }
 
 class QNetworkCookieJar;
+
+namespace tl { template <> struct type_traits<QNetworkCookieJar> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkCookieJar> &qtdecl_QNetworkCookieJar (); }
 
 class QNetworkDiskCache;
+
+namespace tl { template <> struct type_traits<QNetworkDiskCache> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkDiskCache> &qtdecl_QNetworkDiskCache (); }
 
 class QNetworkInterface;
+
+namespace tl { template <> struct type_traits<QNetworkInterface> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkInterface> &qtdecl_QNetworkInterface (); }
 
 class QNetworkProxy;
+
+namespace tl { template <> struct type_traits<QNetworkProxy> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkProxy> &qtdecl_QNetworkProxy (); }
 
 class QNetworkProxyFactory;
+
+namespace tl { template <> struct type_traits<QNetworkProxyFactory> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkProxyFactory> &qtdecl_QNetworkProxyFactory (); }
 
 class QNetworkProxyQuery;
+
+namespace tl { template <> struct type_traits<QNetworkProxyQuery> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkProxyQuery> &qtdecl_QNetworkProxyQuery (); }
 
 class QNetworkReply;
+
+namespace tl { template <> struct type_traits<QNetworkReply> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkReply> &qtdecl_QNetworkReply (); }
 
 class QNetworkRequest;
+
+namespace tl { template <> struct type_traits<QNetworkRequest> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkRequest> &qtdecl_QNetworkRequest (); }
 
 class QSslCertificate;
+
+namespace tl { template <> struct type_traits<QSslCertificate> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslCertificate> &qtdecl_QSslCertificate (); }
 
 class QSslCipher;
+
+namespace tl { template <> struct type_traits<QSslCipher> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslCipher> &qtdecl_QSslCipher (); }
 
 class QSslConfiguration;
+
+namespace tl { template <> struct type_traits<QSslConfiguration> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslConfiguration> &qtdecl_QSslConfiguration (); }
 
 class QSslError;
+
+namespace tl { template <> struct type_traits<QSslError> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslError> &qtdecl_QSslError (); }
 
 class QSslKey;
+
+namespace tl { template <> struct type_traits<QSslKey> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslKey> &qtdecl_QSslKey (); }
 
 class QSslSocket;
+
+namespace tl { template <> struct type_traits<QSslSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslSocket> &qtdecl_QSslSocket (); }
 
 class QTcpServer;
+
+namespace tl { template <> struct type_traits<QTcpServer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QTcpServer> &qtdecl_QTcpServer (); }
 
 class QTcpSocket;
+
+namespace tl { template <> struct type_traits<QTcpSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QTcpSocket> &qtdecl_QTcpSocket (); }
 
 class QUdpSocket;
+
+namespace tl { template <> struct type_traits<QUdpSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QUdpSocket> &qtdecl_QUdpSocket (); }
 
 class QUrlInfo;
+
+namespace tl { template <> struct type_traits<QUrlInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QUrlInfo> &qtdecl_QUrlInfo (); }
 
 
diff --git a/src/gsiqt/qt4/QtSql/gsiQtExternals.h b/src/gsiqt/qt4/QtSql/gsiQtExternals.h
index 7a71b6a35..68b366119 100644
--- a/src/gsiqt/qt4/QtSql/gsiQtExternals.h
+++ b/src/gsiqt/qt4/QtSql/gsiQtExternals.h
@@ -34,42 +34,103 @@
 #include "gsiQtSqlCommon.h"
 
 class QSqlDatabase;
+
+namespace tl { template <> struct type_traits<QSqlDatabase> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlDatabase> &qtdecl_QSqlDatabase (); }
 
 class QSqlDriver;
+
+namespace tl { template <> struct type_traits<QSqlDriver> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlDriver> &qtdecl_QSqlDriver (); }
 
 class QSqlDriverCreatorBase;
+
+namespace tl { template <> struct type_traits<QSqlDriverCreatorBase> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlDriverCreatorBase> &qtdecl_QSqlDriverCreatorBase (); }
 
 class QSqlError;
+
+namespace tl { template <> struct type_traits<QSqlError> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlError> &qtdecl_QSqlError (); }
 
 class QSqlField;
+
+namespace tl { template <> struct type_traits<QSqlField> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlField> &qtdecl_QSqlField (); }
 
 class QSqlIndex;
+
+namespace tl { template <> struct type_traits<QSqlIndex> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlIndex> &qtdecl_QSqlIndex (); }
 
 class QSqlQuery;
+
+namespace tl { template <> struct type_traits<QSqlQuery> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlQuery> &qtdecl_QSqlQuery (); }
 
 class QSqlQueryModel;
+
+namespace tl { template <> struct type_traits<QSqlQueryModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlQueryModel> &qtdecl_QSqlQueryModel (); }
 
 class QSqlRecord;
+
+namespace tl { template <> struct type_traits<QSqlRecord> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlRecord> &qtdecl_QSqlRecord (); }
 
 class QSqlRelation;
+
+namespace tl { template <> struct type_traits<QSqlRelation> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlRelation> &qtdecl_QSqlRelation (); }
 
 class QSqlRelationalTableModel;
+
+namespace tl { template <> struct type_traits<QSqlRelationalTableModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlRelationalTableModel> &qtdecl_QSqlRelationalTableModel (); }
 
 class QSqlResult;
+
+namespace tl { template <> struct type_traits<QSqlResult> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlResult> &qtdecl_QSqlResult (); }
 
 class QSqlTableModel;
+
+namespace tl { template <> struct type_traits<QSqlTableModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlTableModel> &qtdecl_QSqlTableModel (); }
 
 
diff --git a/src/gsiqt/qt4/QtXml/gsiQtExternals.h b/src/gsiqt/qt4/QtXml/gsiQtExternals.h
index aab65c016..0a2223e04 100644
--- a/src/gsiqt/qt4/QtXml/gsiQtExternals.h
+++ b/src/gsiqt/qt4/QtXml/gsiQtExternals.h
@@ -34,96 +34,240 @@
 #include "gsiQtXmlCommon.h"
 
 class QDomAttr;
+
+namespace tl { template <> struct type_traits<QDomAttr> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomAttr> &qtdecl_QDomAttr (); }
 
 class QDomCDATASection;
+
+namespace tl { template <> struct type_traits<QDomCDATASection> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomCDATASection> &qtdecl_QDomCDATASection (); }
 
 class QDomCharacterData;
+
+namespace tl { template <> struct type_traits<QDomCharacterData> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomCharacterData> &qtdecl_QDomCharacterData (); }
 
 class QDomComment;
+
+namespace tl { template <> struct type_traits<QDomComment> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomComment> &qtdecl_QDomComment (); }
 
 class QDomDocument;
+
+namespace tl { template <> struct type_traits<QDomDocument> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomDocument> &qtdecl_QDomDocument (); }
 
 class QDomDocumentFragment;
+
+namespace tl { template <> struct type_traits<QDomDocumentFragment> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomDocumentFragment> &qtdecl_QDomDocumentFragment (); }
 
 class QDomDocumentType;
+
+namespace tl { template <> struct type_traits<QDomDocumentType> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomDocumentType> &qtdecl_QDomDocumentType (); }
 
 class QDomElement;
+
+namespace tl { template <> struct type_traits<QDomElement> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomElement> &qtdecl_QDomElement (); }
 
 class QDomEntity;
+
+namespace tl { template <> struct type_traits<QDomEntity> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomEntity> &qtdecl_QDomEntity (); }
 
 class QDomEntityReference;
+
+namespace tl { template <> struct type_traits<QDomEntityReference> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomEntityReference> &qtdecl_QDomEntityReference (); }
 
 class QDomImplementation;
+
+namespace tl { template <> struct type_traits<QDomImplementation> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomImplementation> &qtdecl_QDomImplementation (); }
 
 class QDomNamedNodeMap;
+
+namespace tl { template <> struct type_traits<QDomNamedNodeMap> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomNamedNodeMap> &qtdecl_QDomNamedNodeMap (); }
 
 class QDomNode;
+
+namespace tl { template <> struct type_traits<QDomNode> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomNode> &qtdecl_QDomNode (); }
 
 class QDomNodeList;
+
+namespace tl { template <> struct type_traits<QDomNodeList> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomNodeList> &qtdecl_QDomNodeList (); }
 
 class QDomNotation;
+
+namespace tl { template <> struct type_traits<QDomNotation> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomNotation> &qtdecl_QDomNotation (); }
 
 class QDomProcessingInstruction;
+
+namespace tl { template <> struct type_traits<QDomProcessingInstruction> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomProcessingInstruction> &qtdecl_QDomProcessingInstruction (); }
 
 class QDomText;
+
+namespace tl { template <> struct type_traits<QDomText> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomText> &qtdecl_QDomText (); }
 
 class QXmlAttributes;
+
+namespace tl { template <> struct type_traits<QXmlAttributes> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlAttributes> &qtdecl_QXmlAttributes (); }
 
 class QXmlContentHandler;
+
+namespace tl { template <> struct type_traits<QXmlContentHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlContentHandler> &qtdecl_QXmlContentHandler (); }
 
 class QXmlDTDHandler;
+
+namespace tl { template <> struct type_traits<QXmlDTDHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlDTDHandler> &qtdecl_QXmlDTDHandler (); }
 
 class QXmlDeclHandler;
+
+namespace tl { template <> struct type_traits<QXmlDeclHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlDeclHandler> &qtdecl_QXmlDeclHandler (); }
 
 class QXmlDefaultHandler;
+
+namespace tl { template <> struct type_traits<QXmlDefaultHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlDefaultHandler> &qtdecl_QXmlDefaultHandler (); }
 
 class QXmlEntityResolver;
+
+namespace tl { template <> struct type_traits<QXmlEntityResolver> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlEntityResolver> &qtdecl_QXmlEntityResolver (); }
 
 class QXmlErrorHandler;
+
+namespace tl { template <> struct type_traits<QXmlErrorHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlErrorHandler> &qtdecl_QXmlErrorHandler (); }
 
 class QXmlInputSource;
+
+namespace tl { template <> struct type_traits<QXmlInputSource> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlInputSource> &qtdecl_QXmlInputSource (); }
 
 class QXmlLexicalHandler;
+
+namespace tl { template <> struct type_traits<QXmlLexicalHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlLexicalHandler> &qtdecl_QXmlLexicalHandler (); }
 
 class QXmlLocator;
+
+namespace tl { template <> struct type_traits<QXmlLocator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlLocator> &qtdecl_QXmlLocator (); }
 
 class QXmlNamespaceSupport;
+
+namespace tl { template <> struct type_traits<QXmlNamespaceSupport> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlNamespaceSupport> &qtdecl_QXmlNamespaceSupport (); }
 
 class QXmlParseException;
+
+namespace tl { template <> struct type_traits<QXmlParseException> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlParseException> &qtdecl_QXmlParseException (); }
 
 class QXmlReader;
+
+namespace tl { template <> struct type_traits<QXmlReader> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlReader> &qtdecl_QXmlReader (); }
 
 class QXmlSimpleReader;
+
+namespace tl { template <> struct type_traits<QXmlSimpleReader> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlSimpleReader> &qtdecl_QXmlSimpleReader (); }
 
 
diff --git a/src/gsiqt/qt5/QtCore/gsiQtExternals.h b/src/gsiqt/qt5/QtCore/gsiQtExternals.h
index aceb9b040..52b63d1a9 100644
--- a/src/gsiqt/qt5/QtCore/gsiQtExternals.h
+++ b/src/gsiqt/qt5/QtCore/gsiQtExternals.h
@@ -34,474 +34,1230 @@
 #include "gsiQtCoreCommon.h"
 
 class QAbstractAnimation;
+
+namespace tl { template <> struct type_traits<QAbstractAnimation> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAbstractAnimation> &qtdecl_QAbstractAnimation (); }
 
 class QAbstractEventDispatcher;
+
+namespace tl { template <> struct type_traits<QAbstractEventDispatcher> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAbstractEventDispatcher> &qtdecl_QAbstractEventDispatcher (); }
 
 class QAbstractItemModel;
+
+namespace tl { template <> struct type_traits<QAbstractItemModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAbstractItemModel> &qtdecl_QAbstractItemModel (); }
 
 class QAbstractListModel;
+
+namespace tl { template <> struct type_traits<QAbstractListModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAbstractListModel> &qtdecl_QAbstractListModel (); }
 
 class QAbstractNativeEventFilter;
+
+namespace tl { template <> struct type_traits<QAbstractNativeEventFilter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAbstractNativeEventFilter> &qtdecl_QAbstractNativeEventFilter (); }
 
 class QAbstractProxyModel;
+
+namespace tl { template <> struct type_traits<QAbstractProxyModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAbstractProxyModel> &qtdecl_QAbstractProxyModel (); }
 
 class QAbstractState;
+
+namespace tl { template <> struct type_traits<QAbstractState> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAbstractState> &qtdecl_QAbstractState (); }
 
 class QAbstractTableModel;
+
+namespace tl { template <> struct type_traits<QAbstractTableModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAbstractTableModel> &qtdecl_QAbstractTableModel (); }
 
 class QAbstractTransition;
+
+namespace tl { template <> struct type_traits<QAbstractTransition> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAbstractTransition> &qtdecl_QAbstractTransition (); }
 
 class QAnimationDriver;
+
+namespace tl { template <> struct type_traits<QAnimationDriver> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAnimationDriver> &qtdecl_QAnimationDriver (); }
 
 class QAnimationGroup;
+
+namespace tl { template <> struct type_traits<QAnimationGroup> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAnimationGroup> &qtdecl_QAnimationGroup (); }
 
 class QAssociativeIterable;
+
+namespace tl { template <> struct type_traits<QAssociativeIterable> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAssociativeIterable> &qtdecl_QAssociativeIterable (); }
 
 class QBasicMutex;
+
+namespace tl { template <> struct type_traits<QBasicMutex> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QBasicMutex> &qtdecl_QBasicMutex (); }
 
 class QBasicTimer;
+
+namespace tl { template <> struct type_traits<QBasicTimer> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QBasicTimer> &qtdecl_QBasicTimer (); }
 
 class QBuffer;
+
+namespace tl { template <> struct type_traits<QBuffer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QBuffer> &qtdecl_QBuffer (); }
 
 struct QByteArrayDataPtr;
+
+namespace tl { template <> struct type_traits<QByteArrayDataPtr> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QByteArrayDataPtr> &qtdecl_QByteArrayDataPtr (); }
 
 class QByteArrayMatcher;
+
+namespace tl { template <> struct type_traits<QByteArrayMatcher> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QByteArrayMatcher> &qtdecl_QByteArrayMatcher (); }
 
 class QChildEvent;
+
+namespace tl { template <> struct type_traits<QChildEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QChildEvent> &qtdecl_QChildEvent (); }
 
 class QCollator;
+
+namespace tl { template <> struct type_traits<QCollator> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QCollator> &qtdecl_QCollator (); }
 
 class QCollatorSortKey;
+
+namespace tl { template <> struct type_traits<QCollatorSortKey> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QCollatorSortKey> &qtdecl_QCollatorSortKey (); }
 
 class QCommandLineOption;
+
+namespace tl { template <> struct type_traits<QCommandLineOption> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QCommandLineOption> &qtdecl_QCommandLineOption (); }
 
 class QCommandLineParser;
+
+namespace tl { template <> struct type_traits<QCommandLineParser> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QCommandLineParser> &qtdecl_QCommandLineParser (); }
 
 class QCoreApplication;
+
+namespace tl { template <> struct type_traits<QCoreApplication> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QCoreApplication> &qtdecl_QCoreApplication (); }
 
 class QCryptographicHash;
+
+namespace tl { template <> struct type_traits<QCryptographicHash> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QCryptographicHash> &qtdecl_QCryptographicHash (); }
 
 class QDataStream;
+
+namespace tl { template <> struct type_traits<QDataStream> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDataStream> &qtdecl_QDataStream (); }
 
 class QDate;
+
+namespace tl { template <> struct type_traits<QDate> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDate> &qtdecl_QDate (); }
 
 class QDateTime;
+
+namespace tl { template <> struct type_traits<QDateTime> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDateTime> &qtdecl_QDateTime (); }
 
 class QDebug;
+
+namespace tl { template <> struct type_traits<QDebug> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDebug> &qtdecl_QDebug (); }
 
 class QDebugStateSaver;
+
+namespace tl { template <> struct type_traits<QDebugStateSaver> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDebugStateSaver> &qtdecl_QDebugStateSaver (); }
 
 class QDeferredDeleteEvent;
+
+namespace tl { template <> struct type_traits<QDeferredDeleteEvent> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDeferredDeleteEvent> &qtdecl_QDeferredDeleteEvent (); }
 
 class QDir;
+
+namespace tl { template <> struct type_traits<QDir> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDir> &qtdecl_QDir (); }
 
 class QDirIterator;
+
+namespace tl { template <> struct type_traits<QDirIterator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDirIterator> &qtdecl_QDirIterator (); }
 
 class QDynamicPropertyChangeEvent;
+
+namespace tl { template <> struct type_traits<QDynamicPropertyChangeEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDynamicPropertyChangeEvent> &qtdecl_QDynamicPropertyChangeEvent (); }
 
 class QEasingCurve;
+
+namespace tl { template <> struct type_traits<QEasingCurve> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QEasingCurve> &qtdecl_QEasingCurve (); }
 
 class QElapsedTimer;
+
+namespace tl { template <> struct type_traits<QElapsedTimer> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QElapsedTimer> &qtdecl_QElapsedTimer (); }
 
 class QEvent;
+
+namespace tl { template <> struct type_traits<QEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QEvent> &qtdecl_QEvent (); }
 
 class QEventLoop;
+
+namespace tl { template <> struct type_traits<QEventLoop> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QEventLoop> &qtdecl_QEventLoop (); }
 
 class QEventLoopLocker;
+
+namespace tl { template <> struct type_traits<QEventLoopLocker> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QEventLoopLocker> &qtdecl_QEventLoopLocker (); }
 
 class QEventTransition;
+
+namespace tl { template <> struct type_traits<QEventTransition> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QEventTransition> &qtdecl_QEventTransition (); }
 
 struct QFactoryInterface;
+
+namespace tl { template <> struct type_traits<QFactoryInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QFactoryInterface> &qtdecl_QFactoryInterface (); }
 
 class QFile;
+
+namespace tl { template <> struct type_traits<QFile> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QFile> &qtdecl_QFile (); }
 
 class QFileDevice;
+
+namespace tl { template <> struct type_traits<QFileDevice> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QFileDevice> &qtdecl_QFileDevice (); }
 
 class QFileInfo;
+
+namespace tl { template <> struct type_traits<QFileInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QFileInfo> &qtdecl_QFileInfo (); }
 
 class QFileSelector;
+
+namespace tl { template <> struct type_traits<QFileSelector> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QFileSelector> &qtdecl_QFileSelector (); }
 
 class QFileSystemWatcher;
+
+namespace tl { template <> struct type_traits<QFileSystemWatcher> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QFileSystemWatcher> &qtdecl_QFileSystemWatcher (); }
 
 class QFinalState;
+
+namespace tl { template <> struct type_traits<QFinalState> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QFinalState> &qtdecl_QFinalState (); }
 
 class QHistoryState;
+
+namespace tl { template <> struct type_traits<QHistoryState> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QHistoryState> &qtdecl_QHistoryState (); }
 
 class QIODevice;
+
+namespace tl { template <> struct type_traits<QIODevice> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QIODevice> &qtdecl_QIODevice (); }
 
 class QIdentityProxyModel;
+
+namespace tl { template <> struct type_traits<QIdentityProxyModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QIdentityProxyModel> &qtdecl_QIdentityProxyModel (); }
 
 class QItemSelection;
+
+namespace tl { template <> struct type_traits<QItemSelection> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QItemSelection> &qtdecl_QItemSelection (); }
 
 class QItemSelectionModel;
+
+namespace tl { template <> struct type_traits<QItemSelectionModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QItemSelectionModel> &qtdecl_QItemSelectionModel (); }
 
 class QItemSelectionRange;
+
+namespace tl { template <> struct type_traits<QItemSelectionRange> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QItemSelectionRange> &qtdecl_QItemSelectionRange (); }
 
 class QJsonArray;
+
+namespace tl { template <> struct type_traits<QJsonArray> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QJsonArray> &qtdecl_QJsonArray (); }
 
 class QJsonDocument;
+
+namespace tl { template <> struct type_traits<QJsonDocument> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QJsonDocument> &qtdecl_QJsonDocument (); }
 
 class QJsonObject;
+
+namespace tl { template <> struct type_traits<QJsonObject> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QJsonObject> &qtdecl_QJsonObject (); }
 
 struct QJsonParseError;
+
+namespace tl { template <> struct type_traits<QJsonParseError> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QJsonParseError> &qtdecl_QJsonParseError (); }
 
 class QJsonValue;
+
+namespace tl { template <> struct type_traits<QJsonValue> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QJsonValue> &qtdecl_QJsonValue (); }
 
 class QJsonValuePtr;
+
+namespace tl { template <> struct type_traits<QJsonValuePtr> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QJsonValuePtr> &qtdecl_QJsonValuePtr (); }
 
 class QJsonValueRef;
+
+namespace tl { template <> struct type_traits<QJsonValueRef> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QJsonValueRef> &qtdecl_QJsonValueRef (); }
 
 class QJsonValueRefPtr;
+
+namespace tl { template <> struct type_traits<QJsonValueRefPtr> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QJsonValueRefPtr> &qtdecl_QJsonValueRefPtr (); }
 
 class QLibrary;
+
+namespace tl { template <> struct type_traits<QLibrary> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QLibrary> &qtdecl_QLibrary (); }
 
 class QLibraryInfo;
+
+namespace tl { template <> struct type_traits<QLibraryInfo> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QLibraryInfo> &qtdecl_QLibraryInfo (); }
 
 class QLine;
+
+namespace tl { template <> struct type_traits<QLine> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QLine> &qtdecl_QLine (); }
 
 class QLineF;
+
+namespace tl { template <> struct type_traits<QLineF> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QLineF> &qtdecl_QLineF (); }
 
 class QLocale;
+
+namespace tl { template <> struct type_traits<QLocale> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QLocale> &qtdecl_QLocale (); }
 
 class QLockFile;
+
+namespace tl { template <> struct type_traits<QLockFile> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QLockFile> &qtdecl_QLockFile (); }
 
 class QLoggingCategory;
+
+namespace tl { template <> struct type_traits<QLoggingCategory> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QLoggingCategory> &qtdecl_QLoggingCategory (); }
 
 struct QMapDataBase;
+
+namespace tl { template <> struct type_traits<QMapDataBase> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMapDataBase> &qtdecl_QMapDataBase (); }
 
 struct QMapNodeBase;
+
+namespace tl { template <> struct type_traits<QMapNodeBase> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMapNodeBase> &qtdecl_QMapNodeBase (); }
 
 class QMargins;
+
+namespace tl { template <> struct type_traits<QMargins> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMargins> &qtdecl_QMargins (); }
 
 class QMarginsF;
+
+namespace tl { template <> struct type_traits<QMarginsF> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMarginsF> &qtdecl_QMarginsF (); }
 
 class QMessageAuthenticationCode;
+
+namespace tl { template <> struct type_traits<QMessageAuthenticationCode> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMessageAuthenticationCode> &qtdecl_QMessageAuthenticationCode (); }
 
 class QMessageLogContext;
+
+namespace tl { template <> struct type_traits<QMessageLogContext> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMessageLogContext> &qtdecl_QMessageLogContext (); }
 
 class QMessageLogger;
+
+namespace tl { template <> struct type_traits<QMessageLogger> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMessageLogger> &qtdecl_QMessageLogger (); }
 
 class QMetaClassInfo;
+
+namespace tl { template <> struct type_traits<QMetaClassInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMetaClassInfo> &qtdecl_QMetaClassInfo (); }
 
 class QMetaEnum;
+
+namespace tl { template <> struct type_traits<QMetaEnum> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMetaEnum> &qtdecl_QMetaEnum (); }
 
 class QMetaMethod;
+
+namespace tl { template <> struct type_traits<QMetaMethod> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMetaMethod> &qtdecl_QMetaMethod (); }
 
 struct QMetaObject;
+
+namespace tl { template <> struct type_traits<QMetaObject> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMetaObject> &qtdecl_QMetaObject (); }
 
 class QMetaProperty;
+
+namespace tl { template <> struct type_traits<QMetaProperty> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMetaProperty> &qtdecl_QMetaProperty (); }
 
 class QMimeData;
+
+namespace tl { template <> struct type_traits<QMimeData> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMimeData> &qtdecl_QMimeData (); }
 
 class QMimeDatabase;
+
+namespace tl { template <> struct type_traits<QMimeDatabase> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMimeDatabase> &qtdecl_QMimeDatabase (); }
 
 class QMimeType;
+
+namespace tl { template <> struct type_traits<QMimeType> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMimeType> &qtdecl_QMimeType (); }
 
 class QModelIndex;
+
+namespace tl { template <> struct type_traits<QModelIndex> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QModelIndex> &qtdecl_QModelIndex (); }
 
 class QMutex;
+
+namespace tl { template <> struct type_traits<QMutex> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMutex> &qtdecl_QMutex (); }
 
 class QNoDebug;
+
+namespace tl { template <> struct type_traits<QNoDebug> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QNoDebug> &qtdecl_QNoDebug (); }
 
 class QObject;
+
+namespace tl { template <> struct type_traits<QObject> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QObject> &qtdecl_QObject (); }
 
 class QParallelAnimationGroup;
+
+namespace tl { template <> struct type_traits<QParallelAnimationGroup> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QParallelAnimationGroup> &qtdecl_QParallelAnimationGroup (); }
 
 class QPauseAnimation;
+
+namespace tl { template <> struct type_traits<QPauseAnimation> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QPauseAnimation> &qtdecl_QPauseAnimation (); }
 
 class QPersistentModelIndex;
+
+namespace tl { template <> struct type_traits<QPersistentModelIndex> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QPersistentModelIndex> &qtdecl_QPersistentModelIndex (); }
 
 class QPluginLoader;
+
+namespace tl { template <> struct type_traits<QPluginLoader> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QPluginLoader> &qtdecl_QPluginLoader (); }
 
 class QPoint;
+
+namespace tl { template <> struct type_traits<QPoint> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QPoint> &qtdecl_QPoint (); }
 
 class QPointF;
+
+namespace tl { template <> struct type_traits<QPointF> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QPointF> &qtdecl_QPointF (); }
 
 class QProcess;
+
+namespace tl { template <> struct type_traits<QProcess> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QProcess> &qtdecl_QProcess (); }
 
 class QProcessEnvironment;
+
+namespace tl { template <> struct type_traits<QProcessEnvironment> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QProcessEnvironment> &qtdecl_QProcessEnvironment (); }
 
 class QPropertyAnimation;
+
+namespace tl { template <> struct type_traits<QPropertyAnimation> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QPropertyAnimation> &qtdecl_QPropertyAnimation (); }
 
 class QReadLocker;
+
+namespace tl { template <> struct type_traits<QReadLocker> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QReadLocker> &qtdecl_QReadLocker (); }
 
 class QReadWriteLock;
+
+namespace tl { template <> struct type_traits<QReadWriteLock> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QReadWriteLock> &qtdecl_QReadWriteLock (); }
 
 class QRect;
+
+namespace tl { template <> struct type_traits<QRect> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QRect> &qtdecl_QRect (); }
 
 class QRectF;
+
+namespace tl { template <> struct type_traits<QRectF> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QRectF> &qtdecl_QRectF (); }
 
 class QRegExp;
+
+namespace tl { template <> struct type_traits<QRegExp> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QRegExp> &qtdecl_QRegExp (); }
 
 class QRegularExpression;
+
+namespace tl { template <> struct type_traits<QRegularExpression> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QRegularExpression> &qtdecl_QRegularExpression (); }
 
 class QRegularExpressionMatch;
+
+namespace tl { template <> struct type_traits<QRegularExpressionMatch> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QRegularExpressionMatch> &qtdecl_QRegularExpressionMatch (); }
 
 class QRegularExpressionMatchIterator;
+
+namespace tl { template <> struct type_traits<QRegularExpressionMatchIterator> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QRegularExpressionMatchIterator> &qtdecl_QRegularExpressionMatchIterator (); }
 
 class QResource;
+
+namespace tl { template <> struct type_traits<QResource> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QResource> &qtdecl_QResource (); }
 
 class QRunnable;
+
+namespace tl { template <> struct type_traits<QRunnable> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QRunnable> &qtdecl_QRunnable (); }
 
 class QSaveFile;
+
+namespace tl { template <> struct type_traits<QSaveFile> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSaveFile> &qtdecl_QSaveFile (); }
 
 class QSemaphore;
+
+namespace tl { template <> struct type_traits<QSemaphore> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSemaphore> &qtdecl_QSemaphore (); }
 
 class QSequentialAnimationGroup;
+
+namespace tl { template <> struct type_traits<QSequentialAnimationGroup> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSequentialAnimationGroup> &qtdecl_QSequentialAnimationGroup (); }
 
 class QSequentialIterable;
+
+namespace tl { template <> struct type_traits<QSequentialIterable> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSequentialIterable> &qtdecl_QSequentialIterable (); }
 
 class QSettings;
+
+namespace tl { template <> struct type_traits<QSettings> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSettings> &qtdecl_QSettings (); }
 
 class QSharedMemory;
+
+namespace tl { template <> struct type_traits<QSharedMemory> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSharedMemory> &qtdecl_QSharedMemory (); }
 
 class QSignalBlocker;
+
+namespace tl { template <> struct type_traits<QSignalBlocker> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSignalBlocker> &qtdecl_QSignalBlocker (); }
 
 class QSignalMapper;
+
+namespace tl { template <> struct type_traits<QSignalMapper> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSignalMapper> &qtdecl_QSignalMapper (); }
 
 class QSignalTransition;
+
+namespace tl { template <> struct type_traits<QSignalTransition> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSignalTransition> &qtdecl_QSignalTransition (); }
 
 class QSize;
+
+namespace tl { template <> struct type_traits<QSize> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSize> &qtdecl_QSize (); }
 
 class QSizeF;
+
+namespace tl { template <> struct type_traits<QSizeF> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSizeF> &qtdecl_QSizeF (); }
 
 class QSocketNotifier;
+
+namespace tl { template <> struct type_traits<QSocketNotifier> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSocketNotifier> &qtdecl_QSocketNotifier (); }
 
 class QSortFilterProxyModel;
+
+namespace tl { template <> struct type_traits<QSortFilterProxyModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSortFilterProxyModel> &qtdecl_QSortFilterProxyModel (); }
 
 class QStandardPaths;
+
+namespace tl { template <> struct type_traits<QStandardPaths> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QStandardPaths> &qtdecl_QStandardPaths (); }
 
 class QState;
+
+namespace tl { template <> struct type_traits<QState> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QState> &qtdecl_QState (); }
 
 class QStateMachine;
+
+namespace tl { template <> struct type_traits<QStateMachine> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QStateMachine> &qtdecl_QStateMachine (); }
 
 struct QStaticPlugin;
+
+namespace tl { template <> struct type_traits<QStaticPlugin> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QStaticPlugin> &qtdecl_QStaticPlugin (); }
 
 class QStorageInfo;
+
+namespace tl { template <> struct type_traits<QStorageInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QStorageInfo> &qtdecl_QStorageInfo (); }
 
 struct QStringDataPtr;
+
+namespace tl { template <> struct type_traits<QStringDataPtr> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QStringDataPtr> &qtdecl_QStringDataPtr (); }
 
 class QStringListModel;
+
+namespace tl { template <> struct type_traits<QStringListModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QStringListModel> &qtdecl_QStringListModel (); }
 
 class QStringMatcher;
+
+namespace tl { template <> struct type_traits<QStringMatcher> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QStringMatcher> &qtdecl_QStringMatcher (); }
 
 class QSysInfo;
+
+namespace tl { template <> struct type_traits<QSysInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSysInfo> &qtdecl_QSysInfo (); }
 
 class QSystemSemaphore;
+
+namespace tl { template <> struct type_traits<QSystemSemaphore> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSystemSemaphore> &qtdecl_QSystemSemaphore (); }
 
 class QTemporaryDir;
+
+namespace tl { template <> struct type_traits<QTemporaryDir> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTemporaryDir> &qtdecl_QTemporaryDir (); }
 
 class QTemporaryFile;
+
+namespace tl { template <> struct type_traits<QTemporaryFile> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTemporaryFile> &qtdecl_QTemporaryFile (); }
 
 class QTextBoundaryFinder;
+
+namespace tl { template <> struct type_traits<QTextBoundaryFinder> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTextBoundaryFinder> &qtdecl_QTextBoundaryFinder (); }
 
 class QTextCodec;
+
+namespace tl { template <> struct type_traits<QTextCodec> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTextCodec> &qtdecl_QTextCodec (); }
 
 class QTextDecoder;
+
+namespace tl { template <> struct type_traits<QTextDecoder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTextDecoder> &qtdecl_QTextDecoder (); }
 
 class QTextEncoder;
+
+namespace tl { template <> struct type_traits<QTextEncoder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTextEncoder> &qtdecl_QTextEncoder (); }
 
 class QTextStream;
+
+namespace tl { template <> struct type_traits<QTextStream> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTextStream> &qtdecl_QTextStream (); }
 
 class QThread;
+
+namespace tl { template <> struct type_traits<QThread> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QThread> &qtdecl_QThread (); }
 
 class QThreadPool;
+
+namespace tl { template <> struct type_traits<QThreadPool> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QThreadPool> &qtdecl_QThreadPool (); }
 
 class QTime;
+
+namespace tl { template <> struct type_traits<QTime> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTime> &qtdecl_QTime (); }
 
 class QTimeLine;
+
+namespace tl { template <> struct type_traits<QTimeLine> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTimeLine> &qtdecl_QTimeLine (); }
 
 class QTimeZone;
+
+namespace tl { template <> struct type_traits<QTimeZone> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTimeZone> &qtdecl_QTimeZone (); }
 
 class QTimer;
+
+namespace tl { template <> struct type_traits<QTimer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTimer> &qtdecl_QTimer (); }
 
 class QTimerEvent;
+
+namespace tl { template <> struct type_traits<QTimerEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTimerEvent> &qtdecl_QTimerEvent (); }
 
 class QTranslator;
+
+namespace tl { template <> struct type_traits<QTranslator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTranslator> &qtdecl_QTranslator (); }
 
 class QUrl;
+
+namespace tl { template <> struct type_traits<QUrl> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QUrl> &qtdecl_QUrl (); }
 
 class QUrlQuery;
+
+namespace tl { template <> struct type_traits<QUrlQuery> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QUrlQuery> &qtdecl_QUrlQuery (); }
 
 class QVariantAnimation;
+
+namespace tl { template <> struct type_traits<QVariantAnimation> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QVariantAnimation> &qtdecl_QVariantAnimation (); }
 
 class QWaitCondition;
+
+namespace tl { template <> struct type_traits<QWaitCondition> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QWaitCondition> &qtdecl_QWaitCondition (); }
 
 class QWriteLocker;
+
+namespace tl { template <> struct type_traits<QWriteLocker> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QWriteLocker> &qtdecl_QWriteLocker (); }
 
 class QXmlStreamAttribute;
+
+namespace tl { template <> struct type_traits<QXmlStreamAttribute> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QXmlStreamAttribute> &qtdecl_QXmlStreamAttribute (); }
 
 class QXmlStreamAttributes;
+
+namespace tl { template <> struct type_traits<QXmlStreamAttributes> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QXmlStreamAttributes> &qtdecl_QXmlStreamAttributes (); }
 
 class QXmlStreamEntityDeclaration;
+
+namespace tl { template <> struct type_traits<QXmlStreamEntityDeclaration> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QXmlStreamEntityDeclaration> &qtdecl_QXmlStreamEntityDeclaration (); }
 
 class QXmlStreamEntityResolver;
+
+namespace tl { template <> struct type_traits<QXmlStreamEntityResolver> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QXmlStreamEntityResolver> &qtdecl_QXmlStreamEntityResolver (); }
 
 class QXmlStreamNamespaceDeclaration;
+
+namespace tl { template <> struct type_traits<QXmlStreamNamespaceDeclaration> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QXmlStreamNamespaceDeclaration> &qtdecl_QXmlStreamNamespaceDeclaration (); }
 
 class QXmlStreamNotationDeclaration;
+
+namespace tl { template <> struct type_traits<QXmlStreamNotationDeclaration> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QXmlStreamNotationDeclaration> &qtdecl_QXmlStreamNotationDeclaration (); }
 
 class QXmlStreamReader;
+
+namespace tl { template <> struct type_traits<QXmlStreamReader> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QXmlStreamReader> &qtdecl_QXmlStreamReader (); }
 
 class QXmlStreamStringRef;
+
+namespace tl { template <> struct type_traits<QXmlStreamStringRef> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QXmlStreamStringRef> &qtdecl_QXmlStreamStringRef (); }
 
 class QXmlStreamWriter;
+
+namespace tl { template <> struct type_traits<QXmlStreamWriter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QXmlStreamWriter> &qtdecl_QXmlStreamWriter (); }
 
 
diff --git a/src/gsiqt/qt5/QtDesigner/gsiQtExternals.h b/src/gsiqt/qt5/QtDesigner/gsiQtExternals.h
index 70bf4605b..d22bfdd17 100644
--- a/src/gsiqt/qt5/QtDesigner/gsiQtExternals.h
+++ b/src/gsiqt/qt5/QtDesigner/gsiQtExternals.h
@@ -34,15 +34,37 @@
 #include "gsiQtDesignerCommon.h"
 
 class QAbstractExtensionFactory;
+
+namespace tl { template <> struct type_traits<QAbstractExtensionFactory> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTDESIGNER_PUBLIC gsi::Class<QAbstractExtensionFactory> &qtdecl_QAbstractExtensionFactory (); }
 
 class QAbstractExtensionManager;
+
+namespace tl { template <> struct type_traits<QAbstractExtensionManager> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTDESIGNER_PUBLIC gsi::Class<QAbstractExtensionManager> &qtdecl_QAbstractExtensionManager (); }
 
 class QAbstractFormBuilder;
+
+namespace tl { template <> struct type_traits<QAbstractFormBuilder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTDESIGNER_PUBLIC gsi::Class<QAbstractFormBuilder> &qtdecl_QAbstractFormBuilder (); }
 
 class QFormBuilder;
+
+namespace tl { template <> struct type_traits<QFormBuilder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTDESIGNER_PUBLIC gsi::Class<QFormBuilder> &qtdecl_QFormBuilder (); }
 
 
diff --git a/src/gsiqt/qt5/QtGui/gsiQtExternals.h b/src/gsiqt/qt5/QtGui/gsiQtExternals.h
index 21cc01ff4..b010fceea 100644
--- a/src/gsiqt/qt5/QtGui/gsiQtExternals.h
+++ b/src/gsiqt/qt5/QtGui/gsiQtExternals.h
@@ -34,501 +34,1323 @@
 #include "gsiQtGuiCommon.h"
 
 class QAbstractTextDocumentLayout;
+
+namespace tl { template <> struct type_traits<QAbstractTextDocumentLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAbstractTextDocumentLayout> &qtdecl_QAbstractTextDocumentLayout (); }
 
 class QAbstractUndoItem;
+
+namespace tl { template <> struct type_traits<QAbstractUndoItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAbstractUndoItem> &qtdecl_QAbstractUndoItem (); }
 
 class QAccessible;
+
+namespace tl { template <> struct type_traits<QAccessible> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessible> &qtdecl_QAccessible (); }
 
 class QAccessibleActionInterface;
+
+namespace tl { template <> struct type_traits<QAccessibleActionInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleActionInterface> &qtdecl_QAccessibleActionInterface (); }
 
 class QAccessibleEditableTextInterface;
+
+namespace tl { template <> struct type_traits<QAccessibleEditableTextInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleEditableTextInterface> &qtdecl_QAccessibleEditableTextInterface (); }
 
 class QAccessibleEvent;
+
+namespace tl { template <> struct type_traits<QAccessibleEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleEvent> &qtdecl_QAccessibleEvent (); }
 
 class QAccessibleImageInterface;
+
+namespace tl { template <> struct type_traits<QAccessibleImageInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleImageInterface> &qtdecl_QAccessibleImageInterface (); }
 
 class QAccessibleInterface;
+
+namespace tl { template <> struct type_traits<QAccessibleInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleInterface> &qtdecl_QAccessibleInterface (); }
 
 class QAccessibleObject;
+
+namespace tl { template <> struct type_traits<QAccessibleObject> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleObject> &qtdecl_QAccessibleObject (); }
 
 class QAccessibleStateChangeEvent;
+
+namespace tl { template <> struct type_traits<QAccessibleStateChangeEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleStateChangeEvent> &qtdecl_QAccessibleStateChangeEvent (); }
 
 class QAccessibleTableCellInterface;
+
+namespace tl { template <> struct type_traits<QAccessibleTableCellInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleTableCellInterface> &qtdecl_QAccessibleTableCellInterface (); }
 
 class QAccessibleTableInterface;
+
+namespace tl { template <> struct type_traits<QAccessibleTableInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleTableInterface> &qtdecl_QAccessibleTableInterface (); }
 
 class QAccessibleTableModelChangeEvent;
+
+namespace tl { template <> struct type_traits<QAccessibleTableModelChangeEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleTableModelChangeEvent> &qtdecl_QAccessibleTableModelChangeEvent (); }
 
 class QAccessibleTextCursorEvent;
+
+namespace tl { template <> struct type_traits<QAccessibleTextCursorEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleTextCursorEvent> &qtdecl_QAccessibleTextCursorEvent (); }
 
 class QAccessibleTextInsertEvent;
+
+namespace tl { template <> struct type_traits<QAccessibleTextInsertEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleTextInsertEvent> &qtdecl_QAccessibleTextInsertEvent (); }
 
 class QAccessibleTextInterface;
+
+namespace tl { template <> struct type_traits<QAccessibleTextInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleTextInterface> &qtdecl_QAccessibleTextInterface (); }
 
 class QAccessibleTextRemoveEvent;
+
+namespace tl { template <> struct type_traits<QAccessibleTextRemoveEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleTextRemoveEvent> &qtdecl_QAccessibleTextRemoveEvent (); }
 
 class QAccessibleTextSelectionEvent;
+
+namespace tl { template <> struct type_traits<QAccessibleTextSelectionEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleTextSelectionEvent> &qtdecl_QAccessibleTextSelectionEvent (); }
 
 class QAccessibleTextUpdateEvent;
+
+namespace tl { template <> struct type_traits<QAccessibleTextUpdateEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleTextUpdateEvent> &qtdecl_QAccessibleTextUpdateEvent (); }
 
 class QAccessibleValueChangeEvent;
+
+namespace tl { template <> struct type_traits<QAccessibleValueChangeEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleValueChangeEvent> &qtdecl_QAccessibleValueChangeEvent (); }
 
 class QAccessibleValueInterface;
+
+namespace tl { template <> struct type_traits<QAccessibleValueInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QAccessibleValueInterface> &qtdecl_QAccessibleValueInterface (); }
 
 class QActionEvent;
+
+namespace tl { template <> struct type_traits<QActionEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QActionEvent> &qtdecl_QActionEvent (); }
 
 class QApplicationStateChangeEvent;
+
+namespace tl { template <> struct type_traits<QApplicationStateChangeEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QApplicationStateChangeEvent> &qtdecl_QApplicationStateChangeEvent (); }
 
 class QBackingStore;
+
+namespace tl { template <> struct type_traits<QBackingStore> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QBackingStore> &qtdecl_QBackingStore (); }
 
 class QBitmap;
+
+namespace tl { template <> struct type_traits<QBitmap> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QBitmap> &qtdecl_QBitmap (); }
 
 class QBrush;
+
+namespace tl { template <> struct type_traits<QBrush> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QBrush> &qtdecl_QBrush (); }
 
 class QClipboard;
+
+namespace tl { template <> struct type_traits<QClipboard> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QClipboard> &qtdecl_QClipboard (); }
 
 class QCloseEvent;
+
+namespace tl { template <> struct type_traits<QCloseEvent> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QCloseEvent> &qtdecl_QCloseEvent (); }
 
 class QColor;
+
+namespace tl { template <> struct type_traits<QColor> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QColor> &qtdecl_QColor (); }
 
 class QConicalGradient;
+
+namespace tl { template <> struct type_traits<QConicalGradient> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QConicalGradient> &qtdecl_QConicalGradient (); }
 
 class QContextMenuEvent;
+
+namespace tl { template <> struct type_traits<QContextMenuEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QContextMenuEvent> &qtdecl_QContextMenuEvent (); }
 
 class QCursor;
+
+namespace tl { template <> struct type_traits<QCursor> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QCursor> &qtdecl_QCursor (); }
 
 class QDesktopServices;
+
+namespace tl { template <> struct type_traits<QDesktopServices> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDesktopServices> &qtdecl_QDesktopServices (); }
 
 class QDoubleValidator;
+
+namespace tl { template <> struct type_traits<QDoubleValidator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDoubleValidator> &qtdecl_QDoubleValidator (); }
 
 class QDrag;
+
+namespace tl { template <> struct type_traits<QDrag> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDrag> &qtdecl_QDrag (); }
 
 class QDragEnterEvent;
+
+namespace tl { template <> struct type_traits<QDragEnterEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDragEnterEvent> &qtdecl_QDragEnterEvent (); }
 
 class QDragLeaveEvent;
+
+namespace tl { template <> struct type_traits<QDragLeaveEvent> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDragLeaveEvent> &qtdecl_QDragLeaveEvent (); }
 
 class QDragMoveEvent;
+
+namespace tl { template <> struct type_traits<QDragMoveEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDragMoveEvent> &qtdecl_QDragMoveEvent (); }
 
 class QDropEvent;
+
+namespace tl { template <> struct type_traits<QDropEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QDropEvent> &qtdecl_QDropEvent (); }
 
 class QEnterEvent;
+
+namespace tl { template <> struct type_traits<QEnterEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QEnterEvent> &qtdecl_QEnterEvent (); }
 
 class QExposeEvent;
+
+namespace tl { template <> struct type_traits<QExposeEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QExposeEvent> &qtdecl_QExposeEvent (); }
 
 class QFileOpenEvent;
+
+namespace tl { template <> struct type_traits<QFileOpenEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFileOpenEvent> &qtdecl_QFileOpenEvent (); }
 
 class QFocusEvent;
+
+namespace tl { template <> struct type_traits<QFocusEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFocusEvent> &qtdecl_QFocusEvent (); }
 
 class QFont;
+
+namespace tl { template <> struct type_traits<QFont> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFont> &qtdecl_QFont (); }
 
 class QFontDatabase;
+
+namespace tl { template <> struct type_traits<QFontDatabase> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFontDatabase> &qtdecl_QFontDatabase (); }
 
 class QFontInfo;
+
+namespace tl { template <> struct type_traits<QFontInfo> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFontInfo> &qtdecl_QFontInfo (); }
 
 class QFontMetrics;
+
+namespace tl { template <> struct type_traits<QFontMetrics> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFontMetrics> &qtdecl_QFontMetrics (); }
 
 class QFontMetricsF;
+
+namespace tl { template <> struct type_traits<QFontMetricsF> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QFontMetricsF> &qtdecl_QFontMetricsF (); }
 
 class QGenericPlugin;
+
+namespace tl { template <> struct type_traits<QGenericPlugin> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGenericPlugin> &qtdecl_QGenericPlugin (); }
 
 class QGenericPluginFactory;
+
+namespace tl { template <> struct type_traits<QGenericPluginFactory> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGenericPluginFactory> &qtdecl_QGenericPluginFactory (); }
 
 class QGlyphRun;
+
+namespace tl { template <> struct type_traits<QGlyphRun> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGlyphRun> &qtdecl_QGlyphRun (); }
 
 class QGradient;
+
+namespace tl { template <> struct type_traits<QGradient> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGradient> &qtdecl_QGradient (); }
 
 class QGuiApplication;
+
+namespace tl { template <> struct type_traits<QGuiApplication> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QGuiApplication> &qtdecl_QGuiApplication (); }
 
 class QHelpEvent;
+
+namespace tl { template <> struct type_traits<QHelpEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QHelpEvent> &qtdecl_QHelpEvent (); }
 
 class QHideEvent;
+
+namespace tl { template <> struct type_traits<QHideEvent> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QHideEvent> &qtdecl_QHideEvent (); }
 
 class QHoverEvent;
+
+namespace tl { template <> struct type_traits<QHoverEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QHoverEvent> &qtdecl_QHoverEvent (); }
 
 class QIcon;
+
+namespace tl { template <> struct type_traits<QIcon> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QIcon> &qtdecl_QIcon (); }
 
 class QIconDragEvent;
+
+namespace tl { template <> struct type_traits<QIconDragEvent> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QIconDragEvent> &qtdecl_QIconDragEvent (); }
 
 class QIconEngine;
+
+namespace tl { template <> struct type_traits<QIconEngine> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QIconEngine> &qtdecl_QIconEngine (); }
 
 class QIconEnginePlugin;
+
+namespace tl { template <> struct type_traits<QIconEnginePlugin> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QIconEnginePlugin> &qtdecl_QIconEnginePlugin (); }
 
 class QImage;
+
+namespace tl { template <> struct type_traits<QImage> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QImage> &qtdecl_QImage (); }
 
 class QImageIOHandler;
+
+namespace tl { template <> struct type_traits<QImageIOHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QImageIOHandler> &qtdecl_QImageIOHandler (); }
 
 class QImageIOPlugin;
+
+namespace tl { template <> struct type_traits<QImageIOPlugin> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QImageIOPlugin> &qtdecl_QImageIOPlugin (); }
 
 class QImageReader;
+
+namespace tl { template <> struct type_traits<QImageReader> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QImageReader> &qtdecl_QImageReader (); }
 
 class QImageWriter;
+
+namespace tl { template <> struct type_traits<QImageWriter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QImageWriter> &qtdecl_QImageWriter (); }
 
 class QInputEvent;
+
+namespace tl { template <> struct type_traits<QInputEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QInputEvent> &qtdecl_QInputEvent (); }
 
 class QInputMethod;
+
+namespace tl { template <> struct type_traits<QInputMethod> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QInputMethod> &qtdecl_QInputMethod (); }
 
 class QInputMethodEvent;
+
+namespace tl { template <> struct type_traits<QInputMethodEvent> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QInputMethodEvent> &qtdecl_QInputMethodEvent (); }
 
 class QInputMethodQueryEvent;
+
+namespace tl { template <> struct type_traits<QInputMethodQueryEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QInputMethodQueryEvent> &qtdecl_QInputMethodQueryEvent (); }
 
 class QIntValidator;
+
+namespace tl { template <> struct type_traits<QIntValidator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QIntValidator> &qtdecl_QIntValidator (); }
 
 class QKeyEvent;
+
+namespace tl { template <> struct type_traits<QKeyEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QKeyEvent> &qtdecl_QKeyEvent (); }
 
 class QKeySequence;
+
+namespace tl { template <> struct type_traits<QKeySequence> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QKeySequence> &qtdecl_QKeySequence (); }
 
 class QLinearGradient;
+
+namespace tl { template <> struct type_traits<QLinearGradient> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QLinearGradient> &qtdecl_QLinearGradient (); }
 
 class QMatrix;
+
+namespace tl { template <> struct type_traits<QMatrix> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMatrix> &qtdecl_QMatrix (); }
 
 class QMatrix4x4;
+
+namespace tl { template <> struct type_traits<QMatrix4x4> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMatrix4x4> &qtdecl_QMatrix4x4 (); }
 
 class QMouseEvent;
+
+namespace tl { template <> struct type_traits<QMouseEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMouseEvent> &qtdecl_QMouseEvent (); }
 
 class QMoveEvent;
+
+namespace tl { template <> struct type_traits<QMoveEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMoveEvent> &qtdecl_QMoveEvent (); }
 
 class QMovie;
+
+namespace tl { template <> struct type_traits<QMovie> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QMovie> &qtdecl_QMovie (); }
 
 class QNativeGestureEvent;
+
+namespace tl { template <> struct type_traits<QNativeGestureEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QNativeGestureEvent> &qtdecl_QNativeGestureEvent (); }
 
 class QOffscreenSurface;
+
+namespace tl { template <> struct type_traits<QOffscreenSurface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QOffscreenSurface> &qtdecl_QOffscreenSurface (); }
 
 class QPageLayout;
+
+namespace tl { template <> struct type_traits<QPageLayout> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPageLayout> &qtdecl_QPageLayout (); }
 
 class QPageSize;
+
+namespace tl { template <> struct type_traits<QPageSize> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPageSize> &qtdecl_QPageSize (); }
 
 class QPagedPaintDevice;
+
+namespace tl { template <> struct type_traits<QPagedPaintDevice> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPagedPaintDevice> &qtdecl_QPagedPaintDevice (); }
 
 class QPaintDevice;
+
+namespace tl { template <> struct type_traits<QPaintDevice> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPaintDevice> &qtdecl_QPaintDevice (); }
 
 class QPaintDeviceWindow;
+
+namespace tl { template <> struct type_traits<QPaintDeviceWindow> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPaintDeviceWindow> &qtdecl_QPaintDeviceWindow (); }
 
 class QPaintEngine;
+
+namespace tl { template <> struct type_traits<QPaintEngine> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPaintEngine> &qtdecl_QPaintEngine (); }
 
 class QPaintEngineState;
+
+namespace tl { template <> struct type_traits<QPaintEngineState> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPaintEngineState> &qtdecl_QPaintEngineState (); }
 
 class QPaintEvent;
+
+namespace tl { template <> struct type_traits<QPaintEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPaintEvent> &qtdecl_QPaintEvent (); }
 
 class QPainter;
+
+namespace tl { template <> struct type_traits<QPainter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPainter> &qtdecl_QPainter (); }
 
 class QPainterPath;
+
+namespace tl { template <> struct type_traits<QPainterPath> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPainterPath> &qtdecl_QPainterPath (); }
 
 class QPainterPathStroker;
+
+namespace tl { template <> struct type_traits<QPainterPathStroker> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPainterPathStroker> &qtdecl_QPainterPathStroker (); }
 
 class QPalette;
+
+namespace tl { template <> struct type_traits<QPalette> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPalette> &qtdecl_QPalette (); }
 
 class QPdfWriter;
+
+namespace tl { template <> struct type_traits<QPdfWriter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPdfWriter> &qtdecl_QPdfWriter (); }
 
 class QPen;
+
+namespace tl { template <> struct type_traits<QPen> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPen> &qtdecl_QPen (); }
 
 class QPicture;
+
+namespace tl { template <> struct type_traits<QPicture> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPicture> &qtdecl_QPicture (); }
 
 class QPictureFormatPlugin;
+
+namespace tl { template <> struct type_traits<QPictureFormatPlugin> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPictureFormatPlugin> &qtdecl_QPictureFormatPlugin (); }
 
 class QPixelFormat;
+
+namespace tl { template <> struct type_traits<QPixelFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPixelFormat> &qtdecl_QPixelFormat (); }
 
 class QPixmap;
+
+namespace tl { template <> struct type_traits<QPixmap> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPixmap> &qtdecl_QPixmap (); }
 
 class QPixmapCache;
+
+namespace tl { template <> struct type_traits<QPixmapCache> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPixmapCache> &qtdecl_QPixmapCache (); }
 
 class QPlatformSurfaceEvent;
+
+namespace tl { template <> struct type_traits<QPlatformSurfaceEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPlatformSurfaceEvent> &qtdecl_QPlatformSurfaceEvent (); }
 
 class QPolygon;
+
+namespace tl { template <> struct type_traits<QPolygon> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPolygon> &qtdecl_QPolygon (); }
 
 class QPolygonF;
+
+namespace tl { template <> struct type_traits<QPolygonF> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QPolygonF> &qtdecl_QPolygonF (); }
 
 class QQuaternion;
+
+namespace tl { template <> struct type_traits<QQuaternion> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QQuaternion> &qtdecl_QQuaternion (); }
 
 class QRadialGradient;
+
+namespace tl { template <> struct type_traits<QRadialGradient> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QRadialGradient> &qtdecl_QRadialGradient (); }
 
 class QRasterWindow;
+
+namespace tl { template <> struct type_traits<QRasterWindow> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QRasterWindow> &qtdecl_QRasterWindow (); }
 
 class QRawFont;
+
+namespace tl { template <> struct type_traits<QRawFont> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QRawFont> &qtdecl_QRawFont (); }
 
 class QRegExpValidator;
+
+namespace tl { template <> struct type_traits<QRegExpValidator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QRegExpValidator> &qtdecl_QRegExpValidator (); }
 
 class QRegion;
+
+namespace tl { template <> struct type_traits<QRegion> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QRegion> &qtdecl_QRegion (); }
 
 class QRegularExpressionValidator;
+
+namespace tl { template <> struct type_traits<QRegularExpressionValidator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QRegularExpressionValidator> &qtdecl_QRegularExpressionValidator (); }
 
 class QResizeEvent;
+
+namespace tl { template <> struct type_traits<QResizeEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QResizeEvent> &qtdecl_QResizeEvent (); }
 
 class QScreen;
+
+namespace tl { template <> struct type_traits<QScreen> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QScreen> &qtdecl_QScreen (); }
 
 class QScreenOrientationChangeEvent;
+
+namespace tl { template <> struct type_traits<QScreenOrientationChangeEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QScreenOrientationChangeEvent> &qtdecl_QScreenOrientationChangeEvent (); }
 
 class QScrollEvent;
+
+namespace tl { template <> struct type_traits<QScrollEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QScrollEvent> &qtdecl_QScrollEvent (); }
 
 class QScrollPrepareEvent;
+
+namespace tl { template <> struct type_traits<QScrollPrepareEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QScrollPrepareEvent> &qtdecl_QScrollPrepareEvent (); }
 
 class QSessionManager;
+
+namespace tl { template <> struct type_traits<QSessionManager> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QSessionManager> &qtdecl_QSessionManager (); }
 
 class QShortcutEvent;
+
+namespace tl { template <> struct type_traits<QShortcutEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QShortcutEvent> &qtdecl_QShortcutEvent (); }
 
 class QShowEvent;
+
+namespace tl { template <> struct type_traits<QShowEvent> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QShowEvent> &qtdecl_QShowEvent (); }
 
 class QStandardItem;
+
+namespace tl { template <> struct type_traits<QStandardItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStandardItem> &qtdecl_QStandardItem (); }
 
 class QStandardItemModel;
+
+namespace tl { template <> struct type_traits<QStandardItemModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStandardItemModel> &qtdecl_QStandardItemModel (); }
 
 class QStaticText;
+
+namespace tl { template <> struct type_traits<QStaticText> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStaticText> &qtdecl_QStaticText (); }
 
 class QStatusTipEvent;
+
+namespace tl { template <> struct type_traits<QStatusTipEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStatusTipEvent> &qtdecl_QStatusTipEvent (); }
 
 class QStyleHints;
+
+namespace tl { template <> struct type_traits<QStyleHints> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QStyleHints> &qtdecl_QStyleHints (); }
 
 class QSurface;
+
+namespace tl { template <> struct type_traits<QSurface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QSurface> &qtdecl_QSurface (); }
 
 class QSurfaceFormat;
+
+namespace tl { template <> struct type_traits<QSurfaceFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QSurfaceFormat> &qtdecl_QSurfaceFormat (); }
 
 class QSyntaxHighlighter;
+
+namespace tl { template <> struct type_traits<QSyntaxHighlighter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QSyntaxHighlighter> &qtdecl_QSyntaxHighlighter (); }
 
 class QTabletEvent;
+
+namespace tl { template <> struct type_traits<QTabletEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTabletEvent> &qtdecl_QTabletEvent (); }
 
 class QTextBlock;
+
+namespace tl { template <> struct type_traits<QTextBlock> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextBlock> &qtdecl_QTextBlock (); }
 
 class QTextBlockFormat;
+
+namespace tl { template <> struct type_traits<QTextBlockFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextBlockFormat> &qtdecl_QTextBlockFormat (); }
 
 class QTextBlockGroup;
+
+namespace tl { template <> struct type_traits<QTextBlockGroup> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextBlockGroup> &qtdecl_QTextBlockGroup (); }
 
 class QTextBlockUserData;
+
+namespace tl { template <> struct type_traits<QTextBlockUserData> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextBlockUserData> &qtdecl_QTextBlockUserData (); }
 
 class QTextCharFormat;
+
+namespace tl { template <> struct type_traits<QTextCharFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextCharFormat> &qtdecl_QTextCharFormat (); }
 
 class QTextCursor;
+
+namespace tl { template <> struct type_traits<QTextCursor> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextCursor> &qtdecl_QTextCursor (); }
 
 class QTextDocument;
+
+namespace tl { template <> struct type_traits<QTextDocument> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextDocument> &qtdecl_QTextDocument (); }
 
 class QTextDocumentFragment;
+
+namespace tl { template <> struct type_traits<QTextDocumentFragment> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextDocumentFragment> &qtdecl_QTextDocumentFragment (); }
 
 class QTextDocumentWriter;
+
+namespace tl { template <> struct type_traits<QTextDocumentWriter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextDocumentWriter> &qtdecl_QTextDocumentWriter (); }
 
 class QTextFormat;
+
+namespace tl { template <> struct type_traits<QTextFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextFormat> &qtdecl_QTextFormat (); }
 
 class QTextFragment;
+
+namespace tl { template <> struct type_traits<QTextFragment> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextFragment> &qtdecl_QTextFragment (); }
 
 class QTextFrame;
+
+namespace tl { template <> struct type_traits<QTextFrame> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextFrame> &qtdecl_QTextFrame (); }
 
 class QTextFrameFormat;
+
+namespace tl { template <> struct type_traits<QTextFrameFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextFrameFormat> &qtdecl_QTextFrameFormat (); }
 
 class QTextImageFormat;
+
+namespace tl { template <> struct type_traits<QTextImageFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextImageFormat> &qtdecl_QTextImageFormat (); }
 
 class QTextInlineObject;
+
+namespace tl { template <> struct type_traits<QTextInlineObject> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextInlineObject> &qtdecl_QTextInlineObject (); }
 
 class QTextItem;
+
+namespace tl { template <> struct type_traits<QTextItem> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextItem> &qtdecl_QTextItem (); }
 
 class QTextLayout;
+
+namespace tl { template <> struct type_traits<QTextLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextLayout> &qtdecl_QTextLayout (); }
 
 class QTextLength;
+
+namespace tl { template <> struct type_traits<QTextLength> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextLength> &qtdecl_QTextLength (); }
 
 class QTextLine;
+
+namespace tl { template <> struct type_traits<QTextLine> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextLine> &qtdecl_QTextLine (); }
 
 class QTextList;
+
+namespace tl { template <> struct type_traits<QTextList> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextList> &qtdecl_QTextList (); }
 
 class QTextListFormat;
+
+namespace tl { template <> struct type_traits<QTextListFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextListFormat> &qtdecl_QTextListFormat (); }
 
 class QTextObject;
+
+namespace tl { template <> struct type_traits<QTextObject> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextObject> &qtdecl_QTextObject (); }
 
 class QTextObjectInterface;
+
+namespace tl { template <> struct type_traits<QTextObjectInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextObjectInterface> &qtdecl_QTextObjectInterface (); }
 
 class QTextOption;
+
+namespace tl { template <> struct type_traits<QTextOption> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextOption> &qtdecl_QTextOption (); }
 
 class QTextTable;
+
+namespace tl { template <> struct type_traits<QTextTable> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextTable> &qtdecl_QTextTable (); }
 
 class QTextTableCell;
+
+namespace tl { template <> struct type_traits<QTextTableCell> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextTableCell> &qtdecl_QTextTableCell (); }
 
 class QTextTableCellFormat;
+
+namespace tl { template <> struct type_traits<QTextTableCellFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextTableCellFormat> &qtdecl_QTextTableCellFormat (); }
 
 class QTextTableFormat;
+
+namespace tl { template <> struct type_traits<QTextTableFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTextTableFormat> &qtdecl_QTextTableFormat (); }
 
 class QToolBarChangeEvent;
+
+namespace tl { template <> struct type_traits<QToolBarChangeEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QToolBarChangeEvent> &qtdecl_QToolBarChangeEvent (); }
 
 class QTouchDevice;
+
+namespace tl { template <> struct type_traits<QTouchDevice> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTouchDevice> &qtdecl_QTouchDevice (); }
 
 class QTouchEvent;
+
+namespace tl { template <> struct type_traits<QTouchEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTouchEvent> &qtdecl_QTouchEvent (); }
 
 class QTransform;
+
+namespace tl { template <> struct type_traits<QTransform> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QTransform> &qtdecl_QTransform (); }
 
 class QValidator;
+
+namespace tl { template <> struct type_traits<QValidator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QValidator> &qtdecl_QValidator (); }
 
 class QVector2D;
+
+namespace tl { template <> struct type_traits<QVector2D> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QVector2D> &qtdecl_QVector2D (); }
 
 class QVector3D;
+
+namespace tl { template <> struct type_traits<QVector3D> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QVector3D> &qtdecl_QVector3D (); }
 
 class QVector4D;
+
+namespace tl { template <> struct type_traits<QVector4D> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QVector4D> &qtdecl_QVector4D (); }
 
 class QWhatsThisClickedEvent;
+
+namespace tl { template <> struct type_traits<QWhatsThisClickedEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QWhatsThisClickedEvent> &qtdecl_QWhatsThisClickedEvent (); }
 
 class QWheelEvent;
+
+namespace tl { template <> struct type_traits<QWheelEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QWheelEvent> &qtdecl_QWheelEvent (); }
 
 class QWindow;
+
+namespace tl { template <> struct type_traits<QWindow> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QWindow> &qtdecl_QWindow (); }
 
 class QWindowStateChangeEvent;
+
+namespace tl { template <> struct type_traits<QWindowStateChangeEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTGUI_PUBLIC gsi::Class<QWindowStateChangeEvent> &qtdecl_QWindowStateChangeEvent (); }
 
 
diff --git a/src/gsiqt/qt5/QtMultimedia/gsiQtExternals.h b/src/gsiqt/qt5/QtMultimedia/gsiQtExternals.h
index 37de47e1a..61c2369a7 100644
--- a/src/gsiqt/qt5/QtMultimedia/gsiQtExternals.h
+++ b/src/gsiqt/qt5/QtMultimedia/gsiQtExternals.h
@@ -34,279 +34,789 @@
 #include "gsiQtMultimediaCommon.h"
 
 class QAbstractAudioDeviceInfo;
+
+namespace tl { template <> struct type_traits<QAbstractAudioDeviceInfo> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAbstractAudioDeviceInfo> &qtdecl_QAbstractAudioDeviceInfo (); }
 
 class QAbstractAudioInput;
+
+namespace tl { template <> struct type_traits<QAbstractAudioInput> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAbstractAudioInput> &qtdecl_QAbstractAudioInput (); }
 
 class QAbstractAudioOutput;
+
+namespace tl { template <> struct type_traits<QAbstractAudioOutput> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAbstractAudioOutput> &qtdecl_QAbstractAudioOutput (); }
 
 class QAbstractVideoBuffer;
+
+namespace tl { template <> struct type_traits<QAbstractVideoBuffer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAbstractVideoBuffer> &qtdecl_QAbstractVideoBuffer (); }
 
 class QAbstractVideoFilter;
+
+namespace tl { template <> struct type_traits<QAbstractVideoFilter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAbstractVideoFilter> &qtdecl_QAbstractVideoFilter (); }
 
 class QAbstractVideoSurface;
+
+namespace tl { template <> struct type_traits<QAbstractVideoSurface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAbstractVideoSurface> &qtdecl_QAbstractVideoSurface (); }
 
 class QAudioBuffer;
+
+namespace tl { template <> struct type_traits<QAudioBuffer> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioBuffer> &qtdecl_QAudioBuffer (); }
 
 class QAudioDecoder;
+
+namespace tl { template <> struct type_traits<QAudioDecoder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioDecoder> &qtdecl_QAudioDecoder (); }
 
 class QAudioDecoderControl;
+
+namespace tl { template <> struct type_traits<QAudioDecoderControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioDecoderControl> &qtdecl_QAudioDecoderControl (); }
 
 class QAudioDeviceInfo;
+
+namespace tl { template <> struct type_traits<QAudioDeviceInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioDeviceInfo> &qtdecl_QAudioDeviceInfo (); }
 
 class QAudioEncoderSettings;
+
+namespace tl { template <> struct type_traits<QAudioEncoderSettings> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioEncoderSettings> &qtdecl_QAudioEncoderSettings (); }
 
 class QAudioEncoderSettingsControl;
+
+namespace tl { template <> struct type_traits<QAudioEncoderSettingsControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioEncoderSettingsControl> &qtdecl_QAudioEncoderSettingsControl (); }
 
 class QAudioFormat;
+
+namespace tl { template <> struct type_traits<QAudioFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioFormat> &qtdecl_QAudioFormat (); }
 
 class QAudioInput;
+
+namespace tl { template <> struct type_traits<QAudioInput> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioInput> &qtdecl_QAudioInput (); }
 
 class QAudioInputSelectorControl;
+
+namespace tl { template <> struct type_traits<QAudioInputSelectorControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioInputSelectorControl> &qtdecl_QAudioInputSelectorControl (); }
 
 class QAudioOutput;
+
+namespace tl { template <> struct type_traits<QAudioOutput> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioOutput> &qtdecl_QAudioOutput (); }
 
 class QAudioOutputSelectorControl;
+
+namespace tl { template <> struct type_traits<QAudioOutputSelectorControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioOutputSelectorControl> &qtdecl_QAudioOutputSelectorControl (); }
 
 class QAudioProbe;
+
+namespace tl { template <> struct type_traits<QAudioProbe> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioProbe> &qtdecl_QAudioProbe (); }
 
 class QAudioRecorder;
+
+namespace tl { template <> struct type_traits<QAudioRecorder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioRecorder> &qtdecl_QAudioRecorder (); }
 
 struct QAudioSystemFactoryInterface;
+
+namespace tl { template <> struct type_traits<QAudioSystemFactoryInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioSystemFactoryInterface> &qtdecl_QAudioSystemFactoryInterface (); }
 
 class QAudioSystemPlugin;
+
+namespace tl { template <> struct type_traits<QAudioSystemPlugin> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioSystemPlugin> &qtdecl_QAudioSystemPlugin (); }
 
 class QCamera;
+
+namespace tl { template <> struct type_traits<QCamera> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCamera> &qtdecl_QCamera (); }
 
 class QCameraCaptureBufferFormatControl;
+
+namespace tl { template <> struct type_traits<QCameraCaptureBufferFormatControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraCaptureBufferFormatControl> &qtdecl_QCameraCaptureBufferFormatControl (); }
 
 class QCameraCaptureDestinationControl;
+
+namespace tl { template <> struct type_traits<QCameraCaptureDestinationControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraCaptureDestinationControl> &qtdecl_QCameraCaptureDestinationControl (); }
 
 class QCameraControl;
+
+namespace tl { template <> struct type_traits<QCameraControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraControl> &qtdecl_QCameraControl (); }
 
 class QCameraExposure;
+
+namespace tl { template <> struct type_traits<QCameraExposure> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraExposure> &qtdecl_QCameraExposure (); }
 
 class QCameraExposureControl;
+
+namespace tl { template <> struct type_traits<QCameraExposureControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraExposureControl> &qtdecl_QCameraExposureControl (); }
 
 class QCameraFeedbackControl;
+
+namespace tl { template <> struct type_traits<QCameraFeedbackControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraFeedbackControl> &qtdecl_QCameraFeedbackControl (); }
 
 class QCameraFlashControl;
+
+namespace tl { template <> struct type_traits<QCameraFlashControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraFlashControl> &qtdecl_QCameraFlashControl (); }
 
 class QCameraFocus;
+
+namespace tl { template <> struct type_traits<QCameraFocus> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraFocus> &qtdecl_QCameraFocus (); }
 
 class QCameraFocusControl;
+
+namespace tl { template <> struct type_traits<QCameraFocusControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraFocusControl> &qtdecl_QCameraFocusControl (); }
 
 class QCameraFocusZone;
+
+namespace tl { template <> struct type_traits<QCameraFocusZone> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraFocusZone> &qtdecl_QCameraFocusZone (); }
 
 class QCameraImageCapture;
+
+namespace tl { template <> struct type_traits<QCameraImageCapture> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraImageCapture> &qtdecl_QCameraImageCapture (); }
 
 class QCameraImageCaptureControl;
+
+namespace tl { template <> struct type_traits<QCameraImageCaptureControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraImageCaptureControl> &qtdecl_QCameraImageCaptureControl (); }
 
 class QCameraImageProcessing;
+
+namespace tl { template <> struct type_traits<QCameraImageProcessing> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraImageProcessing> &qtdecl_QCameraImageProcessing (); }
 
 class QCameraImageProcessingControl;
+
+namespace tl { template <> struct type_traits<QCameraImageProcessingControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraImageProcessingControl> &qtdecl_QCameraImageProcessingControl (); }
 
 class QCameraInfo;
+
+namespace tl { template <> struct type_traits<QCameraInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraInfo> &qtdecl_QCameraInfo (); }
 
 class QCameraInfoControl;
+
+namespace tl { template <> struct type_traits<QCameraInfoControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraInfoControl> &qtdecl_QCameraInfoControl (); }
 
 class QCameraLocksControl;
+
+namespace tl { template <> struct type_traits<QCameraLocksControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraLocksControl> &qtdecl_QCameraLocksControl (); }
 
 class QCameraViewfinderSettings;
+
+namespace tl { template <> struct type_traits<QCameraViewfinderSettings> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraViewfinderSettings> &qtdecl_QCameraViewfinderSettings (); }
 
 class QCameraViewfinderSettingsControl;
+
+namespace tl { template <> struct type_traits<QCameraViewfinderSettingsControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraViewfinderSettingsControl> &qtdecl_QCameraViewfinderSettingsControl (); }
 
 class QCameraViewfinderSettingsControl2;
+
+namespace tl { template <> struct type_traits<QCameraViewfinderSettingsControl2> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraViewfinderSettingsControl2> &qtdecl_QCameraViewfinderSettingsControl2 (); }
 
 class QCameraZoomControl;
+
+namespace tl { template <> struct type_traits<QCameraZoomControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraZoomControl> &qtdecl_QCameraZoomControl (); }
 
 class QGraphicsVideoItem;
+
+namespace tl { template <> struct type_traits<QGraphicsVideoItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QGraphicsVideoItem> &qtdecl_QGraphicsVideoItem (); }
 
 class QImageEncoderControl;
+
+namespace tl { template <> struct type_traits<QImageEncoderControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QImageEncoderControl> &qtdecl_QImageEncoderControl (); }
 
 class QImageEncoderSettings;
+
+namespace tl { template <> struct type_traits<QImageEncoderSettings> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QImageEncoderSettings> &qtdecl_QImageEncoderSettings (); }
 
 class QMediaAudioProbeControl;
+
+namespace tl { template <> struct type_traits<QMediaAudioProbeControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaAudioProbeControl> &qtdecl_QMediaAudioProbeControl (); }
 
 class QMediaAvailabilityControl;
+
+namespace tl { template <> struct type_traits<QMediaAvailabilityControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaAvailabilityControl> &qtdecl_QMediaAvailabilityControl (); }
 
 class QMediaBindableInterface;
+
+namespace tl { template <> struct type_traits<QMediaBindableInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaBindableInterface> &qtdecl_QMediaBindableInterface (); }
 
 class QMediaContainerControl;
+
+namespace tl { template <> struct type_traits<QMediaContainerControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaContainerControl> &qtdecl_QMediaContainerControl (); }
 
 class QMediaContent;
+
+namespace tl { template <> struct type_traits<QMediaContent> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaContent> &qtdecl_QMediaContent (); }
 
 class QMediaControl;
+
+namespace tl { template <> struct type_traits<QMediaControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaControl> &qtdecl_QMediaControl (); }
 
 class QMediaGaplessPlaybackControl;
+
+namespace tl { template <> struct type_traits<QMediaGaplessPlaybackControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaGaplessPlaybackControl> &qtdecl_QMediaGaplessPlaybackControl (); }
 
 class QMediaNetworkAccessControl;
+
+namespace tl { template <> struct type_traits<QMediaNetworkAccessControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaNetworkAccessControl> &qtdecl_QMediaNetworkAccessControl (); }
 
 class QMediaObject;
+
+namespace tl { template <> struct type_traits<QMediaObject> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaObject> &qtdecl_QMediaObject (); }
 
 class QMediaPlayer;
+
+namespace tl { template <> struct type_traits<QMediaPlayer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaPlayer> &qtdecl_QMediaPlayer (); }
 
 class QMediaPlayerControl;
+
+namespace tl { template <> struct type_traits<QMediaPlayerControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaPlayerControl> &qtdecl_QMediaPlayerControl (); }
 
 class QMediaPlaylist;
+
+namespace tl { template <> struct type_traits<QMediaPlaylist> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaPlaylist> &qtdecl_QMediaPlaylist (); }
 
 class QMediaRecorder;
+
+namespace tl { template <> struct type_traits<QMediaRecorder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaRecorder> &qtdecl_QMediaRecorder (); }
 
 class QMediaRecorderControl;
+
+namespace tl { template <> struct type_traits<QMediaRecorderControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaRecorderControl> &qtdecl_QMediaRecorderControl (); }
 
 class QMediaResource;
+
+namespace tl { template <> struct type_traits<QMediaResource> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaResource> &qtdecl_QMediaResource (); }
 
 class QMediaService;
+
+namespace tl { template <> struct type_traits<QMediaService> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaService> &qtdecl_QMediaService (); }
 
 struct QMediaServiceCameraInfoInterface;
+
+namespace tl { template <> struct type_traits<QMediaServiceCameraInfoInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaServiceCameraInfoInterface> &qtdecl_QMediaServiceCameraInfoInterface (); }
 
 struct QMediaServiceDefaultDeviceInterface;
+
+namespace tl { template <> struct type_traits<QMediaServiceDefaultDeviceInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaServiceDefaultDeviceInterface> &qtdecl_QMediaServiceDefaultDeviceInterface (); }
 
 struct QMediaServiceFeaturesInterface;
+
+namespace tl { template <> struct type_traits<QMediaServiceFeaturesInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaServiceFeaturesInterface> &qtdecl_QMediaServiceFeaturesInterface (); }
 
 struct QMediaServiceProviderFactoryInterface;
+
+namespace tl { template <> struct type_traits<QMediaServiceProviderFactoryInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaServiceProviderFactoryInterface> &qtdecl_QMediaServiceProviderFactoryInterface (); }
 
 class QMediaServiceProviderHint;
+
+namespace tl { template <> struct type_traits<QMediaServiceProviderHint> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaServiceProviderHint> &qtdecl_QMediaServiceProviderHint (); }
 
 class QMediaServiceProviderPlugin;
+
+namespace tl { template <> struct type_traits<QMediaServiceProviderPlugin> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaServiceProviderPlugin> &qtdecl_QMediaServiceProviderPlugin (); }
 
 struct QMediaServiceSupportedDevicesInterface;
+
+namespace tl { template <> struct type_traits<QMediaServiceSupportedDevicesInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaServiceSupportedDevicesInterface> &qtdecl_QMediaServiceSupportedDevicesInterface (); }
 
 struct QMediaServiceSupportedFormatsInterface;
+
+namespace tl { template <> struct type_traits<QMediaServiceSupportedFormatsInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaServiceSupportedFormatsInterface> &qtdecl_QMediaServiceSupportedFormatsInterface (); }
 
 class QMediaStreamsControl;
+
+namespace tl { template <> struct type_traits<QMediaStreamsControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaStreamsControl> &qtdecl_QMediaStreamsControl (); }
 
 class QMediaTimeInterval;
+
+namespace tl { template <> struct type_traits<QMediaTimeInterval> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaTimeInterval> &qtdecl_QMediaTimeInterval (); }
 
 class QMediaTimeRange;
+
+namespace tl { template <> struct type_traits<QMediaTimeRange> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaTimeRange> &qtdecl_QMediaTimeRange (); }
 
 class QMediaVideoProbeControl;
+
+namespace tl { template <> struct type_traits<QMediaVideoProbeControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaVideoProbeControl> &qtdecl_QMediaVideoProbeControl (); }
 
 class QMetaDataReaderControl;
+
+namespace tl { template <> struct type_traits<QMetaDataReaderControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMetaDataReaderControl> &qtdecl_QMetaDataReaderControl (); }
 
 class QMetaDataWriterControl;
+
+namespace tl { template <> struct type_traits<QMetaDataWriterControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMetaDataWriterControl> &qtdecl_QMetaDataWriterControl (); }
 
 class QRadioData;
+
+namespace tl { template <> struct type_traits<QRadioData> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QRadioData> &qtdecl_QRadioData (); }
 
 class QRadioDataControl;
+
+namespace tl { template <> struct type_traits<QRadioDataControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QRadioDataControl> &qtdecl_QRadioDataControl (); }
 
 class QRadioTuner;
+
+namespace tl { template <> struct type_traits<QRadioTuner> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QRadioTuner> &qtdecl_QRadioTuner (); }
 
 class QRadioTunerControl;
+
+namespace tl { template <> struct type_traits<QRadioTunerControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QRadioTunerControl> &qtdecl_QRadioTunerControl (); }
 
 class QSound;
+
+namespace tl { template <> struct type_traits<QSound> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QSound> &qtdecl_QSound (); }
 
 class QSoundEffect;
+
+namespace tl { template <> struct type_traits<QSoundEffect> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QSoundEffect> &qtdecl_QSoundEffect (); }
 
 class QVideoDeviceSelectorControl;
+
+namespace tl { template <> struct type_traits<QVideoDeviceSelectorControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoDeviceSelectorControl> &qtdecl_QVideoDeviceSelectorControl (); }
 
 class QVideoEncoderSettings;
+
+namespace tl { template <> struct type_traits<QVideoEncoderSettings> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoEncoderSettings> &qtdecl_QVideoEncoderSettings (); }
 
 class QVideoEncoderSettingsControl;
+
+namespace tl { template <> struct type_traits<QVideoEncoderSettingsControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoEncoderSettingsControl> &qtdecl_QVideoEncoderSettingsControl (); }
 
 class QVideoFilterRunnable;
+
+namespace tl { template <> struct type_traits<QVideoFilterRunnable> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoFilterRunnable> &qtdecl_QVideoFilterRunnable (); }
 
 class QVideoFrame;
+
+namespace tl { template <> struct type_traits<QVideoFrame> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoFrame> &qtdecl_QVideoFrame (); }
 
 class QVideoProbe;
+
+namespace tl { template <> struct type_traits<QVideoProbe> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoProbe> &qtdecl_QVideoProbe (); }
 
 class QVideoRendererControl;
+
+namespace tl { template <> struct type_traits<QVideoRendererControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoRendererControl> &qtdecl_QVideoRendererControl (); }
 
 class QVideoSurfaceFormat;
+
+namespace tl { template <> struct type_traits<QVideoSurfaceFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoSurfaceFormat> &qtdecl_QVideoSurfaceFormat (); }
 
 class QVideoWidget;
+
+namespace tl { template <> struct type_traits<QVideoWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoWidget> &qtdecl_QVideoWidget (); }
 
 class QVideoWindowControl;
+
+namespace tl { template <> struct type_traits<QVideoWindowControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoWindowControl> &qtdecl_QVideoWindowControl (); }
 
 
diff --git a/src/gsiqt/qt5/QtNetwork/gsiQtExternals.h b/src/gsiqt/qt5/QtNetwork/gsiQtExternals.h
index c41a209bf..8c4e53eca 100644
--- a/src/gsiqt/qt5/QtNetwork/gsiQtExternals.h
+++ b/src/gsiqt/qt5/QtNetwork/gsiQtExternals.h
@@ -34,132 +34,326 @@
 #include "gsiQtNetworkCommon.h"
 
 class QAbstractNetworkCache;
+
+namespace tl { template <> struct type_traits<QAbstractNetworkCache> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QAbstractNetworkCache> &qtdecl_QAbstractNetworkCache (); }
 
 class QAbstractSocket;
+
+namespace tl { template <> struct type_traits<QAbstractSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QAbstractSocket> &qtdecl_QAbstractSocket (); }
 
 class QAuthenticator;
+
+namespace tl { template <> struct type_traits<QAuthenticator> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QAuthenticator> &qtdecl_QAuthenticator (); }
 
 class QDnsDomainNameRecord;
+
+namespace tl { template <> struct type_traits<QDnsDomainNameRecord> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QDnsDomainNameRecord> &qtdecl_QDnsDomainNameRecord (); }
 
 class QDnsHostAddressRecord;
+
+namespace tl { template <> struct type_traits<QDnsHostAddressRecord> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QDnsHostAddressRecord> &qtdecl_QDnsHostAddressRecord (); }
 
 class QDnsLookup;
+
+namespace tl { template <> struct type_traits<QDnsLookup> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QDnsLookup> &qtdecl_QDnsLookup (); }
 
 class QDnsMailExchangeRecord;
+
+namespace tl { template <> struct type_traits<QDnsMailExchangeRecord> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QDnsMailExchangeRecord> &qtdecl_QDnsMailExchangeRecord (); }
 
 class QDnsServiceRecord;
+
+namespace tl { template <> struct type_traits<QDnsServiceRecord> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QDnsServiceRecord> &qtdecl_QDnsServiceRecord (); }
 
 class QDnsTextRecord;
+
+namespace tl { template <> struct type_traits<QDnsTextRecord> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QDnsTextRecord> &qtdecl_QDnsTextRecord (); }
 
 class QHostAddress;
+
+namespace tl { template <> struct type_traits<QHostAddress> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QHostAddress> &qtdecl_QHostAddress (); }
 
 class QHostInfo;
+
+namespace tl { template <> struct type_traits<QHostInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QHostInfo> &qtdecl_QHostInfo (); }
 
 class QHttpMultiPart;
+
+namespace tl { template <> struct type_traits<QHttpMultiPart> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QHttpMultiPart> &qtdecl_QHttpMultiPart (); }
 
 class QHttpPart;
+
+namespace tl { template <> struct type_traits<QHttpPart> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QHttpPart> &qtdecl_QHttpPart (); }
 
 class QIPv6Address;
+
+namespace tl { template <> struct type_traits<QIPv6Address> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QIPv6Address> &qtdecl_QIPv6Address (); }
 
 class QLocalServer;
+
+namespace tl { template <> struct type_traits<QLocalServer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QLocalServer> &qtdecl_QLocalServer (); }
 
 class QLocalSocket;
+
+namespace tl { template <> struct type_traits<QLocalSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QLocalSocket> &qtdecl_QLocalSocket (); }
 
 class QNetworkAccessManager;
+
+namespace tl { template <> struct type_traits<QNetworkAccessManager> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkAccessManager> &qtdecl_QNetworkAccessManager (); }
 
 class QNetworkAddressEntry;
+
+namespace tl { template <> struct type_traits<QNetworkAddressEntry> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkAddressEntry> &qtdecl_QNetworkAddressEntry (); }
 
 class QNetworkCacheMetaData;
+
+namespace tl { template <> struct type_traits<QNetworkCacheMetaData> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkCacheMetaData> &qtdecl_QNetworkCacheMetaData (); }
 
 class QNetworkConfiguration;
+
+namespace tl { template <> struct type_traits<QNetworkConfiguration> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkConfiguration> &qtdecl_QNetworkConfiguration (); }
 
 class QNetworkConfigurationManager;
+
+namespace tl { template <> struct type_traits<QNetworkConfigurationManager> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkConfigurationManager> &qtdecl_QNetworkConfigurationManager (); }
 
 class QNetworkCookie;
+
+namespace tl { template <> struct type_traits<QNetworkCookie> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkCookie> &qtdecl_QNetworkCookie (); }
 
 class QNetworkCookieJar;
+
+namespace tl { template <> struct type_traits<QNetworkCookieJar> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkCookieJar> &qtdecl_QNetworkCookieJar (); }
 
 class QNetworkDiskCache;
+
+namespace tl { template <> struct type_traits<QNetworkDiskCache> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkDiskCache> &qtdecl_QNetworkDiskCache (); }
 
 class QNetworkInterface;
+
+namespace tl { template <> struct type_traits<QNetworkInterface> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkInterface> &qtdecl_QNetworkInterface (); }
 
 class QNetworkProxy;
+
+namespace tl { template <> struct type_traits<QNetworkProxy> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkProxy> &qtdecl_QNetworkProxy (); }
 
 class QNetworkProxyFactory;
+
+namespace tl { template <> struct type_traits<QNetworkProxyFactory> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkProxyFactory> &qtdecl_QNetworkProxyFactory (); }
 
 class QNetworkProxyQuery;
+
+namespace tl { template <> struct type_traits<QNetworkProxyQuery> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkProxyQuery> &qtdecl_QNetworkProxyQuery (); }
 
 class QNetworkReply;
+
+namespace tl { template <> struct type_traits<QNetworkReply> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkReply> &qtdecl_QNetworkReply (); }
 
 class QNetworkRequest;
+
+namespace tl { template <> struct type_traits<QNetworkRequest> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkRequest> &qtdecl_QNetworkRequest (); }
 
 class QNetworkSession;
+
+namespace tl { template <> struct type_traits<QNetworkSession> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkSession> &qtdecl_QNetworkSession (); }
 
 class QSslCertificate;
+
+namespace tl { template <> struct type_traits<QSslCertificate> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslCertificate> &qtdecl_QSslCertificate (); }
 
 class QSslCertificateExtension;
+
+namespace tl { template <> struct type_traits<QSslCertificateExtension> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslCertificateExtension> &qtdecl_QSslCertificateExtension (); }
 
 class QSslCipher;
+
+namespace tl { template <> struct type_traits<QSslCipher> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslCipher> &qtdecl_QSslCipher (); }
 
 class QSslConfiguration;
+
+namespace tl { template <> struct type_traits<QSslConfiguration> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslConfiguration> &qtdecl_QSslConfiguration (); }
 
 class QSslEllipticCurve;
+
+namespace tl { template <> struct type_traits<QSslEllipticCurve> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslEllipticCurve> &qtdecl_QSslEllipticCurve (); }
 
 class QSslError;
+
+namespace tl { template <> struct type_traits<QSslError> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslError> &qtdecl_QSslError (); }
 
 class QSslKey;
+
+namespace tl { template <> struct type_traits<QSslKey> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslKey> &qtdecl_QSslKey (); }
 
 class QSslPreSharedKeyAuthenticator;
+
+namespace tl { template <> struct type_traits<QSslPreSharedKeyAuthenticator> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslPreSharedKeyAuthenticator> &qtdecl_QSslPreSharedKeyAuthenticator (); }
 
 class QSslSocket;
+
+namespace tl { template <> struct type_traits<QSslSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslSocket> &qtdecl_QSslSocket (); }
 
 class QTcpServer;
+
+namespace tl { template <> struct type_traits<QTcpServer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QTcpServer> &qtdecl_QTcpServer (); }
 
 class QTcpSocket;
+
+namespace tl { template <> struct type_traits<QTcpSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QTcpSocket> &qtdecl_QTcpSocket (); }
 
 class QUdpSocket;
+
+namespace tl { template <> struct type_traits<QUdpSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QUdpSocket> &qtdecl_QUdpSocket (); }
 
 
diff --git a/src/gsiqt/qt5/QtPrintSupport/gsiQtExternals.h b/src/gsiqt/qt5/QtPrintSupport/gsiQtExternals.h
index 92511f9dc..dbcee1274 100644
--- a/src/gsiqt/qt5/QtPrintSupport/gsiQtExternals.h
+++ b/src/gsiqt/qt5/QtPrintSupport/gsiQtExternals.h
@@ -34,27 +34,68 @@
 #include "gsiQtPrintSupportCommon.h"
 
 class QAbstractPrintDialog;
+
+namespace tl { template <> struct type_traits<QAbstractPrintDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTPRINTSUPPORT_PUBLIC gsi::Class<QAbstractPrintDialog> &qtdecl_QAbstractPrintDialog (); }
 
 class QPageSetupDialog;
+
+namespace tl { template <> struct type_traits<QPageSetupDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTPRINTSUPPORT_PUBLIC gsi::Class<QPageSetupDialog> &qtdecl_QPageSetupDialog (); }
 
 class QPrintDialog;
+
+namespace tl { template <> struct type_traits<QPrintDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTPRINTSUPPORT_PUBLIC gsi::Class<QPrintDialog> &qtdecl_QPrintDialog (); }
 
 class QPrintEngine;
+
+namespace tl { template <> struct type_traits<QPrintEngine> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTPRINTSUPPORT_PUBLIC gsi::Class<QPrintEngine> &qtdecl_QPrintEngine (); }
 
 class QPrintPreviewDialog;
+
+namespace tl { template <> struct type_traits<QPrintPreviewDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTPRINTSUPPORT_PUBLIC gsi::Class<QPrintPreviewDialog> &qtdecl_QPrintPreviewDialog (); }
 
 class QPrintPreviewWidget;
+
+namespace tl { template <> struct type_traits<QPrintPreviewWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTPRINTSUPPORT_PUBLIC gsi::Class<QPrintPreviewWidget> &qtdecl_QPrintPreviewWidget (); }
 
 class QPrinter;
+
+namespace tl { template <> struct type_traits<QPrinter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTPRINTSUPPORT_PUBLIC gsi::Class<QPrinter> &qtdecl_QPrinter (); }
 
 class QPrinterInfo;
+
+namespace tl { template <> struct type_traits<QPrinterInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTPRINTSUPPORT_PUBLIC gsi::Class<QPrinterInfo> &qtdecl_QPrinterInfo (); }
 
 
diff --git a/src/gsiqt/qt5/QtSql/gsiQtExternals.h b/src/gsiqt/qt5/QtSql/gsiQtExternals.h
index 7a71b6a35..68b366119 100644
--- a/src/gsiqt/qt5/QtSql/gsiQtExternals.h
+++ b/src/gsiqt/qt5/QtSql/gsiQtExternals.h
@@ -34,42 +34,103 @@
 #include "gsiQtSqlCommon.h"
 
 class QSqlDatabase;
+
+namespace tl { template <> struct type_traits<QSqlDatabase> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlDatabase> &qtdecl_QSqlDatabase (); }
 
 class QSqlDriver;
+
+namespace tl { template <> struct type_traits<QSqlDriver> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlDriver> &qtdecl_QSqlDriver (); }
 
 class QSqlDriverCreatorBase;
+
+namespace tl { template <> struct type_traits<QSqlDriverCreatorBase> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlDriverCreatorBase> &qtdecl_QSqlDriverCreatorBase (); }
 
 class QSqlError;
+
+namespace tl { template <> struct type_traits<QSqlError> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlError> &qtdecl_QSqlError (); }
 
 class QSqlField;
+
+namespace tl { template <> struct type_traits<QSqlField> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlField> &qtdecl_QSqlField (); }
 
 class QSqlIndex;
+
+namespace tl { template <> struct type_traits<QSqlIndex> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlIndex> &qtdecl_QSqlIndex (); }
 
 class QSqlQuery;
+
+namespace tl { template <> struct type_traits<QSqlQuery> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlQuery> &qtdecl_QSqlQuery (); }
 
 class QSqlQueryModel;
+
+namespace tl { template <> struct type_traits<QSqlQueryModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlQueryModel> &qtdecl_QSqlQueryModel (); }
 
 class QSqlRecord;
+
+namespace tl { template <> struct type_traits<QSqlRecord> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlRecord> &qtdecl_QSqlRecord (); }
 
 class QSqlRelation;
+
+namespace tl { template <> struct type_traits<QSqlRelation> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlRelation> &qtdecl_QSqlRelation (); }
 
 class QSqlRelationalTableModel;
+
+namespace tl { template <> struct type_traits<QSqlRelationalTableModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlRelationalTableModel> &qtdecl_QSqlRelationalTableModel (); }
 
 class QSqlResult;
+
+namespace tl { template <> struct type_traits<QSqlResult> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlResult> &qtdecl_QSqlResult (); }
 
 class QSqlTableModel;
+
+namespace tl { template <> struct type_traits<QSqlTableModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlTableModel> &qtdecl_QSqlTableModel (); }
 
 
diff --git a/src/gsiqt/qt5/QtSvg/gsiQtExternals.h b/src/gsiqt/qt5/QtSvg/gsiQtExternals.h
index 8b906519c..dad18b0cc 100644
--- a/src/gsiqt/qt5/QtSvg/gsiQtExternals.h
+++ b/src/gsiqt/qt5/QtSvg/gsiQtExternals.h
@@ -34,15 +34,35 @@
 #include "gsiQtSvgCommon.h"
 
 class QGraphicsSvgItem;
+
+namespace tl { template <> struct type_traits<QGraphicsSvgItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSVG_PUBLIC gsi::Class<QGraphicsSvgItem> &qtdecl_QGraphicsSvgItem (); }
 
 class QSvgGenerator;
+
+namespace tl { template <> struct type_traits<QSvgGenerator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSVG_PUBLIC gsi::Class<QSvgGenerator> &qtdecl_QSvgGenerator (); }
 
 class QSvgRenderer;
+
+namespace tl { template <> struct type_traits<QSvgRenderer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSVG_PUBLIC gsi::Class<QSvgRenderer> &qtdecl_QSvgRenderer (); }
 
 class QSvgWidget;
+
+namespace tl { template <> struct type_traits<QSvgWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSVG_PUBLIC gsi::Class<QSvgWidget> &qtdecl_QSvgWidget (); }
 
 
diff --git a/src/gsiqt/qt5/QtWidgets/gsiQtExternals.h b/src/gsiqt/qt5/QtWidgets/gsiQtExternals.h
index a3bcea4d7..62e8f7a50 100644
--- a/src/gsiqt/qt5/QtWidgets/gsiQtExternals.h
+++ b/src/gsiqt/qt5/QtWidgets/gsiQtExternals.h
@@ -34,588 +34,1562 @@
 #include "gsiQtWidgetsCommon.h"
 
 class QAbstractButton;
+
+namespace tl { template <> struct type_traits<QAbstractButton> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QAbstractButton> &qtdecl_QAbstractButton (); }
 
 class QAbstractGraphicsShapeItem;
+
+namespace tl { template <> struct type_traits<QAbstractGraphicsShapeItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QAbstractGraphicsShapeItem> &qtdecl_QAbstractGraphicsShapeItem (); }
 
 class QAbstractItemDelegate;
+
+namespace tl { template <> struct type_traits<QAbstractItemDelegate> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QAbstractItemDelegate> &qtdecl_QAbstractItemDelegate (); }
 
 class QAbstractItemView;
+
+namespace tl { template <> struct type_traits<QAbstractItemView> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QAbstractItemView> &qtdecl_QAbstractItemView (); }
 
 class QAbstractScrollArea;
+
+namespace tl { template <> struct type_traits<QAbstractScrollArea> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QAbstractScrollArea> &qtdecl_QAbstractScrollArea (); }
 
 class QAbstractSlider;
+
+namespace tl { template <> struct type_traits<QAbstractSlider> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QAbstractSlider> &qtdecl_QAbstractSlider (); }
 
 class QAbstractSpinBox;
+
+namespace tl { template <> struct type_traits<QAbstractSpinBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QAbstractSpinBox> &qtdecl_QAbstractSpinBox (); }
 
 class QAccessibleWidget;
+
+namespace tl { template <> struct type_traits<QAccessibleWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QAccessibleWidget> &qtdecl_QAccessibleWidget (); }
 
 class QAction;
+
+namespace tl { template <> struct type_traits<QAction> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QAction> &qtdecl_QAction (); }
 
 class QActionGroup;
+
+namespace tl { template <> struct type_traits<QActionGroup> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QActionGroup> &qtdecl_QActionGroup (); }
 
 class QApplication;
+
+namespace tl { template <> struct type_traits<QApplication> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QApplication> &qtdecl_QApplication (); }
 
 class QBoxLayout;
+
+namespace tl { template <> struct type_traits<QBoxLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QBoxLayout> &qtdecl_QBoxLayout (); }
 
 class QButtonGroup;
+
+namespace tl { template <> struct type_traits<QButtonGroup> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QButtonGroup> &qtdecl_QButtonGroup (); }
 
 class QCalendarWidget;
+
+namespace tl { template <> struct type_traits<QCalendarWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QCalendarWidget> &qtdecl_QCalendarWidget (); }
 
 class QCheckBox;
+
+namespace tl { template <> struct type_traits<QCheckBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QCheckBox> &qtdecl_QCheckBox (); }
 
 class QColorDialog;
+
+namespace tl { template <> struct type_traits<QColorDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QColorDialog> &qtdecl_QColorDialog (); }
 
 class QColormap;
+
+namespace tl { template <> struct type_traits<QColormap> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QColormap> &qtdecl_QColormap (); }
 
 class QColumnView;
+
+namespace tl { template <> struct type_traits<QColumnView> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QColumnView> &qtdecl_QColumnView (); }
 
 class QComboBox;
+
+namespace tl { template <> struct type_traits<QComboBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QComboBox> &qtdecl_QComboBox (); }
 
 class QCommandLinkButton;
+
+namespace tl { template <> struct type_traits<QCommandLinkButton> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QCommandLinkButton> &qtdecl_QCommandLinkButton (); }
 
 class QCommonStyle;
+
+namespace tl { template <> struct type_traits<QCommonStyle> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QCommonStyle> &qtdecl_QCommonStyle (); }
 
 class QCompleter;
+
+namespace tl { template <> struct type_traits<QCompleter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QCompleter> &qtdecl_QCompleter (); }
 
 class QDataWidgetMapper;
+
+namespace tl { template <> struct type_traits<QDataWidgetMapper> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QDataWidgetMapper> &qtdecl_QDataWidgetMapper (); }
 
 class QDateEdit;
+
+namespace tl { template <> struct type_traits<QDateEdit> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QDateEdit> &qtdecl_QDateEdit (); }
 
 class QDateTimeEdit;
+
+namespace tl { template <> struct type_traits<QDateTimeEdit> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QDateTimeEdit> &qtdecl_QDateTimeEdit (); }
 
 class QDesktopWidget;
+
+namespace tl { template <> struct type_traits<QDesktopWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QDesktopWidget> &qtdecl_QDesktopWidget (); }
 
 class QDial;
+
+namespace tl { template <> struct type_traits<QDial> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QDial> &qtdecl_QDial (); }
 
 class QDialog;
+
+namespace tl { template <> struct type_traits<QDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QDialog> &qtdecl_QDialog (); }
 
 class QDialogButtonBox;
+
+namespace tl { template <> struct type_traits<QDialogButtonBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QDialogButtonBox> &qtdecl_QDialogButtonBox (); }
 
 class QDirModel;
+
+namespace tl { template <> struct type_traits<QDirModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QDirModel> &qtdecl_QDirModel (); }
 
 class QDockWidget;
+
+namespace tl { template <> struct type_traits<QDockWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QDockWidget> &qtdecl_QDockWidget (); }
 
 class QDoubleSpinBox;
+
+namespace tl { template <> struct type_traits<QDoubleSpinBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QDoubleSpinBox> &qtdecl_QDoubleSpinBox (); }
 
 class QErrorMessage;
+
+namespace tl { template <> struct type_traits<QErrorMessage> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QErrorMessage> &qtdecl_QErrorMessage (); }
 
 class QFileDialog;
+
+namespace tl { template <> struct type_traits<QFileDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QFileDialog> &qtdecl_QFileDialog (); }
 
 class QFileIconProvider;
+
+namespace tl { template <> struct type_traits<QFileIconProvider> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QFileIconProvider> &qtdecl_QFileIconProvider (); }
 
 class QFileSystemModel;
+
+namespace tl { template <> struct type_traits<QFileSystemModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QFileSystemModel> &qtdecl_QFileSystemModel (); }
 
 class QFocusFrame;
+
+namespace tl { template <> struct type_traits<QFocusFrame> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QFocusFrame> &qtdecl_QFocusFrame (); }
 
 class QFontComboBox;
+
+namespace tl { template <> struct type_traits<QFontComboBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QFontComboBox> &qtdecl_QFontComboBox (); }
 
 class QFontDialog;
+
+namespace tl { template <> struct type_traits<QFontDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QFontDialog> &qtdecl_QFontDialog (); }
 
 class QFormLayout;
+
+namespace tl { template <> struct type_traits<QFormLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QFormLayout> &qtdecl_QFormLayout (); }
 
 class QFrame;
+
+namespace tl { template <> struct type_traits<QFrame> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QFrame> &qtdecl_QFrame (); }
 
 class QGesture;
+
+namespace tl { template <> struct type_traits<QGesture> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGesture> &qtdecl_QGesture (); }
 
 class QGestureEvent;
+
+namespace tl { template <> struct type_traits<QGestureEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGestureEvent> &qtdecl_QGestureEvent (); }
 
 class QGestureRecognizer;
+
+namespace tl { template <> struct type_traits<QGestureRecognizer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGestureRecognizer> &qtdecl_QGestureRecognizer (); }
 
 class QGraphicsAnchor;
+
+namespace tl { template <> struct type_traits<QGraphicsAnchor> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsAnchor> &qtdecl_QGraphicsAnchor (); }
 
 class QGraphicsAnchorLayout;
+
+namespace tl { template <> struct type_traits<QGraphicsAnchorLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsAnchorLayout> &qtdecl_QGraphicsAnchorLayout (); }
 
 class QGraphicsBlurEffect;
+
+namespace tl { template <> struct type_traits<QGraphicsBlurEffect> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsBlurEffect> &qtdecl_QGraphicsBlurEffect (); }
 
 class QGraphicsColorizeEffect;
+
+namespace tl { template <> struct type_traits<QGraphicsColorizeEffect> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsColorizeEffect> &qtdecl_QGraphicsColorizeEffect (); }
 
 class QGraphicsDropShadowEffect;
+
+namespace tl { template <> struct type_traits<QGraphicsDropShadowEffect> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsDropShadowEffect> &qtdecl_QGraphicsDropShadowEffect (); }
 
 class QGraphicsEffect;
+
+namespace tl { template <> struct type_traits<QGraphicsEffect> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsEffect> &qtdecl_QGraphicsEffect (); }
 
 class QGraphicsEllipseItem;
+
+namespace tl { template <> struct type_traits<QGraphicsEllipseItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsEllipseItem> &qtdecl_QGraphicsEllipseItem (); }
 
 class QGraphicsGridLayout;
+
+namespace tl { template <> struct type_traits<QGraphicsGridLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsGridLayout> &qtdecl_QGraphicsGridLayout (); }
 
 class QGraphicsItem;
+
+namespace tl { template <> struct type_traits<QGraphicsItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsItem> &qtdecl_QGraphicsItem (); }
 
 class QGraphicsItemAnimation;
+
+namespace tl { template <> struct type_traits<QGraphicsItemAnimation> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsItemAnimation> &qtdecl_QGraphicsItemAnimation (); }
 
 class QGraphicsItemGroup;
+
+namespace tl { template <> struct type_traits<QGraphicsItemGroup> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsItemGroup> &qtdecl_QGraphicsItemGroup (); }
 
 class QGraphicsLayout;
+
+namespace tl { template <> struct type_traits<QGraphicsLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsLayout> &qtdecl_QGraphicsLayout (); }
 
 class QGraphicsLayoutItem;
+
+namespace tl { template <> struct type_traits<QGraphicsLayoutItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsLayoutItem> &qtdecl_QGraphicsLayoutItem (); }
 
 class QGraphicsLineItem;
+
+namespace tl { template <> struct type_traits<QGraphicsLineItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsLineItem> &qtdecl_QGraphicsLineItem (); }
 
 class QGraphicsLinearLayout;
+
+namespace tl { template <> struct type_traits<QGraphicsLinearLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsLinearLayout> &qtdecl_QGraphicsLinearLayout (); }
 
 class QGraphicsObject;
+
+namespace tl { template <> struct type_traits<QGraphicsObject> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsObject> &qtdecl_QGraphicsObject (); }
 
 class QGraphicsOpacityEffect;
+
+namespace tl { template <> struct type_traits<QGraphicsOpacityEffect> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsOpacityEffect> &qtdecl_QGraphicsOpacityEffect (); }
 
 class QGraphicsPathItem;
+
+namespace tl { template <> struct type_traits<QGraphicsPathItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsPathItem> &qtdecl_QGraphicsPathItem (); }
 
 class QGraphicsPixmapItem;
+
+namespace tl { template <> struct type_traits<QGraphicsPixmapItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsPixmapItem> &qtdecl_QGraphicsPixmapItem (); }
 
 class QGraphicsPolygonItem;
+
+namespace tl { template <> struct type_traits<QGraphicsPolygonItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsPolygonItem> &qtdecl_QGraphicsPolygonItem (); }
 
 class QGraphicsProxyWidget;
+
+namespace tl { template <> struct type_traits<QGraphicsProxyWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsProxyWidget> &qtdecl_QGraphicsProxyWidget (); }
 
 class QGraphicsRectItem;
+
+namespace tl { template <> struct type_traits<QGraphicsRectItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsRectItem> &qtdecl_QGraphicsRectItem (); }
 
 class QGraphicsRotation;
+
+namespace tl { template <> struct type_traits<QGraphicsRotation> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsRotation> &qtdecl_QGraphicsRotation (); }
 
 class QGraphicsScale;
+
+namespace tl { template <> struct type_traits<QGraphicsScale> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsScale> &qtdecl_QGraphicsScale (); }
 
 class QGraphicsScene;
+
+namespace tl { template <> struct type_traits<QGraphicsScene> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsScene> &qtdecl_QGraphicsScene (); }
 
 class QGraphicsSceneContextMenuEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneContextMenuEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsSceneContextMenuEvent> &qtdecl_QGraphicsSceneContextMenuEvent (); }
 
 class QGraphicsSceneDragDropEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneDragDropEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsSceneDragDropEvent> &qtdecl_QGraphicsSceneDragDropEvent (); }
 
 class QGraphicsSceneEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsSceneEvent> &qtdecl_QGraphicsSceneEvent (); }
 
 class QGraphicsSceneHelpEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneHelpEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsSceneHelpEvent> &qtdecl_QGraphicsSceneHelpEvent (); }
 
 class QGraphicsSceneHoverEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneHoverEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsSceneHoverEvent> &qtdecl_QGraphicsSceneHoverEvent (); }
 
 class QGraphicsSceneMouseEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneMouseEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsSceneMouseEvent> &qtdecl_QGraphicsSceneMouseEvent (); }
 
 class QGraphicsSceneMoveEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneMoveEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsSceneMoveEvent> &qtdecl_QGraphicsSceneMoveEvent (); }
 
 class QGraphicsSceneResizeEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneResizeEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsSceneResizeEvent> &qtdecl_QGraphicsSceneResizeEvent (); }
 
 class QGraphicsSceneWheelEvent;
+
+namespace tl { template <> struct type_traits<QGraphicsSceneWheelEvent> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsSceneWheelEvent> &qtdecl_QGraphicsSceneWheelEvent (); }
 
 class QGraphicsSimpleTextItem;
+
+namespace tl { template <> struct type_traits<QGraphicsSimpleTextItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsSimpleTextItem> &qtdecl_QGraphicsSimpleTextItem (); }
 
 class QGraphicsTextItem;
+
+namespace tl { template <> struct type_traits<QGraphicsTextItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsTextItem> &qtdecl_QGraphicsTextItem (); }
 
 class QGraphicsTransform;
+
+namespace tl { template <> struct type_traits<QGraphicsTransform> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsTransform> &qtdecl_QGraphicsTransform (); }
 
 class QGraphicsView;
+
+namespace tl { template <> struct type_traits<QGraphicsView> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsView> &qtdecl_QGraphicsView (); }
 
 class QGraphicsWidget;
+
+namespace tl { template <> struct type_traits<QGraphicsWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGraphicsWidget> &qtdecl_QGraphicsWidget (); }
 
 class QGridLayout;
+
+namespace tl { template <> struct type_traits<QGridLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGridLayout> &qtdecl_QGridLayout (); }
 
 class QGroupBox;
+
+namespace tl { template <> struct type_traits<QGroupBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QGroupBox> &qtdecl_QGroupBox (); }
 
 class QHBoxLayout;
+
+namespace tl { template <> struct type_traits<QHBoxLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QHBoxLayout> &qtdecl_QHBoxLayout (); }
 
 class QHeaderView;
+
+namespace tl { template <> struct type_traits<QHeaderView> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QHeaderView> &qtdecl_QHeaderView (); }
 
 class QInputDialog;
+
+namespace tl { template <> struct type_traits<QInputDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QInputDialog> &qtdecl_QInputDialog (); }
 
 class QItemDelegate;
+
+namespace tl { template <> struct type_traits<QItemDelegate> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QItemDelegate> &qtdecl_QItemDelegate (); }
 
 class QItemEditorCreatorBase;
+
+namespace tl { template <> struct type_traits<QItemEditorCreatorBase> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QItemEditorCreatorBase> &qtdecl_QItemEditorCreatorBase (); }
 
 class QItemEditorFactory;
+
+namespace tl { template <> struct type_traits<QItemEditorFactory> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QItemEditorFactory> &qtdecl_QItemEditorFactory (); }
 
 class QKeySequenceEdit;
+
+namespace tl { template <> struct type_traits<QKeySequenceEdit> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QKeySequenceEdit> &qtdecl_QKeySequenceEdit (); }
 
 class QLCDNumber;
+
+namespace tl { template <> struct type_traits<QLCDNumber> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QLCDNumber> &qtdecl_QLCDNumber (); }
 
 class QLabel;
+
+namespace tl { template <> struct type_traits<QLabel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QLabel> &qtdecl_QLabel (); }
 
 class QLayout;
+
+namespace tl { template <> struct type_traits<QLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QLayout> &qtdecl_QLayout (); }
 
 class QLayoutItem;
+
+namespace tl { template <> struct type_traits<QLayoutItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QLayoutItem> &qtdecl_QLayoutItem (); }
 
 class QLineEdit;
+
+namespace tl { template <> struct type_traits<QLineEdit> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QLineEdit> &qtdecl_QLineEdit (); }
 
 class QListView;
+
+namespace tl { template <> struct type_traits<QListView> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QListView> &qtdecl_QListView (); }
 
 class QListWidget;
+
+namespace tl { template <> struct type_traits<QListWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QListWidget> &qtdecl_QListWidget (); }
 
 class QListWidgetItem;
+
+namespace tl { template <> struct type_traits<QListWidgetItem> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QListWidgetItem> &qtdecl_QListWidgetItem (); }
 
 class QMainWindow;
+
+namespace tl { template <> struct type_traits<QMainWindow> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QMainWindow> &qtdecl_QMainWindow (); }
 
 class QMdiArea;
+
+namespace tl { template <> struct type_traits<QMdiArea> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QMdiArea> &qtdecl_QMdiArea (); }
 
 class QMdiSubWindow;
+
+namespace tl { template <> struct type_traits<QMdiSubWindow> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QMdiSubWindow> &qtdecl_QMdiSubWindow (); }
 
 class QMenu;
+
+namespace tl { template <> struct type_traits<QMenu> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QMenu> &qtdecl_QMenu (); }
 
 class QMenuBar;
+
+namespace tl { template <> struct type_traits<QMenuBar> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QMenuBar> &qtdecl_QMenuBar (); }
 
 class QMessageBox;
+
+namespace tl { template <> struct type_traits<QMessageBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QMessageBox> &qtdecl_QMessageBox (); }
 
 class QPanGesture;
+
+namespace tl { template <> struct type_traits<QPanGesture> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QPanGesture> &qtdecl_QPanGesture (); }
 
 class QPinchGesture;
+
+namespace tl { template <> struct type_traits<QPinchGesture> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QPinchGesture> &qtdecl_QPinchGesture (); }
 
 class QPlainTextDocumentLayout;
+
+namespace tl { template <> struct type_traits<QPlainTextDocumentLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QPlainTextDocumentLayout> &qtdecl_QPlainTextDocumentLayout (); }
 
 class QPlainTextEdit;
+
+namespace tl { template <> struct type_traits<QPlainTextEdit> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QPlainTextEdit> &qtdecl_QPlainTextEdit (); }
 
 class QProgressBar;
+
+namespace tl { template <> struct type_traits<QProgressBar> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QProgressBar> &qtdecl_QProgressBar (); }
 
 class QProgressDialog;
+
+namespace tl { template <> struct type_traits<QProgressDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QProgressDialog> &qtdecl_QProgressDialog (); }
 
 class QPushButton;
+
+namespace tl { template <> struct type_traits<QPushButton> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QPushButton> &qtdecl_QPushButton (); }
 
 class QRadioButton;
+
+namespace tl { template <> struct type_traits<QRadioButton> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QRadioButton> &qtdecl_QRadioButton (); }
 
 class QRubberBand;
+
+namespace tl { template <> struct type_traits<QRubberBand> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QRubberBand> &qtdecl_QRubberBand (); }
 
 class QScrollArea;
+
+namespace tl { template <> struct type_traits<QScrollArea> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QScrollArea> &qtdecl_QScrollArea (); }
 
 class QScrollBar;
+
+namespace tl { template <> struct type_traits<QScrollBar> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QScrollBar> &qtdecl_QScrollBar (); }
 
 class QScroller;
+
+namespace tl { template <> struct type_traits<QScroller> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QScroller> &qtdecl_QScroller (); }
 
 class QScrollerProperties;
+
+namespace tl { template <> struct type_traits<QScrollerProperties> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QScrollerProperties> &qtdecl_QScrollerProperties (); }
 
 class QShortcut;
+
+namespace tl { template <> struct type_traits<QShortcut> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QShortcut> &qtdecl_QShortcut (); }
 
 class QSizeGrip;
+
+namespace tl { template <> struct type_traits<QSizeGrip> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QSizeGrip> &qtdecl_QSizeGrip (); }
 
 class QSizePolicy;
+
+namespace tl { template <> struct type_traits<QSizePolicy> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QSizePolicy> &qtdecl_QSizePolicy (); }
 
 class QSlider;
+
+namespace tl { template <> struct type_traits<QSlider> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QSlider> &qtdecl_QSlider (); }
 
 class QSpacerItem;
+
+namespace tl { template <> struct type_traits<QSpacerItem> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QSpacerItem> &qtdecl_QSpacerItem (); }
 
 class QSpinBox;
+
+namespace tl { template <> struct type_traits<QSpinBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QSpinBox> &qtdecl_QSpinBox (); }
 
 class QSplashScreen;
+
+namespace tl { template <> struct type_traits<QSplashScreen> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QSplashScreen> &qtdecl_QSplashScreen (); }
 
 class QSplitter;
+
+namespace tl { template <> struct type_traits<QSplitter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QSplitter> &qtdecl_QSplitter (); }
 
 class QSplitterHandle;
+
+namespace tl { template <> struct type_traits<QSplitterHandle> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QSplitterHandle> &qtdecl_QSplitterHandle (); }
 
 class QStackedLayout;
+
+namespace tl { template <> struct type_traits<QStackedLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStackedLayout> &qtdecl_QStackedLayout (); }
 
 class QStackedWidget;
+
+namespace tl { template <> struct type_traits<QStackedWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStackedWidget> &qtdecl_QStackedWidget (); }
 
 class QStatusBar;
+
+namespace tl { template <> struct type_traits<QStatusBar> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStatusBar> &qtdecl_QStatusBar (); }
 
 class QStyle;
+
+namespace tl { template <> struct type_traits<QStyle> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyle> &qtdecl_QStyle (); }
 
 class QStyleFactory;
+
+namespace tl { template <> struct type_traits<QStyleFactory> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleFactory> &qtdecl_QStyleFactory (); }
 
 class QStyleHintReturn;
+
+namespace tl { template <> struct type_traits<QStyleHintReturn> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleHintReturn> &qtdecl_QStyleHintReturn (); }
 
 class QStyleHintReturnMask;
+
+namespace tl { template <> struct type_traits<QStyleHintReturnMask> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleHintReturnMask> &qtdecl_QStyleHintReturnMask (); }
 
 class QStyleHintReturnVariant;
+
+namespace tl { template <> struct type_traits<QStyleHintReturnVariant> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleHintReturnVariant> &qtdecl_QStyleHintReturnVariant (); }
 
 class QStyleOption;
+
+namespace tl { template <> struct type_traits<QStyleOption> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOption> &qtdecl_QStyleOption (); }
 
 class QStyleOptionButton;
+
+namespace tl { template <> struct type_traits<QStyleOptionButton> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionButton> &qtdecl_QStyleOptionButton (); }
 
 class QStyleOptionComboBox;
+
+namespace tl { template <> struct type_traits<QStyleOptionComboBox> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionComboBox> &qtdecl_QStyleOptionComboBox (); }
 
 class QStyleOptionComplex;
+
+namespace tl { template <> struct type_traits<QStyleOptionComplex> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionComplex> &qtdecl_QStyleOptionComplex (); }
 
 class QStyleOptionDockWidget;
+
+namespace tl { template <> struct type_traits<QStyleOptionDockWidget> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionDockWidget> &qtdecl_QStyleOptionDockWidget (); }
 
 class QStyleOptionFocusRect;
+
+namespace tl { template <> struct type_traits<QStyleOptionFocusRect> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionFocusRect> &qtdecl_QStyleOptionFocusRect (); }
 
 class QStyleOptionFrame;
+
+namespace tl { template <> struct type_traits<QStyleOptionFrame> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionFrame> &qtdecl_QStyleOptionFrame (); }
 
 class QStyleOptionGraphicsItem;
+
+namespace tl { template <> struct type_traits<QStyleOptionGraphicsItem> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionGraphicsItem> &qtdecl_QStyleOptionGraphicsItem (); }
 
 class QStyleOptionGroupBox;
+
+namespace tl { template <> struct type_traits<QStyleOptionGroupBox> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionGroupBox> &qtdecl_QStyleOptionGroupBox (); }
 
 class QStyleOptionHeader;
+
+namespace tl { template <> struct type_traits<QStyleOptionHeader> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionHeader> &qtdecl_QStyleOptionHeader (); }
 
 class QStyleOptionMenuItem;
+
+namespace tl { template <> struct type_traits<QStyleOptionMenuItem> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionMenuItem> &qtdecl_QStyleOptionMenuItem (); }
 
 class QStyleOptionProgressBar;
+
+namespace tl { template <> struct type_traits<QStyleOptionProgressBar> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionProgressBar> &qtdecl_QStyleOptionProgressBar (); }
 
 class QStyleOptionRubberBand;
+
+namespace tl { template <> struct type_traits<QStyleOptionRubberBand> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionRubberBand> &qtdecl_QStyleOptionRubberBand (); }
 
 class QStyleOptionSizeGrip;
+
+namespace tl { template <> struct type_traits<QStyleOptionSizeGrip> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionSizeGrip> &qtdecl_QStyleOptionSizeGrip (); }
 
 class QStyleOptionSlider;
+
+namespace tl { template <> struct type_traits<QStyleOptionSlider> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionSlider> &qtdecl_QStyleOptionSlider (); }
 
 class QStyleOptionSpinBox;
+
+namespace tl { template <> struct type_traits<QStyleOptionSpinBox> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionSpinBox> &qtdecl_QStyleOptionSpinBox (); }
 
 class QStyleOptionTab;
+
+namespace tl { template <> struct type_traits<QStyleOptionTab> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionTab> &qtdecl_QStyleOptionTab (); }
 
 class QStyleOptionTabBarBase;
+
+namespace tl { template <> struct type_traits<QStyleOptionTabBarBase> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionTabBarBase> &qtdecl_QStyleOptionTabBarBase (); }
 
 class QStyleOptionTabWidgetFrame;
+
+namespace tl { template <> struct type_traits<QStyleOptionTabWidgetFrame> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionTabWidgetFrame> &qtdecl_QStyleOptionTabWidgetFrame (); }
 
 class QStyleOptionTitleBar;
+
+namespace tl { template <> struct type_traits<QStyleOptionTitleBar> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionTitleBar> &qtdecl_QStyleOptionTitleBar (); }
 
 class QStyleOptionToolBar;
+
+namespace tl { template <> struct type_traits<QStyleOptionToolBar> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionToolBar> &qtdecl_QStyleOptionToolBar (); }
 
 class QStyleOptionToolBox;
+
+namespace tl { template <> struct type_traits<QStyleOptionToolBox> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionToolBox> &qtdecl_QStyleOptionToolBox (); }
 
 class QStyleOptionToolButton;
+
+namespace tl { template <> struct type_traits<QStyleOptionToolButton> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionToolButton> &qtdecl_QStyleOptionToolButton (); }
 
 class QStyleOptionViewItem;
+
+namespace tl { template <> struct type_traits<QStyleOptionViewItem> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyleOptionViewItem> &qtdecl_QStyleOptionViewItem (); }
 
 class QStylePainter;
+
+namespace tl { template <> struct type_traits<QStylePainter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStylePainter> &qtdecl_QStylePainter (); }
 
 class QStylePlugin;
+
+namespace tl { template <> struct type_traits<QStylePlugin> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStylePlugin> &qtdecl_QStylePlugin (); }
 
 class QStyledItemDelegate;
+
+namespace tl { template <> struct type_traits<QStyledItemDelegate> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QStyledItemDelegate> &qtdecl_QStyledItemDelegate (); }
 
 class QSwipeGesture;
+
+namespace tl { template <> struct type_traits<QSwipeGesture> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QSwipeGesture> &qtdecl_QSwipeGesture (); }
 
 class QSystemTrayIcon;
+
+namespace tl { template <> struct type_traits<QSystemTrayIcon> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QSystemTrayIcon> &qtdecl_QSystemTrayIcon (); }
 
 class QTabBar;
+
+namespace tl { template <> struct type_traits<QTabBar> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QTabBar> &qtdecl_QTabBar (); }
 
 class QTabWidget;
+
+namespace tl { template <> struct type_traits<QTabWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QTabWidget> &qtdecl_QTabWidget (); }
 
 class QTableView;
+
+namespace tl { template <> struct type_traits<QTableView> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QTableView> &qtdecl_QTableView (); }
 
 class QTableWidget;
+
+namespace tl { template <> struct type_traits<QTableWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QTableWidget> &qtdecl_QTableWidget (); }
 
 class QTableWidgetItem;
+
+namespace tl { template <> struct type_traits<QTableWidgetItem> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QTableWidgetItem> &qtdecl_QTableWidgetItem (); }
 
 class QTableWidgetSelectionRange;
+
+namespace tl { template <> struct type_traits<QTableWidgetSelectionRange> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QTableWidgetSelectionRange> &qtdecl_QTableWidgetSelectionRange (); }
 
 class QTapAndHoldGesture;
+
+namespace tl { template <> struct type_traits<QTapAndHoldGesture> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QTapAndHoldGesture> &qtdecl_QTapAndHoldGesture (); }
 
 class QTapGesture;
+
+namespace tl { template <> struct type_traits<QTapGesture> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QTapGesture> &qtdecl_QTapGesture (); }
 
 class QTextBrowser;
+
+namespace tl { template <> struct type_traits<QTextBrowser> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QTextBrowser> &qtdecl_QTextBrowser (); }
 
 class QTextEdit;
+
+namespace tl { template <> struct type_traits<QTextEdit> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QTextEdit> &qtdecl_QTextEdit (); }
 
 class QTimeEdit;
+
+namespace tl { template <> struct type_traits<QTimeEdit> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QTimeEdit> &qtdecl_QTimeEdit (); }
 
 class QToolBar;
+
+namespace tl { template <> struct type_traits<QToolBar> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QToolBar> &qtdecl_QToolBar (); }
 
 class QToolBox;
+
+namespace tl { template <> struct type_traits<QToolBox> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QToolBox> &qtdecl_QToolBox (); }
 
 class QToolButton;
+
+namespace tl { template <> struct type_traits<QToolButton> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QToolButton> &qtdecl_QToolButton (); }
 
 class QToolTip;
+
+namespace tl { template <> struct type_traits<QToolTip> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QToolTip> &qtdecl_QToolTip (); }
 
 class QTreeView;
+
+namespace tl { template <> struct type_traits<QTreeView> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QTreeView> &qtdecl_QTreeView (); }
 
 class QTreeWidget;
+
+namespace tl { template <> struct type_traits<QTreeWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QTreeWidget> &qtdecl_QTreeWidget (); }
 
 class QTreeWidgetItem;
+
+namespace tl { template <> struct type_traits<QTreeWidgetItem> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QTreeWidgetItem> &qtdecl_QTreeWidgetItem (); }
 
 class QTreeWidgetItemIterator;
+
+namespace tl { template <> struct type_traits<QTreeWidgetItemIterator> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QTreeWidgetItemIterator> &qtdecl_QTreeWidgetItemIterator (); }
 
 class QUndoCommand;
+
+namespace tl { template <> struct type_traits<QUndoCommand> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QUndoCommand> &qtdecl_QUndoCommand (); }
 
 class QUndoGroup;
+
+namespace tl { template <> struct type_traits<QUndoGroup> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QUndoGroup> &qtdecl_QUndoGroup (); }
 
 class QUndoStack;
+
+namespace tl { template <> struct type_traits<QUndoStack> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QUndoStack> &qtdecl_QUndoStack (); }
 
 class QUndoView;
+
+namespace tl { template <> struct type_traits<QUndoView> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QUndoView> &qtdecl_QUndoView (); }
 
 class QVBoxLayout;
+
+namespace tl { template <> struct type_traits<QVBoxLayout> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QVBoxLayout> &qtdecl_QVBoxLayout (); }
 
 class QWhatsThis;
+
+namespace tl { template <> struct type_traits<QWhatsThis> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QWhatsThis> &qtdecl_QWhatsThis (); }
 
 class QWidget;
+
+namespace tl { template <> struct type_traits<QWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QWidget> &qtdecl_QWidget (); }
 
 class QWidgetAction;
+
+namespace tl { template <> struct type_traits<QWidgetAction> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QWidgetAction> &qtdecl_QWidgetAction (); }
 
 class QWidgetItem;
+
+namespace tl { template <> struct type_traits<QWidgetItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QWidgetItem> &qtdecl_QWidgetItem (); }
 
 class QWizard;
+
+namespace tl { template <> struct type_traits<QWizard> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QWizard> &qtdecl_QWizard (); }
 
 class QWizardPage;
+
+namespace tl { template <> struct type_traits<QWizardPage> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTWIDGETS_PUBLIC gsi::Class<QWizardPage> &qtdecl_QWizardPage (); }
 
 
diff --git a/src/gsiqt/qt5/QtXml/gsiQtExternals.h b/src/gsiqt/qt5/QtXml/gsiQtExternals.h
index aab65c016..0a2223e04 100644
--- a/src/gsiqt/qt5/QtXml/gsiQtExternals.h
+++ b/src/gsiqt/qt5/QtXml/gsiQtExternals.h
@@ -34,96 +34,240 @@
 #include "gsiQtXmlCommon.h"
 
 class QDomAttr;
+
+namespace tl { template <> struct type_traits<QDomAttr> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomAttr> &qtdecl_QDomAttr (); }
 
 class QDomCDATASection;
+
+namespace tl { template <> struct type_traits<QDomCDATASection> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomCDATASection> &qtdecl_QDomCDATASection (); }
 
 class QDomCharacterData;
+
+namespace tl { template <> struct type_traits<QDomCharacterData> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomCharacterData> &qtdecl_QDomCharacterData (); }
 
 class QDomComment;
+
+namespace tl { template <> struct type_traits<QDomComment> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomComment> &qtdecl_QDomComment (); }
 
 class QDomDocument;
+
+namespace tl { template <> struct type_traits<QDomDocument> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomDocument> &qtdecl_QDomDocument (); }
 
 class QDomDocumentFragment;
+
+namespace tl { template <> struct type_traits<QDomDocumentFragment> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomDocumentFragment> &qtdecl_QDomDocumentFragment (); }
 
 class QDomDocumentType;
+
+namespace tl { template <> struct type_traits<QDomDocumentType> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomDocumentType> &qtdecl_QDomDocumentType (); }
 
 class QDomElement;
+
+namespace tl { template <> struct type_traits<QDomElement> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomElement> &qtdecl_QDomElement (); }
 
 class QDomEntity;
+
+namespace tl { template <> struct type_traits<QDomEntity> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomEntity> &qtdecl_QDomEntity (); }
 
 class QDomEntityReference;
+
+namespace tl { template <> struct type_traits<QDomEntityReference> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomEntityReference> &qtdecl_QDomEntityReference (); }
 
 class QDomImplementation;
+
+namespace tl { template <> struct type_traits<QDomImplementation> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomImplementation> &qtdecl_QDomImplementation (); }
 
 class QDomNamedNodeMap;
+
+namespace tl { template <> struct type_traits<QDomNamedNodeMap> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomNamedNodeMap> &qtdecl_QDomNamedNodeMap (); }
 
 class QDomNode;
+
+namespace tl { template <> struct type_traits<QDomNode> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomNode> &qtdecl_QDomNode (); }
 
 class QDomNodeList;
+
+namespace tl { template <> struct type_traits<QDomNodeList> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomNodeList> &qtdecl_QDomNodeList (); }
 
 class QDomNotation;
+
+namespace tl { template <> struct type_traits<QDomNotation> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomNotation> &qtdecl_QDomNotation (); }
 
 class QDomProcessingInstruction;
+
+namespace tl { template <> struct type_traits<QDomProcessingInstruction> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomProcessingInstruction> &qtdecl_QDomProcessingInstruction (); }
 
 class QDomText;
+
+namespace tl { template <> struct type_traits<QDomText> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomText> &qtdecl_QDomText (); }
 
 class QXmlAttributes;
+
+namespace tl { template <> struct type_traits<QXmlAttributes> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlAttributes> &qtdecl_QXmlAttributes (); }
 
 class QXmlContentHandler;
+
+namespace tl { template <> struct type_traits<QXmlContentHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlContentHandler> &qtdecl_QXmlContentHandler (); }
 
 class QXmlDTDHandler;
+
+namespace tl { template <> struct type_traits<QXmlDTDHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlDTDHandler> &qtdecl_QXmlDTDHandler (); }
 
 class QXmlDeclHandler;
+
+namespace tl { template <> struct type_traits<QXmlDeclHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlDeclHandler> &qtdecl_QXmlDeclHandler (); }
 
 class QXmlDefaultHandler;
+
+namespace tl { template <> struct type_traits<QXmlDefaultHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlDefaultHandler> &qtdecl_QXmlDefaultHandler (); }
 
 class QXmlEntityResolver;
+
+namespace tl { template <> struct type_traits<QXmlEntityResolver> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlEntityResolver> &qtdecl_QXmlEntityResolver (); }
 
 class QXmlErrorHandler;
+
+namespace tl { template <> struct type_traits<QXmlErrorHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlErrorHandler> &qtdecl_QXmlErrorHandler (); }
 
 class QXmlInputSource;
+
+namespace tl { template <> struct type_traits<QXmlInputSource> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlInputSource> &qtdecl_QXmlInputSource (); }
 
 class QXmlLexicalHandler;
+
+namespace tl { template <> struct type_traits<QXmlLexicalHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlLexicalHandler> &qtdecl_QXmlLexicalHandler (); }
 
 class QXmlLocator;
+
+namespace tl { template <> struct type_traits<QXmlLocator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlLocator> &qtdecl_QXmlLocator (); }
 
 class QXmlNamespaceSupport;
+
+namespace tl { template <> struct type_traits<QXmlNamespaceSupport> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlNamespaceSupport> &qtdecl_QXmlNamespaceSupport (); }
 
 class QXmlParseException;
+
+namespace tl { template <> struct type_traits<QXmlParseException> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlParseException> &qtdecl_QXmlParseException (); }
 
 class QXmlReader;
+
+namespace tl { template <> struct type_traits<QXmlReader> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlReader> &qtdecl_QXmlReader (); }
 
 class QXmlSimpleReader;
+
+namespace tl { template <> struct type_traits<QXmlSimpleReader> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlSimpleReader> &qtdecl_QXmlSimpleReader (); }
 
 
diff --git a/src/gsiqt/qt5/QtXmlPatterns/gsiQtExternals.h b/src/gsiqt/qt5/QtXmlPatterns/gsiQtExternals.h
index 644b95216..b10fbd333 100644
--- a/src/gsiqt/qt5/QtXmlPatterns/gsiQtExternals.h
+++ b/src/gsiqt/qt5/QtXmlPatterns/gsiQtExternals.h
@@ -34,51 +34,131 @@
 #include "gsiQtXmlPatternsCommon.h"
 
 class QAbstractMessageHandler;
+
+namespace tl { template <> struct type_traits<QAbstractMessageHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QAbstractMessageHandler> &qtdecl_QAbstractMessageHandler (); }
 
 class QAbstractUriResolver;
+
+namespace tl { template <> struct type_traits<QAbstractUriResolver> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QAbstractUriResolver> &qtdecl_QAbstractUriResolver (); }
 
 class QAbstractXmlNodeModel;
+
+namespace tl { template <> struct type_traits<QAbstractXmlNodeModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QAbstractXmlNodeModel> &qtdecl_QAbstractXmlNodeModel (); }
 
 class QAbstractXmlReceiver;
+
+namespace tl { template <> struct type_traits<QAbstractXmlReceiver> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QAbstractXmlReceiver> &qtdecl_QAbstractXmlReceiver (); }
 
 class QSimpleXmlNodeModel;
+
+namespace tl { template <> struct type_traits<QSimpleXmlNodeModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QSimpleXmlNodeModel> &qtdecl_QSimpleXmlNodeModel (); }
 
 class QSourceLocation;
+
+namespace tl { template <> struct type_traits<QSourceLocation> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QSourceLocation> &qtdecl_QSourceLocation (); }
 
 class QXmlFormatter;
+
+namespace tl { template <> struct type_traits<QXmlFormatter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlFormatter> &qtdecl_QXmlFormatter (); }
 
 class QXmlItem;
+
+namespace tl { template <> struct type_traits<QXmlItem> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlItem> &qtdecl_QXmlItem (); }
 
 class QXmlName;
+
+namespace tl { template <> struct type_traits<QXmlName> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlName> &qtdecl_QXmlName (); }
 
 class QXmlNamePool;
+
+namespace tl { template <> struct type_traits<QXmlNamePool> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlNamePool> &qtdecl_QXmlNamePool (); }
 
 class QXmlNodeModelIndex;
+
+namespace tl { template <> struct type_traits<QXmlNodeModelIndex> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlNodeModelIndex> &qtdecl_QXmlNodeModelIndex (); }
 
 class QXmlQuery;
+
+namespace tl { template <> struct type_traits<QXmlQuery> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlQuery> &qtdecl_QXmlQuery (); }
 
 class QXmlResultItems;
+
+namespace tl { template <> struct type_traits<QXmlResultItems> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlResultItems> &qtdecl_QXmlResultItems (); }
 
 class QXmlSchema;
+
+namespace tl { template <> struct type_traits<QXmlSchema> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlSchema> &qtdecl_QXmlSchema (); }
 
 class QXmlSchemaValidator;
+
+namespace tl { template <> struct type_traits<QXmlSchemaValidator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlSchemaValidator> &qtdecl_QXmlSchemaValidator (); }
 
 class QXmlSerializer;
+
+namespace tl { template <> struct type_traits<QXmlSerializer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlSerializer> &qtdecl_QXmlSerializer (); }