#include <PythonQt.h>
#include <QObject>
#include <QStringList>
#include <QTextCodec>
#include <QVarLengthArray>
#include <QVariant>
#include <qabstractanimation.h>
#include <qabstractitemmodel.h>
#include <qabstractstate.h>
#include <qabstracttransition.h>
#include <qanimationgroup.h>
#include <qbytearray.h>
#include <qcoreevent.h>
#include <qeasingcurve.h>
#include <qfile.h>
#include <qiodevice.h>
#include <qlist.h>
#include <qlocale.h>
#include <qmutex.h>
#include <qobject.h>
#include <qpair.h>
#include <qparallelanimationgroup.h>
#include <qpauseanimation.h>
#include <qprocess.h>
#include <qpropertyanimation.h>
#include <qreadwritelock.h>
#include <qrunnable.h>
#include <qsemaphore.h>
#include <qsequentialanimationgroup.h>
#include <qsettings.h>
#include <qsignalmapper.h>
#include <qsignaltransition.h>
#include <qsocketnotifier.h>
#include <qstate.h>
#include <qstatemachine.h>
#include <qstringlist.h>
#include <qstringmatcher.h>
#include <qsystemsemaphore.h>
#include <qtemporaryfile.h>
#include <qtextboundaryfinder.h>
#include <qtextcodec.h>
#include <qtextstream.h>
#include <qthreadpool.h>
#include <qtimeline.h>
#include <qvector.h>



class PythonQtWrapper_QModelIndex : public QObject
{ Q_OBJECT
public:
public slots:
QModelIndex* new_QModelIndex();
QModelIndex* new_QModelIndex(const QModelIndex& other) {
QModelIndex* a = new QModelIndex();
*((QModelIndex*)a) = other;
return a; }
void delete_QModelIndex(QModelIndex* obj) { delete obj; } 
    QModelIndex  child(QModelIndex* theWrappedObject, int  row, int  column) const;
    int  column(QModelIndex* theWrappedObject) const;
    QVariant  data(QModelIndex* theWrappedObject, int  role = Qt::DisplayRole) const;
    Qt::ItemFlags  flags(QModelIndex* theWrappedObject) const;
    quintptr  internalId(QModelIndex* theWrappedObject) const;
    void*  internalPointer(QModelIndex* theWrappedObject) const;
    bool  isValid(QModelIndex* theWrappedObject) const;
    const QAbstractItemModel*  model(QModelIndex* theWrappedObject) const;
    bool  __ne__(QModelIndex* theWrappedObject, const QModelIndex&  other) const;
    bool  __lt__(QModelIndex* theWrappedObject, const QModelIndex&  other) const;
    bool  __eq__(QModelIndex* theWrappedObject, const QModelIndex&  other) const;
    QModelIndex  parent(QModelIndex* theWrappedObject) const;
    int  row(QModelIndex* theWrappedObject) const;
    QModelIndex  sibling(QModelIndex* theWrappedObject, int  row, int  column) const;
    QString py_toString(QModelIndex*);
};





class PythonQtWrapper_QMutex : public QObject
{ Q_OBJECT
public:
Q_ENUMS(RecursionMode )
enum RecursionMode{
  NonRecursive = QMutex::NonRecursive,   Recursive = QMutex::Recursive};
public slots:
QMutex* new_QMutex(QMutex::RecursionMode  mode = QMutex::NonRecursive);
void delete_QMutex(QMutex* obj) { delete obj; } 
    void lock(QMutex* theWrappedObject);
    bool  tryLock(QMutex* theWrappedObject, int  timeout = 0);
    void unlock(QMutex* theWrappedObject);
};





class PythonQtShell_QObject : public QObject
{
public:
    PythonQtShell_QObject(QObject*  parent = 0):QObject(parent),_wrapper(NULL) {};

   ~PythonQtShell_QObject();

virtual void childEvent(QChildEvent*  arg__1);
virtual void customEvent(QEvent*  arg__1);
virtual bool  event(QEvent*  arg__1);
virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
virtual void timerEvent(QTimerEvent*  arg__1);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QObject : public QObject
{ public:
inline void promoted_childEvent(QChildEvent*  arg__1) { QObject::childEvent(arg__1); }
inline void promoted_customEvent(QEvent*  arg__1) { QObject::customEvent(arg__1); }
inline bool  promoted_event(QEvent*  arg__1) { return QObject::event(arg__1); }
inline bool  promoted_eventFilter(QObject*  arg__1, QEvent*  arg__2) { return QObject::eventFilter(arg__1, arg__2); }
inline void promoted_timerEvent(QTimerEvent*  arg__1) { QObject::timerEvent(arg__1); }
};

class PythonQtWrapper_QObject : public QObject
{ Q_OBJECT
public:
public slots:
QObject* new_QObject(QObject*  parent = 0);
void delete_QObject(QObject* obj) { delete obj; } 
    bool  blockSignals(QObject* theWrappedObject, bool  b);
    void childEvent(QObject* theWrappedObject, QChildEvent*  arg__1);
    const QList<QObject* >*  children(QObject* theWrappedObject) const;
    void customEvent(QObject* theWrappedObject, QEvent*  arg__1);
    void dumpObjectInfo(QObject* theWrappedObject);
    void dumpObjectTree(QObject* theWrappedObject);
    QList<QByteArray >  dynamicPropertyNames(QObject* theWrappedObject) const;
    bool  event(QObject* theWrappedObject, QEvent*  arg__1);
    bool  eventFilter(QObject* theWrappedObject, QObject*  arg__1, QEvent*  arg__2);
    bool  inherits(QObject* theWrappedObject, const char*  classname) const;
    void installEventFilter(QObject* theWrappedObject, QObject*  arg__1);
    bool  isWidgetType(QObject* theWrappedObject) const;
    bool  isWindowType(QObject* theWrappedObject) const;
    void killTimer(QObject* theWrappedObject, int  id);
    QString  objectName(QObject* theWrappedObject) const;
    QObject*  parent(QObject* theWrappedObject) const;
    QVariant  property(QObject* theWrappedObject, const char*  name) const;
    void removeEventFilter(QObject* theWrappedObject, QObject*  arg__1);
    void setObjectName(QObject* theWrappedObject, const QString&  name);
    void setParent(QObject* theWrappedObject, QObject*  arg__1);
    bool  setProperty(QObject* theWrappedObject, const char*  name, const QVariant&  value);
    bool  signalsBlocked(QObject* theWrappedObject) const;
    int  startTimer(QObject* theWrappedObject, int  interval, Qt::TimerType  timerType = Qt::CoarseTimer);
    void timerEvent(QObject* theWrappedObject, QTimerEvent*  arg__1);
};





class PythonQtShell_QParallelAnimationGroup : public QParallelAnimationGroup
{
public:
    PythonQtShell_QParallelAnimationGroup(QObject*  parent = 0):QParallelAnimationGroup(parent),_wrapper(NULL) {};

   ~PythonQtShell_QParallelAnimationGroup();

virtual void childEvent(QChildEvent*  arg__1);
virtual void customEvent(QEvent*  arg__1);
virtual int  duration() const;
virtual bool  event(QEvent*  event);
virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
virtual void timerEvent(QTimerEvent*  arg__1);
virtual void updateCurrentTime(int  currentTime);
virtual void updateDirection(QAbstractAnimation::Direction  direction);
virtual void updateState(QAbstractAnimation::State  newState, QAbstractAnimation::State  oldState);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QParallelAnimationGroup : public QParallelAnimationGroup
{ public:
inline int  promoted_duration() const { return QParallelAnimationGroup::duration(); }
inline bool  promoted_event(QEvent*  event) { return QParallelAnimationGroup::event(event); }
inline void promoted_updateCurrentTime(int  currentTime) { QParallelAnimationGroup::updateCurrentTime(currentTime); }
inline void promoted_updateDirection(QAbstractAnimation::Direction  direction) { QParallelAnimationGroup::updateDirection(direction); }
inline void promoted_updateState(QAbstractAnimation::State  newState, QAbstractAnimation::State  oldState) { QParallelAnimationGroup::updateState(newState, oldState); }
};

class PythonQtWrapper_QParallelAnimationGroup : public QObject
{ Q_OBJECT
public:
public slots:
QParallelAnimationGroup* new_QParallelAnimationGroup(QObject*  parent = 0);
void delete_QParallelAnimationGroup(QParallelAnimationGroup* obj) { delete obj; } 
    int  duration(QParallelAnimationGroup* theWrappedObject) const;
    bool  event(QParallelAnimationGroup* theWrappedObject, QEvent*  event);
    void updateCurrentTime(QParallelAnimationGroup* theWrappedObject, int  currentTime);
    void updateDirection(QParallelAnimationGroup* theWrappedObject, QAbstractAnimation::Direction  direction);
    void updateState(QParallelAnimationGroup* theWrappedObject, QAbstractAnimation::State  newState, QAbstractAnimation::State  oldState);
};





class PythonQtShell_QPauseAnimation : public QPauseAnimation
{
public:
    PythonQtShell_QPauseAnimation(QObject*  parent = 0):QPauseAnimation(parent),_wrapper(NULL) {};
    PythonQtShell_QPauseAnimation(int  msecs, QObject*  parent = 0):QPauseAnimation(msecs, parent),_wrapper(NULL) {};

