#include <PythonQt.h>
#include <QDateTime>
#include <QObject>
#include <QVariant>
#include <qabstractnetworkcache.h>
#include <qabstractsocket.h>
#include <qauthenticator.h>
#include <qbytearray.h>
#include <qcoreevent.h>
#include <qdatetime.h>
#include <qhostaddress.h>
#include <qhostinfo.h>
#include <qiodevice.h>
#include <qlist.h>
#include <qlocalserver.h>
#include <qlocalsocket.h>
#include <qnetworkaccessmanager.h>
#include <qnetworkcookie.h>
#include <qnetworkcookiejar.h>
#include <qnetworkdiskcache.h>
#include <qnetworkinterface.h>
#include <qnetworkproxy.h>
#include <qnetworkreply.h>
#include <qnetworkrequest.h>
#include <qobject.h>
#include <qpair.h>
#include <qssl.h>
#include <qsslcertificate.h>
#include <qsslcipher.h>
#include <qsslconfiguration.h>
#include <qsslerror.h>
#include <qsslkey.h>
#include <qsslsocket.h>
#include <qstringlist.h>
#include <qtcpserver.h>
#include <qtcpsocket.h>
#include <qudpsocket.h>
#include <qurl.h>



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

   ~PythonQtShell_QAbstractNetworkCache();

virtual qint64  cacheSize() const;
virtual void childEvent(QChildEvent*  arg__1);
virtual void clear();
virtual void customEvent(QEvent*  arg__1);
virtual QIODevice*  data(const QUrl&  url);
virtual bool  event(QEvent*  arg__1);
virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
virtual void insert(QIODevice*  device);
virtual QNetworkCacheMetaData  metaData(const QUrl&  url);
virtual QIODevice*  prepare(const QNetworkCacheMetaData&  metaData);
virtual bool  remove(const QUrl&  url);
virtual void timerEvent(QTimerEvent*  arg__1);
virtual void updateMetaData(const QNetworkCacheMetaData&  metaData);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtWrapper_QAbstractNetworkCache : public QObject
{ Q_OBJECT
public:
public slots:
void delete_QAbstractNetworkCache(QAbstractNetworkCache* obj) { delete obj; } 
};





class PythonQtShell_QAbstractSocket : public QAbstractSocket
{
public:
    PythonQtShell_QAbstractSocket(QAbstractSocket::SocketType  socketType, QObject*  parent):QAbstractSocket(socketType, parent),_wrapper(NULL) {};

   ~PythonQtShell_QAbstractSocket();

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 connectToHost(const QHostAddress&  address, unsigned short  port, QIODevice::OpenMode  mode = QIODevice::ReadWrite);
virtual void connectToHost(const QString&  hostName, unsigned short  port, QIODevice::OpenMode  mode = QIODevice::ReadWrite, QAbstractSocket::NetworkLayerProtocol  protocol = QAbstractSocket::AnyIPProtocol);
virtual void customEvent(QEvent*  arg__1);
virtual void disconnectFromHost();
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 void resume();
virtual bool  seek(qint64  pos);
virtual void setReadBufferSize(qint64  size);
virtual void setSocketOption(QAbstractSocket::SocketOption  option, const QVariant&  value);
virtual qint64  size() const;
virtual QVariant  socketOption(QAbstractSocket::SocketOption  option);
virtual void timerEvent(QTimerEvent*  arg__1);
virtual bool  waitForBytesWritten(int  msecs = 30000);
virtual bool  waitForConnected(int  msecs = 30000);
virtual bool  waitForDisconnected(int  msecs = 30000);
virtual bool  waitForReadyRead(int  msecs = 30000);
virtual qint64  writeData(const char*  data, qint64  len);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QAbstractSocket : public QAbstractSocket
{ public:
inline bool  promoted_atEnd() const { return QAbstractSocket::atEnd(); }
inline qint64  promoted_bytesAvailable() const { return QAbstractSocket::bytesAvailable(); }
inline qint64  promoted_bytesToWrite() const { return QAbstractSocket::bytesToWrite(); }
inline bool  promoted_canReadLine() const { return QAbstractSocket::canReadLine(); }
inline void promoted_close() { QAbstractSocket::close(); }
inline void promoted_connectToHost(const QHostAddress&  address, unsigned short  port, QIODevice::OpenMode  mode = QIODevice::ReadWrite) { QAbstractSocket::connectToHost(address, port, mode); }
inline void promoted_connectToHost(const QString&  hostName, unsigned short  port, QIODevice::OpenMode  mode = QIODevice::ReadWrite, QAbstractSocket::NetworkLayerProtocol  protocol = QAbstractSocket::AnyIPProtocol) { QAbstractSocket::connectToHost(hostName, port, mode, protocol); }
inline void promoted_disconnectFromHost() { QAbstractSocket::disconnectFromHost(); }
inline bool  promoted_isSequential() const { return QAbstractSocket::isSequential(); }
inline qint64  promoted_readData(char*  data, qint64  maxlen) { return QAbstractSocket::readData(data, maxlen); }
inline qint64  promoted_readLineData(char*  data, qint64  maxlen) { return QAbstractSocket::readLineData(data, maxlen); }
inline void promoted_resume() { QAbstractSocket::resume(); }
inline void promoted_setReadBufferSize(qint64  size) { QAbstractSocket::setReadBufferSize(size); }
inline void promoted_setSocketOption(QAbstractSocket::SocketOption  option, const QVariant&  value) { QAbstractSocket::setSocketOption(option, value); }
inline QVariant  promoted_socketOption(QAbstractSocket::SocketOption  option) { return QAbstractSocket::socketOption(option); }
inline bool  promoted_waitForBytesWritten(int  msecs = 30000) { return QAbstractSocket::waitForBytesWritten(msecs); }
inline bool  promoted_waitForConnected(int  msecs = 30000) { return QAbstractSocket::waitForConnected(msecs); }
inline bool  promoted_waitForDisconnected(int  msecs = 30000) { return QAbstractSocket::waitForDisconnected(msecs); }
inline bool  promoted_waitForReadyRead(int  msecs = 30000) { return QAbstractSocket::waitForReadyRead(msecs); }
inline qint64  promoted_writeData(const char*  data, qint64  len) { return QAbstractSocket::writeData(data, len); }
};

class PythonQtWrapper_QAbstractSocket : public QObject
{ Q_OBJECT
public:
Q_ENUMS(PauseMode BindFlag )
enum PauseMode{
  PauseNever = QAbstractSocket::PauseNever,   PauseOnSslErrors = QAbstractSocket::PauseOnSslErrors};
enum BindFlag{
  DefaultForPlatform = QAbstractSocket::DefaultForPlatform,   ShareAddress = QAbstractSocket::ShareAddress,   DontShareAddress = QAbstractSocket::DontShareAddress,   ReuseAddressHint = QAbstractSocket::ReuseAddressHint};
public slots:
QAbstractSocket* new_QAbstractSocket(QAbstractSocket::SocketType  socketType, QObject*  parent);
void delete_QAbstractSocket(QAbstractSocket* obj) { delete obj; } 
    void abort(QAbstractSocket* theWrappedObject);
    bool  atEnd(QAbstractSocket* theWrappedObject) const;
    qint64  bytesAvailable(QAbstractSocket* theWrappedObject) const;
    qint64  bytesToWrite(QAbstractSocket* theWrappedObject) const;
    bool  canReadLine(QAbstractSocket* theWrappedObject) const;
    void close(QAbstractSocket* theWrappedObject);
    void connectToHost(QAbstractSocket* theWrappedObject, const QHostAddress&  address, unsigned short  port, QIODevice::OpenMode  mode = QIODevice::ReadWrite);
    void connectToHost(QAbstractSocket* theWrappedObject, const QString&  hostName, unsigned short  port, QIODevice::OpenMode  mode = QIODevice::ReadWrite, QAbstractSocket::NetworkLayerProtocol  protocol = QAbstractSocket::AnyIPProtocol);
    void disconnectFromHost(QAbstractSocket* theWrappedObject);
    QAbstractSocket::SocketError  error(QAbstractSocket* theWrappedObject) const;
    bool  flush(QAbstractSocket* theWrappedObject);
    bool  isSequential(QAbstractSocket* theWrappedObject) const;
    bool  isValid(QAbstractSocket* theWrappedObject) const;
    QHostAddress  localAddress(QAbstractSocket* theWrappedObject) const;
    unsigned short  localPort(QAbstractSocket* theWrappedObject) const;
    QHostAddress  peerAddress(QAbstractSocket* theWrappedObject) const;
    QString  peerName(QAbstractSocket* theWrappedObject) const;
    unsigned short  peerPort(QAbstractSocket* theWrappedObject) const;
    QNetworkProxy  proxy(QAbstractSocket* theWrappedObject) const;
    qint64  readBufferSize(QAbstractSocket* theWrappedObject) const;
    qint64  readData(QAbstractSocket* theWrappedObject, char*  data, qint64  maxlen);
    qint64  readLineData(QAbstractSocket* theWrappedObject, char*  data, qint64  maxlen);
    void resume(QAbstractSocket* theWrappedObject);
    void setProxy(QAbstractSocket* theWrappedObject, const QNetworkProxy&  networkProxy);
    void setReadBufferSize(QAbstractSocket* theWrappedObject, qint64  size);
    void setSocketOption(QAbstractSocket* theWrappedObject, QAbstractSocket::SocketOption  option, const QVariant&  value);
    QVariant  socketOption(QAbstractSocket* theWrappedObject, QAbstractSocket::SocketOption  option);
    QAbstractSocket::SocketType  socketType(QAbstractSocket* theWrappedObject) const;
    QAbstractSocket::SocketState  state(QAbstractSocket* theWrappedObject) const;
    bool  waitForBytesWritten(QAbstractSocket* theWrappedObject, int  msecs = 30000);
    bool  waitForConnected(QAbstractSocket* theWrappedObject, int  msecs = 30000);
    bool  waitForDisconnected(QAbstractSocket* theWrappedObject, int  msecs = 30000);
    bool  waitForReadyRead(QAbstractSocket* theWrappedObject, int  msecs = 30000);
    qint64  writeData(QAbstractSocket* theWrappedObject, const char*  data, qint64  len);
};





class PythonQtWrapper_QAuthenticator : public QObject
{ Q_OBJECT
public:
public slots:
QAuthenticator* new_QAuthenticator();
QAuthenticator* new_QAuthenticator(const QAuthenticator&  other);
void delete_QAuthenticator(QAuthenticator* obj) { delete obj; } 
    bool  isNull(QAuthenticator* theWrappedObject) const;
    bool  __ne__(QAuthenticator* theWrappedObject, const QAuthenticator&  other) const;
    bool  __eq__(QAuthenticator* theWrappedObject, const QAuthenticator&  other) const;
    QVariant  option(QAuthenticator* theWrappedObject, const QString&  opt) const;
    QHash<QString , QVariant >  options(QAuthenticator* theWrappedObject) const;
    QString  password(QAuthenticator* theWrappedObject) const;
    QString  realm(QAuthenticator* theWrappedObject) const;
    void setOption(QAuthenticator* theWrappedObject, const QString&  opt, const QVariant&  value);
    void setPassword(QAuthenticator* theWrappedObject, const QString&  password);
    void setUser(QAuthenticator* theWrappedObject, const QString&  user);
    QString  user(QAuthenticator* theWrappedObject) const;
    bool __nonzero__(QAuthenticator* obj) { return !obj->isNull(); }
};





class PythonQtWrapper_QHostAddress : public QObject
{ Q_OBJECT
public:
Q_ENUMS(SpecialAddress )
enum SpecialAddress{
  Null = QHostAddress::Null,   Broadcast = QHostAddress::Broadcast,   LocalHost = QHostAddress::LocalHost,   LocalHostIPv6 = QHostAddress::LocalHostIPv6,   Any = QHostAddress::Any,   AnyIPv6 = QHostAddress::AnyIPv6,   AnyIPv4 = QHostAddress::AnyIPv4};
public slots:
QHostAddress* new_QHostAddress();
QHostAddress* new_QHostAddress(QHostAddress::SpecialAddress  address);
QHostAddress* new_QHostAddress(const QHostAddress&  copy);
QHostAddress* new_QHostAddress(const QIPv6Address&  ip6Addr);
QHostAddress* new_QHostAddress(const QString&  address);
QHostAddress* new_QHostAddress(unsigned int  ip4Addr);
void delete_QHostAddress(QHostAddress* obj) { delete obj; } 
    void clear(QHostAddress* theWrappedObject);
    bool  isInSubnet(QHostAddress* theWrappedObject, const QHostAddress&  subnet, int  netmask) const;
    bool  isInSubnet(QHostAddress* theWrappedObject, const QPair<QHostAddress , int >&  subnet) const;
    bool  isLoopback(QHostAddress* theWrappedObject) const;
    bool  isNull(QHostAddress* theWrappedObject) const;
    bool  __ne__(QHostAddress* theWrappedObject, QHostAddress::SpecialAddress  address) const;
    bool  __ne__(QHostAddress* theWrappedObject, const QHostAddress&  address) const;
    bool  __eq__(QHostAddress* theWrappedObject, QHostAddress::SpecialAddress  address) const;
    bool  __eq__(QHostAddress* theWrappedObject, const QHostAddress&  address) const;
    QPair<QHostAddress , int >  static_QHostAddress_parseSubnet(const QString&  subnet);
    QAbstractSocket::NetworkLayerProtocol  protocol(QHostAddress* theWrappedObject) const;
    QString  scopeId(QHostAddress* theWrappedObject) const;
    void setAddress(QHostAddress* theWrappedObject, const QIPv6Address&  ip6Addr);
    bool  setAddress(QHostAddress* theWrappedObject, const QString&  address);
    void setAddress(QHostAddress* theWrappedObject, unsigned int  ip4Addr);
    void setScopeId(QHostAddress* theWrappedObject, const QString&  id);
    unsigned int  toIPv4Address(QHostAddress* theWrappedObject) const;
    QIPv6Address  toIPv6Address(QHostAddress* theWrappedObject) const;
    QString  toString(QHostAddress* theWrappedObject) const;
    QString py_toString(QHostAddress*);
    bool __nonzero__(QHostAddress* obj) { return !obj->isNull(); }
};





class PythonQtWrapper_QHostInfo : public QObject
{ Q_OBJECT
public:
Q_ENUMS(HostInfoError )
enum HostInfoError{
  NoError = QHostInfo::NoError,   HostNotFound = QHostInfo::HostNotFound,   UnknownError = QHostInfo::UnknownError};
public slots:
QHostInfo* new_QHostInfo(const QHostInfo&  d);
QHostInfo* new_QHostInfo(int  lookupId = -1);
void delete_QHostInfo(QHostInfo* obj) { delete obj; } 
    void static_QHostInfo_abortHostLookup(int  lookupId);
    QList<QHostAddress >  addresses(QHostInfo* theWrappedObject) const;
    QHostInfo::HostInfoError  error(QHostInfo* theWrappedObject) const;
    QString  errorString(QHostInfo* theWrappedObject) const;
    QHostInfo  static_QHostInfo_fromName(const QString&  name);
    QString  hostName(QHostInfo* theWrappedObject) const;
    QString  static_QHostInfo_localDomainName();
    QString  static_QHostInfo_localHostName();
    int  static_QHostInfo_lookupHost(const QString&  name, QObject*  receiver, const char*  member);
    int  lookupId(QHostInfo* theWrappedObject) const;
    void setAddresses(QHostInfo* theWrappedObject, const QList<QHostAddress >&  addresses);
    void setError(QHostInfo* theWrappedObject, QHostInfo::HostInfoError  error);
    void setErrorString(QHostInfo* theWrappedObject, const QString&  errorString);
    void setHostName(QHostInfo* theWrappedObject, const QString&  name);
    void setLookupId(QHostInfo* theWrappedObject, int  id);
};





class PythonQtShell_QIPv6Address : public QIPv6Address
{
public:
    PythonQtShell_QIPv6Address():QIPv6Address(),_wrapper(NULL) {};

