
/*

  KLayout Layout Viewer
  Copyright (C) 2006-2021 Matthias Koefferlein

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

/**
*  @file generated/gsiDeclQtGuiTypeTraits.h
*  @brief Type traits for the Qt binding classes
*
*  DO NOT EDIT THIS FILE. 
*  This file has been created automatically
*/

#ifndef _HDR_gsiDeclQtGuiTypeTraits
#define _HDR_gsiDeclQtGuiTypeTraits

#include "gsiTypes.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;
};
}

class QAbstractAnimation_Adaptor;
namespace tl {
template <> struct type_traits<QAbstractAnimation_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QAbstractEventDispatcher_Adaptor;
namespace tl {
template <> struct type_traits<QAbstractEventDispatcher_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

#include <QAbstractEventDispatcher>
namespace tl {
template <> struct type_traits<QAbstractEventDispatcher::TimerInfo> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QAbstractItemModel_Adaptor;
namespace tl {
template <> struct type_traits<QAbstractItemModel_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QAbstractListModel_Adaptor;
namespace tl {
template <> struct type_traits<QAbstractListModel_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QAbstractNativeEventFilter_Adaptor;
namespace tl {
template <> struct type_traits<QAbstractNativeEventFilter_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QAbstractProxyModel_Adaptor;
namespace tl {
template <> struct type_traits<QAbstractProxyModel_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QAbstractState_Adaptor;
namespace tl {
template <> struct type_traits<QAbstractState_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QAbstractTableModel_Adaptor;
namespace tl {
template <> struct type_traits<QAbstractTableModel_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QAbstractTextDocumentLayout_Adaptor;
namespace tl {
template <> struct type_traits<QAbstractTextDocumentLayout_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

#include <QAbstractTextDocumentLayout>
namespace tl {
template <> struct type_traits<QAbstractTextDocumentLayout::Selection> : public type_traits<void> {
};
}

#include <QAbstractTextDocumentLayout>
namespace tl {
template <> struct type_traits<QAbstractTextDocumentLayout::PaintContext> : public type_traits<void> {
};
}

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;
};
}

class QAbstractTransition_Adaptor;
namespace tl {
template <> struct type_traits<QAbstractTransition_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QAbstractUndoItem_Adaptor;
namespace tl {
template <> struct type_traits<QAbstractUndoItem_Adaptor> : public type_traits<void> {
};
}

class QAccessible;
namespace tl {
template <> struct type_traits<QAccessible> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

#include <QAccessible>
namespace tl {
template <> struct type_traits<QAccessible::State> : public type_traits<void> {
};
}

#include <QAccessible>
namespace tl {
template <> struct type_traits<QAccessible::ActivationObserver> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

class QAccessible_ActivationObserver_Adaptor;
namespace tl {
template <> struct type_traits<QAccessible_ActivationObserver_Adaptor> : public type_traits<void> {
};
}

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;
};
}

class QAccessibleActionInterface_Adaptor;
namespace tl {
template <> struct type_traits<QAccessibleActionInterface_Adaptor> : public type_traits<void> {
};
}

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;
};
}

class QAccessibleEditableTextInterface_Adaptor;
namespace tl {
template <> struct type_traits<QAccessibleEditableTextInterface_Adaptor> : public type_traits<void> {
};
}

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;
};
}

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;
};
}

class QAccessibleImageInterface_Adaptor;
namespace tl {
template <> struct type_traits<QAccessibleImageInterface_Adaptor> : public type_traits<void> {
};
}

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;
};
}

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;
};
}

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;
};
}

class QAccessibleStateChangeEvent_Adaptor;
namespace tl {
template <> struct type_traits<QAccessibleStateChangeEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QAccessibleTableCellInterface_Adaptor;
namespace tl {
template <> struct type_traits<QAccessibleTableCellInterface_Adaptor> : public type_traits<void> {
};
}

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;
};
}

class QAccessibleTableInterface_Adaptor;
namespace tl {
template <> struct type_traits<QAccessibleTableInterface_Adaptor> : public type_traits<void> {
};
}

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;
};
}