   ~PythonQtShell_QPauseAnimation();

virtual void childEvent(QChildEvent*  arg__1);
virtual void customEvent(QEvent*  arg__1);
virtual int  duration() const;
virtual bool  event(QEvent*  e);
virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
virtual void timerEvent(QTimerEvent*  arg__1);
virtual void updateCurrentTime(int  arg__1);
virtual void updateDirection(QAbstractAnimation::Direction  direction);
virtual void updateState(QAbstractAnimation::State  newState, QAbstractAnimation::State  oldState);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QPauseAnimation : public QPauseAnimation
{ public:
inline int  promoted_duration() const { return QPauseAnimation::duration(); }
inline bool  promoted_event(QEvent*  e) { return QPauseAnimation::event(e); }
inline void promoted_updateCurrentTime(int  arg__1) { QPauseAnimation::updateCurrentTime(arg__1); }
};

class PythonQtWrapper_QPauseAnimation : public QObject
{ Q_OBJECT
public:
public slots:
QPauseAnimation* new_QPauseAnimation(QObject*  parent = 0);
QPauseAnimation* new_QPauseAnimation(int  msecs, QObject*  parent = 0);
void delete_QPauseAnimation(QPauseAnimation* obj) { delete obj; } 
    int  duration(QPauseAnimation* theWrappedObject) const;
    bool  event(QPauseAnimation* theWrappedObject, QEvent*  e);
    void setDuration(QPauseAnimation* theWrappedObject, int  msecs);
    void updateCurrentTime(QPauseAnimation* theWrappedObject, int  arg__1);
};





class PythonQtShell_QProcess : public QProcess
{
public:
    PythonQtShell_QProcess(QObject*  parent = 0):QProcess(parent),_wrapper(NULL) {};

   ~PythonQtShell_QProcess();

virtual bool  atEnd() const;
virtual qint64  bytesAvailable() const;
virtual qint64  bytesToWrite() const;
virtual bool  canReadLine() const;
virtual void childEvent(QChildEvent*  arg__1);
virtual void close();
virtual void customEvent(QEvent*  arg__1);
virtual bool  event(QEvent*  arg__1);
virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
virtual bool  isSequential() const;
virtual bool  open(QIODevice::OpenMode  mode);
virtual qint64  pos() const;
virtual qint64  readData(char*  data, qint64  maxlen);
virtual qint64  readLineData(char*  data, qint64  maxlen);
virtual bool  reset();
virtual bool  seek(qint64  pos);
virtual void setupChildProcess();
virtual qint64  size() const;
virtual void timerEvent(QTimerEvent*  arg__1);
virtual bool  waitForBytesWritten(int  msecs = 30000);
virtual bool  waitForReadyRead(int  msecs = 30000);
virtual qint64  writeData(const char*  data, qint64  len);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QProcess : public QProcess
{ public:
inline bool  promoted_atEnd() const { return QProcess::atEnd(); }
inline qint64  promoted_bytesAvailable() const { return QProcess::bytesAvailable(); }
inline qint64  promoted_bytesToWrite() const { return QProcess::bytesToWrite(); }
inline bool  promoted_canReadLine() const { return QProcess::canReadLine(); }
inline void promoted_close() { QProcess::close(); }
inline bool  promoted_isSequential() const { return QProcess::isSequential(); }
inline qint64  promoted_readData(char*  data, qint64  maxlen) { return QProcess::readData(data, maxlen); }
inline void promoted_setupChildProcess() { QProcess::setupChildProcess(); }
inline bool  promoted_waitForBytesWritten(int  msecs = 30000) { return QProcess::waitForBytesWritten(msecs); }
inline bool  promoted_waitForReadyRead(int  msecs = 30000) { return QProcess::waitForReadyRead(msecs); }
inline qint64  promoted_writeData(const char*  data, qint64  len) { return QProcess::writeData(data, len); }
};

class PythonQtWrapper_QProcess : public QObject
{ Q_OBJECT
public:
Q_ENUMS(ProcessState ProcessError ProcessChannelMode ExitStatus ProcessChannel )
enum ProcessState{
  NotRunning = QProcess::NotRunning,   Starting = QProcess::Starting,   Running = QProcess::Running};
enum ProcessError{
  FailedToStart = QProcess::FailedToStart,   Crashed = QProcess::Crashed,   Timedout = QProcess::Timedout,   ReadError = QProcess::ReadError,   WriteError = QProcess::WriteError,   UnknownError = QProcess::UnknownError};
enum ProcessChannelMode{
  SeparateChannels = QProcess::SeparateChannels,   MergedChannels = QProcess::MergedChannels,   ForwardedChannels = QProcess::ForwardedChannels};
enum ExitStatus{
  NormalExit = QProcess::NormalExit,   CrashExit = QProcess::CrashExit};
enum ProcessChannel{
  StandardOutput = QProcess::StandardOutput,   StandardError = QProcess::StandardError};
public slots:
QProcess* new_QProcess(QObject*  parent = 0);
void delete_QProcess(QProcess* obj) { delete obj; } 
    QStringList  arguments(QProcess* theWrappedObject) const;
    bool  atEnd(QProcess* theWrappedObject) const;
    qint64  bytesAvailable(QProcess* theWrappedObject) const;
    qint64  bytesToWrite(QProcess* theWrappedObject) const;
    bool  canReadLine(QProcess* theWrappedObject) const;
    void close(QProcess* theWrappedObject);
    void closeReadChannel(QProcess* theWrappedObject, QProcess::ProcessChannel  channel);
    void closeWriteChannel(QProcess* theWrappedObject);
    QStringList  environment(QProcess* theWrappedObject) const;
    QProcess::ProcessError  error(QProcess* theWrappedObject) const;
    int  static_QProcess_execute(const QString&  program);
    int  static_QProcess_execute(const QString&  program, const QStringList&  arguments);
    int  exitCode(QProcess* theWrappedObject) const;
    QProcess::ExitStatus  exitStatus(QProcess* theWrappedObject) const;
    bool  isSequential(QProcess* theWrappedObject) const;
    QProcess::ProcessChannelMode  processChannelMode(QProcess* theWrappedObject) const;
    QProcessEnvironment  processEnvironment(QProcess* theWrappedObject) const;
    QString  program(QProcess* theWrappedObject) const;
    QByteArray  readAllStandardError(QProcess* theWrappedObject);
    QByteArray  readAllStandardOutput(QProcess* theWrappedObject);
    QProcess::ProcessChannel  readChannel(QProcess* theWrappedObject) const;
    qint64  readData(QProcess* theWrappedObject, char*  data, qint64  maxlen);
    void setEnvironment(QProcess* theWrappedObject, const QStringList&  environment);
    void setProcessChannelMode(QProcess* theWrappedObject, QProcess::ProcessChannelMode  mode);
    void setProcessEnvironment(QProcess* theWrappedObject, const QProcessEnvironment&  environment);
    void setReadChannel(QProcess* theWrappedObject, QProcess::ProcessChannel  channel);
    void setStandardErrorFile(QProcess* theWrappedObject, const QString&  fileName, QIODevice::OpenMode  mode = QIODevice::Truncate);
    void setStandardInputFile(QProcess* theWrappedObject, const QString&  fileName);
    void setStandardOutputFile(QProcess* theWrappedObject, const QString&  fileName, QIODevice::OpenMode  mode = QIODevice::Truncate);
    void setStandardOutputProcess(QProcess* theWrappedObject, QProcess*  destination);
    void setWorkingDirectory(QProcess* theWrappedObject, const QString&  dir);
    void setupChildProcess(QProcess* theWrappedObject);
    void start(QProcess* theWrappedObject, const QString&  command, QIODevice::OpenMode  mode = QIODevice::ReadWrite);
    void start(QProcess* theWrappedObject, const QString&  program, const QStringList&  arguments, QIODevice::OpenMode  mode = QIODevice::ReadWrite);
    bool  static_QProcess_startDetached(const QString&  program);
    bool  static_QProcess_startDetached(const QString&  program, const QStringList&  arguments);
    bool  static_QProcess_startDetached(const QString&  program, const QStringList&  arguments, const QString&  workingDirectory, qint64*  pid = 0);
    QProcess::ProcessState  state(QProcess* theWrappedObject) const;
    QStringList  static_QProcess_systemEnvironment();
    bool  waitForBytesWritten(QProcess* theWrappedObject, int  msecs = 30000);
    bool  waitForFinished(QProcess* theWrappedObject, int  msecs = 30000);
    bool  waitForReadyRead(QProcess* theWrappedObject, int  msecs = 30000);
    bool  waitForStarted(QProcess* theWrappedObject, int  msecs = 30000);
    QString  workingDirectory(QProcess* theWrappedObject) const;
    qint64  writeData(QProcess* theWrappedObject, const char*  data, qint64  len);
};





class PythonQtWrapper_QProcessEnvironment : public QObject
{ Q_OBJECT
public:
public slots:
QProcessEnvironment* new_QProcessEnvironment();
QProcessEnvironment* new_QProcessEnvironment(const QProcessEnvironment&  other);
void delete_QProcessEnvironment(QProcessEnvironment* obj) { delete obj; } 
    void clear(QProcessEnvironment* theWrappedObject);
    bool  contains(QProcessEnvironment* theWrappedObject, const QString&  name) const;
    void insert(QProcessEnvironment* theWrappedObject, const QProcessEnvironment&  e);
    void insert(QProcessEnvironment* theWrappedObject, const QString&  name, const QString&  value);
    bool  isEmpty(QProcessEnvironment* theWrappedObject) const;
    QStringList  keys(QProcessEnvironment* theWrappedObject) const;
    bool  __ne__(QProcessEnvironment* theWrappedObject, const QProcessEnvironment&  other) const;
    QProcessEnvironment*  operator_assign(QProcessEnvironment* theWrappedObject, const QProcessEnvironment&  other);
    bool  __eq__(QProcessEnvironment* theWrappedObject, const QProcessEnvironment&  other) const;
    void remove(QProcessEnvironment* theWrappedObject, const QString&  name);
    void swap(QProcessEnvironment* theWrappedObject, QProcessEnvironment&  other);
    QProcessEnvironment  static_QProcessEnvironment_systemEnvironment();
    QStringList  toStringList(QProcessEnvironment* theWrappedObject) const;
    QString  value(QProcessEnvironment* theWrappedObject, const QString&  name, const QString&  defaultValue = QString()) const;
};





class PythonQtShell_QPropertyAnimation : public QPropertyAnimation
{
public:
    PythonQtShell_QPropertyAnimation(QObject*  parent = 0):QPropertyAnimation(parent),_wrapper(NULL) {};
    PythonQtShell_QPropertyAnimation(QObject*  target, const QByteArray&  propertyName, QObject*  parent = 0):QPropertyAnimation(target, propertyName, parent),_wrapper(NULL) {};