   ~PythonQtShell_QIPv6Address();


  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtWrapper_QIPv6Address : public QObject
{ Q_OBJECT
public:
public slots:
QIPv6Address* new_QIPv6Address();
QIPv6Address* new_QIPv6Address(const QIPv6Address& other) {
PythonQtShell_QIPv6Address* a = new PythonQtShell_QIPv6Address();
*((QIPv6Address*)a) = other;
return a; }
void delete_QIPv6Address(QIPv6Address* obj) { delete obj; } 
};





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

   ~PythonQtShell_QLocalServer();

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 bool  hasPendingConnections() const;
virtual void incomingConnection(quintptr  socketDescriptor);
virtual QLocalSocket*  nextPendingConnection();
virtual void timerEvent(QTimerEvent*  arg__1);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QLocalServer : public QLocalServer
{ public:
inline bool  promoted_hasPendingConnections() const { return QLocalServer::hasPendingConnections(); }
inline void promoted_incomingConnection(quintptr  socketDescriptor) { QLocalServer::incomingConnection(socketDescriptor); }
inline QLocalSocket*  promoted_nextPendingConnection() { return QLocalServer::nextPendingConnection(); }
};

class PythonQtWrapper_QLocalServer : public QObject
{ Q_OBJECT
public:
public slots:
QLocalServer* new_QLocalServer(QObject*  parent = 0);
void delete_QLocalServer(QLocalServer* obj) { delete obj; } 
    void close(QLocalServer* theWrappedObject);
    QString  errorString(QLocalServer* theWrappedObject) const;
    QString  fullServerName(QLocalServer* theWrappedObject) const;
    bool  hasPendingConnections(QLocalServer* theWrappedObject) const;
    void incomingConnection(QLocalServer* theWrappedObject, quintptr  socketDescriptor);
    bool  isListening(QLocalServer* theWrappedObject) const;
    bool  listen(QLocalServer* theWrappedObject, const QString&  name);
    int  maxPendingConnections(QLocalServer* theWrappedObject) const;
    QLocalSocket*  nextPendingConnection(QLocalServer* theWrappedObject);
    bool  static_QLocalServer_removeServer(const QString&  name);
    QAbstractSocket::SocketError  serverError(QLocalServer* theWrappedObject) const;
    QString  serverName(QLocalServer* theWrappedObject) const;
    void setMaxPendingConnections(QLocalServer* theWrappedObject, int  numConnections);
    bool  waitForNewConnection(QLocalServer* theWrappedObject, int  msec = 0, bool*  timedOut = 0);
};





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

   ~PythonQtShell_QLocalSocket();

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*  arg__1, qint64  arg__2);
virtual qint64  readLineData(char*  data, qint64  maxlen);
virtual bool  reset();
virtual bool  seek(qint64  pos);
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*  arg__1, qint64  arg__2);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QLocalSocket : public QLocalSocket
{ public:
inline qint64  promoted_bytesAvailable() const { return QLocalSocket::bytesAvailable(); }
inline qint64  promoted_bytesToWrite() const { return QLocalSocket::bytesToWrite(); }
inline bool  promoted_canReadLine() const { return QLocalSocket::canReadLine(); }
inline void promoted_close() { QLocalSocket::close(); }
inline bool  promoted_isSequential() const { return QLocalSocket::isSequential(); }
inline qint64  promoted_readData(char*  arg__1, qint64  arg__2) { return QLocalSocket::readData(arg__1, arg__2); }
inline bool  promoted_waitForBytesWritten(int  msecs = 30000) { return QLocalSocket::waitForBytesWritten(msecs); }
inline bool  promoted_waitForReadyRead(int  msecs = 30000) { return QLocalSocket::waitForReadyRead(msecs); }
inline qint64  promoted_writeData(const char*  arg__1, qint64  arg__2) { return QLocalSocket::writeData(arg__1, arg__2); }
};

class PythonQtWrapper_QLocalSocket : public QObject
{ Q_OBJECT
public:
Q_ENUMS(LocalSocketState LocalSocketError )
enum LocalSocketState{
  UnconnectedState = QLocalSocket::UnconnectedState,   ConnectingState = QLocalSocket::ConnectingState,   ConnectedState = QLocalSocket::ConnectedState,   ClosingState = QLocalSocket::ClosingState};
enum LocalSocketError{
  ConnectionRefusedError = QLocalSocket::ConnectionRefusedError,   PeerClosedError = QLocalSocket::PeerClosedError,   ServerNotFoundError = QLocalSocket::ServerNotFoundError,   SocketAccessError = QLocalSocket::SocketAccessError,   SocketResourceError = QLocalSocket::SocketResourceError,   SocketTimeoutError = QLocalSocket::SocketTimeoutError,   DatagramTooLargeError = QLocalSocket::DatagramTooLargeError,   ConnectionError = QLocalSocket::ConnectionError,   UnsupportedSocketOperationError = QLocalSocket::UnsupportedSocketOperationError,   UnknownSocketError = QLocalSocket::UnknownSocketError,   OperationError = QLocalSocket::OperationError};
public slots:
QLocalSocket* new_QLocalSocket(QObject*  parent = 0);
void delete_QLocalSocket(QLocalSocket* obj) { delete obj; } 
    void abort(QLocalSocket* theWrappedObject);
    qint64  bytesAvailable(QLocalSocket* theWrappedObject) const;
    qint64  bytesToWrite(QLocalSocket* theWrappedObject) const;
    bool  canReadLine(QLocalSocket* theWrappedObject) const;
    void close(QLocalSocket* theWrappedObject);
    void connectToServer(QLocalSocket* theWrappedObject, const QString&  name, QIODevice::OpenMode  openMode = QIODevice::ReadWrite);
    void disconnectFromServer(QLocalSocket* theWrappedObject);
    QLocalSocket::LocalSocketError  error(QLocalSocket* theWrappedObject) const;
    bool  flush(QLocalSocket* theWrappedObject);
    QString  fullServerName(QLocalSocket* theWrappedObject) const;
    bool  isSequential(QLocalSocket* theWrappedObject) const;
    bool  isValid(QLocalSocket* theWrappedObject) const;
    qint64  readBufferSize(QLocalSocket* theWrappedObject) const;
    qint64  readData(QLocalSocket* theWrappedObject, char*  arg__1, qint64  arg__2);
    QString  serverName(QLocalSocket* theWrappedObject) const;
    void setReadBufferSize(QLocalSocket* theWrappedObject, qint64  size);
    QLocalSocket::LocalSocketState  state(QLocalSocket* theWrappedObject) const;
    bool  waitForBytesWritten(QLocalSocket* theWrappedObject, int  msecs = 30000);
    bool  waitForConnected(QLocalSocket* theWrappedObject, int  msecs = 30000);
    bool  waitForDisconnected(QLocalSocket* theWrappedObject, int  msecs = 30000);
    bool  waitForReadyRead(QLocalSocket* theWrappedObject, int  msecs = 30000);
    qint64  writeData(QLocalSocket* theWrappedObject, const char*  arg__1, qint64  arg__2);
};





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

   ~PythonQtShell_QNetworkAccessManager();