class QAccessibleTableModelChangeEvent_Adaptor;
namespace tl {
template <> struct type_traits<QAccessibleTableModelChangeEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QAccessibleTextCursorEvent_Adaptor;
namespace tl {
template <> struct type_traits<QAccessibleTextCursorEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QAccessibleTextInsertEvent_Adaptor;
namespace tl {
template <> struct type_traits<QAccessibleTextInsertEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QAccessibleTextInterface_Adaptor;
namespace tl {
template <> struct type_traits<QAccessibleTextInterface_Adaptor> : public type_traits<void> {
};
}

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;
};
}

class QAccessibleTextRemoveEvent_Adaptor;
namespace tl {
template <> struct type_traits<QAccessibleTextRemoveEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QAccessibleTextSelectionEvent_Adaptor;
namespace tl {
template <> struct type_traits<QAccessibleTextSelectionEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QAccessibleTextUpdateEvent_Adaptor;
namespace tl {
template <> struct type_traits<QAccessibleTextUpdateEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QAccessibleValueChangeEvent_Adaptor;
namespace tl {
template <> struct type_traits<QAccessibleValueChangeEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QAccessibleValueInterface_Adaptor;
namespace tl {
template <> struct type_traits<QAccessibleValueInterface_Adaptor> : public type_traits<void> {
};
}

class QActionEvent;
namespace tl {
template <> struct type_traits<QActionEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QActionEvent_Adaptor;
namespace tl {
template <> struct type_traits<QActionEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QAnimationDriver;
namespace tl {
template <> struct type_traits<QAnimationDriver> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QAnimationDriver_Adaptor;
namespace tl {
template <> struct type_traits<QAnimationDriver_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QAnimationGroup_Adaptor;
namespace tl {
template <> struct type_traits<QAnimationGroup_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QApplicationStateChangeEvent;
namespace tl {
template <> struct type_traits<QApplicationStateChangeEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QAssociativeIterable;
namespace tl {
template <> struct type_traits<QAssociativeIterable> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QBasicMutex;
namespace tl {
template <> struct type_traits<QBasicMutex> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QBasicTimer;
namespace tl {
template <> struct type_traits<QBasicTimer> : public type_traits<void> {
};
}

class QBitmap;
namespace tl {
template <> struct type_traits<QBitmap> : public type_traits<void> {
};
}

class QBitmap_Adaptor;
namespace tl {
template <> struct type_traits<QBitmap_Adaptor> : public type_traits<void> {
};
}

class QBrush;
namespace tl {
template <> struct type_traits<QBrush> : public type_traits<void> {
};
}

class QBuffer;
namespace tl {
template <> struct type_traits<QBuffer> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

struct QByteArrayDataPtr;
namespace tl {
template <> struct type_traits<QByteArrayDataPtr> : public type_traits<void> {
};
}

class QByteArrayMatcher;
namespace tl {
template <> struct type_traits<QByteArrayMatcher> : public type_traits<void> {
};
}

class QChildEvent;
namespace tl {
template <> struct type_traits<QChildEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QChildEvent_Adaptor;
namespace tl {
template <> struct type_traits<QChildEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QCloseEvent;
namespace tl {
template <> struct type_traits<QCloseEvent> : public type_traits<void> {
};
}

class QCloseEvent_Adaptor;
namespace tl {
template <> struct type_traits<QCloseEvent_Adaptor> : public type_traits<void> {
};
}

class QCollator;
namespace tl {
template <> struct type_traits<QCollator> : public type_traits<void> {
};
}

class QCollatorSortKey;
namespace tl {
template <> struct type_traits<QCollatorSortKey> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QColor;
namespace tl {
template <> struct type_traits<QColor> : public type_traits<void> {
};
}

class QCommandLineOption;
namespace tl {
template <> struct type_traits<QCommandLineOption> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QCommandLineParser;
namespace tl {
template <> struct type_traits<QCommandLineParser> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QConicalGradient;
namespace tl {
template <> struct type_traits<QConicalGradient> : public type_traits<void> {
};
}

class QContextMenuEvent;
namespace tl {
template <> struct type_traits<QContextMenuEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QContextMenuEvent_Adaptor;
namespace tl {
template <> struct type_traits<QContextMenuEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QCoreApplication_Adaptor;
namespace tl {
template <> struct type_traits<QCoreApplication_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QCursor;
namespace tl {
template <> struct type_traits<QCursor> : public type_traits<void> {
};
}

class QDataStream;
namespace tl {
template <> struct type_traits<QDataStream> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QDate;
namespace tl {
template <> struct type_traits<QDate> : public type_traits<void> {
};
}

class QDateTime;
namespace tl {
template <> struct type_traits<QDateTime> : public type_traits<void> {
};
}

class QDebug;
namespace tl {
template <> struct type_traits<QDebug> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QDeferredDeleteEvent;
namespace tl {
template <> struct type_traits<QDeferredDeleteEvent> : public type_traits<void> {
};
}

class QDeferredDeleteEvent_Adaptor;
namespace tl {
template <> struct type_traits<QDeferredDeleteEvent_Adaptor> : public type_traits<void> {
};
}

class QDesktopServices;
namespace tl {
template <> struct type_traits<QDesktopServices> : public type_traits<void> {
};
}

class QDir;
namespace tl {
template <> struct type_traits<QDir> : public type_traits<void> {
};
}

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;
};
}

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;
};
}

class QDoubleValidator_Adaptor;
namespace tl {
template <> struct type_traits<QDoubleValidator_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QDrag_Adaptor;
namespace tl {
template <> struct type_traits<QDrag_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

class QDragEnterEvent;
namespace tl {
template <> struct type_traits<QDragEnterEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QDragEnterEvent_Adaptor;
namespace tl {
template <> struct type_traits<QDragEnterEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QDragLeaveEvent;
namespace tl {
template <> struct type_traits<QDragLeaveEvent> : public type_traits<void> {
};
}

class QDragLeaveEvent_Adaptor;
namespace tl {
template <> struct type_traits<QDragLeaveEvent_Adaptor> : public type_traits<void> {
};
}

class QDragMoveEvent;
namespace tl {
template <> struct type_traits<QDragMoveEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QDragMoveEvent_Adaptor;
namespace tl {
template <> struct type_traits<QDragMoveEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QDropEvent;
namespace tl {
template <> struct type_traits<QDropEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QDropEvent_Adaptor;
namespace tl {
template <> struct type_traits<QDropEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QDynamicPropertyChangeEvent;
namespace tl {
template <> struct type_traits<QDynamicPropertyChangeEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QDynamicPropertyChangeEvent_Adaptor;
namespace tl {
template <> struct type_traits<QDynamicPropertyChangeEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QEasingCurve;
namespace tl {
template <> struct type_traits<QEasingCurve> : public type_traits<void> {
};
}

class QElapsedTimer;
namespace tl {
template <> struct type_traits<QElapsedTimer> : public type_traits<void> {
};
}

class QEnterEvent;
namespace tl {
template <> struct type_traits<QEnterEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QEnterEvent_Adaptor;
namespace tl {
template <> struct type_traits<QEnterEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QEvent;
namespace tl {
template <> struct type_traits<QEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QEvent_Adaptor;
namespace tl {
template <> struct type_traits<QEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QEventLoop;
namespace tl {
template <> struct type_traits<QEventLoop> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QEventLoop_Adaptor;
namespace tl {
template <> struct type_traits<QEventLoop_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QEventLoopLocker;
namespace tl {
template <> struct type_traits<QEventLoopLocker> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QEventTransition;
namespace tl {
template <> struct type_traits<QEventTransition> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QEventTransition_Adaptor;
namespace tl {
template <> struct type_traits<QEventTransition_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QExposeEvent;
namespace tl {
template <> struct type_traits<QExposeEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QExposeEvent_Adaptor;
namespace tl {
template <> struct type_traits<QExposeEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QFactoryInterface_Adaptor;
namespace tl {
template <> struct type_traits<QFactoryInterface_Adaptor> : public type_traits<void> {
};
}

class QFile;
namespace tl {
template <> struct type_traits<QFile> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QFileDevice_Adaptor;
namespace tl {
template <> struct type_traits<QFileDevice_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

class QFileInfo;
namespace tl {
template <> struct type_traits<QFileInfo> : public type_traits<void> {
};
}

class QFileOpenEvent;
namespace tl {
template <> struct type_traits<QFileOpenEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QFileOpenEvent_Adaptor;
namespace tl {
template <> struct type_traits<QFileOpenEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QFileSelector;
namespace tl {
template <> struct type_traits<QFileSelector> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QFileSelector_Adaptor;
namespace tl {
template <> struct type_traits<QFileSelector_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QFileSystemWatcher;
namespace tl {
template <> struct type_traits<QFileSystemWatcher> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QFileSystemWatcher_Adaptor;
namespace tl {
template <> struct type_traits<QFileSystemWatcher_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QFinalState;
namespace tl {
template <> struct type_traits<QFinalState> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QFinalState_Adaptor;
namespace tl {
template <> struct type_traits<QFinalState_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QFocusEvent;
namespace tl {
template <> struct type_traits<QFocusEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QFocusEvent_Adaptor;
namespace tl {
template <> struct type_traits<QFocusEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QFont;
namespace tl {
template <> struct type_traits<QFont> : public type_traits<void> {
};
}

class QFontDatabase;
namespace tl {
template <> struct type_traits<QFontDatabase> : public type_traits<void> {
};
}

class QFontInfo;
namespace tl {
template <> struct type_traits<QFontInfo> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QFontMetrics;
namespace tl {
template <> struct type_traits<QFontMetrics> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QFontMetricsF;
namespace tl {
template <> struct type_traits<QFontMetricsF> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QGenericPlugin_Adaptor;
namespace tl {
template <> struct type_traits<QGenericPlugin_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QGenericPluginFactory;
namespace tl {
template <> struct type_traits<QGenericPluginFactory> : public type_traits<void> {
};
}

class QGlyphRun;
namespace tl {
template <> struct type_traits<QGlyphRun> : public type_traits<void> {
};
}

class QGradient;
namespace tl {
template <> struct type_traits<QGradient> : public type_traits<void> {
};
}

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;
};
}

class QGuiApplication_Adaptor;
namespace tl {
template <> struct type_traits<QGuiApplication_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

class QHelpEvent;
namespace tl {
template <> struct type_traits<QHelpEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QHelpEvent_Adaptor;
namespace tl {
template <> struct type_traits<QHelpEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QHideEvent;
namespace tl {
template <> struct type_traits<QHideEvent> : public type_traits<void> {
};
}

class QHideEvent_Adaptor;
namespace tl {
template <> struct type_traits<QHideEvent_Adaptor> : public type_traits<void> {
};
}

class QHistoryState;
namespace tl {
template <> struct type_traits<QHistoryState> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QHistoryState_Adaptor;
namespace tl {
template <> struct type_traits<QHistoryState_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QHoverEvent;
namespace tl {
template <> struct type_traits<QHoverEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QHoverEvent_Adaptor;
namespace tl {
template <> struct type_traits<QHoverEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QIcon;
namespace tl {
template <> struct type_traits<QIcon> : public type_traits<void> {
};
}

class QIconDragEvent;
namespace tl {
template <> struct type_traits<QIconDragEvent> : public type_traits<void> {
};
}

class QIconDragEvent_Adaptor;
namespace tl {
template <> struct type_traits<QIconDragEvent_Adaptor> : public type_traits<void> {
};
}

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;
};
}

class QIconEngine_Adaptor;
namespace tl {
template <> struct type_traits<QIconEngine_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

#include <QIconEngine>
namespace tl {
template <> struct type_traits<QIconEngine::AvailableSizesArgument> : public type_traits<void> {
};
}

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;
};
}

class QIconEnginePlugin_Adaptor;
namespace tl {
template <> struct type_traits<QIconEnginePlugin_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QIdentityProxyModel;
namespace tl {
template <> struct type_traits<QIdentityProxyModel> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QIdentityProxyModel_Adaptor;
namespace tl {
template <> struct type_traits<QIdentityProxyModel_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QImage;
namespace tl {
template <> struct type_traits<QImage> : public type_traits<void> {
};
}

class QImage_Adaptor;
namespace tl {
template <> struct type_traits<QImage_Adaptor> : public type_traits<void> {
};
}

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;
};
}

class QImageIOHandler_Adaptor;
namespace tl {
template <> struct type_traits<QImageIOHandler_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QImageIOPlugin_Adaptor;
namespace tl {
template <> struct type_traits<QImageIOPlugin_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QImageReader;
namespace tl {
template <> struct type_traits<QImageReader> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QImageWriter;
namespace tl {
template <> struct type_traits<QImageWriter> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QInputEvent;
namespace tl {
template <> struct type_traits<QInputEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QInputEvent_Adaptor;
namespace tl {
template <> struct type_traits<QInputEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QInputMethodEvent;
namespace tl {
template <> struct type_traits<QInputMethodEvent> : public type_traits<void> {
};
}

#include <QInputMethodEvent>
namespace tl {
template <> struct type_traits<QInputMethodEvent::Attribute> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QInputMethodQueryEvent;
namespace tl {
template <> struct type_traits<QInputMethodQueryEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QInputMethodQueryEvent_Adaptor;
namespace tl {
template <> struct type_traits<QInputMethodQueryEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QIntValidator;
namespace tl {
template <> struct type_traits<QIntValidator> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QIntValidator_Adaptor;
namespace tl {
template <> struct type_traits<QIntValidator_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QItemSelection;
namespace tl {
template <> struct type_traits<QItemSelection> : public type_traits<void> {
};
}

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;
};
}

class QItemSelectionModel_Adaptor;
namespace tl {
template <> struct type_traits<QItemSelectionModel_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

class QItemSelectionRange;
namespace tl {
template <> struct type_traits<QItemSelectionRange> : public type_traits<void> {
};
}

class QJsonArray;
namespace tl {
template <> struct type_traits<QJsonArray> : public type_traits<void> {
};
}

#include <QJsonArray>
namespace tl {
template <> struct type_traits<QJsonArray::iterator> : public type_traits<void> {
};
}

#include <QJsonArray>
namespace tl {
template <> struct type_traits<QJsonArray::const_iterator> : public type_traits<void> {
};
}

class QJsonDocument;
namespace tl {
template <> struct type_traits<QJsonDocument> : public type_traits<void> {
};
}

class QJsonObject;
namespace tl {
template <> struct type_traits<QJsonObject> : public type_traits<void> {
};
}

#include <QJsonObject>
namespace tl {
template <> struct type_traits<QJsonObject::iterator> : public type_traits<void> {
};
}

#include <QJsonObject>
namespace tl {
template <> struct type_traits<QJsonObject::const_iterator> : public type_traits<void> {
};
}

struct QJsonParseError;
namespace tl {
template <> struct type_traits<QJsonParseError> : public type_traits<void> {
};
}

class QJsonValue;
namespace tl {
template <> struct type_traits<QJsonValue> : public type_traits<void> {
};
}

class QJsonValuePtr;
namespace tl {
template <> struct type_traits<QJsonValuePtr> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QJsonValueRef;
namespace tl {
template <> struct type_traits<QJsonValueRef> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QJsonValueRefPtr;
namespace tl {
template <> struct type_traits<QJsonValueRefPtr> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QKeyEvent;
namespace tl {
template <> struct type_traits<QKeyEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QKeyEvent_Adaptor;
namespace tl {
template <> struct type_traits<QKeyEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QKeySequence;
namespace tl {
template <> struct type_traits<QKeySequence> : public type_traits<void> {
};
}

class QLibrary;
namespace tl {
template <> struct type_traits<QLibrary> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QLibrary_Adaptor;
namespace tl {
template <> struct type_traits<QLibrary_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QLibraryInfo;
namespace tl {
template <> struct type_traits<QLibraryInfo> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QLine;
namespace tl {
template <> struct type_traits<QLine> : public type_traits<void> {
};
}

class QLineF;
namespace tl {
template <> struct type_traits<QLineF> : public type_traits<void> {
};
}

class QLinearGradient;
namespace tl {
template <> struct type_traits<QLinearGradient> : public type_traits<void> {
};
}

class QLocale;
namespace tl {
template <> struct type_traits<QLocale> : public type_traits<void> {
};
}

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;
};
}

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;
};
}

struct QMapDataBase;
namespace tl {
template <> struct type_traits<QMapDataBase> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

struct QMapNodeBase;
namespace tl {
template <> struct type_traits<QMapNodeBase> : public type_traits<void> {
};
}

class QMargins;
namespace tl {
template <> struct type_traits<QMargins> : public type_traits<void> {
};
}

class QMarginsF;
namespace tl {
template <> struct type_traits<QMarginsF> : public type_traits<void> {
};
}

class QMatrix;
namespace tl {
template <> struct type_traits<QMatrix> : public type_traits<void> {
};
}

class QMatrix4x4;
namespace tl {
template <> struct type_traits<QMatrix4x4> : public type_traits<void> {
};
}

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;
};
}

class QMessageLogContext;
namespace tl {
template <> struct type_traits<QMessageLogContext> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QMessageLogger;
namespace tl {
template <> struct type_traits<QMessageLogger> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QMetaClassInfo;
namespace tl {
template <> struct type_traits<QMetaClassInfo> : public type_traits<void> {
};
}

class QMetaEnum;
namespace tl {
template <> struct type_traits<QMetaEnum> : public type_traits<void> {
};
}

class QMetaMethod;
namespace tl {
template <> struct type_traits<QMetaMethod> : public type_traits<void> {
};
}

struct QMetaObject;
namespace tl {
template <> struct type_traits<QMetaObject> : public type_traits<void> {
};
}

#include <QMetaObject>
namespace tl {
template <> struct type_traits<QMetaObject::Connection> : public type_traits<void> {
};
}

class QMetaProperty;
namespace tl {
template <> struct type_traits<QMetaProperty> : public type_traits<void> {
};
}

class QMimeData;
namespace tl {
template <> struct type_traits<QMimeData> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QMimeData_Adaptor;
namespace tl {
template <> struct type_traits<QMimeData_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QMimeDatabase;
namespace tl {
template <> struct type_traits<QMimeDatabase> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QMimeType;
namespace tl {
template <> struct type_traits<QMimeType> : public type_traits<void> {
};
}

class QModelIndex;
namespace tl {
template <> struct type_traits<QModelIndex> : public type_traits<void> {
};
}

class QMouseEvent;
namespace tl {
template <> struct type_traits<QMouseEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QMouseEvent_Adaptor;
namespace tl {
template <> struct type_traits<QMouseEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QMoveEvent;
namespace tl {
template <> struct type_traits<QMoveEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QMoveEvent_Adaptor;
namespace tl {
template <> struct type_traits<QMoveEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QMovie;
namespace tl {
template <> struct type_traits<QMovie> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QMovie_Adaptor;
namespace tl {
template <> struct type_traits<QMovie_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QMutex;
namespace tl {
template <> struct type_traits<QMutex> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QNativeGestureEvent;
namespace tl {
template <> struct type_traits<QNativeGestureEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QNoDebug;
namespace tl {
template <> struct type_traits<QNoDebug> : public type_traits<void> {
};
}

class QObject;
namespace tl {
template <> struct type_traits<QObject> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QObject_Adaptor;
namespace tl {
template <> struct type_traits<QObject_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QOffscreenSurface;
namespace tl {
template <> struct type_traits<QOffscreenSurface> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QOffscreenSurface_Adaptor;
namespace tl {
template <> struct type_traits<QOffscreenSurface_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QPageLayout;
namespace tl {
template <> struct type_traits<QPageLayout> : public type_traits<void> {
};
}

class QPageSize;
namespace tl {
template <> struct type_traits<QPageSize> : public type_traits<void> {
};
}

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;
};
}

class QPagedPaintDevice_Adaptor;
namespace tl {
template <> struct type_traits<QPagedPaintDevice_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

#include <QPagedPaintDevice>
namespace tl {
template <> struct type_traits<QPagedPaintDevice::Margins> : public type_traits<void> {
};
}

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;
};
}

class QPaintDevice_Adaptor;
namespace tl {
template <> struct type_traits<QPaintDevice_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QPaintDeviceWindow_Adaptor;
namespace tl {
template <> struct type_traits<QPaintDeviceWindow_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QPaintEngine_Adaptor;
namespace tl {
template <> struct type_traits<QPaintEngine_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QPaintEngineState;
namespace tl {
template <> struct type_traits<QPaintEngineState> : public type_traits<void> {
};
}

class QPaintEvent;
namespace tl {
template <> struct type_traits<QPaintEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QPaintEvent_Adaptor;
namespace tl {
template <> struct type_traits<QPaintEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QPainter;
namespace tl {
template <> struct type_traits<QPainter> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

#include <QPainter>
namespace tl {
template <> struct type_traits<QPainter::PixmapFragment> : public type_traits<void> {
};
}

class QPainterPath;
namespace tl {
template <> struct type_traits<QPainterPath> : public type_traits<void> {
};
}

#include <QPainterPath>
namespace tl {
template <> struct type_traits<QPainterPath::Element> : public type_traits<void> {
};
}

class QPainterPathStroker;
namespace tl {
template <> struct type_traits<QPainterPathStroker> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QPalette;
namespace tl {
template <> struct type_traits<QPalette> : public type_traits<void> {
};
}

class QParallelAnimationGroup;
namespace tl {
template <> struct type_traits<QParallelAnimationGroup> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QParallelAnimationGroup_Adaptor;
namespace tl {
template <> struct type_traits<QParallelAnimationGroup_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QPauseAnimation;
namespace tl {
template <> struct type_traits<QPauseAnimation> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QPauseAnimation_Adaptor;
namespace tl {
template <> struct type_traits<QPauseAnimation_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QPdfWriter_Adaptor;
namespace tl {
template <> struct type_traits<QPdfWriter_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

class QPen;
namespace tl {
template <> struct type_traits<QPen> : public type_traits<void> {
};
}

class QPersistentModelIndex;
namespace tl {
template <> struct type_traits<QPersistentModelIndex> : public type_traits<void> {
};
}

class QPicture;
namespace tl {
template <> struct type_traits<QPicture> : public type_traits<void> {
};
}

class QPicture_Adaptor;
namespace tl {
template <> struct type_traits<QPicture_Adaptor> : public type_traits<void> {
};
}

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;
};
}

class QPictureFormatPlugin_Adaptor;
namespace tl {
template <> struct type_traits<QPictureFormatPlugin_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QPixelFormat;
namespace tl {
template <> struct type_traits<QPixelFormat> : public type_traits<void> {
};
}

class QPixmap;
namespace tl {
template <> struct type_traits<QPixmap> : public type_traits<void> {
};
}

class QPixmap_Adaptor;
namespace tl {
template <> struct type_traits<QPixmap_Adaptor> : public type_traits<void> {
};
}

class QPixmapCache;
namespace tl {
template <> struct type_traits<QPixmapCache> : public type_traits<void> {
};
}

class QPlatformSurfaceEvent;
namespace tl {
template <> struct type_traits<QPlatformSurfaceEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QPlatformSurfaceEvent_Adaptor;
namespace tl {
template <> struct type_traits<QPlatformSurfaceEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QPluginLoader;
namespace tl {
template <> struct type_traits<QPluginLoader> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QPluginLoader_Adaptor;
namespace tl {
template <> struct type_traits<QPluginLoader_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QPoint;
namespace tl {
template <> struct type_traits<QPoint> : public type_traits<void> {
};
}

class QPointF;
namespace tl {
template <> struct type_traits<QPointF> : public type_traits<void> {
};
}

class QPolygon;
namespace tl {
template <> struct type_traits<QPolygon> : public type_traits<void> {
};
}

class QPolygonF;
namespace tl {
template <> struct type_traits<QPolygonF> : public type_traits<void> {
};
}

class QProcess;
namespace tl {
template <> struct type_traits<QProcess> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QProcessEnvironment;
namespace tl {
template <> struct type_traits<QProcessEnvironment> : public type_traits<void> {
};
}

class QPropertyAnimation;
namespace tl {
template <> struct type_traits<QPropertyAnimation> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QPropertyAnimation_Adaptor;
namespace tl {
template <> struct type_traits<QPropertyAnimation_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QQuaternion;
namespace tl {
template <> struct type_traits<QQuaternion> : public type_traits<void> {
};
}

class QRadialGradient;
namespace tl {
template <> struct type_traits<QRadialGradient> : public type_traits<void> {
};
}

class QRasterWindow;
namespace tl {
template <> struct type_traits<QRasterWindow> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QRasterWindow_Adaptor;
namespace tl {
template <> struct type_traits<QRasterWindow_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QRawFont;
namespace tl {
template <> struct type_traits<QRawFont> : public type_traits<void> {
};
}

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;
};
}

class QReadWriteLock;
namespace tl {
template <> struct type_traits<QReadWriteLock> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QRect;
namespace tl {
template <> struct type_traits<QRect> : public type_traits<void> {
};
}

class QRectF;
namespace tl {
template <> struct type_traits<QRectF> : public type_traits<void> {
};
}

class QRegExp;
namespace tl {
template <> struct type_traits<QRegExp> : public type_traits<void> {
};
}

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;
};
}

class QRegExpValidator_Adaptor;
namespace tl {
template <> struct type_traits<QRegExpValidator_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

class QRegion;
namespace tl {
template <> struct type_traits<QRegion> : public type_traits<void> {
};
}

class QRegularExpression;
namespace tl {
template <> struct type_traits<QRegularExpression> : public type_traits<void> {
};
}

class QRegularExpressionMatch;
namespace tl {
template <> struct type_traits<QRegularExpressionMatch> : public type_traits<void> {
};
}

class QRegularExpressionMatchIterator;
namespace tl {
template <> struct type_traits<QRegularExpressionMatchIterator> : public type_traits<void> {
};
}

class QRegularExpressionValidator;
namespace tl {
template <> struct type_traits<QRegularExpressionValidator> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QRegularExpressionValidator_Adaptor;
namespace tl {
template <> struct type_traits<QRegularExpressionValidator_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QResizeEvent;
namespace tl {
template <> struct type_traits<QResizeEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QResizeEvent_Adaptor;
namespace tl {
template <> struct type_traits<QResizeEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QResource;
namespace tl {
template <> struct type_traits<QResource> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QRunnable_Adaptor;
namespace tl {
template <> struct type_traits<QRunnable_Adaptor> : public type_traits<void> {
};
}

class QSaveFile;
namespace tl {
template <> struct type_traits<QSaveFile> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QSaveFile_Adaptor;
namespace tl {
template <> struct type_traits<QSaveFile_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QScreen_Adaptor;
namespace tl {
template <> struct type_traits<QScreen_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

class QScreenOrientationChangeEvent;
namespace tl {
template <> struct type_traits<QScreenOrientationChangeEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QScreenOrientationChangeEvent_Adaptor;
namespace tl {
template <> struct type_traits<QScreenOrientationChangeEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QScrollEvent;
namespace tl {
template <> struct type_traits<QScrollEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QScrollEvent_Adaptor;
namespace tl {
template <> struct type_traits<QScrollEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QScrollPrepareEvent;
namespace tl {
template <> struct type_traits<QScrollPrepareEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QScrollPrepareEvent_Adaptor;
namespace tl {
template <> struct type_traits<QScrollPrepareEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QSemaphore;
namespace tl {
template <> struct type_traits<QSemaphore> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QSequentialAnimationGroup;
namespace tl {
template <> struct type_traits<QSequentialAnimationGroup> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QSequentialAnimationGroup_Adaptor;
namespace tl {
template <> struct type_traits<QSequentialAnimationGroup_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QSequentialIterable;
namespace tl {
template <> struct type_traits<QSequentialIterable> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QSettings;
namespace tl {
template <> struct type_traits<QSettings> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QSettings_Adaptor;
namespace tl {
template <> struct type_traits<QSettings_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QSharedMemory;
namespace tl {
template <> struct type_traits<QSharedMemory> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QSharedMemory_Adaptor;
namespace tl {
template <> struct type_traits<QSharedMemory_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QShortcutEvent;
namespace tl {
template <> struct type_traits<QShortcutEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QShortcutEvent_Adaptor;
namespace tl {
template <> struct type_traits<QShortcutEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QShowEvent;
namespace tl {
template <> struct type_traits<QShowEvent> : public type_traits<void> {
};
}

class QShowEvent_Adaptor;
namespace tl {
template <> struct type_traits<QShowEvent_Adaptor> : public type_traits<void> {
};
}

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;
};
}

class QSignalMapper;
namespace tl {
template <> struct type_traits<QSignalMapper> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QSignalMapper_Adaptor;
namespace tl {
template <> struct type_traits<QSignalMapper_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QSignalTransition;
namespace tl {
template <> struct type_traits<QSignalTransition> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QSignalTransition_Adaptor;
namespace tl {
template <> struct type_traits<QSignalTransition_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QSize;
namespace tl {
template <> struct type_traits<QSize> : public type_traits<void> {
};
}

class QSizeF;
namespace tl {
template <> struct type_traits<QSizeF> : public type_traits<void> {
};
}

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;
};
}

class QSocketNotifier_Adaptor;
namespace tl {
template <> struct type_traits<QSocketNotifier_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

class QSortFilterProxyModel;
namespace tl {
template <> struct type_traits<QSortFilterProxyModel> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QSortFilterProxyModel_Adaptor;
namespace tl {
template <> struct type_traits<QSortFilterProxyModel_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QStandardItem;
namespace tl {
template <> struct type_traits<QStandardItem> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QStandardItem_Adaptor;
namespace tl {
template <> struct type_traits<QStandardItem_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QStandardItemModel;
namespace tl {
template <> struct type_traits<QStandardItemModel> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QStandardItemModel_Adaptor;
namespace tl {
template <> struct type_traits<QStandardItemModel_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QState;
namespace tl {
template <> struct type_traits<QState> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QState_Adaptor;
namespace tl {
template <> struct type_traits<QState_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QStateMachine;
namespace tl {
template <> struct type_traits<QStateMachine> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QStateMachine_Adaptor;
namespace tl {
template <> struct type_traits<QStateMachine_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

#include <QStateMachine>
namespace tl {
template <> struct type_traits<QStateMachine::SignalEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QStateMachine_SignalEvent_Adaptor;
namespace tl {
template <> struct type_traits<QStateMachine_SignalEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

#include <QStateMachine>
namespace tl {
template <> struct type_traits<QStateMachine::WrappedEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QStateMachine_WrappedEvent_Adaptor;
namespace tl {
template <> struct type_traits<QStateMachine_WrappedEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

struct QStaticPlugin;
namespace tl {
template <> struct type_traits<QStaticPlugin> : public type_traits<void> {
};
}

class QStaticText;
namespace tl {
template <> struct type_traits<QStaticText> : public type_traits<void> {
};
}

class QStatusTipEvent;
namespace tl {
template <> struct type_traits<QStatusTipEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QStatusTipEvent_Adaptor;
namespace tl {
template <> struct type_traits<QStatusTipEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QStorageInfo;
namespace tl {
template <> struct type_traits<QStorageInfo> : public type_traits<void> {
};
}

struct QStringDataPtr;
namespace tl {
template <> struct type_traits<QStringDataPtr> : public type_traits<void> {
};
}

class QStringListModel;
namespace tl {
template <> struct type_traits<QStringListModel> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QStringListModel_Adaptor;
namespace tl {
template <> struct type_traits<QStringListModel_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QStringMatcher;
namespace tl {
template <> struct type_traits<QStringMatcher> : public type_traits<void> {
};
}

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;
};
}

class QStyleHints_Adaptor;
namespace tl {
template <> struct type_traits<QStyleHints_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QSurfaceFormat;
namespace tl {
template <> struct type_traits<QSurfaceFormat> : public type_traits<void> {
};
}

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;
};
}

class QSyntaxHighlighter_Adaptor;
namespace tl {
template <> struct type_traits<QSyntaxHighlighter_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

class QSysInfo;
namespace tl {
template <> struct type_traits<QSysInfo> : public type_traits<void> {
};
}

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;
};
}

class QTabletEvent;
namespace tl {
template <> struct type_traits<QTabletEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QTabletEvent_Adaptor;
namespace tl {
template <> struct type_traits<QTabletEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QTemporaryDir;
namespace tl {
template <> struct type_traits<QTemporaryDir> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QTemporaryFile;
namespace tl {
template <> struct type_traits<QTemporaryFile> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QTextBlock;
namespace tl {
template <> struct type_traits<QTextBlock> : public type_traits<void> {
};
}

#include <QTextBlock>
namespace tl {
template <> struct type_traits<QTextBlock::iterator> : public type_traits<void> {
};
}

class QTextBlockFormat;
namespace tl {
template <> struct type_traits<QTextBlockFormat> : public type_traits<void> {
};
}

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;
};
}

class QTextBlockGroup_Adaptor;
namespace tl {
template <> struct type_traits<QTextBlockGroup_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

class QTextBlockUserData;
namespace tl {
template <> struct type_traits<QTextBlockUserData> : public type_traits<void> {
};
}

class QTextBlockUserData_Adaptor;
namespace tl {
template <> struct type_traits<QTextBlockUserData_Adaptor> : public type_traits<void> {
};
}

class QTextBoundaryFinder;
namespace tl {
template <> struct type_traits<QTextBoundaryFinder> : public type_traits<void> {
};
}

class QTextCharFormat;
namespace tl {
template <> struct type_traits<QTextCharFormat> : public type_traits<void> {
};
}

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;
};
}

class QTextCodec_Adaptor;
namespace tl {
template <> struct type_traits<QTextCodec_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

#include <QTextCodec>
namespace tl {
template <> struct type_traits<QTextCodec::ConverterState> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QTextCursor;
namespace tl {
template <> struct type_traits<QTextCursor> : public type_traits<void> {
};
}

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;
};
}

class QTextDocument;
namespace tl {
template <> struct type_traits<QTextDocument> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QTextDocument_Adaptor;
namespace tl {
template <> struct type_traits<QTextDocument_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QTextDocumentFragment;
namespace tl {
template <> struct type_traits<QTextDocumentFragment> : public type_traits<void> {
};
}

class QTextDocumentWriter;
namespace tl {
template <> struct type_traits<QTextDocumentWriter> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QTextFormat;
namespace tl {
template <> struct type_traits<QTextFormat> : public type_traits<void> {
};
}

class QTextFragment;
namespace tl {
template <> struct type_traits<QTextFragment> : public type_traits<void> {
};
}

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;
};
}

class QTextFrame_Adaptor;
namespace tl {
template <> struct type_traits<QTextFrame_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

#include <QTextFrame>
namespace tl {
template <> struct type_traits<QTextFrame::iterator> : public type_traits<void> {
};
}

class QTextFrameFormat;
namespace tl {
template <> struct type_traits<QTextFrameFormat> : public type_traits<void> {
};
}

class QTextImageFormat;
namespace tl {
template <> struct type_traits<QTextImageFormat> : public type_traits<void> {
};
}

class QTextInlineObject;
namespace tl {
template <> struct type_traits<QTextInlineObject> : public type_traits<void> {
};
}

class QTextItem;
namespace tl {
template <> struct type_traits<QTextItem> : public type_traits<void> {
};
}

class QTextLayout;
namespace tl {
template <> struct type_traits<QTextLayout> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

#include <QTextLayout>
namespace tl {
template <> struct type_traits<QTextLayout::FormatRange> : public type_traits<void> {
};
}

class QTextLength;
namespace tl {
template <> struct type_traits<QTextLength> : public type_traits<void> {
};
}

class QTextLine;
namespace tl {
template <> struct type_traits<QTextLine> : public type_traits<void> {
};
}

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;
};
}

class QTextList_Adaptor;
namespace tl {
template <> struct type_traits<QTextList_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

class QTextListFormat;
namespace tl {
template <> struct type_traits<QTextListFormat> : public type_traits<void> {
};
}

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;
};
}

class QTextObject_Adaptor;
namespace tl {
template <> struct type_traits<QTextObject_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QTextObjectInterface_Adaptor;
namespace tl {
template <> struct type_traits<QTextObjectInterface_Adaptor> : public type_traits<void> {
};
}

class QTextOption;
namespace tl {
template <> struct type_traits<QTextOption> : public type_traits<void> {
};
}

#include <QTextOption>
namespace tl {
template <> struct type_traits<QTextOption::Tab> : public type_traits<void> {
};
}

class QTextStream;
namespace tl {
template <> struct type_traits<QTextStream> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QTextStream_Adaptor;
namespace tl {
template <> struct type_traits<QTextStream_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

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;
};
}

class QTextTable_Adaptor;
namespace tl {
template <> struct type_traits<QTextTable_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}

class QTextTableCell;
namespace tl {
template <> struct type_traits<QTextTableCell> : public type_traits<void> {
};
}

class QTextTableCellFormat;
namespace tl {
template <> struct type_traits<QTextTableCellFormat> : public type_traits<void> {
};
}

class QTextTableFormat;
namespace tl {
template <> struct type_traits<QTextTableFormat> : public type_traits<void> {
};
}

class QThread;
namespace tl {
template <> struct type_traits<QThread> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QThread_Adaptor;
namespace tl {
template <> struct type_traits<QThread_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QThreadPool;
namespace tl {
template <> struct type_traits<QThreadPool> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QThreadPool_Adaptor;
namespace tl {
template <> struct type_traits<QThreadPool_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QTime;
namespace tl {
template <> struct type_traits<QTime> : public type_traits<void> {
};
}

class QTimeLine;
namespace tl {
template <> struct type_traits<QTimeLine> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QTimeLine_Adaptor;
namespace tl {
template <> struct type_traits<QTimeLine_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QTimeZone;
namespace tl {
template <> struct type_traits<QTimeZone> : public type_traits<void> {
};
}

#include <QTimeZone>
namespace tl {
template <> struct type_traits<QTimeZone::OffsetData> : public type_traits<void> {
};
}

class QTimer;
namespace tl {
template <> struct type_traits<QTimer> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QTimer_Adaptor;
namespace tl {
template <> struct type_traits<QTimer_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QTimerEvent;
namespace tl {
template <> struct type_traits<QTimerEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QTimerEvent_Adaptor;
namespace tl {
template <> struct type_traits<QTimerEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QToolBarChangeEvent;
namespace tl {
template <> struct type_traits<QToolBarChangeEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QToolBarChangeEvent_Adaptor;
namespace tl {
template <> struct type_traits<QToolBarChangeEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QTouchDevice;
namespace tl {
template <> struct type_traits<QTouchDevice> : public type_traits<void> {
};
}

class QTouchEvent;
namespace tl {
template <> struct type_traits<QTouchEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QTouchEvent_Adaptor;
namespace tl {
template <> struct type_traits<QTouchEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

#include <QTouchEvent>
namespace tl {
template <> struct type_traits<QTouchEvent::TouchPoint> : public type_traits<void> {
};
}

class QTransform;
namespace tl {
template <> struct type_traits<QTransform> : public type_traits<void> {
};
}

class QTranslator;
namespace tl {
template <> struct type_traits<QTranslator> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QTranslator_Adaptor;
namespace tl {
template <> struct type_traits<QTranslator_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QUrl;
namespace tl {
template <> struct type_traits<QUrl> : public type_traits<void> {
};
}

class QUrlQuery;
namespace tl {
template <> struct type_traits<QUrlQuery> : public type_traits<void> {
};
}

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;
};
}

class QValidator_Adaptor;
namespace tl {
template <> struct type_traits<QValidator_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QVariantAnimation;
namespace tl {
template <> struct type_traits<QVariantAnimation> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QVariantAnimation_Adaptor;
namespace tl {
template <> struct type_traits<QVariantAnimation_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QVector2D;
namespace tl {
template <> struct type_traits<QVector2D> : public type_traits<void> {
};
}

class QVector3D;
namespace tl {
template <> struct type_traits<QVector3D> : public type_traits<void> {
};
}

class QVector4D;
namespace tl {
template <> struct type_traits<QVector4D> : public type_traits<void> {
};
}

class QWaitCondition;
namespace tl {
template <> struct type_traits<QWaitCondition> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QWhatsThisClickedEvent;
namespace tl {
template <> struct type_traits<QWhatsThisClickedEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QWhatsThisClickedEvent_Adaptor;
namespace tl {
template <> struct type_traits<QWhatsThisClickedEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QWheelEvent;
namespace tl {
template <> struct type_traits<QWheelEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QWheelEvent_Adaptor;
namespace tl {
template <> struct type_traits<QWheelEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QWindow;
namespace tl {
template <> struct type_traits<QWindow> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QWindow_Adaptor;
namespace tl {
template <> struct type_traits<QWindow_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QWindowStateChangeEvent;
namespace tl {
template <> struct type_traits<QWindowStateChangeEvent> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

class QWindowStateChangeEvent_Adaptor;
namespace tl {
template <> struct type_traits<QWindowStateChangeEvent_Adaptor> : public type_traits<void> {
  typedef tl::false_tag has_default_constructor;
};
}

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;
};
}

class QXmlStreamAttribute;
namespace tl {
template <> struct type_traits<QXmlStreamAttribute> : public type_traits<void> {
};
}

class QXmlStreamAttributes;
namespace tl {
template <> struct type_traits<QXmlStreamAttributes> : public type_traits<void> {
};
}

class QXmlStreamEntityDeclaration;
namespace tl {
template <> struct type_traits<QXmlStreamEntityDeclaration> : public type_traits<void> {
};
}

class QXmlStreamEntityResolver;
namespace tl {
template <> struct type_traits<QXmlStreamEntityResolver> : public type_traits<void> {
};
}

class QXmlStreamEntityResolver_Adaptor;
namespace tl {
template <> struct type_traits<QXmlStreamEntityResolver_Adaptor> : public type_traits<void> {
};
}

class QXmlStreamNamespaceDeclaration;
namespace tl {
template <> struct type_traits<QXmlStreamNamespaceDeclaration> : public type_traits<void> {
};
}

class QXmlStreamNotationDeclaration;
namespace tl {
template <> struct type_traits<QXmlStreamNotationDeclaration> : public type_traits<void> {
};
}

class QXmlStreamReader;
namespace tl {
template <> struct type_traits<QXmlStreamReader> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class QXmlStreamStringRef;
namespace tl {
template <> struct type_traits<QXmlStreamStringRef> : public type_traits<void> {
};
}

class QXmlStreamWriter;
namespace tl {
template <> struct type_traits<QXmlStreamWriter> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
};
}

class Qt_Namespace;
namespace tl {
template <> struct type_traits<Qt_Namespace> : public type_traits<void> {
  typedef tl::false_tag has_copy_constructor;
  typedef tl::false_tag has_default_constructor;
};
}


#endif