   ~PythonQtShell_QPropertyAnimation();

virtual void childEvent(QChildEvent*  arg__1);
virtual void customEvent(QEvent*  arg__1);
virtual int  duration() const;
virtual bool  event(QEvent*  event);
virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
virtual QVariant  interpolated(const QVariant&  from, const QVariant&  to, qreal  progress) const;
virtual void timerEvent(QTimerEvent*  arg__1);
virtual void updateCurrentTime(int  arg__1);
virtual void updateCurrentValue(const QVariant&  value);
virtual void updateDirection(QAbstractAnimation::Direction  direction);
virtual void updateState(QAbstractAnimation::State  newState, QAbstractAnimation::State  oldState);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QPropertyAnimation : public QPropertyAnimation
{ public:
inline bool  promoted_event(QEvent*  event) { return QPropertyAnimation::event(event); }
inline void promoted_updateCurrentValue(const QVariant&  value) { QPropertyAnimation::updateCurrentValue(value); }
inline void promoted_updateState(QAbstractAnimation::State  newState, QAbstractAnimation::State  oldState) { QPropertyAnimation::updateState(newState, oldState); }
};

class PythonQtWrapper_QPropertyAnimation : public QObject
{ Q_OBJECT
public:
public slots:
QPropertyAnimation* new_QPropertyAnimation(QObject*  parent = 0);
QPropertyAnimation* new_QPropertyAnimation(QObject*  target, const QByteArray&  propertyName, QObject*  parent = 0);
void delete_QPropertyAnimation(QPropertyAnimation* obj) { delete obj; } 
    bool  event(QPropertyAnimation* theWrappedObject, QEvent*  event);
    QByteArray  propertyName(QPropertyAnimation* theWrappedObject) const;
    void setPropertyName(QPropertyAnimation* theWrappedObject, const QByteArray&  propertyName);
    void setTargetObject(QPropertyAnimation* theWrappedObject, QObject*  target);
    QObject*  targetObject(QPropertyAnimation* theWrappedObject) const;
    void updateCurrentValue(QPropertyAnimation* theWrappedObject, const QVariant&  value);
    void updateState(QPropertyAnimation* theWrappedObject, QAbstractAnimation::State  newState, QAbstractAnimation::State  oldState);
};





class PythonQtWrapper_QReadWriteLock : public QObject
{ Q_OBJECT
public:
Q_ENUMS(RecursionMode )
enum RecursionMode{
  NonRecursive = QReadWriteLock::NonRecursive,   Recursive = QReadWriteLock::Recursive};
public slots:
QReadWriteLock* new_QReadWriteLock(QReadWriteLock::RecursionMode  recursionMode = QReadWriteLock::NonRecursive);
void delete_QReadWriteLock(QReadWriteLock* obj) { delete obj; } 
    void lockForRead(QReadWriteLock* theWrappedObject);
    void lockForWrite(QReadWriteLock* theWrappedObject);
    bool  tryLockForRead(QReadWriteLock* theWrappedObject);
    bool  tryLockForRead(QReadWriteLock* theWrappedObject, int  timeout);
    bool  tryLockForWrite(QReadWriteLock* theWrappedObject);
    bool  tryLockForWrite(QReadWriteLock* theWrappedObject, int  timeout);
    void unlock(QReadWriteLock* theWrappedObject);
};





class PythonQtShell_QRunnable : public QRunnable
{
public:
    PythonQtShell_QRunnable():QRunnable(),_wrapper(NULL) {};

   ~PythonQtShell_QRunnable();

virtual void run();

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtWrapper_QRunnable : public QObject
{ Q_OBJECT
public:
public slots:
QRunnable* new_QRunnable();
void delete_QRunnable(QRunnable* obj) { delete obj; } 
    bool  autoDelete(QRunnable* theWrappedObject) const;
    void setAutoDelete(QRunnable* theWrappedObject, bool  _autoDelete);
};





class PythonQtWrapper_QSemaphore : public QObject
{ Q_OBJECT
public:
public slots:
QSemaphore* new_QSemaphore(int  n = 0);
void delete_QSemaphore(QSemaphore* obj) { delete obj; } 
    void acquire(QSemaphore* theWrappedObject, int  n = 1);
    int  available(QSemaphore* theWrappedObject) const;
    void release(QSemaphore* theWrappedObject, int  n = 1);
    bool  tryAcquire(QSemaphore* theWrappedObject, int  n = 1);
    bool  tryAcquire(QSemaphore* theWrappedObject, int  n, int  timeout);
};





class PythonQtShell_QSequentialAnimationGroup : public QSequentialAnimationGroup
{
public:
    PythonQtShell_QSequentialAnimationGroup(QObject*  parent = 0):QSequentialAnimationGroup(parent),_wrapper(NULL) {};