virtual void childEvent(QChildEvent*  arg__1);
virtual QNetworkReply*  createRequest(QNetworkAccessManager::Operation  op, const QNetworkRequest&  request, QIODevice*  outgoingData = 0);
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_QNetworkAccessManager : public QNetworkAccessManager
{ public:
inline QNetworkReply*  promoted_createRequest(QNetworkAccessManager::Operation  op, const QNetworkRequest&  request, QIODevice*  outgoingData = 0) { return QNetworkAccessManager::createRequest(op, request, outgoingData); }
};

class PythonQtWrapper_QNetworkAccessManager : public QObject
{ Q_OBJECT
public:
Q_ENUMS(NetworkAccessibility Operation )
enum NetworkAccessibility{
  UnknownAccessibility = QNetworkAccessManager::UnknownAccessibility,   NotAccessible = QNetworkAccessManager::NotAccessible,   Accessible = QNetworkAccessManager::Accessible};
enum Operation{
  HeadOperation = QNetworkAccessManager::HeadOperation,   GetOperation = QNetworkAccessManager::GetOperation,   PutOperation = QNetworkAccessManager::PutOperation,   PostOperation = QNetworkAccessManager::PostOperation,   DeleteOperation = QNetworkAccessManager::DeleteOperation,   CustomOperation = QNetworkAccessManager::CustomOperation,   UnknownOperation = QNetworkAccessManager::UnknownOperation};
public slots:
QNetworkAccessManager* new_QNetworkAccessManager(QObject*  parent = 0);
void delete_QNetworkAccessManager(QNetworkAccessManager* obj) { delete obj; } 
    QAbstractNetworkCache*  cache(QNetworkAccessManager* theWrappedObject) const;
    void clearAccessCache(QNetworkAccessManager* theWrappedObject);
    QNetworkCookieJar*  cookieJar(QNetworkAccessManager* theWrappedObject) const;
    QNetworkReply*  createRequest(QNetworkAccessManager* theWrappedObject, QNetworkAccessManager::Operation  op, const QNetworkRequest&  request, QIODevice*  outgoingData = 0);
    QNetworkReply*  deleteResource(QNetworkAccessManager* theWrappedObject, const QNetworkRequest&  request);
    QNetworkReply*  get(QNetworkAccessManager* theWrappedObject, const QNetworkRequest&  request);
    QNetworkReply*  head(QNetworkAccessManager* theWrappedObject, const QNetworkRequest&  request);
    QNetworkAccessManager::NetworkAccessibility  networkAccessible(QNetworkAccessManager* theWrappedObject) const;
    QNetworkReply*  post(QNetworkAccessManager* theWrappedObject, const QNetworkRequest&  request, QIODevice*  data);
    QNetworkReply*  post(QNetworkAccessManager* theWrappedObject, const QNetworkRequest&  request, const QByteArray&  data);
    QNetworkProxy  proxy(QNetworkAccessManager* theWrappedObject) const;
    QNetworkProxyFactory*  proxyFactory(QNetworkAccessManager* theWrappedObject) const;
    QNetworkReply*  put(QNetworkAccessManager* theWrappedObject, const QNetworkRequest&  request, QIODevice*  data);
    QNetworkReply*  put(QNetworkAccessManager* theWrappedObject, const QNetworkRequest&  request, const QByteArray&  data);
    QNetworkReply*  sendCustomRequest(QNetworkAccessManager* theWrappedObject, const QNetworkRequest&  request, const QByteArray&  verb, QIODevice*  data = 0);
    void setCache(QNetworkAccessManager* theWrappedObject, QAbstractNetworkCache*  cache);
    void setCookieJar(QNetworkAccessManager* theWrappedObject, QNetworkCookieJar*  cookieJar);
    void setNetworkAccessible(QNetworkAccessManager* theWrappedObject, QNetworkAccessManager::NetworkAccessibility  accessible);
    void setProxy(QNetworkAccessManager* theWrappedObject, const QNetworkProxy&  proxy);
    void setProxyFactory(QNetworkAccessManager* theWrappedObject, QNetworkProxyFactory*  factory);
};





class PythonQtWrapper_QNetworkAddressEntry : public QObject
{ Q_OBJECT
public:
public slots:
QNetworkAddressEntry* new_QNetworkAddressEntry();
QNetworkAddressEntry* new_QNetworkAddressEntry(const QNetworkAddressEntry&  other);
void delete_QNetworkAddressEntry(QNetworkAddressEntry* obj) { delete obj; } 
    QHostAddress  broadcast(QNetworkAddressEntry* theWrappedObject) const;
    QHostAddress  ip(QNetworkAddressEntry* theWrappedObject) const;
    QHostAddress  netmask(QNetworkAddressEntry* theWrappedObject) const;
    bool  __ne__(QNetworkAddressEntry* theWrappedObject, const QNetworkAddressEntry&  other) const;
    bool  __eq__(QNetworkAddressEntry* theWrappedObject, const QNetworkAddressEntry&  other) const;
    int  prefixLength(QNetworkAddressEntry* theWrappedObject) const;
    void setBroadcast(QNetworkAddressEntry* theWrappedObject, const QHostAddress&  newBroadcast);
    void setIp(QNetworkAddressEntry* theWrappedObject, const QHostAddress&  newIp);
    void setNetmask(QNetworkAddressEntry* theWrappedObject, const QHostAddress&  newNetmask);
    void setPrefixLength(QNetworkAddressEntry* theWrappedObject, int  length);
    void swap(QNetworkAddressEntry* theWrappedObject, QNetworkAddressEntry&  other);
};





class PythonQtWrapper_QNetworkCacheMetaData : public QObject
{ Q_OBJECT
public:
public slots:
QNetworkCacheMetaData* new_QNetworkCacheMetaData();
QNetworkCacheMetaData* new_QNetworkCacheMetaData(const QNetworkCacheMetaData&  other);
void delete_QNetworkCacheMetaData(QNetworkCacheMetaData* obj) { delete obj; } 
    QHash<QNetworkRequest::Attribute , QVariant >  attributes(QNetworkCacheMetaData* theWrappedObject) const;
    QDateTime  expirationDate(QNetworkCacheMetaData* theWrappedObject) const;
    bool  isValid(QNetworkCacheMetaData* theWrappedObject) const;
    QDateTime  lastModified(QNetworkCacheMetaData* theWrappedObject) const;
    bool  __ne__(QNetworkCacheMetaData* theWrappedObject, const QNetworkCacheMetaData&  other) const;
    bool  __eq__(QNetworkCacheMetaData* theWrappedObject, const QNetworkCacheMetaData&  other) const;
    QList<QPair<QByteArray , QByteArray >  >  rawHeaders(QNetworkCacheMetaData* theWrappedObject) const;
    bool  saveToDisk(QNetworkCacheMetaData* theWrappedObject) const;
    void setAttributes(QNetworkCacheMetaData* theWrappedObject, const QHash<QNetworkRequest::Attribute , QVariant >&  attributes);
    void setExpirationDate(QNetworkCacheMetaData* theWrappedObject, const QDateTime&  dateTime);
    void setLastModified(QNetworkCacheMetaData* theWrappedObject, const QDateTime&  dateTime);
    void setRawHeaders(QNetworkCacheMetaData* theWrappedObject, const QList<QPair<QByteArray , QByteArray >  >&  headers);
    void setSaveToDisk(QNetworkCacheMetaData* theWrappedObject, bool  allow);
    void setUrl(QNetworkCacheMetaData* theWrappedObject, const QUrl&  url);
    void swap(QNetworkCacheMetaData* theWrappedObject, QNetworkCacheMetaData&  other);
    QUrl  url(QNetworkCacheMetaData* theWrappedObject) const;
};





class PythonQtWrapper_QNetworkCookie : public QObject
{ Q_OBJECT
public:
Q_ENUMS(RawForm )
enum RawForm{
  NameAndValueOnly = QNetworkCookie::NameAndValueOnly,   Full = QNetworkCookie::Full};
public slots:
QNetworkCookie* new_QNetworkCookie(const QByteArray&  name = QByteArray(), const QByteArray&  value = QByteArray());
QNetworkCookie* new_QNetworkCookie(const QNetworkCookie&  other);
void delete_QNetworkCookie(QNetworkCookie* obj) { delete obj; } 
    QString  domain(QNetworkCookie* theWrappedObject) const;
    QDateTime  expirationDate(QNetworkCookie* theWrappedObject) const;
    bool  hasSameIdentifier(QNetworkCookie* theWrappedObject, const QNetworkCookie&  other) const;
    bool  isHttpOnly(QNetworkCookie* theWrappedObject) const;
    bool  isSecure(QNetworkCookie* theWrappedObject) const;
    bool  isSessionCookie(QNetworkCookie* theWrappedObject) const;
    QByteArray  name(QNetworkCookie* theWrappedObject) const;
    void normalize(QNetworkCookie* theWrappedObject, const QUrl&  url);
    bool  __ne__(QNetworkCookie* theWrappedObject, const QNetworkCookie&  other) const;
    bool  __eq__(QNetworkCookie* theWrappedObject, const QNetworkCookie&  other) const;
    QList<QNetworkCookie >  static_QNetworkCookie_parseCookies(const QByteArray&  cookieString);
    QString  path(QNetworkCookie* theWrappedObject) const;
    void setDomain(QNetworkCookie* theWrappedObject, const QString&  domain);
    void setExpirationDate(QNetworkCookie* theWrappedObject, const QDateTime&  date);
    void setHttpOnly(QNetworkCookie* theWrappedObject, bool  enable);
    void setName(QNetworkCookie* theWrappedObject, const QByteArray&  cookieName);
    void setPath(QNetworkCookie* theWrappedObject, const QString&  path);
    void setSecure(QNetworkCookie* theWrappedObject, bool  enable);
    void setValue(QNetworkCookie* theWrappedObject, const QByteArray&  value);
    void swap(QNetworkCookie* theWrappedObject, QNetworkCookie&  other);
    QByteArray  toRawForm(QNetworkCookie* theWrappedObject, QNetworkCookie::RawForm  form = QNetworkCookie::Full) const;
    QByteArray  value(QNetworkCookie* theWrappedObject) const;
    QString py_toString(QNetworkCookie*);
};





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

   ~PythonQtShell_QNetworkCookieJar();

virtual void childEvent(QChildEvent*  arg__1);
virtual QList<QNetworkCookie >  cookiesForUrl(const QUrl&  url) const;
virtual void customEvent(QEvent*  arg__1);
virtual bool  deleteCookie(const QNetworkCookie&  cookie);
virtual bool  event(QEvent*  arg__1);
virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
virtual bool  insertCookie(const QNetworkCookie&  cookie);
virtual bool  setCookiesFromUrl(const QList<QNetworkCookie >&  cookieList, const QUrl&  url);
virtual void timerEvent(QTimerEvent*  arg__1);
virtual bool  updateCookie(const QNetworkCookie&  cookie);
virtual bool  validateCookie(const QNetworkCookie&  cookie, const QUrl&  url) const;

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QNetworkCookieJar : public QNetworkCookieJar
{ public:
inline QList<QNetworkCookie >  promoted_cookiesForUrl(const QUrl&  url) const { return QNetworkCookieJar::cookiesForUrl(url); }
inline bool  promoted_deleteCookie(const QNetworkCookie&  cookie) { return QNetworkCookieJar::deleteCookie(cookie); }
inline bool  promoted_insertCookie(const QNetworkCookie&  cookie) { return QNetworkCookieJar::insertCookie(cookie); }
inline bool  promoted_setCookiesFromUrl(const QList<QNetworkCookie >&  cookieList, const QUrl&  url) { return QNetworkCookieJar::setCookiesFromUrl(cookieList, url); }
inline bool  promoted_updateCookie(const QNetworkCookie&  cookie) { return QNetworkCookieJar::updateCookie(cookie); }
inline bool  promoted_validateCookie(const QNetworkCookie&  cookie, const QUrl&  url) const { return QNetworkCookieJar::validateCookie(cookie, url); }
};

class PythonQtWrapper_QNetworkCookieJar : public QObject
{ Q_OBJECT
public:
public slots:
QNetworkCookieJar* new_QNetworkCookieJar(QObject*  parent = 0);
void delete_QNetworkCookieJar(QNetworkCookieJar* obj) { delete obj; } 
    QList<QNetworkCookie >  cookiesForUrl(QNetworkCookieJar* theWrappedObject, const QUrl&  url) const;
    bool  deleteCookie(QNetworkCookieJar* theWrappedObject, const QNetworkCookie&  cookie);
    bool  insertCookie(QNetworkCookieJar* theWrappedObject, const QNetworkCookie&  cookie);
    bool  setCookiesFromUrl(QNetworkCookieJar* theWrappedObject, const QList<QNetworkCookie >&  cookieList, const QUrl&  url);
    bool  updateCookie(QNetworkCookieJar* theWrappedObject, const QNetworkCookie&  cookie);
    bool  validateCookie(QNetworkCookieJar* theWrappedObject, const QNetworkCookie&  cookie, const QUrl&  url) const;
};





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

   ~PythonQtShell_QNetworkDiskCache();

virtual qint64  cacheSize() const;
virtual void childEvent(QChildEvent*  arg__1);
virtual void clear();
virtual void customEvent(QEvent*  arg__1);
virtual QIODevice*  data(const QUrl&  url);
virtual bool  event(QEvent*  arg__1);
virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
virtual qint64  expire();
virtual void insert(QIODevice*  device);
virtual QNetworkCacheMetaData  metaData(const QUrl&  url);
virtual QIODevice*  prepare(const QNetworkCacheMetaData&  metaData);
virtual bool  remove(const QUrl&  url);
virtual void timerEvent(QTimerEvent*  arg__1);
virtual void updateMetaData(const QNetworkCacheMetaData&  metaData);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QNetworkDiskCache : public QNetworkDiskCache
{ public:
inline qint64  promoted_cacheSize() const { return QNetworkDiskCache::cacheSize(); }
inline void promoted_clear() { QNetworkDiskCache::clear(); }
inline QIODevice*  promoted_data(const QUrl&  url) { return QNetworkDiskCache::data(url); }
inline qint64  promoted_expire() { return QNetworkDiskCache::expire(); }
inline void promoted_insert(QIODevice*  device) { QNetworkDiskCache::insert(device); }
inline QNetworkCacheMetaData  promoted_metaData(const QUrl&  url) { return QNetworkDiskCache::metaData(url); }
inline QIODevice*  promoted_prepare(const QNetworkCacheMetaData&  metaData) { return QNetworkDiskCache::prepare(metaData); }
inline bool  promoted_remove(const QUrl&  url) { return QNetworkDiskCache::remove(url); }
inline void promoted_updateMetaData(const QNetworkCacheMetaData&  metaData) { QNetworkDiskCache::updateMetaData(metaData); }
};

class PythonQtWrapper_QNetworkDiskCache : public QObject
{ Q_OBJECT
public:
public slots:
QNetworkDiskCache* new_QNetworkDiskCache(QObject*  parent = 0);
void delete_QNetworkDiskCache(QNetworkDiskCache* obj) { delete obj; } 
    QString  cacheDirectory(QNetworkDiskCache* theWrappedObject) const;
    qint64  cacheSize(QNetworkDiskCache* theWrappedObject) const;
    void clear(QNetworkDiskCache* theWrappedObject);
    QIODevice*  data(QNetworkDiskCache* theWrappedObject, const QUrl&  url);
    qint64  expire(QNetworkDiskCache* theWrappedObject);
    QNetworkCacheMetaData  fileMetaData(QNetworkDiskCache* theWrappedObject, const QString&  fileName) const;
    void insert(QNetworkDiskCache* theWrappedObject, QIODevice*  device);
    qint64  maximumCacheSize(QNetworkDiskCache* theWrappedObject) const;
    QNetworkCacheMetaData  metaData(QNetworkDiskCache* theWrappedObject, const QUrl&  url);
    QIODevice*  prepare(QNetworkDiskCache* theWrappedObject, const QNetworkCacheMetaData&  metaData);
    bool  remove(QNetworkDiskCache* theWrappedObject, const QUrl&  url);
    void setCacheDirectory(QNetworkDiskCache* theWrappedObject, const QString&  cacheDir);
    void setMaximumCacheSize(QNetworkDiskCache* theWrappedObject, qint64  size);
    void updateMetaData(QNetworkDiskCache* theWrappedObject, const QNetworkCacheMetaData&  metaData);
};





class PythonQtWrapper_QNetworkInterface : public QObject
{ Q_OBJECT
public:
Q_ENUMS(InterfaceFlag )
Q_FLAGS(InterfaceFlags )
enum InterfaceFlag{
  IsUp = QNetworkInterface::IsUp,   IsRunning = QNetworkInterface::IsRunning,   CanBroadcast = QNetworkInterface::CanBroadcast,   IsLoopBack = QNetworkInterface::IsLoopBack,   IsPointToPoint = QNetworkInterface::IsPointToPoint,   CanMulticast = QNetworkInterface::CanMulticast};
Q_DECLARE_FLAGS(InterfaceFlags, InterfaceFlag)
public slots:
QNetworkInterface* new_QNetworkInterface();
QNetworkInterface* new_QNetworkInterface(const QNetworkInterface&  other);
void delete_QNetworkInterface(QNetworkInterface* obj) { delete obj; } 
    QList<QNetworkAddressEntry >  addressEntries(QNetworkInterface* theWrappedObject) const;
    QList<QHostAddress >  static_QNetworkInterface_allAddresses();
    QList<QNetworkInterface >  static_QNetworkInterface_allInterfaces();
    QNetworkInterface::InterfaceFlags  flags(QNetworkInterface* theWrappedObject) const;
    QString  hardwareAddress(QNetworkInterface* theWrappedObject) const;
    QString  humanReadableName(QNetworkInterface* theWrappedObject) const;
    int  index(QNetworkInterface* theWrappedObject) const;
    QNetworkInterface  static_QNetworkInterface_interfaceFromIndex(int  index);
    QNetworkInterface  static_QNetworkInterface_interfaceFromName(const QString&  name);
    bool  isValid(QNetworkInterface* theWrappedObject) const;
    QString  name(QNetworkInterface* theWrappedObject) const;
    void swap(QNetworkInterface* theWrappedObject, QNetworkInterface&  other);
    QString py_toString(QNetworkInterface*);
};





class PythonQtWrapper_QNetworkProxy : public QObject
{ Q_OBJECT
public:
Q_ENUMS(Capability ProxyType )
Q_FLAGS(Capabilities )
enum Capability{
  TunnelingCapability = QNetworkProxy::TunnelingCapability,   ListeningCapability = QNetworkProxy::ListeningCapability,   UdpTunnelingCapability = QNetworkProxy::UdpTunnelingCapability,   CachingCapability = QNetworkProxy::CachingCapability,   HostNameLookupCapability = QNetworkProxy::HostNameLookupCapability};
enum ProxyType{
  DefaultProxy = QNetworkProxy::DefaultProxy,   Socks5Proxy = QNetworkProxy::Socks5Proxy,   NoProxy = QNetworkProxy::NoProxy,   HttpProxy = QNetworkProxy::HttpProxy,   HttpCachingProxy = QNetworkProxy::HttpCachingProxy,   FtpCachingProxy = QNetworkProxy::FtpCachingProxy};
Q_DECLARE_FLAGS(Capabilities, Capability)
public slots:
QNetworkProxy* new_QNetworkProxy();
QNetworkProxy* new_QNetworkProxy(QNetworkProxy::ProxyType  type, const QString&  hostName = QString(), unsigned short  port = 0, const QString&  user = QString(), const QString&  password = QString());
QNetworkProxy* new_QNetworkProxy(const QNetworkProxy&  other);
void delete_QNetworkProxy(QNetworkProxy* obj) { delete obj; } 
    QNetworkProxy  static_QNetworkProxy_applicationProxy();
    QNetworkProxy::Capabilities  capabilities(QNetworkProxy* theWrappedObject) const;
    bool  hasRawHeader(QNetworkProxy* theWrappedObject, const QByteArray&  headerName) const;
    QVariant  header(QNetworkProxy* theWrappedObject, QNetworkRequest::KnownHeaders  header) const;
    QString  hostName(QNetworkProxy* theWrappedObject) const;
    bool  isCachingProxy(QNetworkProxy* theWrappedObject) const;
    bool  isTransparentProxy(QNetworkProxy* theWrappedObject) const;
    bool  __ne__(QNetworkProxy* theWrappedObject, const QNetworkProxy&  other) const;
    bool  __eq__(QNetworkProxy* theWrappedObject, const QNetworkProxy&  other) const;
    QString  password(QNetworkProxy* theWrappedObject) const;
    unsigned short  port(QNetworkProxy* theWrappedObject) const;
    QByteArray  rawHeader(QNetworkProxy* theWrappedObject, const QByteArray&  headerName) const;
    QList<QByteArray >  rawHeaderList(QNetworkProxy* theWrappedObject) const;
    void static_QNetworkProxy_setApplicationProxy(const QNetworkProxy&  proxy);
    void setCapabilities(QNetworkProxy* theWrappedObject, QNetworkProxy::Capabilities  capab);
    void setHeader(QNetworkProxy* theWrappedObject, QNetworkRequest::KnownHeaders  header, const QVariant&  value);
    void setHostName(QNetworkProxy* theWrappedObject, const QString&  hostName);
    void setPassword(QNetworkProxy* theWrappedObject, const QString&  password);
    void setPort(QNetworkProxy* theWrappedObject, unsigned short  port);
    void setRawHeader(QNetworkProxy* theWrappedObject, const QByteArray&  headerName, const QByteArray&  value);
    void setType(QNetworkProxy* theWrappedObject, QNetworkProxy::ProxyType  type);
    void setUser(QNetworkProxy* theWrappedObject, const QString&  userName);
    void swap(QNetworkProxy* theWrappedObject, QNetworkProxy&  other);
    QNetworkProxy::ProxyType  type(QNetworkProxy* theWrappedObject) const;
    QString  user(QNetworkProxy* theWrappedObject) const;
    QString py_toString(QNetworkProxy*);
};