   ~PythonQtShell_QSequentialAnimationGroup();

virtual void childEvent(QChildEvent*  arg__1);
virtual void customEvent(QEvent*  arg__1);
virtual int  duration() const;
virtual bool  event(QEvent*  event);
virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
virtual void timerEvent(QTimerEvent*  arg__1);
virtual void updateCurrentTime(int  arg__1);
virtual void updateDirection(QAbstractAnimation::Direction  direction);
virtual void updateState(QAbstractAnimation::State  newState, QAbstractAnimation::State  oldState);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QSequentialAnimationGroup : public QSequentialAnimationGroup
{ public:
inline int  promoted_duration() const { return QSequentialAnimationGroup::duration(); }
inline bool  promoted_event(QEvent*  event) { return QSequentialAnimationGroup::event(event); }
inline void promoted_updateCurrentTime(int  arg__1) { QSequentialAnimationGroup::updateCurrentTime(arg__1); }
inline void promoted_updateDirection(QAbstractAnimation::Direction  direction) { QSequentialAnimationGroup::updateDirection(direction); }
inline void promoted_updateState(QAbstractAnimation::State  newState, QAbstractAnimation::State  oldState) { QSequentialAnimationGroup::updateState(newState, oldState); }
};

class PythonQtWrapper_QSequentialAnimationGroup : public QObject
{ Q_OBJECT
public:
public slots:
QSequentialAnimationGroup* new_QSequentialAnimationGroup(QObject*  parent = 0);
void delete_QSequentialAnimationGroup(QSequentialAnimationGroup* obj) { delete obj; } 
    QPauseAnimation*  addPause(QSequentialAnimationGroup* theWrappedObject, int  msecs);
    QAbstractAnimation*  currentAnimation(QSequentialAnimationGroup* theWrappedObject) const;
    int  duration(QSequentialAnimationGroup* theWrappedObject) const;
    bool  event(QSequentialAnimationGroup* theWrappedObject, QEvent*  event);
    QPauseAnimation*  insertPause(QSequentialAnimationGroup* theWrappedObject, int  index, int  msecs);
    void updateCurrentTime(QSequentialAnimationGroup* theWrappedObject, int  arg__1);
    void updateDirection(QSequentialAnimationGroup* theWrappedObject, QAbstractAnimation::Direction  direction);
    void updateState(QSequentialAnimationGroup* theWrappedObject, QAbstractAnimation::State  newState, QAbstractAnimation::State  oldState);
};





class PythonQtShell_QSettings : public QSettings
{
public:
    PythonQtShell_QSettings(QObject*  parent = 0):QSettings(parent),_wrapper(NULL) {};
    PythonQtShell_QSettings(QSettings::Format  format, QSettings::Scope  scope, const QString&  organization, const QString&  application = QString(), QObject*  parent = 0):QSettings(format, scope, organization, application, parent),_wrapper(NULL) {};
    PythonQtShell_QSettings(QSettings::Scope  scope, const QString&  organization, const QString&  application = QString(), QObject*  parent = 0):QSettings(scope, organization, application, parent),_wrapper(NULL) {};
    PythonQtShell_QSettings(const QString&  fileName, QSettings::Format  format, QObject*  parent = 0):QSettings(fileName, format, parent),_wrapper(NULL) {};
    PythonQtShell_QSettings(const QString&  organization, const QString&  application = QString(), QObject*  parent = 0):QSettings(organization, application, parent),_wrapper(NULL) {};

   ~PythonQtShell_QSettings();

virtual void childEvent(QChildEvent*  arg__1);
virtual void customEvent(QEvent*  arg__1);
virtual bool  event(QEvent*  event);
virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
virtual void timerEvent(QTimerEvent*  arg__1);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QSettings : public QSettings
{ public:
inline bool  promoted_event(QEvent*  event) { return QSettings::event(event); }
};

class PythonQtWrapper_QSettings : public QObject
{ Q_OBJECT
public:
Q_ENUMS(Format Status Scope )
enum Format{
  NativeFormat = QSettings::NativeFormat,   IniFormat = QSettings::IniFormat,   InvalidFormat = QSettings::InvalidFormat,   CustomFormat1 = QSettings::CustomFormat1,   CustomFormat2 = QSettings::CustomFormat2,   CustomFormat3 = QSettings::CustomFormat3,   CustomFormat4 = QSettings::CustomFormat4,   CustomFormat5 = QSettings::CustomFormat5,   CustomFormat6 = QSettings::CustomFormat6,   CustomFormat7 = QSettings::CustomFormat7,   CustomFormat8 = QSettings::CustomFormat8,   CustomFormat9 = QSettings::CustomFormat9,   CustomFormat10 = QSettings::CustomFormat10,   CustomFormat11 = QSettings::CustomFormat11,   CustomFormat12 = QSettings::CustomFormat12,   CustomFormat13 = QSettings::CustomFormat13,   CustomFormat14 = QSettings::CustomFormat14,   CustomFormat15 = QSettings::CustomFormat15,   CustomFormat16 = QSettings::CustomFormat16};
enum Status{
  NoError = QSettings::NoError,   AccessError = QSettings::AccessError,   FormatError = QSettings::FormatError};
enum Scope{
  UserScope = QSettings::UserScope,   SystemScope = QSettings::SystemScope};
public slots:
QSettings* new_QSettings(QObject*  parent = 0);
QSettings* new_QSettings(QSettings::Format  format, QSettings::Scope  scope, const QString&  organization, const QString&  application = QString(), QObject*  parent = 0);
QSettings* new_QSettings(QSettings::Scope  scope, const QString&  organization, const QString&  application = QString(), QObject*  parent = 0);
QSettings* new_QSettings(const QString&  fileName, QSettings::Format  format, QObject*  parent = 0);
QSettings* new_QSettings(const QString&  organization, const QString&  application = QString(), QObject*  parent = 0);
void delete_QSettings(QSettings* obj) { delete obj; } 
    QStringList  allKeys(QSettings* theWrappedObject) const;
    QString  applicationName(QSettings* theWrappedObject) const;
    void beginGroup(QSettings* theWrappedObject, const QString&  prefix);
    int  beginReadArray(QSettings* theWrappedObject, const QString&  prefix);
    void beginWriteArray(QSettings* theWrappedObject, const QString&  prefix, int  size = -1);
    QStringList  childGroups(QSettings* theWrappedObject) const;
    QStringList  childKeys(QSettings* theWrappedObject) const;
    void clear(QSettings* theWrappedObject);
    bool  contains(QSettings* theWrappedObject, const QString&  key) const;
    QSettings::Format  static_QSettings_defaultFormat();
    void endArray(QSettings* theWrappedObject);
    void endGroup(QSettings* theWrappedObject);
    bool  event(QSettings* theWrappedObject, QEvent*  event);
    bool  fallbacksEnabled(QSettings* theWrappedObject) const;
    QString  fileName(QSettings* theWrappedObject) const;
    QSettings::Format  format(QSettings* theWrappedObject) const;
    QString  group(QSettings* theWrappedObject) const;
    QTextCodec*  iniCodec(QSettings* theWrappedObject) const;
    bool  isWritable(QSettings* theWrappedObject) const;
    QString  organizationName(QSettings* theWrappedObject) const;
    void remove(QSettings* theWrappedObject, const QString&  key);
    QSettings::Scope  scope(QSettings* theWrappedObject) const;
    void setArrayIndex(QSettings* theWrappedObject, int  i);
    void static_QSettings_setDefaultFormat(QSettings::Format  format);
    void setFallbacksEnabled(QSettings* theWrappedObject, bool  b);
    void setIniCodec(QSettings* theWrappedObject, QTextCodec*  codec);
    void setIniCodec(QSettings* theWrappedObject, const char*  codecName);
    void static_QSettings_setPath(QSettings::Format  format, QSettings::Scope  scope, const QString&  path);
    void setValue(QSettings* theWrappedObject, const QString&  key, const QVariant&  value);
    QSettings::Status  status(QSettings* theWrappedObject) const;
    void sync(QSettings* theWrappedObject);
    QVariant  value(QSettings* theWrappedObject, const QString&  key, const QVariant&  defaultValue = QVariant()) const;
};





class PythonQtShell_QSignalMapper : public QSignalMapper
{
public:
    PythonQtShell_QSignalMapper(QObject*  parent = 0):QSignalMapper(parent),_wrapper(NULL) {};