class PythonQtShell_QNetworkProxyFactory : public QNetworkProxyFactory
{
public:
    PythonQtShell_QNetworkProxyFactory():QNetworkProxyFactory(),_wrapper(NULL) {};

   ~PythonQtShell_QNetworkProxyFactory();

virtual QList<QNetworkProxy >  queryProxy(const QNetworkProxyQuery&  query = QNetworkProxyQuery());

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtWrapper_QNetworkProxyFactory : public QObject
{ Q_OBJECT
public:
public slots:
QNetworkProxyFactory* new_QNetworkProxyFactory();
void delete_QNetworkProxyFactory(QNetworkProxyFactory* obj) { delete obj; } 
    QList<QNetworkProxy >  static_QNetworkProxyFactory_proxyForQuery(const QNetworkProxyQuery&  query);
    void static_QNetworkProxyFactory_setApplicationProxyFactory(QNetworkProxyFactory*  factory);
    void static_QNetworkProxyFactory_setUseSystemConfiguration(bool  enable);
    QList<QNetworkProxy >  static_QNetworkProxyFactory_systemProxyForQuery(const QNetworkProxyQuery&  query = QNetworkProxyQuery());
};





class PythonQtWrapper_QNetworkProxyQuery : public QObject
{ Q_OBJECT
public:
Q_ENUMS(QueryType )
enum QueryType{
  TcpSocket = QNetworkProxyQuery::TcpSocket,   UdpSocket = QNetworkProxyQuery::UdpSocket,   TcpServer = QNetworkProxyQuery::TcpServer,   UrlRequest = QNetworkProxyQuery::UrlRequest};
public slots:
QNetworkProxyQuery* new_QNetworkProxyQuery();
QNetworkProxyQuery* new_QNetworkProxyQuery(const QNetworkProxyQuery&  other);
QNetworkProxyQuery* new_QNetworkProxyQuery(const QString&  hostname, int  port, const QString&  protocolTag = QString(), QNetworkProxyQuery::QueryType  queryType = QNetworkProxyQuery::TcpSocket);
QNetworkProxyQuery* new_QNetworkProxyQuery(const QUrl&  requestUrl, QNetworkProxyQuery::QueryType  queryType = QNetworkProxyQuery::UrlRequest);
QNetworkProxyQuery* new_QNetworkProxyQuery(unsigned short  bindPort, const QString&  protocolTag = QString(), QNetworkProxyQuery::QueryType  queryType = QNetworkProxyQuery::TcpServer);
void delete_QNetworkProxyQuery(QNetworkProxyQuery* obj) { delete obj; } 
    int  localPort(QNetworkProxyQuery* theWrappedObject) const;
    bool  __ne__(QNetworkProxyQuery* theWrappedObject, const QNetworkProxyQuery&  other) const;
    bool  __eq__(QNetworkProxyQuery* theWrappedObject, const QNetworkProxyQuery&  other) const;
    QString  peerHostName(QNetworkProxyQuery* theWrappedObject) const;
    int  peerPort(QNetworkProxyQuery* theWrappedObject) const;
    QString  protocolTag(QNetworkProxyQuery* theWrappedObject) const;
    QNetworkProxyQuery::QueryType  queryType(QNetworkProxyQuery* theWrappedObject) const;
    void setLocalPort(QNetworkProxyQuery* theWrappedObject, int  port);
    void setPeerHostName(QNetworkProxyQuery* theWrappedObject, const QString&  hostname);
    void setPeerPort(QNetworkProxyQuery* theWrappedObject, int  port);
    void setProtocolTag(QNetworkProxyQuery* theWrappedObject, const QString&  protocolTag);
    void setQueryType(QNetworkProxyQuery* theWrappedObject, QNetworkProxyQuery::QueryType  type);
    void setUrl(QNetworkProxyQuery* theWrappedObject, const QUrl&  url);
    void swap(QNetworkProxyQuery* theWrappedObject, QNetworkProxyQuery&  other);
    QUrl  url(QNetworkProxyQuery* theWrappedObject) const;
};





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

   ~PythonQtShell_QNetworkReply();

virtual void abort();
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 void ignoreSslErrors();
virtual void ignoreSslErrorsImplementation(const QList<QSslError >&  arg__1);
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 setReadBufferSize(qint64  size);
virtual void setSslConfigurationImplementation(const QSslConfiguration&  arg__1);
virtual qint64  size() const;
virtual void sslConfigurationImplementation(QSslConfiguration&  arg__1) const;
virtual void timerEvent(QTimerEvent*  arg__1);
virtual bool  waitForBytesWritten(int  msecs);
virtual bool  waitForReadyRead(int  msecs);
virtual qint64  writeData(const char*  data, qint64  len);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QNetworkReply : public QNetworkReply
{ public:
inline void promoted_close() { QNetworkReply::close(); }
inline void promoted_ignoreSslErrors() { QNetworkReply::ignoreSslErrors(); }
inline void promoted_ignoreSslErrorsImplementation(const QList<QSslError >&  arg__1) { QNetworkReply::ignoreSslErrorsImplementation(arg__1); }
inline bool  promoted_isSequential() const { return QNetworkReply::isSequential(); }
inline void promoted_setReadBufferSize(qint64  size) { QNetworkReply::setReadBufferSize(size); }
inline void promoted_setSslConfigurationImplementation(const QSslConfiguration&  arg__1) { QNetworkReply::setSslConfigurationImplementation(arg__1); }
inline void promoted_sslConfigurationImplementation(QSslConfiguration&  arg__1) const { QNetworkReply::sslConfigurationImplementation(arg__1); }
inline qint64  promoted_writeData(const char*  data, qint64  len) { return QNetworkReply::writeData(data, len); }
};

class PythonQtWrapper_QNetworkReply : public QObject
{ Q_OBJECT
public:
public slots:
void delete_QNetworkReply(QNetworkReply* obj) { delete obj; } 
    QVariant  attribute(QNetworkReply* theWrappedObject, QNetworkRequest::Attribute  code) const;
    void close(QNetworkReply* theWrappedObject);
    QNetworkReply::NetworkError  error(QNetworkReply* theWrappedObject) const;
    bool  hasRawHeader(QNetworkReply* theWrappedObject, const QByteArray&  headerName) const;
    QVariant  header(QNetworkReply* theWrappedObject, QNetworkRequest::KnownHeaders  header) const;
    void ignoreSslErrors(QNetworkReply* theWrappedObject);
    void ignoreSslErrors(QNetworkReply* theWrappedObject, const QList<QSslError >&  errors);
    void ignoreSslErrorsImplementation(QNetworkReply* theWrappedObject, const QList<QSslError >&  arg__1);
    bool  isFinished(QNetworkReply* theWrappedObject) const;
    bool  isRunning(QNetworkReply* theWrappedObject) const;
    bool  isSequential(QNetworkReply* theWrappedObject) const;
    QNetworkAccessManager*  manager(QNetworkReply* theWrappedObject) const;
    QNetworkAccessManager::Operation  operation(QNetworkReply* theWrappedObject) const;
    QByteArray  rawHeader(QNetworkReply* theWrappedObject, const QByteArray&  headerName) const;
    QList<QByteArray >  rawHeaderList(QNetworkReply* theWrappedObject) const;
    const QList<QPair<QByteArray , QByteArray >  >*  rawHeaderPairs(QNetworkReply* theWrappedObject) const;
    qint64  readBufferSize(QNetworkReply* theWrappedObject) const;
    QNetworkRequest  request(QNetworkReply* theWrappedObject) const;
    void setReadBufferSize(QNetworkReply* theWrappedObject, qint64  size);
    void setSslConfiguration(QNetworkReply* theWrappedObject, const QSslConfiguration&  configuration);
    void setSslConfigurationImplementation(QNetworkReply* theWrappedObject, const QSslConfiguration&  arg__1);
    QSslConfiguration  sslConfiguration(QNetworkReply* theWrappedObject) const;
    void sslConfigurationImplementation(QNetworkReply* theWrappedObject, QSslConfiguration&  arg__1) const;
    QUrl  url(QNetworkReply* theWrappedObject) const;
    qint64  writeData(QNetworkReply* theWrappedObject, const char*  data, qint64  len);
};





class PythonQtWrapper_QNetworkRequest : public QObject
{ Q_OBJECT
public:
Q_ENUMS(CacheLoadControl Attribute Priority KnownHeaders LoadControl )
enum CacheLoadControl{
  AlwaysNetwork = QNetworkRequest::AlwaysNetwork,   PreferNetwork = QNetworkRequest::PreferNetwork,   PreferCache = QNetworkRequest::PreferCache,   AlwaysCache = QNetworkRequest::AlwaysCache};
enum Attribute{
  HttpStatusCodeAttribute = QNetworkRequest::HttpStatusCodeAttribute,   HttpReasonPhraseAttribute = QNetworkRequest::HttpReasonPhraseAttribute,   RedirectionTargetAttribute = QNetworkRequest::RedirectionTargetAttribute,   ConnectionEncryptedAttribute = QNetworkRequest::ConnectionEncryptedAttribute,   CacheLoadControlAttribute = QNetworkRequest::CacheLoadControlAttribute,   CacheSaveControlAttribute = QNetworkRequest::CacheSaveControlAttribute,   SourceIsFromCacheAttribute = QNetworkRequest::SourceIsFromCacheAttribute,   DoNotBufferUploadDataAttribute = QNetworkRequest::DoNotBufferUploadDataAttribute,   HttpPipeliningAllowedAttribute = QNetworkRequest::HttpPipeliningAllowedAttribute,   HttpPipeliningWasUsedAttribute = QNetworkRequest::HttpPipeliningWasUsedAttribute,   CustomVerbAttribute = QNetworkRequest::CustomVerbAttribute,   CookieLoadControlAttribute = QNetworkRequest::CookieLoadControlAttribute,   AuthenticationReuseAttribute = QNetworkRequest::AuthenticationReuseAttribute,   CookieSaveControlAttribute = QNetworkRequest::CookieSaveControlAttribute,   MaximumDownloadBufferSizeAttribute = QNetworkRequest::MaximumDownloadBufferSizeAttribute,   DownloadBufferAttribute = QNetworkRequest::DownloadBufferAttribute,   SynchronousRequestAttribute = QNetworkRequest::SynchronousRequestAttribute,   BackgroundRequestAttribute = QNetworkRequest::BackgroundRequestAttribute,   User = QNetworkRequest::User,   UserMax = QNetworkRequest::UserMax};
enum Priority{
  HighPriority = QNetworkRequest::HighPriority,   NormalPriority = QNetworkRequest::NormalPriority,   LowPriority = QNetworkRequest::LowPriority};
enum KnownHeaders{
  ContentTypeHeader = QNetworkRequest::ContentTypeHeader,   ContentLengthHeader = QNetworkRequest::ContentLengthHeader,   LocationHeader = QNetworkRequest::LocationHeader,   LastModifiedHeader = QNetworkRequest::LastModifiedHeader,   CookieHeader = QNetworkRequest::CookieHeader,   SetCookieHeader = QNetworkRequest::SetCookieHeader,   ContentDispositionHeader = QNetworkRequest::ContentDispositionHeader,   UserAgentHeader = QNetworkRequest::UserAgentHeader,   ServerHeader = QNetworkRequest::ServerHeader};
enum LoadControl{
  Automatic = QNetworkRequest::Automatic,   Manual = QNetworkRequest::Manual};
public slots:
QNetworkRequest* new_QNetworkRequest(const QNetworkRequest&  other);
QNetworkRequest* new_QNetworkRequest(const QUrl&  url = QUrl());
void delete_QNetworkRequest(QNetworkRequest* obj) { delete obj; } 
    QVariant  attribute(QNetworkRequest* theWrappedObject, QNetworkRequest::Attribute  code, const QVariant&  defaultValue = QVariant()) const;
    bool  hasRawHeader(QNetworkRequest* theWrappedObject, const QByteArray&  headerName) const;
    QVariant  header(QNetworkRequest* theWrappedObject, QNetworkRequest::KnownHeaders  header) const;
    bool  __ne__(QNetworkRequest* theWrappedObject, const QNetworkRequest&  other) const;
    bool  __eq__(QNetworkRequest* theWrappedObject, const QNetworkRequest&  other) const;
    QObject*  originatingObject(QNetworkRequest* theWrappedObject) const;
    QNetworkRequest::Priority  priority(QNetworkRequest* theWrappedObject) const;
    QByteArray  rawHeader(QNetworkRequest* theWrappedObject, const QByteArray&  headerName) const;
    QList<QByteArray >  rawHeaderList(QNetworkRequest* theWrappedObject) const;
    void setAttribute(QNetworkRequest* theWrappedObject, QNetworkRequest::Attribute  code, const QVariant&  value);
    void setHeader(QNetworkRequest* theWrappedObject, QNetworkRequest::KnownHeaders  header, const QVariant&  value);
    void setOriginatingObject(QNetworkRequest* theWrappedObject, QObject*  object);
    void setPriority(QNetworkRequest* theWrappedObject, QNetworkRequest::Priority  priority);
    void setRawHeader(QNetworkRequest* theWrappedObject, const QByteArray&  headerName, const QByteArray&  value);
    void setSslConfiguration(QNetworkRequest* theWrappedObject, const QSslConfiguration&  configuration);
    void setUrl(QNetworkRequest* theWrappedObject, const QUrl&  url);
    QSslConfiguration  sslConfiguration(QNetworkRequest* theWrappedObject) const;
    void swap(QNetworkRequest* theWrappedObject, QNetworkRequest&  other);
    QUrl  url(QNetworkRequest* theWrappedObject) const;
};





class PythonQtWrapper_QSsl : public QObject
{ Q_OBJECT
public:
Q_ENUMS(SslProtocol KeyAlgorithm EncodingFormat KeyType )
enum SslProtocol{
  SslV3 = QSsl::SslV3,   SslV2 = QSsl::SslV2,   TlsV1_0 = QSsl::TlsV1_0,   TlsV1_1 = QSsl::TlsV1_1,   TlsV1_2 = QSsl::TlsV1_2,   AnyProtocol = QSsl::AnyProtocol,   TlsV1SslV3 = QSsl::TlsV1SslV3,   SecureProtocols = QSsl::SecureProtocols,   UnknownProtocol = QSsl::UnknownProtocol};
enum KeyAlgorithm{
  Opaque = QSsl::Opaque,   Rsa = QSsl::Rsa,   Dsa = QSsl::Dsa};
enum EncodingFormat{
  Pem = QSsl::Pem,   Der = QSsl::Der};
enum KeyType{
  PrivateKey = QSsl::PrivateKey,   PublicKey = QSsl::PublicKey};
public slots:
};





class PythonQtWrapper_QSslCertificate : public QObject
{ Q_OBJECT
public:
Q_ENUMS(SubjectInfo )
enum SubjectInfo{
  Organization = QSslCertificate::Organization,   CommonName = QSslCertificate::CommonName,   LocalityName = QSslCertificate::LocalityName,   OrganizationalUnitName = QSslCertificate::OrganizationalUnitName,   CountryName = QSslCertificate::CountryName,   StateOrProvinceName = QSslCertificate::StateOrProvinceName,   DistinguishedNameQualifier = QSslCertificate::DistinguishedNameQualifier,   SerialNumber = QSslCertificate::SerialNumber,   EmailAddress = QSslCertificate::EmailAddress};
public slots:
QSslCertificate* new_QSslCertificate(QIODevice*  device, QSsl::EncodingFormat  format = QSsl::Pem);
QSslCertificate* new_QSslCertificate(const QByteArray&  data = QByteArray(), QSsl::EncodingFormat  format = QSsl::Pem);
QSslCertificate* new_QSslCertificate(const QSslCertificate&  other);
void delete_QSslCertificate(QSslCertificate* obj) { delete obj; } 
    void clear(QSslCertificate* theWrappedObject);
    QByteArray  digest(QSslCertificate* theWrappedObject, QCryptographicHash::Algorithm  algorithm = QCryptographicHash::Md5) const;
    QDateTime  effectiveDate(QSslCertificate* theWrappedObject) const;
    QDateTime  expiryDate(QSslCertificate* theWrappedObject) const;
    QList<QSslCertificate >  static_QSslCertificate_fromData(const QByteArray&  data, QSsl::EncodingFormat  format = QSsl::Pem);
    QList<QSslCertificate >  static_QSslCertificate_fromDevice(QIODevice*  device, QSsl::EncodingFormat  format = QSsl::Pem);
    QList<QSslCertificate >  static_QSslCertificate_fromPath(const QString&  path, QSsl::EncodingFormat  format = QSsl::Pem, QRegExp::PatternSyntax  syntax = QRegExp::FixedString);
    Qt::HANDLE  handle(QSslCertificate* theWrappedObject) const;
    bool  isBlacklisted(QSslCertificate* theWrappedObject) const;
    bool  isNull(QSslCertificate* theWrappedObject) const;
    QStringList  issuerInfo(QSslCertificate* theWrappedObject, QSslCertificate::SubjectInfo  info) const;
    QStringList  issuerInfo(QSslCertificate* theWrappedObject, const QByteArray&  attribute) const;
    QList<QByteArray >  issuerInfoAttributes(QSslCertificate* theWrappedObject) const;
    bool  __ne__(QSslCertificate* theWrappedObject, const QSslCertificate&  other) const;
    QSslCertificate*  operator_assign(QSslCertificate* theWrappedObject, const QSslCertificate&  other);
    bool  __eq__(QSslCertificate* theWrappedObject, const QSslCertificate&  other) const;
    QSslKey  publicKey(QSslCertificate* theWrappedObject) const;
    QByteArray  serialNumber(QSslCertificate* theWrappedObject) const;
    QStringList  subjectInfo(QSslCertificate* theWrappedObject, QSslCertificate::SubjectInfo  info) const;
    QStringList  subjectInfo(QSslCertificate* theWrappedObject, const QByteArray&  attribute) const;
    QList<QByteArray >  subjectInfoAttributes(QSslCertificate* theWrappedObject) const;
    void swap(QSslCertificate* theWrappedObject, QSslCertificate&  other);
    QByteArray  toDer(QSslCertificate* theWrappedObject) const;
    QByteArray  toPem(QSslCertificate* theWrappedObject) const;
    QString  toText(QSslCertificate* theWrappedObject) const;
    QList<QSslError >  static_QSslCertificate_verify(QList<QSslCertificate >  certificateChain, const QString&  hostName = QString());
    QByteArray  version(QSslCertificate* theWrappedObject) const;
    QString py_toString(QSslCertificate*);
    bool __nonzero__(QSslCertificate* obj) { return !obj->isNull(); }
};





class PythonQtWrapper_QSslCipher : public QObject
{ Q_OBJECT
public:
public slots:
QSslCipher* new_QSslCipher();
QSslCipher* new_QSslCipher(const QSslCipher&  other);
QSslCipher* new_QSslCipher(const QString&  name, QSsl::SslProtocol  protocol);
void delete_QSslCipher(QSslCipher* obj) { delete obj; } 
    QString  authenticationMethod(QSslCipher* theWrappedObject) const;
    QString  encryptionMethod(QSslCipher* theWrappedObject) const;
    bool  isNull(QSslCipher* theWrappedObject) const;
    QString  keyExchangeMethod(QSslCipher* theWrappedObject) const;
    QString  name(QSslCipher* theWrappedObject) const;
    bool  __ne__(QSslCipher* theWrappedObject, const QSslCipher&  other) const;
    QSslCipher*  operator_assign(QSslCipher* theWrappedObject, const QSslCipher&  other);
    bool  __eq__(QSslCipher* theWrappedObject, const QSslCipher&  other) const;
    QSsl::SslProtocol  protocol(QSslCipher* theWrappedObject) const;
    QString  protocolString(QSslCipher* theWrappedObject) const;
    int  supportedBits(QSslCipher* theWrappedObject) const;
    void swap(QSslCipher* theWrappedObject, QSslCipher&  other);
    int  usedBits(QSslCipher* theWrappedObject) const;
    QString py_toString(QSslCipher*);
    bool __nonzero__(QSslCipher* obj) { return !obj->isNull(); }
};





class PythonQtWrapper_QSslConfiguration : public QObject
{ Q_OBJECT
public:
public slots:
QSslConfiguration* new_QSslConfiguration();
QSslConfiguration* new_QSslConfiguration(const QSslConfiguration&  other);
void delete_QSslConfiguration(QSslConfiguration* obj) { delete obj; } 
    QList<QSslCertificate >  caCertificates(QSslConfiguration* theWrappedObject) const;
    QList<QSslCipher >  ciphers(QSslConfiguration* theWrappedObject) const;
    QSslConfiguration  static_QSslConfiguration_defaultConfiguration();
    bool  isNull(QSslConfiguration* theWrappedObject) const;
    QSslCertificate  localCertificate(QSslConfiguration* theWrappedObject) const;
    bool  __ne__(QSslConfiguration* theWrappedObject, const QSslConfiguration&  other) const;
    QSslConfiguration*  operator_assign(QSslConfiguration* theWrappedObject, const QSslConfiguration&  other);
    bool  __eq__(QSslConfiguration* theWrappedObject, const QSslConfiguration&  other) const;
    QSslCertificate  peerCertificate(QSslConfiguration* theWrappedObject) const;
    QList<QSslCertificate >  peerCertificateChain(QSslConfiguration* theWrappedObject) const;
    int  peerVerifyDepth(QSslConfiguration* theWrappedObject) const;
    QSslSocket::PeerVerifyMode  peerVerifyMode(QSslConfiguration* theWrappedObject) const;
    QSslKey  privateKey(QSslConfiguration* theWrappedObject) const;
    QSsl::SslProtocol  protocol(QSslConfiguration* theWrappedObject) const;
    QSslCipher  sessionCipher(QSslConfiguration* theWrappedObject) const;
    void setCaCertificates(QSslConfiguration* theWrappedObject, const QList<QSslCertificate >&  certificates);
    void setCiphers(QSslConfiguration* theWrappedObject, const QList<QSslCipher >&  ciphers);
    void static_QSslConfiguration_setDefaultConfiguration(const QSslConfiguration&  configuration);
    void setLocalCertificate(QSslConfiguration* theWrappedObject, const QSslCertificate&  certificate);
    void setPeerVerifyDepth(QSslConfiguration* theWrappedObject, int  depth);
    void setPeerVerifyMode(QSslConfiguration* theWrappedObject, QSslSocket::PeerVerifyMode  mode);
    void setPrivateKey(QSslConfiguration* theWrappedObject, const QSslKey&  key);
    void setProtocol(QSslConfiguration* theWrappedObject, QSsl::SslProtocol  protocol);
    void swap(QSslConfiguration* theWrappedObject, QSslConfiguration&  other);
    bool __nonzero__(QSslConfiguration* obj) { return !obj->isNull(); }
};





class PythonQtWrapper_QSslError : public QObject
{ Q_OBJECT
public:
Q_ENUMS(SslError )
enum SslError{
  NoError = QSslError::NoError,   UnableToGetIssuerCertificate = QSslError::UnableToGetIssuerCertificate,   UnableToDecryptCertificateSignature = QSslError::UnableToDecryptCertificateSignature,   UnableToDecodeIssuerPublicKey = QSslError::UnableToDecodeIssuerPublicKey,   CertificateSignatureFailed = QSslError::CertificateSignatureFailed,   CertificateNotYetValid = QSslError::CertificateNotYetValid,   CertificateExpired = QSslError::CertificateExpired,   InvalidNotBeforeField = QSslError::InvalidNotBeforeField,   InvalidNotAfterField = QSslError::InvalidNotAfterField,   SelfSignedCertificate = QSslError::SelfSignedCertificate,   SelfSignedCertificateInChain = QSslError::SelfSignedCertificateInChain,   UnableToGetLocalIssuerCertificate = QSslError::UnableToGetLocalIssuerCertificate,   UnableToVerifyFirstCertificate = QSslError::UnableToVerifyFirstCertificate,   CertificateRevoked = QSslError::CertificateRevoked,   InvalidCaCertificate = QSslError::InvalidCaCertificate,   PathLengthExceeded = QSslError::PathLengthExceeded,   InvalidPurpose = QSslError::InvalidPurpose,   CertificateUntrusted = QSslError::CertificateUntrusted,   CertificateRejected = QSslError::CertificateRejected,   SubjectIssuerMismatch = QSslError::SubjectIssuerMismatch,   AuthorityIssuerSerialNumberMismatch = QSslError::AuthorityIssuerSerialNumberMismatch,   NoPeerCertificate = QSslError::NoPeerCertificate,   HostNameMismatch = QSslError::HostNameMismatch,   NoSslSupport = QSslError::NoSslSupport,   CertificateBlacklisted = QSslError::CertificateBlacklisted,   UnspecifiedError = QSslError::UnspecifiedError};
public slots:
QSslError* new_QSslError();
QSslError* new_QSslError(QSslError::SslError  error);
QSslError* new_QSslError(QSslError::SslError  error, const QSslCertificate&  certificate);
QSslError* new_QSslError(const QSslError&  other);
void delete_QSslError(QSslError* obj) { delete obj; } 
    QSslCertificate  certificate(QSslError* theWrappedObject) const;
    QSslError::SslError  error(QSslError* theWrappedObject) const;
    QString  errorString(QSslError* theWrappedObject) const;
    bool  __ne__(QSslError* theWrappedObject, const QSslError&  other) const;
    QSslError*  operator_assign(QSslError* theWrappedObject, const QSslError&  other);
    bool  __eq__(QSslError* theWrappedObject, const QSslError&  other) const;
    void swap(QSslError* theWrappedObject, QSslError&  other);
    QString py_toString(QSslError*);
};





class PythonQtWrapper_QSslKey : public QObject
{ Q_OBJECT
public:
public slots:
QSslKey* new_QSslKey();
QSslKey* new_QSslKey(QIODevice*  device, QSsl::KeyAlgorithm  algorithm, QSsl::EncodingFormat  format = QSsl::Pem, QSsl::KeyType  type = QSsl::PrivateKey, const QByteArray&  passPhrase = QByteArray());
QSslKey* new_QSslKey(Qt::HANDLE  handle, QSsl::KeyType  type = QSsl::PrivateKey);
QSslKey* new_QSslKey(const QByteArray&  encoded, QSsl::KeyAlgorithm  algorithm, QSsl::EncodingFormat  format = QSsl::Pem, QSsl::KeyType  type = QSsl::PrivateKey, const QByteArray&  passPhrase = QByteArray());
QSslKey* new_QSslKey(const QSslKey&  other);
void delete_QSslKey(QSslKey* obj) { delete obj; } 
    QSsl::KeyAlgorithm  algorithm(QSslKey* theWrappedObject) const;
    void clear(QSslKey* theWrappedObject);
    Qt::HANDLE  handle(QSslKey* theWrappedObject) const;
    bool  isNull(QSslKey* theWrappedObject) const;
    int  length(QSslKey* theWrappedObject) const;
    bool  __ne__(QSslKey* theWrappedObject, const QSslKey&  key) const;
    QSslKey*  operator_assign(QSslKey* theWrappedObject, const QSslKey&  other);
    bool  __eq__(QSslKey* theWrappedObject, const QSslKey&  key) const;
    void swap(QSslKey* theWrappedObject, QSslKey&  other);
    QByteArray  toDer(QSslKey* theWrappedObject, const QByteArray&  passPhrase = QByteArray()) const;
    QByteArray  toPem(QSslKey* theWrappedObject, const QByteArray&  passPhrase = QByteArray()) const;
    QSsl::KeyType  type(QSslKey* theWrappedObject) const;
    QString py_toString(QSslKey*);
    bool __nonzero__(QSslKey* obj) { return !obj->isNull(); }
};





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