   ~PythonQtShell_QSignalMapper();

virtual void childEvent(QChildEvent*  arg__1);
virtual void customEvent(QEvent*  arg__1);
virtual bool  event(QEvent*  arg__1);
virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
virtual void timerEvent(QTimerEvent*  arg__1);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtWrapper_QSignalMapper : public QObject
{ Q_OBJECT
public:
public slots:
QSignalMapper* new_QSignalMapper(QObject*  parent = 0);
void delete_QSignalMapper(QSignalMapper* obj) { delete obj; } 
    QObject*  mapping(QSignalMapper* theWrappedObject, QObject*  object) const;
    QObject*  mapping(QSignalMapper* theWrappedObject, const QString&  text) const;
    QObject*  mapping(QSignalMapper* theWrappedObject, int  id) const;
    void removeMappings(QSignalMapper* theWrappedObject, QObject*  sender);
    void setMapping(QSignalMapper* theWrappedObject, QObject*  sender, QObject*  object);
    void setMapping(QSignalMapper* theWrappedObject, QObject*  sender, const QString&  text);
    void setMapping(QSignalMapper* theWrappedObject, QObject*  sender, int  id);
};





class PythonQtShell_QSignalTransition : public QSignalTransition
{
public:
    PythonQtShell_QSignalTransition(QState*  sourceState = 0):QSignalTransition(sourceState),_wrapper(NULL) {};
    PythonQtShell_QSignalTransition(const QObject*  sender, const char*  signal, QState*  sourceState = 0):QSignalTransition(sender, signal, sourceState),_wrapper(NULL) {};

   ~PythonQtShell_QSignalTransition();

virtual void childEvent(QChildEvent*  arg__1);
virtual void customEvent(QEvent*  arg__1);
virtual bool  event(QEvent*  e);
virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
virtual bool  eventTest(QEvent*  event);
virtual void onTransition(QEvent*  event);
virtual void timerEvent(QTimerEvent*  arg__1);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QSignalTransition : public QSignalTransition
{ public:
inline bool  promoted_event(QEvent*  e) { return QSignalTransition::event(e); }
inline bool  promoted_eventTest(QEvent*  event) { return QSignalTransition::eventTest(event); }
inline void promoted_onTransition(QEvent*  event) { QSignalTransition::onTransition(event); }
};

class PythonQtWrapper_QSignalTransition : public QObject
{ Q_OBJECT
public:
public slots:
QSignalTransition* new_QSignalTransition(QState*  sourceState = 0);
QSignalTransition* new_QSignalTransition(const QObject*  sender, const char*  signal, QState*  sourceState = 0);
void delete_QSignalTransition(QSignalTransition* obj) { delete obj; } 
    bool  event(QSignalTransition* theWrappedObject, QEvent*  e);
    bool  eventTest(QSignalTransition* theWrappedObject, QEvent*  event);
    void onTransition(QSignalTransition* theWrappedObject, QEvent*  event);
    QObject*  senderObject(QSignalTransition* theWrappedObject) const;
    void setSenderObject(QSignalTransition* theWrappedObject, const QObject*  sender);
    void setSignal(QSignalTransition* theWrappedObject, const QByteArray&  signal);
    QByteArray  signal(QSignalTransition* theWrappedObject) const;
};





class PythonQtPublicPromoter_QSocketNotifier : public QSocketNotifier
{ public:
inline bool  promoted_event(QEvent*  arg__1) { return QSocketNotifier::event(arg__1); }
};

class PythonQtWrapper_QSocketNotifier : public QObject
{ Q_OBJECT
public:
Q_ENUMS(Type )
enum Type{
  Read = QSocketNotifier::Read,   Write = QSocketNotifier::Write,   Exception = QSocketNotifier::Exception};
public slots:
void delete_QSocketNotifier(QSocketNotifier* obj) { delete obj; } 
    bool  event(QSocketNotifier* theWrappedObject, QEvent*  arg__1);
    bool  isEnabled(QSocketNotifier* theWrappedObject) const;
    QSocketNotifier::Type  type(QSocketNotifier* theWrappedObject) const;
};





class PythonQtShell_QState : public QState
{
public:
    PythonQtShell_QState(QState*  parent = 0):QState(parent),_wrapper(NULL) {};
    PythonQtShell_QState(QState::ChildMode  childMode, QState*  parent = 0):QState(childMode, parent),_wrapper(NULL) {};

   ~PythonQtShell_QState();

virtual void childEvent(QChildEvent*  arg__1);
virtual void customEvent(QEvent*  arg__1);
virtual bool  event(QEvent*  e);
virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
virtual void onEntry(QEvent*  event);
virtual void onExit(QEvent*  event);
virtual void timerEvent(QTimerEvent*  arg__1);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QState : public QState
{ public:
inline bool  promoted_event(QEvent*  e) { return QState::event(e); }
inline void promoted_onEntry(QEvent*  event) { QState::onEntry(event); }
inline void promoted_onExit(QEvent*  event) { QState::onExit(event); }
};

class PythonQtWrapper_QState : public QObject
{ Q_OBJECT
public:
public slots:
QState* new_QState(QState*  parent = 0);
QState* new_QState(QState::ChildMode  childMode, QState*  parent = 0);
void delete_QState(QState* obj) { delete obj; } 
    QAbstractTransition*  addTransition(QState* theWrappedObject, QAbstractState*  target);
    void addTransition(QState* theWrappedObject, QAbstractTransition*  transition);
    QSignalTransition*  addTransition(QState* theWrappedObject, const QObject*  sender, const char*  signal, QAbstractState*  target);
    void assignProperty(QState* theWrappedObject, QObject*  object, const char*  name, const QVariant&  value);
    QState::ChildMode  childMode(QState* theWrappedObject) const;
    QAbstractState*  errorState(QState* theWrappedObject) const;
    bool  event(QState* theWrappedObject, QEvent*  e);
    QAbstractState*  initialState(QState* theWrappedObject) const;
    void onEntry(QState* theWrappedObject, QEvent*  event);
    void onExit(QState* theWrappedObject, QEvent*  event);
    void removeTransition(QState* theWrappedObject, QAbstractTransition*  transition);
    void setChildMode(QState* theWrappedObject, QState::ChildMode  mode);
    void setErrorState(QState* theWrappedObject, QAbstractState*  state);
    void setInitialState(QState* theWrappedObject, QAbstractState*  state);
    QList<QAbstractTransition* >  transitions(QState* theWrappedObject) const;
};





class PythonQtShell_QStateMachine : public QStateMachine
{
public:
    PythonQtShell_QStateMachine(QObject*  parent = 0):QStateMachine(parent),_wrapper(NULL) {};
    PythonQtShell_QStateMachine(QState::ChildMode  childMode, QObject*  parent = 0):QStateMachine(childMode, parent),_wrapper(NULL) {};