   ~PythonQtShell_QSslSocket();

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 connectToHost(const QString&  hostName, unsigned short  port, QIODevice::OpenMode  openMode = QIODevice::ReadWrite, QAbstractSocket::NetworkLayerProtocol  protocol = QAbstractSocket::AnyIPProtocol);
virtual void customEvent(QEvent*  arg__1);
virtual void disconnectFromHost();
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 void resume();
virtual bool  seek(qint64  pos);
virtual void setReadBufferSize(qint64  size);
virtual void setSocketOption(QAbstractSocket::SocketOption  option, const QVariant&  value);
virtual qint64  size() const;
virtual QVariant  socketOption(QAbstractSocket::SocketOption  option);
virtual void timerEvent(QTimerEvent*  arg__1);
virtual bool  waitForBytesWritten(int  msecs = 30000);
virtual bool  waitForConnected(int  msecs = 30000);
virtual bool  waitForDisconnected(int  msecs = 30000);
virtual bool  waitForReadyRead(int  msecs = 30000);
virtual qint64  writeData(const char*  data, qint64  len);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QSslSocket : public QSslSocket
{ public:
inline bool  promoted_atEnd() const { return QSslSocket::atEnd(); }
inline qint64  promoted_bytesAvailable() const { return QSslSocket::bytesAvailable(); }
inline qint64  promoted_bytesToWrite() const { return QSslSocket::bytesToWrite(); }
inline bool  promoted_canReadLine() const { return QSslSocket::canReadLine(); }
inline void promoted_close() { QSslSocket::close(); }
inline void promoted_connectToHost(const QString&  hostName, unsigned short  port, QIODevice::OpenMode  openMode = QIODevice::ReadWrite, QAbstractSocket::NetworkLayerProtocol  protocol = QAbstractSocket::AnyIPProtocol) { QSslSocket::connectToHost(hostName, port, openMode, protocol); }
inline void promoted_disconnectFromHost() { QSslSocket::disconnectFromHost(); }
inline qint64  promoted_readData(char*  data, qint64  maxlen) { return QSslSocket::readData(data, maxlen); }
inline void promoted_resume() { QSslSocket::resume(); }
inline void promoted_setReadBufferSize(qint64  size) { QSslSocket::setReadBufferSize(size); }
inline void promoted_setSocketOption(QAbstractSocket::SocketOption  option, const QVariant&  value) { QSslSocket::setSocketOption(option, value); }
inline QVariant  promoted_socketOption(QAbstractSocket::SocketOption  option) { return QSslSocket::socketOption(option); }
inline bool  promoted_waitForBytesWritten(int  msecs = 30000) { return QSslSocket::waitForBytesWritten(msecs); }
inline bool  promoted_waitForConnected(int  msecs = 30000) { return QSslSocket::waitForConnected(msecs); }
inline bool  promoted_waitForDisconnected(int  msecs = 30000) { return QSslSocket::waitForDisconnected(msecs); }
inline bool  promoted_waitForReadyRead(int  msecs = 30000) { return QSslSocket::waitForReadyRead(msecs); }
inline qint64  promoted_writeData(const char*  data, qint64  len) { return QSslSocket::writeData(data, len); }
};

class PythonQtWrapper_QSslSocket : public QObject
{ Q_OBJECT
public:
Q_ENUMS(SslMode PeerVerifyMode )
enum SslMode{
  UnencryptedMode = QSslSocket::UnencryptedMode,   SslClientMode = QSslSocket::SslClientMode,   SslServerMode = QSslSocket::SslServerMode};
enum PeerVerifyMode{
  VerifyNone = QSslSocket::VerifyNone,   QueryPeer = QSslSocket::QueryPeer,   VerifyPeer = QSslSocket::VerifyPeer,   AutoVerifyPeer = QSslSocket::AutoVerifyPeer};
public slots:
QSslSocket* new_QSslSocket(QObject*  parent = 0);
void delete_QSslSocket(QSslSocket* obj) { delete obj; } 
    void abort(QSslSocket* theWrappedObject);
    void addCaCertificate(QSslSocket* theWrappedObject, const QSslCertificate&  certificate);
    void addCaCertificates(QSslSocket* theWrappedObject, const QList<QSslCertificate >&  certificates);
    bool  addCaCertificates(QSslSocket* theWrappedObject, const QString&  path, QSsl::EncodingFormat  format = QSsl::Pem, QRegExp::PatternSyntax  syntax = QRegExp::FixedString);
    void static_QSslSocket_addDefaultCaCertificate(const QSslCertificate&  certificate);
    void static_QSslSocket_addDefaultCaCertificates(const QList<QSslCertificate >&  certificates);
    bool  static_QSslSocket_addDefaultCaCertificates(const QString&  path, QSsl::EncodingFormat  format = QSsl::Pem, QRegExp::PatternSyntax  syntax = QRegExp::FixedString);
    bool  atEnd(QSslSocket* theWrappedObject) const;
    qint64  bytesAvailable(QSslSocket* theWrappedObject) const;
    qint64  bytesToWrite(QSslSocket* theWrappedObject) const;
    QList<QSslCertificate >  caCertificates(QSslSocket* theWrappedObject) const;
    bool  canReadLine(QSslSocket* theWrappedObject) const;
    QList<QSslCipher >  ciphers(QSslSocket* theWrappedObject) const;
    void close(QSslSocket* theWrappedObject);
    void connectToHost(QSslSocket* theWrappedObject, const QString&  hostName, unsigned short  port, QIODevice::OpenMode  openMode = QIODevice::ReadWrite, QAbstractSocket::NetworkLayerProtocol  protocol = QAbstractSocket::AnyIPProtocol);
    void connectToHostEncrypted(QSslSocket* theWrappedObject, const QString&  hostName, unsigned short  port, QIODevice::OpenMode  mode = QIODevice::ReadWrite, QAbstractSocket::NetworkLayerProtocol  protocol = QAbstractSocket::AnyIPProtocol);
    void connectToHostEncrypted(QSslSocket* theWrappedObject, const QString&  hostName, unsigned short  port, const QString&  sslPeerName, QIODevice::OpenMode  mode = QIODevice::ReadWrite, QAbstractSocket::NetworkLayerProtocol  protocol = QAbstractSocket::AnyIPProtocol);
    QList<QSslCertificate >  static_QSslSocket_defaultCaCertificates();
    QList<QSslCipher >  static_QSslSocket_defaultCiphers();
    void disconnectFromHost(QSslSocket* theWrappedObject);
    qint64  encryptedBytesAvailable(QSslSocket* theWrappedObject) const;
    qint64  encryptedBytesToWrite(QSslSocket* theWrappedObject) const;
    bool  flush(QSslSocket* theWrappedObject);
    void ignoreSslErrors(QSslSocket* theWrappedObject, const QList<QSslError >&  errors);
    bool  isEncrypted(QSslSocket* theWrappedObject) const;
    QSslCertificate  localCertificate(QSslSocket* theWrappedObject) const;
    QSslSocket::SslMode  mode(QSslSocket* theWrappedObject) const;
    QSslCertificate  peerCertificate(QSslSocket* theWrappedObject) const;
    QList<QSslCertificate >  peerCertificateChain(QSslSocket* theWrappedObject) const;
    int  peerVerifyDepth(QSslSocket* theWrappedObject) const;
    QSslSocket::PeerVerifyMode  peerVerifyMode(QSslSocket* theWrappedObject) const;
    QString  peerVerifyName(QSslSocket* theWrappedObject) const;
    QSslKey  privateKey(QSslSocket* theWrappedObject) const;
    QSsl::SslProtocol  protocol(QSslSocket* theWrappedObject) const;
    qint64  readData(QSslSocket* theWrappedObject, char*  data, qint64  maxlen);
    void resume(QSslSocket* theWrappedObject);
    QSslCipher  sessionCipher(QSslSocket* theWrappedObject) const;
    void setCaCertificates(QSslSocket* theWrappedObject, const QList<QSslCertificate >&  certificates);
    void setCiphers(QSslSocket* theWrappedObject, const QList<QSslCipher >&  ciphers);
    void setCiphers(QSslSocket* theWrappedObject, const QString&  ciphers);
    void static_QSslSocket_setDefaultCaCertificates(const QList<QSslCertificate >&  certificates);
    void static_QSslSocket_setDefaultCiphers(const QList<QSslCipher >&  ciphers);
    void setLocalCertificate(QSslSocket* theWrappedObject, const QSslCertificate&  certificate);
    void setLocalCertificate(QSslSocket* theWrappedObject, const QString&  fileName, QSsl::EncodingFormat  format = QSsl::Pem);
    void setPeerVerifyDepth(QSslSocket* theWrappedObject, int  depth);
    void setPeerVerifyMode(QSslSocket* theWrappedObject, QSslSocket::PeerVerifyMode  mode);
    void setPeerVerifyName(QSslSocket* theWrappedObject, const QString&  hostName);
    void setPrivateKey(QSslSocket* theWrappedObject, const QSslKey&  key);
    void setPrivateKey(QSslSocket* theWrappedObject, const QString&  fileName, QSsl::KeyAlgorithm  algorithm = QSsl::Rsa, QSsl::EncodingFormat  format = QSsl::Pem, const QByteArray&  passPhrase = QByteArray());
    void setProtocol(QSslSocket* theWrappedObject, QSsl::SslProtocol  protocol);
    void setReadBufferSize(QSslSocket* theWrappedObject, qint64  size);
    void setSocketOption(QSslSocket* theWrappedObject, QAbstractSocket::SocketOption  option, const QVariant&  value);
    void setSslConfiguration(QSslSocket* theWrappedObject, const QSslConfiguration&  config);
    QVariant  socketOption(QSslSocket* theWrappedObject, QAbstractSocket::SocketOption  option);
    QSslConfiguration  sslConfiguration(QSslSocket* theWrappedObject) const;
    QList<QSslError >  sslErrors(QSslSocket* theWrappedObject) const;
    long  static_QSslSocket_sslLibraryVersionNumber();
    QString  static_QSslSocket_sslLibraryVersionString();
    QList<QSslCipher >  static_QSslSocket_supportedCiphers();
    bool  static_QSslSocket_supportsSsl();
    QList<QSslCertificate >  static_QSslSocket_systemCaCertificates();
    bool  waitForBytesWritten(QSslSocket* theWrappedObject, int  msecs = 30000);
    bool  waitForConnected(QSslSocket* theWrappedObject, int  msecs = 30000);
    bool  waitForDisconnected(QSslSocket* theWrappedObject, int  msecs = 30000);
    bool  waitForEncrypted(QSslSocket* theWrappedObject, int  msecs = 30000);
    bool  waitForReadyRead(QSslSocket* theWrappedObject, int  msecs = 30000);
    qint64  writeData(QSslSocket* theWrappedObject, const char*  data, qint64  len);
};





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