   ~PythonQtShell_QStateMachine();

virtual void beginMicrostep(QEvent*  event);
virtual void beginSelectTransitions(QEvent*  event);
virtual void childEvent(QChildEvent*  arg__1);
virtual void customEvent(QEvent*  arg__1);
virtual void endMicrostep(QEvent*  event);
virtual void endSelectTransitions(QEvent*  event);
virtual bool  event(QEvent*  e);
virtual bool  eventFilter(QObject*  watched, QEvent*  event);
virtual void onEntry(QEvent*  event);
virtual void onExit(QEvent*  event);
virtual void timerEvent(QTimerEvent*  arg__1);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QStateMachine : public QStateMachine
{ public:
inline void promoted_beginMicrostep(QEvent*  event) { QStateMachine::beginMicrostep(event); }
inline void promoted_beginSelectTransitions(QEvent*  event) { QStateMachine::beginSelectTransitions(event); }
inline void promoted_endMicrostep(QEvent*  event) { QStateMachine::endMicrostep(event); }
inline void promoted_endSelectTransitions(QEvent*  event) { QStateMachine::endSelectTransitions(event); }
inline bool  promoted_event(QEvent*  e) { return QStateMachine::event(e); }
inline bool  promoted_eventFilter(QObject*  watched, QEvent*  event) { return QStateMachine::eventFilter(watched, event); }
inline void promoted_onEntry(QEvent*  event) { QStateMachine::onEntry(event); }
inline void promoted_onExit(QEvent*  event) { QStateMachine::onExit(event); }
};

class PythonQtWrapper_QStateMachine : public QObject
{ Q_OBJECT
public:
Q_ENUMS(Error EventPriority )
enum Error{
  NoError = QStateMachine::NoError,   NoInitialStateError = QStateMachine::NoInitialStateError,   NoDefaultStateInHistoryStateError = QStateMachine::NoDefaultStateInHistoryStateError,   NoCommonAncestorForTransitionError = QStateMachine::NoCommonAncestorForTransitionError};
enum EventPriority{
  NormalPriority = QStateMachine::NormalPriority,   HighPriority = QStateMachine::HighPriority};
public slots:
QStateMachine* new_QStateMachine(QObject*  parent = 0);
QStateMachine* new_QStateMachine(QState::ChildMode  childMode, QObject*  parent = 0);
void delete_QStateMachine(QStateMachine* obj) { delete obj; } 
    void addDefaultAnimation(QStateMachine* theWrappedObject, QAbstractAnimation*  animation);
    void addState(QStateMachine* theWrappedObject, QAbstractState*  state);
    void beginMicrostep(QStateMachine* theWrappedObject, QEvent*  event);
    void beginSelectTransitions(QStateMachine* theWrappedObject, QEvent*  event);
    bool  cancelDelayedEvent(QStateMachine* theWrappedObject, int  id);
    void clearError(QStateMachine* theWrappedObject);
    QSet<QAbstractState* >  configuration(QStateMachine* theWrappedObject) const;
    QList<QAbstractAnimation* >  defaultAnimations(QStateMachine* theWrappedObject) const;
    void endMicrostep(QStateMachine* theWrappedObject, QEvent*  event);
    void endSelectTransitions(QStateMachine* theWrappedObject, QEvent*  event);
    QStateMachine::Error  error(QStateMachine* theWrappedObject) const;
    QString  errorString(QStateMachine* theWrappedObject) const;
    bool  event(QStateMachine* theWrappedObject, QEvent*  e);
    bool  eventFilter(QStateMachine* theWrappedObject, QObject*  watched, QEvent*  event);
    bool  isAnimated(QStateMachine* theWrappedObject) const;
    bool  isRunning(QStateMachine* theWrappedObject) const;
    void onEntry(QStateMachine* theWrappedObject, QEvent*  event);
    void onExit(QStateMachine* theWrappedObject, QEvent*  event);
    int  postDelayedEvent(QStateMachine* theWrappedObject, QEvent*  event, int  delay);
    void postEvent(QStateMachine* theWrappedObject, QEvent*  event, QStateMachine::EventPriority  priority = QStateMachine::NormalPriority);
    void removeDefaultAnimation(QStateMachine* theWrappedObject, QAbstractAnimation*  animation);
    void removeState(QStateMachine* theWrappedObject, QAbstractState*  state);
    void setAnimated(QStateMachine* theWrappedObject, bool  enabled);
};





class PythonQtWrapper_QStateMachine_SignalEvent : public QObject
{ Q_OBJECT
public:
public slots:
QStateMachine::SignalEvent* new_QStateMachine_SignalEvent(QObject*  sender, int  signalIndex, const QList<QVariant >&  arguments);
void delete_QStateMachine_SignalEvent(QStateMachine::SignalEvent* obj) { delete obj; } 
    QList<QVariant >  arguments(QStateMachine::SignalEvent* theWrappedObject) const;
    QObject*  sender(QStateMachine::SignalEvent* theWrappedObject) const;
    int  signalIndex(QStateMachine::SignalEvent* theWrappedObject) const;
};





class PythonQtWrapper_QStateMachine_WrappedEvent : public QObject
{ Q_OBJECT
public:
public slots:
QStateMachine::WrappedEvent* new_QStateMachine_WrappedEvent(QObject*  object, QEvent*  event);
void delete_QStateMachine_WrappedEvent(QStateMachine::WrappedEvent* obj) { delete obj; } 
    QEvent*  event(QStateMachine::WrappedEvent* theWrappedObject) const;
    QObject*  object(QStateMachine::WrappedEvent* theWrappedObject) const;
};





class PythonQtWrapper_QStringMatcher : public QObject
{ Q_OBJECT
public:
public slots:
QStringMatcher* new_QStringMatcher();
QStringMatcher* new_QStringMatcher(const QString&  pattern, Qt::CaseSensitivity  cs = Qt::CaseSensitive);
QStringMatcher* new_QStringMatcher(const QStringMatcher&  other);
void delete_QStringMatcher(QStringMatcher* obj) { delete obj; } 
    Qt::CaseSensitivity  caseSensitivity(QStringMatcher* theWrappedObject) const;
    int  indexIn(QStringMatcher* theWrappedObject, const QString&  str, int  from = 0) const;
    QString  pattern(QStringMatcher* theWrappedObject) const;
    void setCaseSensitivity(QStringMatcher* theWrappedObject, Qt::CaseSensitivity  cs);
    void setPattern(QStringMatcher* theWrappedObject, const QString&  pattern);
};





class PythonQtWrapper_QSystemSemaphore : public QObject
{ Q_OBJECT
public:
Q_ENUMS(SystemSemaphoreError AccessMode )
enum SystemSemaphoreError{
  NoError = QSystemSemaphore::NoError,   PermissionDenied = QSystemSemaphore::PermissionDenied,   KeyError = QSystemSemaphore::KeyError,   AlreadyExists = QSystemSemaphore::AlreadyExists,   NotFound = QSystemSemaphore::NotFound,   OutOfResources = QSystemSemaphore::OutOfResources,   UnknownError = QSystemSemaphore::UnknownError};
enum AccessMode{
  Open = QSystemSemaphore::Open,   Create = QSystemSemaphore::Create};
public slots:
QSystemSemaphore* new_QSystemSemaphore(const QString&  key, int  initialValue = 0, QSystemSemaphore::AccessMode  mode = QSystemSemaphore::Open);
void delete_QSystemSemaphore(QSystemSemaphore* obj) { delete obj; } 
    bool  acquire(QSystemSemaphore* theWrappedObject);
    QSystemSemaphore::SystemSemaphoreError  error(QSystemSemaphore* theWrappedObject) const;
    QString  errorString(QSystemSemaphore* theWrappedObject) const;
    QString  key(QSystemSemaphore* theWrappedObject) const;
    bool  release(QSystemSemaphore* theWrappedObject, int  n = 1);
    void setKey(QSystemSemaphore* theWrappedObject, const QString&  key, int  initialValue = 0, QSystemSemaphore::AccessMode  mode = QSystemSemaphore::Open);
};





class PythonQtWrapper_QTemporaryFile : public QObject
{ Q_OBJECT
public:
public slots:
QTemporaryFile* new_QTemporaryFile();
QTemporaryFile* new_QTemporaryFile(QObject*  parent);
QTemporaryFile* new_QTemporaryFile(const QString&  templateName);
QTemporaryFile* new_QTemporaryFile(const QString&  templateName, QObject*  parent);
void delete_QTemporaryFile(QTemporaryFile* obj) { delete obj; } 
    bool  autoRemove(QTemporaryFile* theWrappedObject) const;
    QTemporaryFile*  static_QTemporaryFile_createLocalFile(QFile&  file);
    QTemporaryFile*  static_QTemporaryFile_createLocalFile(const QString&  fileName);
    QTemporaryFile*  static_QTemporaryFile_createNativeFile(QFile&  file);
    QTemporaryFile*  static_QTemporaryFile_createNativeFile(const QString&  fileName);
    QString  fileName(QTemporaryFile* theWrappedObject) const;
    QString  fileTemplate(QTemporaryFile* theWrappedObject) const;
    bool  open(QTemporaryFile* theWrappedObject);
    void setAutoRemove(QTemporaryFile* theWrappedObject, bool  b);
    void setFileTemplate(QTemporaryFile* theWrappedObject, const QString&  name);
};





class PythonQtWrapper_QTextBoundaryFinder : public QObject
{ Q_OBJECT
public:
Q_ENUMS(BoundaryReason BoundaryType )
Q_FLAGS(BoundaryReasons )
enum BoundaryReason{
  NotAtBoundary = QTextBoundaryFinder::NotAtBoundary,   BreakOpportunity = QTextBoundaryFinder::BreakOpportunity,   StartOfItem = QTextBoundaryFinder::StartOfItem,   EndOfItem = QTextBoundaryFinder::EndOfItem,   MandatoryBreak = QTextBoundaryFinder::MandatoryBreak,   SoftHyphen = QTextBoundaryFinder::SoftHyphen};
enum BoundaryType{
  Grapheme = QTextBoundaryFinder::Grapheme,   Word = QTextBoundaryFinder::Word,   Sentence = QTextBoundaryFinder::Sentence,   Line = QTextBoundaryFinder::Line};
Q_DECLARE_FLAGS(BoundaryReasons, BoundaryReason)
public slots:
QTextBoundaryFinder* new_QTextBoundaryFinder();
QTextBoundaryFinder* new_QTextBoundaryFinder(QTextBoundaryFinder::BoundaryType  type, const QString&  string);
QTextBoundaryFinder* new_QTextBoundaryFinder(const QTextBoundaryFinder&  other);
void delete_QTextBoundaryFinder(QTextBoundaryFinder* obj) { delete obj; } 
    QTextBoundaryFinder::BoundaryReasons  boundaryReasons(QTextBoundaryFinder* theWrappedObject) const;
    bool  isAtBoundary(QTextBoundaryFinder* theWrappedObject) const;
    bool  isValid(QTextBoundaryFinder* theWrappedObject) const;
    int  position(QTextBoundaryFinder* theWrappedObject) const;
    void setPosition(QTextBoundaryFinder* theWrappedObject, int  position);
    QString  string(QTextBoundaryFinder* theWrappedObject) const;
    void toEnd(QTextBoundaryFinder* theWrappedObject);
    int  toNextBoundary(QTextBoundaryFinder* theWrappedObject);
    int  toPreviousBoundary(QTextBoundaryFinder* theWrappedObject);
    void toStart(QTextBoundaryFinder* theWrappedObject);
    QTextBoundaryFinder::BoundaryType  type(QTextBoundaryFinder* theWrappedObject) const;
};





class PythonQtShell_QTextCodec : public QTextCodec
{
public:
    PythonQtShell_QTextCodec():QTextCodec(),_wrapper(NULL) {};