   ~PythonQtShell_QTcpServer();

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 bool  hasPendingConnections() const;
virtual QTcpSocket*  nextPendingConnection();
virtual void timerEvent(QTimerEvent*  arg__1);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtPublicPromoter_QTcpServer : public QTcpServer
{ public:
inline bool  promoted_hasPendingConnections() const { return QTcpServer::hasPendingConnections(); }
inline QTcpSocket*  promoted_nextPendingConnection() { return QTcpServer::nextPendingConnection(); }
};

class PythonQtWrapper_QTcpServer : public QObject
{ Q_OBJECT
public:
public slots:
QTcpServer* new_QTcpServer(QObject*  parent = 0);
void delete_QTcpServer(QTcpServer* obj) { delete obj; } 
    void close(QTcpServer* theWrappedObject);
    QString  errorString(QTcpServer* theWrappedObject) const;
    bool  hasPendingConnections(QTcpServer* theWrappedObject) const;
    bool  isListening(QTcpServer* theWrappedObject) const;
    bool  listen(QTcpServer* theWrappedObject, const QHostAddress&  address = QHostAddress::Any, unsigned short  port = 0);
    int  maxPendingConnections(QTcpServer* theWrappedObject) const;
    QTcpSocket*  nextPendingConnection(QTcpServer* theWrappedObject);
    void pauseAccepting(QTcpServer* theWrappedObject);
    QNetworkProxy  proxy(QTcpServer* theWrappedObject) const;
    void resumeAccepting(QTcpServer* theWrappedObject);
    QHostAddress  serverAddress(QTcpServer* theWrappedObject) const;
    QAbstractSocket::SocketError  serverError(QTcpServer* theWrappedObject) const;
    unsigned short  serverPort(QTcpServer* theWrappedObject) const;
    void setMaxPendingConnections(QTcpServer* theWrappedObject, int  numConnections);
    void setProxy(QTcpServer* theWrappedObject, const QNetworkProxy&  networkProxy);
    bool  waitForNewConnection(QTcpServer* theWrappedObject, int  msec = 0, bool*  timedOut = 0);
};





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

   ~PythonQtShell_QTcpSocket();

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 connectToHost(const QHostAddress&  address, unsigned short  port, QIODevice::OpenMode  mode);
virtual void connectToHost(const QString&  hostName, unsigned short  port, QIODevice::OpenMode  mode, QAbstractSocket::NetworkLayerProtocol  protocol);
virtual void customEvent(QEvent*  arg__1);
virtual void disconnectFromHost();
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 void resume();
virtual bool  seek(qint64  pos);
virtual void setReadBufferSize(qint64  size);
virtual void setSocketOption(QAbstractSocket::SocketOption  option, const QVariant&  value);
virtual qint64  size() const;
virtual QVariant  socketOption(QAbstractSocket::SocketOption  option);
virtual void timerEvent(QTimerEvent*  arg__1);
virtual bool  waitForBytesWritten(int  msecs);
virtual bool  waitForConnected(int  msecs);
virtual bool  waitForDisconnected(int  msecs);
virtual bool  waitForReadyRead(int  msecs);
virtual qint64  writeData(const char*  data, qint64  len);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtWrapper_QTcpSocket : public QObject
{ Q_OBJECT
public:
public slots:
QTcpSocket* new_QTcpSocket(QObject*  parent = 0);
void delete_QTcpSocket(QTcpSocket* obj) { delete obj; } 
};





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

   ~PythonQtShell_QUdpSocket();

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 connectToHost(const QHostAddress&  address, unsigned short  port, QIODevice::OpenMode  mode);
virtual void connectToHost(const QString&  hostName, unsigned short  port, QIODevice::OpenMode  mode, QAbstractSocket::NetworkLayerProtocol  protocol);
virtual void customEvent(QEvent*  arg__1);
virtual void disconnectFromHost();
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 void resume();
virtual bool  seek(qint64  pos);
virtual void setReadBufferSize(qint64  size);
virtual void setSocketOption(QAbstractSocket::SocketOption  option, const QVariant&  value);
virtual qint64  size() const;
virtual QVariant  socketOption(QAbstractSocket::SocketOption  option);
virtual void timerEvent(QTimerEvent*  arg__1);
virtual bool  waitForBytesWritten(int  msecs);
virtual bool  waitForConnected(int  msecs);
virtual bool  waitForDisconnected(int  msecs);
virtual bool  waitForReadyRead(int  msecs);
virtual qint64  writeData(const char*  data, qint64  len);

  PythonQtInstanceWrapper* _wrapper; 
};

class PythonQtWrapper_QUdpSocket : public QObject
{ Q_OBJECT
public:
public slots:
QUdpSocket* new_QUdpSocket(QObject*  parent = 0);
void delete_QUdpSocket(QUdpSocket* obj) { delete obj; } 
    bool  hasPendingDatagrams(QUdpSocket* theWrappedObject) const;
    bool  joinMulticastGroup(QUdpSocket* theWrappedObject, const QHostAddress&  groupAddress);
    bool  joinMulticastGroup(QUdpSocket* theWrappedObject, const QHostAddress&  groupAddress, const QNetworkInterface&  iface);
    bool  leaveMulticastGroup(QUdpSocket* theWrappedObject, const QHostAddress&  groupAddress);
    bool  leaveMulticastGroup(QUdpSocket* theWrappedObject, const QHostAddress&  groupAddress, const QNetworkInterface&  iface);
    QNetworkInterface  multicastInterface(QUdpSocket* theWrappedObject) const;
    qint64  pendingDatagramSize(QUdpSocket* theWrappedObject) const;
    qint64  readDatagram(QUdpSocket* theWrappedObject, char*  data, qint64  maxlen, QHostAddress*  host = 0, unsigned short*  port = 0);
    void setMulticastInterface(QUdpSocket* theWrappedObject, const QNetworkInterface&  iface);
    qint64  writeDatagram(QUdpSocket* theWrappedObject, const QByteArray&  datagram, const QHostAddress&  host, unsigned short  port);
};