   ~PythonQtShell_QTextCodec();

virtual QList<QByteArray >  aliases() const;
virtual QByteArray  convertFromUnicode(const QChar*  in, int  length, QTextCodec::ConverterState*  state) const;
virtual QString  convertToUnicode(const char*  in, int  length, QTextCodec::ConverterState*  state) const;
virtual int  mibEnum() const;
virtual QByteArray  name() const;

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QTextCodec : public QTextCodec
{ public:
inline QList<QByteArray >  promoted_aliases() const { return QTextCodec::aliases(); }
};

class PythonQtWrapper_QTextCodec : public QObject
{ Q_OBJECT
public:
Q_ENUMS(ConversionFlag )
Q_FLAGS(ConversionFlags )
enum ConversionFlag{
  DefaultConversion = QTextCodec::DefaultConversion,   ConvertInvalidToNull = QTextCodec::ConvertInvalidToNull,   IgnoreHeader = QTextCodec::IgnoreHeader,   FreeFunction = QTextCodec::FreeFunction};
Q_DECLARE_FLAGS(ConversionFlags, ConversionFlag)
public slots:
    QList<QByteArray >  aliases(QTextCodec* theWrappedObject) const;
    QList<QByteArray >  static_QTextCodec_availableCodecs();
    QList<int >  static_QTextCodec_availableMibs();
    bool  canEncode(QTextCodec* theWrappedObject, QChar  arg__1) const;
    bool  canEncode(QTextCodec* theWrappedObject, const QString&  arg__1) const;
    QTextCodec*  static_QTextCodec_codecForHtml(const QByteArray&  ba);
    QTextCodec*  static_QTextCodec_codecForHtml(const QByteArray&  ba, QTextCodec*  defaultCodec);
    QTextCodec*  static_QTextCodec_codecForLocale();
    QTextCodec*  static_QTextCodec_codecForMib(int  mib);
    QTextCodec*  static_QTextCodec_codecForName(const QByteArray&  name);
    QTextCodec*  static_QTextCodec_codecForName(const char*  name);
    QTextCodec*  static_QTextCodec_codecForUtfText(const QByteArray&  ba);
    QTextCodec*  static_QTextCodec_codecForUtfText(const QByteArray&  ba, QTextCodec*  defaultCodec);
    QByteArray  fromUnicode(QTextCodec* theWrappedObject, const QString&  uc) const;
    QTextDecoder*  makeDecoder(QTextCodec* theWrappedObject, QTextCodec::ConversionFlags  flags = QTextCodec::DefaultConversion) const;
    QTextEncoder*  makeEncoder(QTextCodec* theWrappedObject, QTextCodec::ConversionFlags  flags = QTextCodec::DefaultConversion) const;
    void static_QTextCodec_setCodecForLocale(QTextCodec*  c);
    QString  toUnicode(QTextCodec* theWrappedObject, const QByteArray&  arg__1) const;
};





class PythonQtWrapper_QTextDecoder : public QObject
{ Q_OBJECT
public:
public slots:
QTextDecoder* new_QTextDecoder(const QTextCodec*  codec);
QTextDecoder* new_QTextDecoder(const QTextCodec*  codec, QTextCodec::ConversionFlags  flags);
void delete_QTextDecoder(QTextDecoder* obj) { delete obj; } 
    bool  hasFailure(QTextDecoder* theWrappedObject) const;
    QString  toUnicode(QTextDecoder* theWrappedObject, const QByteArray&  ba);
};





class PythonQtWrapper_QTextEncoder : public QObject
{ Q_OBJECT
public:
public slots:
QTextEncoder* new_QTextEncoder(const QTextCodec*  codec);
QTextEncoder* new_QTextEncoder(const QTextCodec*  codec, QTextCodec::ConversionFlags  flags);
void delete_QTextEncoder(QTextEncoder* obj) { delete obj; } 
    QByteArray  fromUnicode(QTextEncoder* theWrappedObject, const QString&  str);
    bool  hasFailure(QTextEncoder* theWrappedObject) const;
};





class PythonQtShell_QTextStream : public QTextStream
{
public:
    PythonQtShell_QTextStream():QTextStream(),_wrapper(NULL) {};
    PythonQtShell_QTextStream(QIODevice*  device):QTextStream(device),_wrapper(NULL) {};
    PythonQtShell_QTextStream(const QByteArray&  array, QIODevice::OpenMode  openMode = QIODevice::ReadOnly):QTextStream(array, openMode),_wrapper(NULL) {};

   ~PythonQtShell_QTextStream();


  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtWrapper_QTextStream : public QObject
{ Q_OBJECT
public:
Q_ENUMS(FieldAlignment NumberFlag Status RealNumberNotation )
Q_FLAGS(NumberFlags )
enum FieldAlignment{
  AlignLeft = QTextStream::AlignLeft,   AlignRight = QTextStream::AlignRight,   AlignCenter = QTextStream::AlignCenter,   AlignAccountingStyle = QTextStream::AlignAccountingStyle};
enum NumberFlag{
  ShowBase = QTextStream::ShowBase,   ForcePoint = QTextStream::ForcePoint,   ForceSign = QTextStream::ForceSign,   UppercaseBase = QTextStream::UppercaseBase,   UppercaseDigits = QTextStream::UppercaseDigits};
enum Status{
  Ok = QTextStream::Ok,   ReadPastEnd = QTextStream::ReadPastEnd,   ReadCorruptData = QTextStream::ReadCorruptData,   WriteFailed = QTextStream::WriteFailed};
enum RealNumberNotation{
  SmartNotation = QTextStream::SmartNotation,   FixedNotation = QTextStream::FixedNotation,   ScientificNotation = QTextStream::ScientificNotation};
Q_DECLARE_FLAGS(NumberFlags, NumberFlag)
public slots:
QTextStream* new_QTextStream();
QTextStream* new_QTextStream(QIODevice*  device);
QTextStream* new_QTextStream(const QByteArray&  array, QIODevice::OpenMode  openMode = QIODevice::ReadOnly);
void delete_QTextStream(QTextStream* obj) { delete obj; } 
    bool  atEnd(QTextStream* theWrappedObject) const;
    bool  autoDetectUnicode(QTextStream* theWrappedObject) const;
    QTextCodec*  codec(QTextStream* theWrappedObject) const;
    QIODevice*  device(QTextStream* theWrappedObject) const;
    QTextStream::FieldAlignment  fieldAlignment(QTextStream* theWrappedObject) const;
    int  fieldWidth(QTextStream* theWrappedObject) const;
    void flush(QTextStream* theWrappedObject);
    bool  generateByteOrderMark(QTextStream* theWrappedObject) const;
    int  integerBase(QTextStream* theWrappedObject) const;
    QLocale  locale(QTextStream* theWrappedObject) const;
    QTextStream::NumberFlags  numberFlags(QTextStream* theWrappedObject) const;
    QTextStream*  writeByte(QTextStream* theWrappedObject, char  ch);
    QTextStream*  writeByteArray(QTextStream* theWrappedObject, const QByteArray&  array);
    QTextStream*  writeString(QTextStream* theWrappedObject, const QString&  s);
    QTextStream*  writeDouble(QTextStream* theWrappedObject, double  f);
    QTextStream*  writeFloat(QTextStream* theWrappedObject, float  f);
    QTextStream*  writeInt(QTextStream* theWrappedObject, signed int  i);
    QTextStream*  writeShort(QTextStream* theWrappedObject, signed short  i);
    QTextStream*  readByte(QTextStream* theWrappedObject, char&  ch);
    QTextStream*  readDouble(QTextStream* theWrappedObject, double&  f);
    QTextStream*  readFloat(QTextStream* theWrappedObject, float&  f);
    QTextStream*  readLongLong(QTextStream* theWrappedObject, qlonglong&  i);
    QTextStream*  readInt(QTextStream* theWrappedObject, signed int&  i);
    QTextStream*  readShort(QTextStream* theWrappedObject, signed short&  i);
    QTextStream*  readUInt(QTextStream* theWrappedObject, unsigned int&  i);
    QTextStream*  readUShort(QTextStream* theWrappedObject, unsigned short&  i);
    QChar  padChar(QTextStream* theWrappedObject) const;
    qint64  pos(QTextStream* theWrappedObject) const;
    QString  read(QTextStream* theWrappedObject, qint64  maxlen);
    QString  readAll(QTextStream* theWrappedObject);
    QString  readLine(QTextStream* theWrappedObject, qint64  maxlen = 0);
    QTextStream::RealNumberNotation  realNumberNotation(QTextStream* theWrappedObject) const;
    int  realNumberPrecision(QTextStream* theWrappedObject) const;
    void reset(QTextStream* theWrappedObject);
    void resetStatus(QTextStream* theWrappedObject);
    bool  seek(QTextStream* theWrappedObject, qint64  pos);
    void setAutoDetectUnicode(QTextStream* theWrappedObject, bool  enabled);
    void setCodec(QTextStream* theWrappedObject, QTextCodec*  codec);
    void setCodec(QTextStream* theWrappedObject, const char*  codecName);
    void setDevice(QTextStream* theWrappedObject, QIODevice*  device);
    void setFieldAlignment(QTextStream* theWrappedObject, QTextStream::FieldAlignment  alignment);
    void setFieldWidth(QTextStream* theWrappedObject, int  width);
    void setGenerateByteOrderMark(QTextStream* theWrappedObject, bool  generate);
    void setIntegerBase(QTextStream* theWrappedObject, int  base);
    void setLocale(QTextStream* theWrappedObject, const QLocale&  locale);
    void setNumberFlags(QTextStream* theWrappedObject, QTextStream::NumberFlags  flags);
    void setPadChar(QTextStream* theWrappedObject, QChar  ch);
    void setRealNumberNotation(QTextStream* theWrappedObject, QTextStream::RealNumberNotation  notation);
    void setRealNumberPrecision(QTextStream* theWrappedObject, int  precision);
    void setStatus(QTextStream* theWrappedObject, QTextStream::Status  status);
    void skipWhiteSpace(QTextStream* theWrappedObject);
    QTextStream::Status  status(QTextStream* theWrappedObject) const;
};





class PythonQtShell_QThreadPool : public QThreadPool
{
public:
    PythonQtShell_QThreadPool(QObject*  parent = 0):QThreadPool(parent),_wrapper(NULL) {};

   ~PythonQtShell_QThreadPool();

virtual void childEvent(QChildEvent*  arg__1);
virtual void customEvent(QEvent*  arg__1);
virtual bool  event(QEvent*  arg__1);
virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
virtual void timerEvent(QTimerEvent*  arg__1);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtWrapper_QThreadPool : public QObject
{ Q_OBJECT
public:
public slots:
QThreadPool* new_QThreadPool(QObject*  parent = 0);
void delete_QThreadPool(QThreadPool* obj) { delete obj; } 
    int  activeThreadCount(QThreadPool* theWrappedObject) const;
    int  expiryTimeout(QThreadPool* theWrappedObject) const;
    QThreadPool*  static_QThreadPool_globalInstance();
    int  maxThreadCount(QThreadPool* theWrappedObject) const;
    void releaseThread(QThreadPool* theWrappedObject);
    void reserveThread(QThreadPool* theWrappedObject);
    void setExpiryTimeout(QThreadPool* theWrappedObject, int  expiryTimeout);
    void setMaxThreadCount(QThreadPool* theWrappedObject, int  maxThreadCount);
    void start(QThreadPool* theWrappedObject, QRunnable*  runnable, int  priority = 0);
    bool  tryStart(QThreadPool* theWrappedObject, QRunnable*  runnable);
    bool  waitForDone(QThreadPool* theWrappedObject, int  msecs = -1);
};





class PythonQtShell_QTimeLine : public QTimeLine
{
public:
    PythonQtShell_QTimeLine(int  duration = 1000, QObject*  parent = 0):QTimeLine(duration, parent),_wrapper(NULL) {};

   ~PythonQtShell_QTimeLine();

virtual void childEvent(QChildEvent*  arg__1);
virtual void customEvent(QEvent*  arg__1);
virtual bool  event(QEvent*  arg__1);
virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
virtual void timerEvent(QTimerEvent*  event);
virtual qreal  valueForTime(int  msec) const;

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QTimeLine : public QTimeLine
{ public:
inline void promoted_timerEvent(QTimerEvent*  event) { QTimeLine::timerEvent(event); }
inline qreal  promoted_valueForTime(int  msec) const { return QTimeLine::valueForTime(msec); }
};

class PythonQtWrapper_QTimeLine : public QObject
{ Q_OBJECT
public:
Q_ENUMS(State CurveShape Direction )
enum State{
  NotRunning = QTimeLine::NotRunning,   Paused = QTimeLine::Paused,   Running = QTimeLine::Running};
enum CurveShape{
  EaseInCurve = QTimeLine::EaseInCurve,   EaseOutCurve = QTimeLine::EaseOutCurve,   EaseInOutCurve = QTimeLine::EaseInOutCurve,   LinearCurve = QTimeLine::LinearCurve,   SineCurve = QTimeLine::SineCurve,   CosineCurve = QTimeLine::CosineCurve};
enum Direction{
  Forward = QTimeLine::Forward,   Backward = QTimeLine::Backward};
public slots:
QTimeLine* new_QTimeLine(int  duration = 1000, QObject*  parent = 0);
void delete_QTimeLine(QTimeLine* obj) { delete obj; } 
    int  currentFrame(QTimeLine* theWrappedObject) const;
    int  currentTime(QTimeLine* theWrappedObject) const;
    qreal  currentValue(QTimeLine* theWrappedObject) const;
    QTimeLine::CurveShape  curveShape(QTimeLine* theWrappedObject) const;
    QTimeLine::Direction  direction(QTimeLine* theWrappedObject) const;
    int  duration(QTimeLine* theWrappedObject) const;
    QEasingCurve  easingCurve(QTimeLine* theWrappedObject) const;
    int  endFrame(QTimeLine* theWrappedObject) const;
    int  frameForTime(QTimeLine* theWrappedObject, int  msec) const;
    int  loopCount(QTimeLine* theWrappedObject) const;
    void setCurveShape(QTimeLine* theWrappedObject, QTimeLine::CurveShape  shape);
    void setDirection(QTimeLine* theWrappedObject, QTimeLine::Direction  direction);
    void setDuration(QTimeLine* theWrappedObject, int  duration);
    void setEasingCurve(QTimeLine* theWrappedObject, const QEasingCurve&  curve);
    void setEndFrame(QTimeLine* theWrappedObject, int  frame);
    void setFrameRange(QTimeLine* theWrappedObject, int  startFrame, int  endFrame);
    void setLoopCount(QTimeLine* theWrappedObject, int  count);
    void setStartFrame(QTimeLine* theWrappedObject, int  frame);
    void setUpdateInterval(QTimeLine* theWrappedObject, int  interval);
    int  startFrame(QTimeLine* theWrappedObject) const;
    QTimeLine::State  state(QTimeLine* theWrappedObject) const;
    void timerEvent(QTimeLine* theWrappedObject, QTimerEvent*  event);
    int  updateInterval(QTimeLine* theWrappedObject) const;
    qreal  valueForTime(QTimeLine* theWrappedObject, int  msec) const;
};