File indexing completed on 2024-05-12 16:09:05

 class pyqtSignal():
  def connect(self, targetSignal): pass
  def emit(self, *args): pass
 from QtCore import *
 
 from QtWidgets import *
 
 import datetime
 
 class QNetworkCacheMetaData():
     """"""
     def __init__(self):
         '''void QNetworkCacheMetaData.__init__()'''
     def __init__(self, other):
         '''void QNetworkCacheMetaData.__init__(QNetworkCacheMetaData other)'''
     def swap(self, other):
         '''void QNetworkCacheMetaData.swap(QNetworkCacheMetaData other)'''
     def setAttributes(self, attributes):
         '''void QNetworkCacheMetaData.setAttributes(dict-of-QNetworkRequest.Attribute-object attributes)'''
     def attributes(self):
         '''dict-of-QNetworkRequest.Attribute-object QNetworkCacheMetaData.attributes()'''
         return {QNetworkRequest.Attribute():object()}
     def setSaveToDisk(self, allow):
         '''void QNetworkCacheMetaData.setSaveToDisk(bool allow)'''
     def saveToDisk(self):
         '''bool QNetworkCacheMetaData.saveToDisk()'''
         return bool()
     def setExpirationDate(self, dateTime):
         '''void QNetworkCacheMetaData.setExpirationDate(QDateTime dateTime)'''
     def expirationDate(self):
         '''QDateTime QNetworkCacheMetaData.expirationDate()'''
         return QDateTime()
     def setLastModified(self, dateTime):
         '''void QNetworkCacheMetaData.setLastModified(QDateTime dateTime)'''
     def lastModified(self):
         '''QDateTime QNetworkCacheMetaData.lastModified()'''
         return QDateTime()
     def setRawHeaders(self, headers):
         '''void QNetworkCacheMetaData.setRawHeaders(list-of-tuple-of-QByteArray-QByteArray headers)'''
     def rawHeaders(self):
         '''list-of-tuple-of-QByteArray-QByteArray QNetworkCacheMetaData.rawHeaders()'''
         return [tuple-of-QByteArray-QByteArray()]
     def setUrl(self, url):
         '''void QNetworkCacheMetaData.setUrl(QUrl url)'''
     def url(self):
         '''QUrl QNetworkCacheMetaData.url()'''
         return QUrl()
     def isValid(self):
         '''bool QNetworkCacheMetaData.isValid()'''
         return bool()
     def __ne__(self, other):
         '''bool QNetworkCacheMetaData.__ne__(QNetworkCacheMetaData other)'''
         return bool()
     def __eq__(self, other):
         '''bool QNetworkCacheMetaData.__eq__(QNetworkCacheMetaData other)'''
         return bool()
 
 
 class QAbstractNetworkCache(QObject):
     """"""
     def __init__(self, parent = None):
         '''void QAbstractNetworkCache.__init__(QObject parent = None)'''
     def clear(self):
         '''abstract void QAbstractNetworkCache.clear()'''
     def insert(self, device):
         '''abstract void QAbstractNetworkCache.insert(QIODevice device)'''
     def prepare(self, metaData):
         '''abstract QIODevice QAbstractNetworkCache.prepare(QNetworkCacheMetaData metaData)'''
         return QIODevice()
     def cacheSize(self):
         '''abstract int QAbstractNetworkCache.cacheSize()'''
         return int()
     def remove(self, url):
         '''abstract bool QAbstractNetworkCache.remove(QUrl url)'''
         return bool()
     def data(self, url):
         '''abstract QIODevice QAbstractNetworkCache.data(QUrl url)'''
         return QIODevice()
     def updateMetaData(self, metaData):
         '''abstract void QAbstractNetworkCache.updateMetaData(QNetworkCacheMetaData metaData)'''
     def metaData(self, url):
         '''abstract QNetworkCacheMetaData QAbstractNetworkCache.metaData(QUrl url)'''
         return QNetworkCacheMetaData()
 
 
 class QAbstractSocket(QIODevice):
     """"""
     # Enum QAbstractSocket.PauseMode
     PauseNever = 0
     PauseOnSslErrors = 0
 
     # Enum QAbstractSocket.BindFlag
     DefaultForPlatform = 0
     ShareAddress = 0
     DontShareAddress = 0
     ReuseAddressHint = 0
 
     # Enum QAbstractSocket.SocketOption
     LowDelayOption = 0
     KeepAliveOption = 0
     MulticastTtlOption = 0
     MulticastLoopbackOption = 0
     TypeOfServiceOption = 0
     SendBufferSizeSocketOption = 0
     ReceiveBufferSizeSocketOption = 0
 
     # Enum QAbstractSocket.SocketState
     UnconnectedState = 0
     HostLookupState = 0
     ConnectingState = 0
     ConnectedState = 0
     BoundState = 0
     ListeningState = 0
     ClosingState = 0
 
     # Enum QAbstractSocket.SocketError
     ConnectionRefusedError = 0
     RemoteHostClosedError = 0
     HostNotFoundError = 0
     SocketAccessError = 0
     SocketResourceError = 0
     SocketTimeoutError = 0
     DatagramTooLargeError = 0
     NetworkError = 0
     AddressInUseError = 0
     SocketAddressNotAvailableError = 0
     UnsupportedSocketOperationError = 0
     UnfinishedSocketOperationError = 0
     ProxyAuthenticationRequiredError = 0
     SslHandshakeFailedError = 0
     ProxyConnectionRefusedError = 0
     ProxyConnectionClosedError = 0
     ProxyConnectionTimeoutError = 0
     ProxyNotFoundError = 0
     ProxyProtocolError = 0
     OperationError = 0
     SslInternalError = 0
     SslInvalidUserDataError = 0
     TemporaryError = 0
     UnknownSocketError = 0
 
     # Enum QAbstractSocket.NetworkLayerProtocol
     IPv4Protocol = 0
     IPv6Protocol = 0
     AnyIPProtocol = 0
     UnknownNetworkLayerProtocol = 0
 
     # Enum QAbstractSocket.SocketType
     TcpSocket = 0
     UdpSocket = 0
     UnknownSocketType = 0
 
     def __init__(self, socketType, parent):
         '''void QAbstractSocket.__init__(QAbstractSocket.SocketType socketType, QObject parent)'''
     def bind(self, address, port = 0, mode = None):
         '''bool QAbstractSocket.bind(QHostAddress address, int port = 0, QAbstractSocket.BindMode mode = QAbstractSocket.DefaultForPlatform)'''
         return bool()
     def bind(self, port = 0, mode = None):
         '''bool QAbstractSocket.bind(int port = 0, QAbstractSocket.BindMode mode = QAbstractSocket.DefaultForPlatform)'''
         return bool()
     def setPauseMode(self, pauseMode):
         '''void QAbstractSocket.setPauseMode(QAbstractSocket.PauseModes pauseMode)'''
     def pauseMode(self):
         '''QAbstractSocket.PauseModes QAbstractSocket.pauseMode()'''
         return QAbstractSocket.PauseModes()
     def resume(self):
         '''void QAbstractSocket.resume()'''
     def socketOption(self, option):
         '''QVariant QAbstractSocket.socketOption(QAbstractSocket.SocketOption option)'''
         return QVariant()
     def setSocketOption(self, option, value):
         '''void QAbstractSocket.setSocketOption(QAbstractSocket.SocketOption option, QVariant value)'''
     def setPeerName(self, name):
         '''void QAbstractSocket.setPeerName(str name)'''
     def setPeerAddress(self, address):
         '''void QAbstractSocket.setPeerAddress(QHostAddress address)'''
     def setPeerPort(self, port):
         '''void QAbstractSocket.setPeerPort(int port)'''
     def setLocalAddress(self, address):
         '''void QAbstractSocket.setLocalAddress(QHostAddress address)'''
     def setLocalPort(self, port):
         '''void QAbstractSocket.setLocalPort(int port)'''
     def setSocketError(self, socketError):
         '''void QAbstractSocket.setSocketError(QAbstractSocket.SocketError socketError)'''
     def setSocketState(self, state):
         '''void QAbstractSocket.setSocketState(QAbstractSocket.SocketState state)'''
     def writeData(self, data):
         '''int QAbstractSocket.writeData(str data)'''
         return int()
     def readLineData(self, maxlen):
         '''str QAbstractSocket.readLineData(int maxlen)'''
         return str()
     def readData(self, maxlen):
         '''str QAbstractSocket.readData(int maxlen)'''
         return str()
     proxyAuthenticationRequired = pyqtSignal() # void proxyAuthenticationRequired(const QNetworkProxyamp;,QAuthenticator*) - signal
     stateChanged = pyqtSignal() # void stateChanged(QAbstractSocket::SocketState) - signal
     disconnected = pyqtSignal() # void disconnected() - signal
     connected = pyqtSignal() # void connected() - signal
     hostFound = pyqtSignal() # void hostFound() - signal
     def proxy(self):
         '''QNetworkProxy QAbstractSocket.proxy()'''
         return QNetworkProxy()
     def setProxy(self, networkProxy):
         '''void QAbstractSocket.setProxy(QNetworkProxy networkProxy)'''
     def waitForDisconnected(self, msecs = 30000):
         '''bool QAbstractSocket.waitForDisconnected(int msecs = 30000)'''
         return bool()
     def waitForBytesWritten(self, msecs = 30000):
         '''bool QAbstractSocket.waitForBytesWritten(int msecs = 30000)'''
         return bool()
     def waitForReadyRead(self, msecs = 30000):
         '''bool QAbstractSocket.waitForReadyRead(int msecs = 30000)'''
         return bool()
     def waitForConnected(self, msecs = 30000):
         '''bool QAbstractSocket.waitForConnected(int msecs = 30000)'''
         return bool()
     def flush(self):
         '''bool QAbstractSocket.flush()'''
         return bool()
     def atEnd(self):
         '''bool QAbstractSocket.atEnd()'''
         return bool()
     def isSequential(self):
         '''bool QAbstractSocket.isSequential()'''
         return bool()
     def close(self):
         '''void QAbstractSocket.close()'''
     def error(self):
         '''QAbstractSocket.SocketError QAbstractSocket.error()'''
         return QAbstractSocket.SocketError()
     error = pyqtSignal() # void error(QAbstractSocket::SocketError) - signal
     def state(self):
         '''QAbstractSocket.SocketState QAbstractSocket.state()'''
         return QAbstractSocket.SocketState()
     def socketType(self):
         '''QAbstractSocket.SocketType QAbstractSocket.socketType()'''
         return QAbstractSocket.SocketType()
     def socketDescriptor(self):
         '''sip.voidptr QAbstractSocket.socketDescriptor()'''
         return sip.voidptr()
     def setSocketDescriptor(self, socketDescriptor, state = None, mode = None):
         '''bool QAbstractSocket.setSocketDescriptor(sip.voidptr socketDescriptor, QAbstractSocket.SocketState state = QAbstractSocket.ConnectedState, QIODevice.OpenMode mode = QIODevice.ReadWrite)'''
         return bool()
     def abort(self):
         '''void QAbstractSocket.abort()'''
     def setReadBufferSize(self, size):
         '''void QAbstractSocket.setReadBufferSize(int size)'''
     def readBufferSize(self):
         '''int QAbstractSocket.readBufferSize()'''
         return int()
     def peerName(self):
         '''str QAbstractSocket.peerName()'''
         return str()
     def peerAddress(self):
         '''QHostAddress QAbstractSocket.peerAddress()'''
         return QHostAddress()
     def peerPort(self):
         '''int QAbstractSocket.peerPort()'''
         return int()
     def localAddress(self):
         '''QHostAddress QAbstractSocket.localAddress()'''
         return QHostAddress()
     def localPort(self):
         '''int QAbstractSocket.localPort()'''
         return int()
     def canReadLine(self):
         '''bool QAbstractSocket.canReadLine()'''
         return bool()
     def bytesToWrite(self):
         '''int QAbstractSocket.bytesToWrite()'''
         return int()
     def bytesAvailable(self):
         '''int QAbstractSocket.bytesAvailable()'''
         return int()
     def isValid(self):
         '''bool QAbstractSocket.isValid()'''
         return bool()
     def disconnectFromHost(self):
         '''void QAbstractSocket.disconnectFromHost()'''
     def connectToHost(self, hostName, port, mode = None, protocol = None):
         '''void QAbstractSocket.connectToHost(str hostName, int port, QIODevice.OpenMode mode = QIODevice.ReadWrite, QAbstractSocket.NetworkLayerProtocol protocol = QAbstractSocket.AnyIPProtocol)'''
     def connectToHost(self, address, port, mode = None):
         '''void QAbstractSocket.connectToHost(QHostAddress address, int port, QIODevice.OpenMode mode = QIODevice.ReadWrite)'''
     class BindMode():
         """"""
         def __init__(self):
             '''QAbstractSocket.BindMode QAbstractSocket.BindMode.__init__()'''
             return QAbstractSocket.BindMode()
         def __init__(self):
             '''int QAbstractSocket.BindMode.__init__()'''
             return int()
         def __init__(self):
             '''void QAbstractSocket.BindMode.__init__()'''
         def __bool__(self):
             '''int QAbstractSocket.BindMode.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool QAbstractSocket.BindMode.__ne__(QAbstractSocket.BindMode f)'''
             return bool()
         def __eq__(self, f):
             '''bool QAbstractSocket.BindMode.__eq__(QAbstractSocket.BindMode f)'''
             return bool()
         def __invert__(self):
             '''QAbstractSocket.BindMode QAbstractSocket.BindMode.__invert__()'''
             return QAbstractSocket.BindMode()
         def __and__(self, mask):
             '''QAbstractSocket.BindMode QAbstractSocket.BindMode.__and__(int mask)'''
             return QAbstractSocket.BindMode()
         def __xor__(self, f):
             '''QAbstractSocket.BindMode QAbstractSocket.BindMode.__xor__(QAbstractSocket.BindMode f)'''
             return QAbstractSocket.BindMode()
         def __xor__(self, f):
             '''QAbstractSocket.BindMode QAbstractSocket.BindMode.__xor__(int f)'''
             return QAbstractSocket.BindMode()
         def __or__(self, f):
             '''QAbstractSocket.BindMode QAbstractSocket.BindMode.__or__(QAbstractSocket.BindMode f)'''
             return QAbstractSocket.BindMode()
         def __or__(self, f):
             '''QAbstractSocket.BindMode QAbstractSocket.BindMode.__or__(int f)'''
             return QAbstractSocket.BindMode()
         def __int__(self):
             '''int QAbstractSocket.BindMode.__int__()'''
             return int()
         def __ixor__(self, f):
             '''QAbstractSocket.BindMode QAbstractSocket.BindMode.__ixor__(QAbstractSocket.BindMode f)'''
             return QAbstractSocket.BindMode()
         def __ior__(self, f):
             '''QAbstractSocket.BindMode QAbstractSocket.BindMode.__ior__(QAbstractSocket.BindMode f)'''
             return QAbstractSocket.BindMode()
         def __iand__(self, mask):
             '''QAbstractSocket.BindMode QAbstractSocket.BindMode.__iand__(int mask)'''
             return QAbstractSocket.BindMode()
     class PauseModes():
         """"""
         def __init__(self):
             '''QAbstractSocket.PauseModes QAbstractSocket.PauseModes.__init__()'''
             return QAbstractSocket.PauseModes()
         def __init__(self):
             '''int QAbstractSocket.PauseModes.__init__()'''
             return int()
         def __init__(self):
             '''void QAbstractSocket.PauseModes.__init__()'''
         def __bool__(self):
             '''int QAbstractSocket.PauseModes.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool QAbstractSocket.PauseModes.__ne__(QAbstractSocket.PauseModes f)'''
             return bool()
         def __eq__(self, f):
             '''bool QAbstractSocket.PauseModes.__eq__(QAbstractSocket.PauseModes f)'''
             return bool()
         def __invert__(self):
             '''QAbstractSocket.PauseModes QAbstractSocket.PauseModes.__invert__()'''
             return QAbstractSocket.PauseModes()
         def __and__(self, mask):
             '''QAbstractSocket.PauseModes QAbstractSocket.PauseModes.__and__(int mask)'''
             return QAbstractSocket.PauseModes()
         def __xor__(self, f):
             '''QAbstractSocket.PauseModes QAbstractSocket.PauseModes.__xor__(QAbstractSocket.PauseModes f)'''
             return QAbstractSocket.PauseModes()
         def __xor__(self, f):
             '''QAbstractSocket.PauseModes QAbstractSocket.PauseModes.__xor__(int f)'''
             return QAbstractSocket.PauseModes()
         def __or__(self, f):
             '''QAbstractSocket.PauseModes QAbstractSocket.PauseModes.__or__(QAbstractSocket.PauseModes f)'''
             return QAbstractSocket.PauseModes()
         def __or__(self, f):
             '''QAbstractSocket.PauseModes QAbstractSocket.PauseModes.__or__(int f)'''
             return QAbstractSocket.PauseModes()
         def __int__(self):
             '''int QAbstractSocket.PauseModes.__int__()'''
             return int()
         def __ixor__(self, f):
             '''QAbstractSocket.PauseModes QAbstractSocket.PauseModes.__ixor__(QAbstractSocket.PauseModes f)'''
             return QAbstractSocket.PauseModes()
         def __ior__(self, f):
             '''QAbstractSocket.PauseModes QAbstractSocket.PauseModes.__ior__(QAbstractSocket.PauseModes f)'''
             return QAbstractSocket.PauseModes()
         def __iand__(self, mask):
             '''QAbstractSocket.PauseModes QAbstractSocket.PauseModes.__iand__(int mask)'''
             return QAbstractSocket.PauseModes()
 
 
 class QAuthenticator():
     """"""
     def __init__(self):
         '''void QAuthenticator.__init__()'''
     def __init__(self, other):
         '''void QAuthenticator.__init__(QAuthenticator other)'''
     def setOption(self, opt, value):
         '''void QAuthenticator.setOption(str opt, QVariant value)'''
     def options(self):
         '''dict-of-str-object QAuthenticator.options()'''
         return {str():object()}
     def option(self, opt):
         '''QVariant QAuthenticator.option(str opt)'''
         return QVariant()
     def isNull(self):
         '''bool QAuthenticator.isNull()'''
         return bool()
     def realm(self):
         '''str QAuthenticator.realm()'''
         return str()
     def setPassword(self, password):
         '''void QAuthenticator.setPassword(str password)'''
     def password(self):
         '''str QAuthenticator.password()'''
         return str()
     def setUser(self, user):
         '''void QAuthenticator.setUser(str user)'''
     def user(self):
         '''str QAuthenticator.user()'''
         return str()
     def __ne__(self, other):
         '''bool QAuthenticator.__ne__(QAuthenticator other)'''
         return bool()
     def __eq__(self, other):
         '''bool QAuthenticator.__eq__(QAuthenticator other)'''
         return bool()
 
 
 class QDnsDomainNameRecord():
     """"""
     def __init__(self):
         '''void QDnsDomainNameRecord.__init__()'''
     def __init__(self, other):
         '''void QDnsDomainNameRecord.__init__(QDnsDomainNameRecord other)'''
     def value(self):
         '''str QDnsDomainNameRecord.value()'''
         return str()
     def timeToLive(self):
         '''int QDnsDomainNameRecord.timeToLive()'''
         return int()
     def name(self):
         '''str QDnsDomainNameRecord.name()'''
         return str()
     def swap(self, other):
         '''void QDnsDomainNameRecord.swap(QDnsDomainNameRecord other)'''
 
 
 class QDnsHostAddressRecord():
     """"""
     def __init__(self):
         '''void QDnsHostAddressRecord.__init__()'''
     def __init__(self, other):
         '''void QDnsHostAddressRecord.__init__(QDnsHostAddressRecord other)'''
     def value(self):
         '''QHostAddress QDnsHostAddressRecord.value()'''
         return QHostAddress()
     def timeToLive(self):
         '''int QDnsHostAddressRecord.timeToLive()'''
         return int()
     def name(self):
         '''str QDnsHostAddressRecord.name()'''
         return str()
     def swap(self, other):
         '''void QDnsHostAddressRecord.swap(QDnsHostAddressRecord other)'''
 
 
 class QDnsMailExchangeRecord():
     """"""
     def __init__(self):
         '''void QDnsMailExchangeRecord.__init__()'''
     def __init__(self, other):
         '''void QDnsMailExchangeRecord.__init__(QDnsMailExchangeRecord other)'''
     def timeToLive(self):
         '''int QDnsMailExchangeRecord.timeToLive()'''
         return int()
     def preference(self):
         '''int QDnsMailExchangeRecord.preference()'''
         return int()
     def name(self):
         '''str QDnsMailExchangeRecord.name()'''
         return str()
     def exchange(self):
         '''str QDnsMailExchangeRecord.exchange()'''
         return str()
     def swap(self, other):
         '''void QDnsMailExchangeRecord.swap(QDnsMailExchangeRecord other)'''
 
 
 class QDnsServiceRecord():
     """"""
     def __init__(self):
         '''void QDnsServiceRecord.__init__()'''
     def __init__(self, other):
         '''void QDnsServiceRecord.__init__(QDnsServiceRecord other)'''
     def weight(self):
         '''int QDnsServiceRecord.weight()'''
         return int()
     def timeToLive(self):
         '''int QDnsServiceRecord.timeToLive()'''
         return int()
     def target(self):
         '''str QDnsServiceRecord.target()'''
         return str()
     def priority(self):
         '''int QDnsServiceRecord.priority()'''
         return int()
     def port(self):
         '''int QDnsServiceRecord.port()'''
         return int()
     def name(self):
         '''str QDnsServiceRecord.name()'''
         return str()
     def swap(self, other):
         '''void QDnsServiceRecord.swap(QDnsServiceRecord other)'''
 
 
 class QDnsTextRecord():
     """"""
     def __init__(self):
         '''void QDnsTextRecord.__init__()'''
     def __init__(self, other):
         '''void QDnsTextRecord.__init__(QDnsTextRecord other)'''
     def values(self):
         '''list-of-QByteArray QDnsTextRecord.values()'''
         return [QByteArray()]
     def timeToLive(self):
         '''int QDnsTextRecord.timeToLive()'''
         return int()
     def name(self):
         '''str QDnsTextRecord.name()'''
         return str()
     def swap(self, other):
         '''void QDnsTextRecord.swap(QDnsTextRecord other)'''
 
 
 class QDnsLookup(QObject):
     """"""
     # Enum QDnsLookup.Type
     A = 0
     AAAA = 0
     ANY = 0
     CNAME = 0
     MX = 0
     NS = 0
     PTR = 0
     SRV = 0
     TXT = 0
 
     # Enum QDnsLookup.Error
     NoError = 0
     ResolverError = 0
     OperationCancelledError = 0
     InvalidRequestError = 0
     InvalidReplyError = 0
     ServerFailureError = 0
     ServerRefusedError = 0
     NotFoundError = 0
 
     def __init__(self, parent = None):
         '''void QDnsLookup.__init__(QObject parent = None)'''
     def __init__(self, type, name, parent = None):
         '''void QDnsLookup.__init__(QDnsLookup.Type type, str name, QObject parent = None)'''
     def __init__(self, type, name, nameserver, parent = None):
         '''void QDnsLookup.__init__(QDnsLookup.Type type, str name, QHostAddress nameserver, QObject parent = None)'''
     nameserverChanged = pyqtSignal() # void nameserverChanged(const QHostAddressamp;) - signal
     def setNameserver(self, nameserver):
         '''void QDnsLookup.setNameserver(QHostAddress nameserver)'''
     def nameserver(self):
         '''QHostAddress QDnsLookup.nameserver()'''
         return QHostAddress()
     typeChanged = pyqtSignal() # void typeChanged(QDnsLookup::Type) - signal
     nameChanged = pyqtSignal() # void nameChanged(const QStringamp;) - signal
     finished = pyqtSignal() # void finished() - signal
     def lookup(self):
         '''void QDnsLookup.lookup()'''
     def abort(self):
         '''void QDnsLookup.abort()'''
     def textRecords(self):
         '''list-of-QDnsTextRecord QDnsLookup.textRecords()'''
         return [QDnsTextRecord()]
     def serviceRecords(self):
         '''list-of-QDnsServiceRecord QDnsLookup.serviceRecords()'''
         return [QDnsServiceRecord()]
     def pointerRecords(self):
         '''list-of-QDnsDomainNameRecord QDnsLookup.pointerRecords()'''
         return [QDnsDomainNameRecord()]
     def nameServerRecords(self):
         '''list-of-QDnsDomainNameRecord QDnsLookup.nameServerRecords()'''
         return [QDnsDomainNameRecord()]
     def mailExchangeRecords(self):
         '''list-of-QDnsMailExchangeRecord QDnsLookup.mailExchangeRecords()'''
         return [QDnsMailExchangeRecord()]
     def hostAddressRecords(self):
         '''list-of-QDnsHostAddressRecord QDnsLookup.hostAddressRecords()'''
         return [QDnsHostAddressRecord()]
     def canonicalNameRecords(self):
         '''list-of-QDnsDomainNameRecord QDnsLookup.canonicalNameRecords()'''
         return [QDnsDomainNameRecord()]
     def setType(self):
         '''QDnsLookup.Type QDnsLookup.setType()'''
         return QDnsLookup.Type()
     def type(self):
         '''QDnsLookup.Type QDnsLookup.type()'''
         return QDnsLookup.Type()
     def setName(self, name):
         '''void QDnsLookup.setName(str name)'''
     def name(self):
         '''str QDnsLookup.name()'''
         return str()
     def isFinished(self):
         '''bool QDnsLookup.isFinished()'''
         return bool()
     def errorString(self):
         '''str QDnsLookup.errorString()'''
         return str()
     def error(self):
         '''QDnsLookup.Error QDnsLookup.error()'''
         return QDnsLookup.Error()
 
 
 class QHostAddress():
     """"""
     # Enum QHostAddress.SpecialAddress
     Null = 0
     Broadcast = 0
     LocalHost = 0
     LocalHostIPv6 = 0
     AnyIPv4 = 0
     AnyIPv6 = 0
     Any = 0
 
     def __init__(self):
         '''void QHostAddress.__init__()'''
     def __init__(self, address):
         '''void QHostAddress.__init__(QHostAddress.SpecialAddress address)'''
     def __init__(self, ip4Addr):
         '''void QHostAddress.__init__(int ip4Addr)'''
     def __init__(self, address):
         '''void QHostAddress.__init__(str address)'''
     def __init__(self, ip6Addr):
         '''void QHostAddress.__init__(16-tuple-of-int ip6Addr)'''
     def __init__(self, copy):
         '''void QHostAddress.__init__(QHostAddress copy)'''
     def parseSubnet(self, subnet):
         '''static tuple-of-QHostAddress-int QHostAddress.parseSubnet(str subnet)'''
         return tuple-of-QHostAddress-int()
     def isLoopback(self):
         '''bool QHostAddress.isLoopback()'''
         return bool()
     def isInSubnet(self, subnet, netmask):
         '''bool QHostAddress.isInSubnet(QHostAddress subnet, int netmask)'''
         return bool()
     def isInSubnet(self, subnet):
         '''bool QHostAddress.isInSubnet(tuple-of-QHostAddress-int subnet)'''
         return bool()
     def __hash__(self):
         '''int QHostAddress.__hash__()'''
         return int()
     def clear(self):
         '''void QHostAddress.clear()'''
     def isNull(self):
         '''bool QHostAddress.isNull()'''
         return bool()
     def __ne__(self, address):
         '''bool QHostAddress.__ne__(QHostAddress address)'''
         return bool()
     def __ne__(self, address):
         '''bool QHostAddress.__ne__(QHostAddress.SpecialAddress address)'''
         return bool()
     def __eq__(self, address):
         '''bool QHostAddress.__eq__(QHostAddress address)'''
         return bool()
     def __eq__(self, address):
         '''bool QHostAddress.__eq__(QHostAddress.SpecialAddress address)'''
         return bool()
     def setScopeId(self, id):
         '''void QHostAddress.setScopeId(str id)'''
     def scopeId(self):
         '''str QHostAddress.scopeId()'''
         return str()
     def toString(self):
         '''str QHostAddress.toString()'''
         return str()
     def toIPv6Address(self):
         '''16-tuple-of-int QHostAddress.toIPv6Address()'''
         return 16-tuple-of-int()
     def toIPv4Address(self):
         '''int QHostAddress.toIPv4Address()'''
         return int()
     def protocol(self):
         '''QAbstractSocket.NetworkLayerProtocol QHostAddress.protocol()'''
         return QAbstractSocket.NetworkLayerProtocol()
     def setAddress(self, ip4Addr):
         '''void QHostAddress.setAddress(int ip4Addr)'''
     def setAddress(self, address):
         '''bool QHostAddress.setAddress(str address)'''
         return bool()
     def setAddress(self, ip6Addr):
         '''void QHostAddress.setAddress(16-tuple-of-int ip6Addr)'''
 
 
 class QHostInfo():
     """"""
     # Enum QHostInfo.HostInfoError
     NoError = 0
     HostNotFound = 0
     UnknownError = 0
 
     def __init__(self, id = None):
         '''void QHostInfo.__init__(int id = -1)'''
     def __init__(self, d):
         '''void QHostInfo.__init__(QHostInfo d)'''
     def localDomainName(self):
         '''static str QHostInfo.localDomainName()'''
         return str()
     def localHostName(self):
         '''static str QHostInfo.localHostName()'''
         return str()
     def fromName(self, name):
         '''static QHostInfo QHostInfo.fromName(str name)'''
         return QHostInfo()
     def abortHostLookup(self, lookupId):
         '''static void QHostInfo.abortHostLookup(int lookupId)'''
     def lookupHost(self, name, slot):
         '''static int QHostInfo.lookupHost(str name, callable-or-signal slot)'''
         return int()
     def lookupId(self):
         '''int QHostInfo.lookupId()'''
         return int()
     def setLookupId(self, id):
         '''void QHostInfo.setLookupId(int id)'''
     def setErrorString(self, errorString):
         '''void QHostInfo.setErrorString(str errorString)'''
     def errorString(self):
         '''str QHostInfo.errorString()'''
         return str()
     def setError(self, error):
         '''void QHostInfo.setError(QHostInfo.HostInfoError error)'''
     def error(self):
         '''QHostInfo.HostInfoError QHostInfo.error()'''
         return QHostInfo.HostInfoError()
     def setAddresses(self, addresses):
         '''void QHostInfo.setAddresses(list-of-QHostAddress addresses)'''
     def addresses(self):
         '''list-of-QHostAddress QHostInfo.addresses()'''
         return [QHostAddress()]
     def setHostName(self, name):
         '''void QHostInfo.setHostName(str name)'''
     def hostName(self):
         '''str QHostInfo.hostName()'''
         return str()
 
 
 class QHttpPart():
     """"""
     def __init__(self):
         '''void QHttpPart.__init__()'''
     def __init__(self, other):
         '''void QHttpPart.__init__(QHttpPart other)'''
     def swap(self, other):
         '''void QHttpPart.swap(QHttpPart other)'''
     def setBodyDevice(self, device):
         '''void QHttpPart.setBodyDevice(QIODevice device)'''
     def setBody(self, body):
         '''void QHttpPart.setBody(QByteArray body)'''
     def setRawHeader(self, headerName, headerValue):
         '''void QHttpPart.setRawHeader(QByteArray headerName, QByteArray headerValue)'''
     def setHeader(self, header, value):
         '''void QHttpPart.setHeader(QNetworkRequest.KnownHeaders header, QVariant value)'''
     def __ne__(self, other):
         '''bool QHttpPart.__ne__(QHttpPart other)'''
         return bool()
     def __eq__(self, other):
         '''bool QHttpPart.__eq__(QHttpPart other)'''
         return bool()
 
 
 class QHttpMultiPart(QObject):
     """"""
     # Enum QHttpMultiPart.ContentType
     MixedType = 0
     RelatedType = 0
     FormDataType = 0
     AlternativeType = 0
 
     def __init__(self, parent = None):
         '''void QHttpMultiPart.__init__(QObject parent = None)'''
     def __init__(self, contentType, parent = None):
         '''void QHttpMultiPart.__init__(QHttpMultiPart.ContentType contentType, QObject parent = None)'''
     def setBoundary(self, boundary):
         '''void QHttpMultiPart.setBoundary(QByteArray boundary)'''
     def boundary(self):
         '''QByteArray QHttpMultiPart.boundary()'''
         return QByteArray()
     def setContentType(self, contentType):
         '''void QHttpMultiPart.setContentType(QHttpMultiPart.ContentType contentType)'''
     def append(self, httpPart):
         '''void QHttpMultiPart.append(QHttpPart httpPart)'''
 
 
 class QLocalServer(QObject):
     """"""
     # Enum QLocalServer.SocketOption
     UserAccessOption = 0
     GroupAccessOption = 0
     OtherAccessOption = 0
     WorldAccessOption = 0
 
     def __init__(self, parent = None):
         '''void QLocalServer.__init__(QObject parent = None)'''
     def socketOptions(self):
         '''QLocalServer.SocketOptions QLocalServer.socketOptions()'''
         return QLocalServer.SocketOptions()
     def setSocketOptions(self, options):
         '''void QLocalServer.setSocketOptions(QLocalServer.SocketOptions options)'''
     def incomingConnection(self, socketDescriptor):
         '''void QLocalServer.incomingConnection(sip.voidptr socketDescriptor)'''
     newConnection = pyqtSignal() # void newConnection() - signal
     def removeServer(self, name):
         '''static bool QLocalServer.removeServer(str name)'''
         return bool()
     def waitForNewConnection(self, msecs = 0, timedOut = None):
         '''bool QLocalServer.waitForNewConnection(int msecs = 0, bool timedOut)'''
         return bool()
     def setMaxPendingConnections(self, numConnections):
         '''void QLocalServer.setMaxPendingConnections(int numConnections)'''
     def serverError(self):
         '''QAbstractSocket.SocketError QLocalServer.serverError()'''
         return QAbstractSocket.SocketError()
     def fullServerName(self):
         '''str QLocalServer.fullServerName()'''
         return str()
     def serverName(self):
         '''str QLocalServer.serverName()'''
         return str()
     def nextPendingConnection(self):
         '''QLocalSocket QLocalServer.nextPendingConnection()'''
         return QLocalSocket()
     def maxPendingConnections(self):
         '''int QLocalServer.maxPendingConnections()'''
         return int()
     def listen(self, name):
         '''bool QLocalServer.listen(str name)'''
         return bool()
     def listen(self, socketDescriptor):
         '''bool QLocalServer.listen(sip.voidptr socketDescriptor)'''
         return bool()
     def isListening(self):
         '''bool QLocalServer.isListening()'''
         return bool()
     def hasPendingConnections(self):
         '''bool QLocalServer.hasPendingConnections()'''
         return bool()
     def errorString(self):
         '''str QLocalServer.errorString()'''
         return str()
     def close(self):
         '''void QLocalServer.close()'''
     class SocketOptions():
         """"""
         def __init__(self):
             '''QLocalServer.SocketOptions QLocalServer.SocketOptions.__init__()'''
             return QLocalServer.SocketOptions()
         def __init__(self):
             '''int QLocalServer.SocketOptions.__init__()'''
             return int()
         def __init__(self):
             '''void QLocalServer.SocketOptions.__init__()'''
         def __bool__(self):
             '''int QLocalServer.SocketOptions.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool QLocalServer.SocketOptions.__ne__(QLocalServer.SocketOptions f)'''
             return bool()
         def __eq__(self, f):
             '''bool QLocalServer.SocketOptions.__eq__(QLocalServer.SocketOptions f)'''
             return bool()
         def __invert__(self):
             '''QLocalServer.SocketOptions QLocalServer.SocketOptions.__invert__()'''
             return QLocalServer.SocketOptions()
         def __and__(self, mask):
             '''QLocalServer.SocketOptions QLocalServer.SocketOptions.__and__(int mask)'''
             return QLocalServer.SocketOptions()
         def __xor__(self, f):
             '''QLocalServer.SocketOptions QLocalServer.SocketOptions.__xor__(QLocalServer.SocketOptions f)'''
             return QLocalServer.SocketOptions()
         def __xor__(self, f):
             '''QLocalServer.SocketOptions QLocalServer.SocketOptions.__xor__(int f)'''
             return QLocalServer.SocketOptions()
         def __or__(self, f):
             '''QLocalServer.SocketOptions QLocalServer.SocketOptions.__or__(QLocalServer.SocketOptions f)'''
             return QLocalServer.SocketOptions()
         def __or__(self, f):
             '''QLocalServer.SocketOptions QLocalServer.SocketOptions.__or__(int f)'''
             return QLocalServer.SocketOptions()
         def __int__(self):
             '''int QLocalServer.SocketOptions.__int__()'''
             return int()
         def __ixor__(self, f):
             '''QLocalServer.SocketOptions QLocalServer.SocketOptions.__ixor__(QLocalServer.SocketOptions f)'''
             return QLocalServer.SocketOptions()
         def __ior__(self, f):
             '''QLocalServer.SocketOptions QLocalServer.SocketOptions.__ior__(QLocalServer.SocketOptions f)'''
             return QLocalServer.SocketOptions()
         def __iand__(self, mask):
             '''QLocalServer.SocketOptions QLocalServer.SocketOptions.__iand__(int mask)'''
             return QLocalServer.SocketOptions()
 
 
 class QLocalSocket(QIODevice):
     """"""
     # Enum QLocalSocket.LocalSocketState
     UnconnectedState = 0
     ConnectingState = 0
     ConnectedState = 0
     ClosingState = 0
 
     # Enum QLocalSocket.LocalSocketError
     ConnectionRefusedError = 0
     PeerClosedError = 0
     ServerNotFoundError = 0
     SocketAccessError = 0
     SocketResourceError = 0
     SocketTimeoutError = 0
     DatagramTooLargeError = 0
     ConnectionError = 0
     UnsupportedSocketOperationError = 0
     OperationError = 0
     UnknownSocketError = 0
 
     def __init__(self, parent = None):
         '''void QLocalSocket.__init__(QObject parent = None)'''
     def writeData(self):
         '''str QLocalSocket.writeData()'''
         return str()
     def readData(self, maxlen):
         '''str QLocalSocket.readData(int maxlen)'''
         return str()
     stateChanged = pyqtSignal() # void stateChanged(QLocalSocket::LocalSocketState) - signal
     disconnected = pyqtSignal() # void disconnected() - signal
     connected = pyqtSignal() # void connected() - signal
     def waitForReadyRead(self, msecs = 30000):
         '''bool QLocalSocket.waitForReadyRead(int msecs = 30000)'''
         return bool()
     def waitForDisconnected(self, msecs = 30000):
         '''bool QLocalSocket.waitForDisconnected(int msecs = 30000)'''
         return bool()
     def waitForConnected(self, msecs = 30000):
         '''bool QLocalSocket.waitForConnected(int msecs = 30000)'''
         return bool()
     def waitForBytesWritten(self, msecs = 30000):
         '''bool QLocalSocket.waitForBytesWritten(int msecs = 30000)'''
         return bool()
     def state(self):
         '''QLocalSocket.LocalSocketState QLocalSocket.state()'''
         return QLocalSocket.LocalSocketState()
     def socketDescriptor(self):
         '''sip.voidptr QLocalSocket.socketDescriptor()'''
         return sip.voidptr()
     def setSocketDescriptor(self, socketDescriptor, state = None, mode = None):
         '''bool QLocalSocket.setSocketDescriptor(sip.voidptr socketDescriptor, QLocalSocket.LocalSocketState state = QLocalSocket.ConnectedState, QIODevice.OpenMode mode = QIODevice.ReadWrite)'''
         return bool()
     def setReadBufferSize(self, size):
         '''void QLocalSocket.setReadBufferSize(int size)'''
     def readBufferSize(self):
         '''int QLocalSocket.readBufferSize()'''
         return int()
     def isValid(self):
         '''bool QLocalSocket.isValid()'''
         return bool()
     def flush(self):
         '''bool QLocalSocket.flush()'''
         return bool()
     def error(self):
         '''QLocalSocket.LocalSocketError QLocalSocket.error()'''
         return QLocalSocket.LocalSocketError()
     error = pyqtSignal() # void error(QLocalSocket::LocalSocketError) - signal
     def close(self):
         '''void QLocalSocket.close()'''
     def canReadLine(self):
         '''bool QLocalSocket.canReadLine()'''
         return bool()
     def bytesToWrite(self):
         '''int QLocalSocket.bytesToWrite()'''
         return int()
     def bytesAvailable(self):
         '''int QLocalSocket.bytesAvailable()'''
         return int()
     def isSequential(self):
         '''bool QLocalSocket.isSequential()'''
         return bool()
     def abort(self):
         '''void QLocalSocket.abort()'''
     def fullServerName(self):
         '''str QLocalSocket.fullServerName()'''
         return str()
     def setServerName(self, name):
         '''void QLocalSocket.setServerName(str name)'''
     def serverName(self):
         '''str QLocalSocket.serverName()'''
         return str()
     def open(self, mode = None):
         '''bool QLocalSocket.open(QIODevice.OpenMode mode = QIODevice.ReadWrite)'''
         return bool()
     def disconnectFromServer(self):
         '''void QLocalSocket.disconnectFromServer()'''
     def connectToServer(self, name, mode = None):
         '''void QLocalSocket.connectToServer(str name, QIODevice.OpenMode mode = QIODevice.ReadWrite)'''
     def connectToServer(self, mode = None):
         '''void QLocalSocket.connectToServer(QIODevice.OpenMode mode = QIODevice.ReadWrite)'''
 
 
 class QNetworkAccessManager(QObject):
     """"""
     # Enum QNetworkAccessManager.NetworkAccessibility
     UnknownAccessibility = 0
     NotAccessible = 0
     Accessible = 0
 
     # Enum QNetworkAccessManager.Operation
     HeadOperation = 0
     GetOperation = 0
     PutOperation = 0
     PostOperation = 0
     DeleteOperation = 0
     CustomOperation = 0
 
     def __init__(self, parent = None):
         '''void QNetworkAccessManager.__init__(QObject parent = None)'''
     def supportedSchemesImplementation(self):
         '''list-of-str QNetworkAccessManager.supportedSchemesImplementation()'''
         return [str()]
     def connectToHost(self, hostName, port = 80):
         '''void QNetworkAccessManager.connectToHost(str hostName, int port = 80)'''
     def connectToHostEncrypted(self, hostName, port = 443, sslConfiguration = None):
         '''void QNetworkAccessManager.connectToHostEncrypted(str hostName, int port = 443, QSslConfiguration sslConfiguration = QSslConfiguration.defaultConfiguration())'''
     def supportedSchemes(self):
         '''list-of-str QNetworkAccessManager.supportedSchemes()'''
         return [str()]
     def clearAccessCache(self):
         '''void QNetworkAccessManager.clearAccessCache()'''
     def networkAccessible(self):
         '''QNetworkAccessManager.NetworkAccessibility QNetworkAccessManager.networkAccessible()'''
         return QNetworkAccessManager.NetworkAccessibility()
     def setNetworkAccessible(self, accessible):
         '''void QNetworkAccessManager.setNetworkAccessible(QNetworkAccessManager.NetworkAccessibility accessible)'''
     def activeConfiguration(self):
         '''QNetworkConfiguration QNetworkAccessManager.activeConfiguration()'''
         return QNetworkConfiguration()
     def configuration(self):
         '''QNetworkConfiguration QNetworkAccessManager.configuration()'''
         return QNetworkConfiguration()
     def setConfiguration(self, config):
         '''void QNetworkAccessManager.setConfiguration(QNetworkConfiguration config)'''
     def sendCustomRequest(self, request, verb, data = None):
         '''QNetworkReply QNetworkAccessManager.sendCustomRequest(QNetworkRequest request, QByteArray verb, QIODevice data = None)'''
         return QNetworkReply()
     def deleteResource(self, request):
         '''QNetworkReply QNetworkAccessManager.deleteResource(QNetworkRequest request)'''
         return QNetworkReply()
     def setCache(self, cache):
         '''void QNetworkAccessManager.setCache(QAbstractNetworkCache cache)'''
     def cache(self):
         '''QAbstractNetworkCache QNetworkAccessManager.cache()'''
         return QAbstractNetworkCache()
     def setProxyFactory(self, factory):
         '''void QNetworkAccessManager.setProxyFactory(QNetworkProxyFactory factory)'''
     def proxyFactory(self):
         '''QNetworkProxyFactory QNetworkAccessManager.proxyFactory()'''
         return QNetworkProxyFactory()
     def createRequest(self, op, request, device = None):
         '''QNetworkReply QNetworkAccessManager.createRequest(QNetworkAccessManager.Operation op, QNetworkRequest request, QIODevice device = None)'''
         return QNetworkReply()
     preSharedKeyAuthenticationRequired = pyqtSignal() # void preSharedKeyAuthenticationRequired(QNetworkReply*,QSslPreSharedKeyAuthenticator*) - signal
     networkAccessibleChanged = pyqtSignal() # void networkAccessibleChanged(QNetworkAccessManager::NetworkAccessibility) - signal
     sslErrors = pyqtSignal() # void sslErrors(QNetworkReply*,const QListlt;QSslErrorgt;amp;) - signal
     encrypted = pyqtSignal() # void encrypted(QNetworkReply*) - signal
     finished = pyqtSignal() # void finished(QNetworkReply*) - signal
     authenticationRequired = pyqtSignal() # void authenticationRequired(QNetworkReply*,QAuthenticator*) - signal
     proxyAuthenticationRequired = pyqtSignal() # void proxyAuthenticationRequired(const QNetworkProxyamp;,QAuthenticator*) - signal
     def put(self, request, data):
         '''QNetworkReply QNetworkAccessManager.put(QNetworkRequest request, QIODevice data)'''
         return QNetworkReply()
     def put(self, request, data):
         '''QNetworkReply QNetworkAccessManager.put(QNetworkRequest request, QByteArray data)'''
         return QNetworkReply()
     def put(self, request, multiPart):
         '''QNetworkReply QNetworkAccessManager.put(QNetworkRequest request, QHttpMultiPart multiPart)'''
         return QNetworkReply()
     def post(self, request, data):
         '''QNetworkReply QNetworkAccessManager.post(QNetworkRequest request, QIODevice data)'''
         return QNetworkReply()
     def post(self, request, data):
         '''QNetworkReply QNetworkAccessManager.post(QNetworkRequest request, QByteArray data)'''
         return QNetworkReply()
     def post(self, request, multiPart):
         '''QNetworkReply QNetworkAccessManager.post(QNetworkRequest request, QHttpMultiPart multiPart)'''
         return QNetworkReply()
     def get(self, request):
         '''QNetworkReply QNetworkAccessManager.get(QNetworkRequest request)'''
         return QNetworkReply()
     def head(self, request):
         '''QNetworkReply QNetworkAccessManager.head(QNetworkRequest request)'''
         return QNetworkReply()
     def setCookieJar(self, cookieJar):
         '''void QNetworkAccessManager.setCookieJar(QNetworkCookieJar cookieJar)'''
     def cookieJar(self):
         '''QNetworkCookieJar QNetworkAccessManager.cookieJar()'''
         return QNetworkCookieJar()
     def setProxy(self, proxy):
         '''void QNetworkAccessManager.setProxy(QNetworkProxy proxy)'''
     def proxy(self):
         '''QNetworkProxy QNetworkAccessManager.proxy()'''
         return QNetworkProxy()
 
 
 class QNetworkConfigurationManager(QObject):
     """"""
     # Enum QNetworkConfigurationManager.Capability
     CanStartAndStopInterfaces = 0
     DirectConnectionRouting = 0
     SystemSessionSupport = 0
     ApplicationLevelRoaming = 0
     ForcedRoaming = 0
     DataStatistics = 0
     NetworkSessionRequired = 0
 
     def __init__(self, parent = None):
         '''void QNetworkConfigurationManager.__init__(QObject parent = None)'''
     updateCompleted = pyqtSignal() # void updateCompleted() - signal
     onlineStateChanged = pyqtSignal() # void onlineStateChanged(bool) - signal
     configurationChanged = pyqtSignal() # void configurationChanged(const QNetworkConfigurationamp;) - signal
     configurationRemoved = pyqtSignal() # void configurationRemoved(const QNetworkConfigurationamp;) - signal
     configurationAdded = pyqtSignal() # void configurationAdded(const QNetworkConfigurationamp;) - signal
     def isOnline(self):
         '''bool QNetworkConfigurationManager.isOnline()'''
         return bool()
     def updateConfigurations(self):
         '''void QNetworkConfigurationManager.updateConfigurations()'''
     def configurationFromIdentifier(self, identifier):
         '''QNetworkConfiguration QNetworkConfigurationManager.configurationFromIdentifier(str identifier)'''
         return QNetworkConfiguration()
     def allConfigurations(self, flags = 0):
         '''list-of-QNetworkConfiguration QNetworkConfigurationManager.allConfigurations(QNetworkConfiguration.StateFlags flags = 0)'''
         return [QNetworkConfiguration()]
     def defaultConfiguration(self):
         '''QNetworkConfiguration QNetworkConfigurationManager.defaultConfiguration()'''
         return QNetworkConfiguration()
     def capabilities(self):
         '''QNetworkConfigurationManager.Capabilities QNetworkConfigurationManager.capabilities()'''
         return QNetworkConfigurationManager.Capabilities()
     class Capabilities():
         """"""
         def __init__(self):
             '''QNetworkConfigurationManager.Capabilities QNetworkConfigurationManager.Capabilities.__init__()'''
             return QNetworkConfigurationManager.Capabilities()
         def __init__(self):
             '''int QNetworkConfigurationManager.Capabilities.__init__()'''
             return int()
         def __init__(self):
             '''void QNetworkConfigurationManager.Capabilities.__init__()'''
         def __bool__(self):
             '''int QNetworkConfigurationManager.Capabilities.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool QNetworkConfigurationManager.Capabilities.__ne__(QNetworkConfigurationManager.Capabilities f)'''
             return bool()
         def __eq__(self, f):
             '''bool QNetworkConfigurationManager.Capabilities.__eq__(QNetworkConfigurationManager.Capabilities f)'''
             return bool()
         def __invert__(self):
             '''QNetworkConfigurationManager.Capabilities QNetworkConfigurationManager.Capabilities.__invert__()'''
             return QNetworkConfigurationManager.Capabilities()
         def __and__(self, mask):
             '''QNetworkConfigurationManager.Capabilities QNetworkConfigurationManager.Capabilities.__and__(int mask)'''
             return QNetworkConfigurationManager.Capabilities()
         def __xor__(self, f):
             '''QNetworkConfigurationManager.Capabilities QNetworkConfigurationManager.Capabilities.__xor__(QNetworkConfigurationManager.Capabilities f)'''
             return QNetworkConfigurationManager.Capabilities()
         def __xor__(self, f):
             '''QNetworkConfigurationManager.Capabilities QNetworkConfigurationManager.Capabilities.__xor__(int f)'''
             return QNetworkConfigurationManager.Capabilities()
         def __or__(self, f):
             '''QNetworkConfigurationManager.Capabilities QNetworkConfigurationManager.Capabilities.__or__(QNetworkConfigurationManager.Capabilities f)'''
             return QNetworkConfigurationManager.Capabilities()
         def __or__(self, f):
             '''QNetworkConfigurationManager.Capabilities QNetworkConfigurationManager.Capabilities.__or__(int f)'''
             return QNetworkConfigurationManager.Capabilities()
         def __int__(self):
             '''int QNetworkConfigurationManager.Capabilities.__int__()'''
             return int()
         def __ixor__(self, f):
             '''QNetworkConfigurationManager.Capabilities QNetworkConfigurationManager.Capabilities.__ixor__(QNetworkConfigurationManager.Capabilities f)'''
             return QNetworkConfigurationManager.Capabilities()
         def __ior__(self, f):
             '''QNetworkConfigurationManager.Capabilities QNetworkConfigurationManager.Capabilities.__ior__(QNetworkConfigurationManager.Capabilities f)'''
             return QNetworkConfigurationManager.Capabilities()
         def __iand__(self, mask):
             '''QNetworkConfigurationManager.Capabilities QNetworkConfigurationManager.Capabilities.__iand__(int mask)'''
             return QNetworkConfigurationManager.Capabilities()
 
 
 class QNetworkConfiguration():
     """"""
     # Enum QNetworkConfiguration.BearerType
     BearerUnknown = 0
     BearerEthernet = 0
     BearerWLAN = 0
     Bearer2G = 0
     BearerCDMA2000 = 0
     BearerWCDMA = 0
     BearerHSPA = 0
     BearerBluetooth = 0
     BearerWiMAX = 0
     BearerEVDO = 0
     BearerLTE = 0
     Bearer3G = 0
     Bearer4G = 0
 
     # Enum QNetworkConfiguration.StateFlag
     Undefined = 0
     Defined = 0
     Discovered = 0
     Active = 0
 
     # Enum QNetworkConfiguration.Purpose
     UnknownPurpose = 0
     PublicPurpose = 0
     PrivatePurpose = 0
     ServiceSpecificPurpose = 0
 
     # Enum QNetworkConfiguration.Type
     InternetAccessPoint = 0
     ServiceNetwork = 0
     UserChoice = 0
     Invalid = 0
 
     def __init__(self):
         '''void QNetworkConfiguration.__init__()'''
     def __init__(self, other):
         '''void QNetworkConfiguration.__init__(QNetworkConfiguration other)'''
     def swap(self, other):
         '''void QNetworkConfiguration.swap(QNetworkConfiguration other)'''
     def isValid(self):
         '''bool QNetworkConfiguration.isValid()'''
         return bool()
     def name(self):
         '''str QNetworkConfiguration.name()'''
         return str()
     def children(self):
         '''list-of-QNetworkConfiguration QNetworkConfiguration.children()'''
         return [QNetworkConfiguration()]
     def isRoamingAvailable(self):
         '''bool QNetworkConfiguration.isRoamingAvailable()'''
         return bool()
     def identifier(self):
         '''str QNetworkConfiguration.identifier()'''
         return str()
     def bearerTypeFamily(self):
         '''QNetworkConfiguration.BearerType QNetworkConfiguration.bearerTypeFamily()'''
         return QNetworkConfiguration.BearerType()
     def bearerTypeName(self):
         '''str QNetworkConfiguration.bearerTypeName()'''
         return str()
     def bearerType(self):
         '''QNetworkConfiguration.BearerType QNetworkConfiguration.bearerType()'''
         return QNetworkConfiguration.BearerType()
     def purpose(self):
         '''QNetworkConfiguration.Purpose QNetworkConfiguration.purpose()'''
         return QNetworkConfiguration.Purpose()
     def type(self):
         '''QNetworkConfiguration.Type QNetworkConfiguration.type()'''
         return QNetworkConfiguration.Type()
     def state(self):
         '''QNetworkConfiguration.StateFlags QNetworkConfiguration.state()'''
         return QNetworkConfiguration.StateFlags()
     def __ne__(self, cp):
         '''bool QNetworkConfiguration.__ne__(QNetworkConfiguration cp)'''
         return bool()
     def __eq__(self, cp):
         '''bool QNetworkConfiguration.__eq__(QNetworkConfiguration cp)'''
         return bool()
     class StateFlags():
         """"""
         def __init__(self):
             '''QNetworkConfiguration.StateFlags QNetworkConfiguration.StateFlags.__init__()'''
             return QNetworkConfiguration.StateFlags()
         def __init__(self):
             '''int QNetworkConfiguration.StateFlags.__init__()'''
             return int()
         def __init__(self):
             '''void QNetworkConfiguration.StateFlags.__init__()'''
         def __bool__(self):
             '''int QNetworkConfiguration.StateFlags.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool QNetworkConfiguration.StateFlags.__ne__(QNetworkConfiguration.StateFlags f)'''
             return bool()
         def __eq__(self, f):
             '''bool QNetworkConfiguration.StateFlags.__eq__(QNetworkConfiguration.StateFlags f)'''
             return bool()
         def __invert__(self):
             '''QNetworkConfiguration.StateFlags QNetworkConfiguration.StateFlags.__invert__()'''
             return QNetworkConfiguration.StateFlags()
         def __and__(self, mask):
             '''QNetworkConfiguration.StateFlags QNetworkConfiguration.StateFlags.__and__(int mask)'''
             return QNetworkConfiguration.StateFlags()
         def __xor__(self, f):
             '''QNetworkConfiguration.StateFlags QNetworkConfiguration.StateFlags.__xor__(QNetworkConfiguration.StateFlags f)'''
             return QNetworkConfiguration.StateFlags()
         def __xor__(self, f):
             '''QNetworkConfiguration.StateFlags QNetworkConfiguration.StateFlags.__xor__(int f)'''
             return QNetworkConfiguration.StateFlags()
         def __or__(self, f):
             '''QNetworkConfiguration.StateFlags QNetworkConfiguration.StateFlags.__or__(QNetworkConfiguration.StateFlags f)'''
             return QNetworkConfiguration.StateFlags()
         def __or__(self, f):
             '''QNetworkConfiguration.StateFlags QNetworkConfiguration.StateFlags.__or__(int f)'''
             return QNetworkConfiguration.StateFlags()
         def __int__(self):
             '''int QNetworkConfiguration.StateFlags.__int__()'''
             return int()
         def __ixor__(self, f):
             '''QNetworkConfiguration.StateFlags QNetworkConfiguration.StateFlags.__ixor__(QNetworkConfiguration.StateFlags f)'''
             return QNetworkConfiguration.StateFlags()
         def __ior__(self, f):
             '''QNetworkConfiguration.StateFlags QNetworkConfiguration.StateFlags.__ior__(QNetworkConfiguration.StateFlags f)'''
             return QNetworkConfiguration.StateFlags()
         def __iand__(self, mask):
             '''QNetworkConfiguration.StateFlags QNetworkConfiguration.StateFlags.__iand__(int mask)'''
             return QNetworkConfiguration.StateFlags()
 
 
 class QNetworkCookie():
     """"""
     # Enum QNetworkCookie.RawForm
     NameAndValueOnly = 0
     Full = 0
 
     def __init__(self, name = QByteArray(), value = QByteArray()):
         '''void QNetworkCookie.__init__(QByteArray name = QByteArray(), QByteArray value = QByteArray())'''
     def __init__(self, other):
         '''void QNetworkCookie.__init__(QNetworkCookie other)'''
     def normalize(self, url):
         '''void QNetworkCookie.normalize(QUrl url)'''
     def hasSameIdentifier(self, other):
         '''bool QNetworkCookie.hasSameIdentifier(QNetworkCookie other)'''
         return bool()
     def swap(self, other):
         '''void QNetworkCookie.swap(QNetworkCookie other)'''
     def setHttpOnly(self, enable):
         '''void QNetworkCookie.setHttpOnly(bool enable)'''
     def isHttpOnly(self):
         '''bool QNetworkCookie.isHttpOnly()'''
         return bool()
     def __ne__(self, other):
         '''bool QNetworkCookie.__ne__(QNetworkCookie other)'''
         return bool()
     def __eq__(self, other):
         '''bool QNetworkCookie.__eq__(QNetworkCookie other)'''
         return bool()
     def parseCookies(self, cookieString):
         '''static list-of-QNetworkCookie QNetworkCookie.parseCookies(QByteArray cookieString)'''
         return [QNetworkCookie()]
     def toRawForm(self, form = None):
         '''QByteArray QNetworkCookie.toRawForm(QNetworkCookie.RawForm form = QNetworkCookie.Full)'''
         return QByteArray()
     def setValue(self, value):
         '''void QNetworkCookie.setValue(QByteArray value)'''
     def value(self):
         '''QByteArray QNetworkCookie.value()'''
         return QByteArray()
     def setName(self, cookieName):
         '''void QNetworkCookie.setName(QByteArray cookieName)'''
     def name(self):
         '''QByteArray QNetworkCookie.name()'''
         return QByteArray()
     def setPath(self, path):
         '''void QNetworkCookie.setPath(str path)'''
     def path(self):
         '''str QNetworkCookie.path()'''
         return str()
     def setDomain(self, domain):
         '''void QNetworkCookie.setDomain(str domain)'''
     def domain(self):
         '''str QNetworkCookie.domain()'''
         return str()
     def setExpirationDate(self, date):
         '''void QNetworkCookie.setExpirationDate(QDateTime date)'''
     def expirationDate(self):
         '''QDateTime QNetworkCookie.expirationDate()'''
         return QDateTime()
     def isSessionCookie(self):
         '''bool QNetworkCookie.isSessionCookie()'''
         return bool()
     def setSecure(self, enable):
         '''void QNetworkCookie.setSecure(bool enable)'''
     def isSecure(self):
         '''bool QNetworkCookie.isSecure()'''
         return bool()
 
 
 class QNetworkCookieJar(QObject):
     """"""
     def __init__(self, parent = None):
         '''void QNetworkCookieJar.__init__(QObject parent = None)'''
     def validateCookie(self, cookie, url):
         '''bool QNetworkCookieJar.validateCookie(QNetworkCookie cookie, QUrl url)'''
         return bool()
     def allCookies(self):
         '''list-of-QNetworkCookie QNetworkCookieJar.allCookies()'''
         return [QNetworkCookie()]
     def setAllCookies(self, cookieList):
         '''void QNetworkCookieJar.setAllCookies(list-of-QNetworkCookie cookieList)'''
     def deleteCookie(self, cookie):
         '''bool QNetworkCookieJar.deleteCookie(QNetworkCookie cookie)'''
         return bool()
     def updateCookie(self, cookie):
         '''bool QNetworkCookieJar.updateCookie(QNetworkCookie cookie)'''
         return bool()
     def insertCookie(self, cookie):
         '''bool QNetworkCookieJar.insertCookie(QNetworkCookie cookie)'''
         return bool()
     def setCookiesFromUrl(self, cookieList, url):
         '''bool QNetworkCookieJar.setCookiesFromUrl(list-of-QNetworkCookie cookieList, QUrl url)'''
         return bool()
     def cookiesForUrl(self, url):
         '''list-of-QNetworkCookie QNetworkCookieJar.cookiesForUrl(QUrl url)'''
         return [QNetworkCookie()]
 
 
 class QNetworkDiskCache(QAbstractNetworkCache):
     """"""
     def __init__(self, parent = None):
         '''void QNetworkDiskCache.__init__(QObject parent = None)'''
     def expire(self):
         '''int QNetworkDiskCache.expire()'''
         return int()
     def clear(self):
         '''void QNetworkDiskCache.clear()'''
     def fileMetaData(self, fileName):
         '''QNetworkCacheMetaData QNetworkDiskCache.fileMetaData(str fileName)'''
         return QNetworkCacheMetaData()
     def insert(self, device):
         '''void QNetworkDiskCache.insert(QIODevice device)'''
     def prepare(self, metaData):
         '''QIODevice QNetworkDiskCache.prepare(QNetworkCacheMetaData metaData)'''
         return QIODevice()
     def remove(self, url):
         '''bool QNetworkDiskCache.remove(QUrl url)'''
         return bool()
     def data(self, url):
         '''QIODevice QNetworkDiskCache.data(QUrl url)'''
         return QIODevice()
     def updateMetaData(self, metaData):
         '''void QNetworkDiskCache.updateMetaData(QNetworkCacheMetaData metaData)'''
     def metaData(self, url):
         '''QNetworkCacheMetaData QNetworkDiskCache.metaData(QUrl url)'''
         return QNetworkCacheMetaData()
     def cacheSize(self):
         '''int QNetworkDiskCache.cacheSize()'''
         return int()
     def setMaximumCacheSize(self, size):
         '''void QNetworkDiskCache.setMaximumCacheSize(int size)'''
     def maximumCacheSize(self):
         '''int QNetworkDiskCache.maximumCacheSize()'''
         return int()
     def setCacheDirectory(self, cacheDir):
         '''void QNetworkDiskCache.setCacheDirectory(str cacheDir)'''
     def cacheDirectory(self):
         '''str QNetworkDiskCache.cacheDirectory()'''
         return str()
 
 
 class QNetworkAddressEntry():
     """"""
     def __init__(self):
         '''void QNetworkAddressEntry.__init__()'''
     def __init__(self, other):
         '''void QNetworkAddressEntry.__init__(QNetworkAddressEntry other)'''
     def swap(self, other):
         '''void QNetworkAddressEntry.swap(QNetworkAddressEntry other)'''
     def setPrefixLength(self, length):
         '''void QNetworkAddressEntry.setPrefixLength(int length)'''
     def prefixLength(self):
         '''int QNetworkAddressEntry.prefixLength()'''
         return int()
     def __ne__(self, other):
         '''bool QNetworkAddressEntry.__ne__(QNetworkAddressEntry other)'''
         return bool()
     def __eq__(self, other):
         '''bool QNetworkAddressEntry.__eq__(QNetworkAddressEntry other)'''
         return bool()
     def setBroadcast(self, newBroadcast):
         '''void QNetworkAddressEntry.setBroadcast(QHostAddress newBroadcast)'''
     def broadcast(self):
         '''QHostAddress QNetworkAddressEntry.broadcast()'''
         return QHostAddress()
     def setNetmask(self, newNetmask):
         '''void QNetworkAddressEntry.setNetmask(QHostAddress newNetmask)'''
     def netmask(self):
         '''QHostAddress QNetworkAddressEntry.netmask()'''
         return QHostAddress()
     def setIp(self, newIp):
         '''void QNetworkAddressEntry.setIp(QHostAddress newIp)'''
     def ip(self):
         '''QHostAddress QNetworkAddressEntry.ip()'''
         return QHostAddress()
 
 
 class QNetworkInterface():
     """"""
     # Enum QNetworkInterface.InterfaceFlag
     IsUp = 0
     IsRunning = 0
     CanBroadcast = 0
     IsLoopBack = 0
     IsPointToPoint = 0
     CanMulticast = 0
 
     def __init__(self):
         '''void QNetworkInterface.__init__()'''
     def __init__(self, other):
         '''void QNetworkInterface.__init__(QNetworkInterface other)'''
     def swap(self, other):
         '''void QNetworkInterface.swap(QNetworkInterface other)'''
     def humanReadableName(self):
         '''str QNetworkInterface.humanReadableName()'''
         return str()
     def index(self):
         '''int QNetworkInterface.index()'''
         return int()
     def allAddresses(self):
         '''static list-of-QHostAddress QNetworkInterface.allAddresses()'''
         return [QHostAddress()]
     def allInterfaces(self):
         '''static list-of-QNetworkInterface QNetworkInterface.allInterfaces()'''
         return [QNetworkInterface()]
     def interfaceFromIndex(self, index):
         '''static QNetworkInterface QNetworkInterface.interfaceFromIndex(int index)'''
         return QNetworkInterface()
     def interfaceFromName(self, name):
         '''static QNetworkInterface QNetworkInterface.interfaceFromName(str name)'''
         return QNetworkInterface()
     def addressEntries(self):
         '''list-of-QNetworkAddressEntry QNetworkInterface.addressEntries()'''
         return [QNetworkAddressEntry()]
     def hardwareAddress(self):
         '''str QNetworkInterface.hardwareAddress()'''
         return str()
     def flags(self):
         '''QNetworkInterface.InterfaceFlags QNetworkInterface.flags()'''
         return QNetworkInterface.InterfaceFlags()
     def name(self):
         '''str QNetworkInterface.name()'''
         return str()
     def isValid(self):
         '''bool QNetworkInterface.isValid()'''
         return bool()
     class InterfaceFlags():
         """"""
         def __init__(self):
             '''QNetworkInterface.InterfaceFlags QNetworkInterface.InterfaceFlags.__init__()'''
             return QNetworkInterface.InterfaceFlags()
         def __init__(self):
             '''int QNetworkInterface.InterfaceFlags.__init__()'''
             return int()
         def __init__(self):
             '''void QNetworkInterface.InterfaceFlags.__init__()'''
         def __bool__(self):
             '''int QNetworkInterface.InterfaceFlags.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool QNetworkInterface.InterfaceFlags.__ne__(QNetworkInterface.InterfaceFlags f)'''
             return bool()
         def __eq__(self, f):
             '''bool QNetworkInterface.InterfaceFlags.__eq__(QNetworkInterface.InterfaceFlags f)'''
             return bool()
         def __invert__(self):
             '''QNetworkInterface.InterfaceFlags QNetworkInterface.InterfaceFlags.__invert__()'''
             return QNetworkInterface.InterfaceFlags()
         def __and__(self, mask):
             '''QNetworkInterface.InterfaceFlags QNetworkInterface.InterfaceFlags.__and__(int mask)'''
             return QNetworkInterface.InterfaceFlags()
         def __xor__(self, f):
             '''QNetworkInterface.InterfaceFlags QNetworkInterface.InterfaceFlags.__xor__(QNetworkInterface.InterfaceFlags f)'''
             return QNetworkInterface.InterfaceFlags()
         def __xor__(self, f):
             '''QNetworkInterface.InterfaceFlags QNetworkInterface.InterfaceFlags.__xor__(int f)'''
             return QNetworkInterface.InterfaceFlags()
         def __or__(self, f):
             '''QNetworkInterface.InterfaceFlags QNetworkInterface.InterfaceFlags.__or__(QNetworkInterface.InterfaceFlags f)'''
             return QNetworkInterface.InterfaceFlags()
         def __or__(self, f):
             '''QNetworkInterface.InterfaceFlags QNetworkInterface.InterfaceFlags.__or__(int f)'''
             return QNetworkInterface.InterfaceFlags()
         def __int__(self):
             '''int QNetworkInterface.InterfaceFlags.__int__()'''
             return int()
         def __ixor__(self, f):
             '''QNetworkInterface.InterfaceFlags QNetworkInterface.InterfaceFlags.__ixor__(QNetworkInterface.InterfaceFlags f)'''
             return QNetworkInterface.InterfaceFlags()
         def __ior__(self, f):
             '''QNetworkInterface.InterfaceFlags QNetworkInterface.InterfaceFlags.__ior__(QNetworkInterface.InterfaceFlags f)'''
             return QNetworkInterface.InterfaceFlags()
         def __iand__(self, mask):
             '''QNetworkInterface.InterfaceFlags QNetworkInterface.InterfaceFlags.__iand__(int mask)'''
             return QNetworkInterface.InterfaceFlags()
 
 
 class QNetworkProxy():
     """"""
     # Enum QNetworkProxy.Capability
     TunnelingCapability = 0
     ListeningCapability = 0
     UdpTunnelingCapability = 0
     CachingCapability = 0
     HostNameLookupCapability = 0
 
     # Enum QNetworkProxy.ProxyType
     DefaultProxy = 0
     Socks5Proxy = 0
     NoProxy = 0
     HttpProxy = 0
     HttpCachingProxy = 0
     FtpCachingProxy = 0
 
     def __init__(self):
         '''void QNetworkProxy.__init__()'''
     def __init__(self, type, hostName = None, port = 0, user = None, password = None):
         '''void QNetworkProxy.__init__(QNetworkProxy.ProxyType type, str hostName = '', int port = 0, str user = '', str password = '')'''
     def __init__(self, other):
         '''void QNetworkProxy.__init__(QNetworkProxy other)'''
     def setRawHeader(self, headerName, value):
         '''void QNetworkProxy.setRawHeader(QByteArray headerName, QByteArray value)'''
     def rawHeader(self, headerName):
         '''QByteArray QNetworkProxy.rawHeader(QByteArray headerName)'''
         return QByteArray()
     def rawHeaderList(self):
         '''list-of-QByteArray QNetworkProxy.rawHeaderList()'''
         return [QByteArray()]
     def hasRawHeader(self, headerName):
         '''bool QNetworkProxy.hasRawHeader(QByteArray headerName)'''
         return bool()
     def setHeader(self, header, value):
         '''void QNetworkProxy.setHeader(QNetworkRequest.KnownHeaders header, QVariant value)'''
     def header(self, header):
         '''QVariant QNetworkProxy.header(QNetworkRequest.KnownHeaders header)'''
         return QVariant()
     def swap(self, other):
         '''void QNetworkProxy.swap(QNetworkProxy other)'''
     def capabilities(self):
         '''QNetworkProxy.Capabilities QNetworkProxy.capabilities()'''
         return QNetworkProxy.Capabilities()
     def setCapabilities(self, capab):
         '''void QNetworkProxy.setCapabilities(QNetworkProxy.Capabilities capab)'''
     def __ne__(self, other):
         '''bool QNetworkProxy.__ne__(QNetworkProxy other)'''
         return bool()
     def __eq__(self, other):
         '''bool QNetworkProxy.__eq__(QNetworkProxy other)'''
         return bool()
     def isTransparentProxy(self):
         '''bool QNetworkProxy.isTransparentProxy()'''
         return bool()
     def isCachingProxy(self):
         '''bool QNetworkProxy.isCachingProxy()'''
         return bool()
     def applicationProxy(self):
         '''static QNetworkProxy QNetworkProxy.applicationProxy()'''
         return QNetworkProxy()
     def setApplicationProxy(self, proxy):
         '''static void QNetworkProxy.setApplicationProxy(QNetworkProxy proxy)'''
     def port(self):
         '''int QNetworkProxy.port()'''
         return int()
     def setPort(self, port):
         '''void QNetworkProxy.setPort(int port)'''
     def hostName(self):
         '''str QNetworkProxy.hostName()'''
         return str()
     def setHostName(self, hostName):
         '''void QNetworkProxy.setHostName(str hostName)'''
     def password(self):
         '''str QNetworkProxy.password()'''
         return str()
     def setPassword(self, password):
         '''void QNetworkProxy.setPassword(str password)'''
     def user(self):
         '''str QNetworkProxy.user()'''
         return str()
     def setUser(self, userName):
         '''void QNetworkProxy.setUser(str userName)'''
     def type(self):
         '''QNetworkProxy.ProxyType QNetworkProxy.type()'''
         return QNetworkProxy.ProxyType()
     def setType(self, type):
         '''void QNetworkProxy.setType(QNetworkProxy.ProxyType type)'''
     class Capabilities():
         """"""
         def __init__(self):
             '''QNetworkProxy.Capabilities QNetworkProxy.Capabilities.__init__()'''
             return QNetworkProxy.Capabilities()
         def __init__(self):
             '''int QNetworkProxy.Capabilities.__init__()'''
             return int()
         def __init__(self):
             '''void QNetworkProxy.Capabilities.__init__()'''
         def __bool__(self):
             '''int QNetworkProxy.Capabilities.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool QNetworkProxy.Capabilities.__ne__(QNetworkProxy.Capabilities f)'''
             return bool()
         def __eq__(self, f):
             '''bool QNetworkProxy.Capabilities.__eq__(QNetworkProxy.Capabilities f)'''
             return bool()
         def __invert__(self):
             '''QNetworkProxy.Capabilities QNetworkProxy.Capabilities.__invert__()'''
             return QNetworkProxy.Capabilities()
         def __and__(self, mask):
             '''QNetworkProxy.Capabilities QNetworkProxy.Capabilities.__and__(int mask)'''
             return QNetworkProxy.Capabilities()
         def __xor__(self, f):
             '''QNetworkProxy.Capabilities QNetworkProxy.Capabilities.__xor__(QNetworkProxy.Capabilities f)'''
             return QNetworkProxy.Capabilities()
         def __xor__(self, f):
             '''QNetworkProxy.Capabilities QNetworkProxy.Capabilities.__xor__(int f)'''
             return QNetworkProxy.Capabilities()
         def __or__(self, f):
             '''QNetworkProxy.Capabilities QNetworkProxy.Capabilities.__or__(QNetworkProxy.Capabilities f)'''
             return QNetworkProxy.Capabilities()
         def __or__(self, f):
             '''QNetworkProxy.Capabilities QNetworkProxy.Capabilities.__or__(int f)'''
             return QNetworkProxy.Capabilities()
         def __int__(self):
             '''int QNetworkProxy.Capabilities.__int__()'''
             return int()
         def __ixor__(self, f):
             '''QNetworkProxy.Capabilities QNetworkProxy.Capabilities.__ixor__(QNetworkProxy.Capabilities f)'''
             return QNetworkProxy.Capabilities()
         def __ior__(self, f):
             '''QNetworkProxy.Capabilities QNetworkProxy.Capabilities.__ior__(QNetworkProxy.Capabilities f)'''
             return QNetworkProxy.Capabilities()
         def __iand__(self, mask):
             '''QNetworkProxy.Capabilities QNetworkProxy.Capabilities.__iand__(int mask)'''
             return QNetworkProxy.Capabilities()
 
 
 class QNetworkProxyQuery():
     """"""
     # Enum QNetworkProxyQuery.QueryType
     TcpSocket = 0
     UdpSocket = 0
     TcpServer = 0
     UrlRequest = 0
 
     def __init__(self):
         '''void QNetworkProxyQuery.__init__()'''
     def __init__(self, requestUrl, type = None):
         '''void QNetworkProxyQuery.__init__(QUrl requestUrl, QNetworkProxyQuery.QueryType type = QNetworkProxyQuery.UrlRequest)'''
     def __init__(self, hostname, port, protocolTag = None, type = None):
         '''void QNetworkProxyQuery.__init__(str hostname, int port, str protocolTag = '', QNetworkProxyQuery.QueryType type = QNetworkProxyQuery.TcpSocket)'''
     def __init__(self, bindPort, protocolTag = None, type = None):
         '''void QNetworkProxyQuery.__init__(int bindPort, str protocolTag = '', QNetworkProxyQuery.QueryType type = QNetworkProxyQuery.TcpServer)'''
     def __init__(self, networkConfiguration, requestUrl, queryType = None):
         '''void QNetworkProxyQuery.__init__(QNetworkConfiguration networkConfiguration, QUrl requestUrl, QNetworkProxyQuery.QueryType queryType = QNetworkProxyQuery.UrlRequest)'''
     def __init__(self, networkConfiguration, hostname, port, protocolTag = None, type = None):
         '''void QNetworkProxyQuery.__init__(QNetworkConfiguration networkConfiguration, str hostname, int port, str protocolTag = '', QNetworkProxyQuery.QueryType type = QNetworkProxyQuery.TcpSocket)'''
     def __init__(self, networkConfiguration, bindPort, protocolTag = None, type = None):
         '''void QNetworkProxyQuery.__init__(QNetworkConfiguration networkConfiguration, int bindPort, str protocolTag = '', QNetworkProxyQuery.QueryType type = QNetworkProxyQuery.TcpServer)'''
     def __init__(self, other):
         '''void QNetworkProxyQuery.__init__(QNetworkProxyQuery other)'''
     def swap(self, other):
         '''void QNetworkProxyQuery.swap(QNetworkProxyQuery other)'''
     def setNetworkConfiguration(self, networkConfiguration):
         '''void QNetworkProxyQuery.setNetworkConfiguration(QNetworkConfiguration networkConfiguration)'''
     def networkConfiguration(self):
         '''QNetworkConfiguration QNetworkProxyQuery.networkConfiguration()'''
         return QNetworkConfiguration()
     def setUrl(self, url):
         '''void QNetworkProxyQuery.setUrl(QUrl url)'''
     def url(self):
         '''QUrl QNetworkProxyQuery.url()'''
         return QUrl()
     def setProtocolTag(self, protocolTag):
         '''void QNetworkProxyQuery.setProtocolTag(str protocolTag)'''
     def protocolTag(self):
         '''str QNetworkProxyQuery.protocolTag()'''
         return str()
     def setLocalPort(self, port):
         '''void QNetworkProxyQuery.setLocalPort(int port)'''
     def localPort(self):
         '''int QNetworkProxyQuery.localPort()'''
         return int()
     def setPeerHostName(self, hostname):
         '''void QNetworkProxyQuery.setPeerHostName(str hostname)'''
     def peerHostName(self):
         '''str QNetworkProxyQuery.peerHostName()'''
         return str()
     def setPeerPort(self, port):
         '''void QNetworkProxyQuery.setPeerPort(int port)'''
     def peerPort(self):
         '''int QNetworkProxyQuery.peerPort()'''
         return int()
     def setQueryType(self, type):
         '''void QNetworkProxyQuery.setQueryType(QNetworkProxyQuery.QueryType type)'''
     def queryType(self):
         '''QNetworkProxyQuery.QueryType QNetworkProxyQuery.queryType()'''
         return QNetworkProxyQuery.QueryType()
     def __ne__(self, other):
         '''bool QNetworkProxyQuery.__ne__(QNetworkProxyQuery other)'''
         return bool()
     def __eq__(self, other):
         '''bool QNetworkProxyQuery.__eq__(QNetworkProxyQuery other)'''
         return bool()
 
 
 class QNetworkProxyFactory():
     """"""
     def __init__(self):
         '''void QNetworkProxyFactory.__init__()'''
     def __init__(self):
         '''QNetworkProxyFactory QNetworkProxyFactory.__init__()'''
         return QNetworkProxyFactory()
     def setUseSystemConfiguration(self, enable):
         '''static void QNetworkProxyFactory.setUseSystemConfiguration(bool enable)'''
     def systemProxyForQuery(self, query = QNetworkProxyQuery()):
         '''static list-of-QNetworkProxy QNetworkProxyFactory.systemProxyForQuery(QNetworkProxyQuery query = QNetworkProxyQuery())'''
         return [QNetworkProxy()]
     def proxyForQuery(self, query):
         '''static list-of-QNetworkProxy QNetworkProxyFactory.proxyForQuery(QNetworkProxyQuery query)'''
         return [QNetworkProxy()]
     def setApplicationProxyFactory(self, factory):
         '''static void QNetworkProxyFactory.setApplicationProxyFactory(QNetworkProxyFactory factory)'''
     def queryProxy(self, query = QNetworkProxyQuery()):
         '''abstract list-of-QNetworkProxy QNetworkProxyFactory.queryProxy(QNetworkProxyQuery query = QNetworkProxyQuery())'''
         return [QNetworkProxy()]
 
 
 class QNetworkReply(QIODevice):
     """"""
     # Enum QNetworkReply.NetworkError
     NoError = 0
     ConnectionRefusedError = 0
     RemoteHostClosedError = 0
     HostNotFoundError = 0
     TimeoutError = 0
     OperationCanceledError = 0
     SslHandshakeFailedError = 0
     UnknownNetworkError = 0
     ProxyConnectionRefusedError = 0
     ProxyConnectionClosedError = 0
     ProxyNotFoundError = 0
     ProxyTimeoutError = 0
     ProxyAuthenticationRequiredError = 0
     UnknownProxyError = 0
     ContentAccessDenied = 0
     ContentOperationNotPermittedError = 0
     ContentNotFoundError = 0
     AuthenticationRequiredError = 0
     UnknownContentError = 0
     ProtocolUnknownError = 0
     ProtocolInvalidOperationError = 0
     ProtocolFailure = 0
     ContentReSendError = 0
     TemporaryNetworkFailureError = 0
     NetworkSessionFailedError = 0
     BackgroundRequestNotAllowedError = 0
     ContentConflictError = 0
     ContentGoneError = 0
     InternalServerError = 0
     OperationNotImplementedError = 0
     ServiceUnavailableError = 0
     UnknownServerError = 0
 
     def __init__(self, parent = None):
         '''void QNetworkReply.__init__(QObject parent = None)'''
     def ignoreSslErrorsImplementation(self):
         '''list-of-QSslError QNetworkReply.ignoreSslErrorsImplementation()'''
         return [QSslError()]
     def setSslConfigurationImplementation(self):
         '''QSslConfiguration QNetworkReply.setSslConfigurationImplementation()'''
         return QSslConfiguration()
     def sslConfigurationImplementation(self):
         '''QSslConfiguration QNetworkReply.sslConfigurationImplementation()'''
         return QSslConfiguration()
     def rawHeaderPairs(self):
         '''list-of-tuple-of-QByteArray-QByteArray QNetworkReply.rawHeaderPairs()'''
         return [tuple-of-QByteArray-QByteArray()]
     def isRunning(self):
         '''bool QNetworkReply.isRunning()'''
         return bool()
     def isFinished(self):
         '''bool QNetworkReply.isFinished()'''
         return bool()
     def setFinished(self, finished):
         '''void QNetworkReply.setFinished(bool finished)'''
     def setAttribute(self, code, value):
         '''void QNetworkReply.setAttribute(QNetworkRequest.Attribute code, QVariant value)'''
     def setRawHeader(self, headerName, value):
         '''void QNetworkReply.setRawHeader(QByteArray headerName, QByteArray value)'''
     def setHeader(self, header, value):
         '''void QNetworkReply.setHeader(QNetworkRequest.KnownHeaders header, QVariant value)'''
     def setUrl(self, url):
         '''void QNetworkReply.setUrl(QUrl url)'''
     def setError(self, errorCode, errorString):
         '''void QNetworkReply.setError(QNetworkReply.NetworkError errorCode, str errorString)'''
     def setRequest(self, request):
         '''void QNetworkReply.setRequest(QNetworkRequest request)'''
     def setOperation(self, operation):
         '''void QNetworkReply.setOperation(QNetworkAccessManager.Operation operation)'''
     def writeData(self, data):
         '''int QNetworkReply.writeData(str data)'''
         return int()
     preSharedKeyAuthenticationRequired = pyqtSignal() # void preSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator*) - signal
     downloadProgress = pyqtSignal() # void downloadProgress(qint64,qint64) - signal
     uploadProgress = pyqtSignal() # void uploadProgress(qint64,qint64) - signal
     sslErrors = pyqtSignal() # void sslErrors(const QListlt;QSslErrorgt;amp;) - signal
     encrypted = pyqtSignal() # void encrypted() - signal
     finished = pyqtSignal() # void finished() - signal
     metaDataChanged = pyqtSignal() # void metaDataChanged() - signal
     def ignoreSslErrors(self):
         '''void QNetworkReply.ignoreSslErrors()'''
     def ignoreSslErrors(self, errors):
         '''void QNetworkReply.ignoreSslErrors(list-of-QSslError errors)'''
     def setSslConfiguration(self, configuration):
         '''void QNetworkReply.setSslConfiguration(QSslConfiguration configuration)'''
     def sslConfiguration(self):
         '''QSslConfiguration QNetworkReply.sslConfiguration()'''
         return QSslConfiguration()
     def attribute(self, code):
         '''QVariant QNetworkReply.attribute(QNetworkRequest.Attribute code)'''
         return QVariant()
     def rawHeader(self, headerName):
         '''QByteArray QNetworkReply.rawHeader(QByteArray headerName)'''
         return QByteArray()
     def rawHeaderList(self):
         '''list-of-QByteArray QNetworkReply.rawHeaderList()'''
         return [QByteArray()]
     def hasRawHeader(self, headerName):
         '''bool QNetworkReply.hasRawHeader(QByteArray headerName)'''
         return bool()
     def header(self, header):
         '''QVariant QNetworkReply.header(QNetworkRequest.KnownHeaders header)'''
         return QVariant()
     def url(self):
         '''QUrl QNetworkReply.url()'''
         return QUrl()
     def error(self):
         '''QNetworkReply.NetworkError QNetworkReply.error()'''
         return QNetworkReply.NetworkError()
     error = pyqtSignal() # void error(QNetworkReply::NetworkError) - signal
     def request(self):
         '''QNetworkRequest QNetworkReply.request()'''
         return QNetworkRequest()
     def operation(self):
         '''QNetworkAccessManager.Operation QNetworkReply.operation()'''
         return QNetworkAccessManager.Operation()
     def manager(self):
         '''QNetworkAccessManager QNetworkReply.manager()'''
         return QNetworkAccessManager()
     def setReadBufferSize(self, size):
         '''void QNetworkReply.setReadBufferSize(int size)'''
     def readBufferSize(self):
         '''int QNetworkReply.readBufferSize()'''
         return int()
     def isSequential(self):
         '''bool QNetworkReply.isSequential()'''
         return bool()
     def close(self):
         '''void QNetworkReply.close()'''
     def abort(self):
         '''abstract void QNetworkReply.abort()'''
 
 
 class QNetworkRequest():
     """"""
     # Enum QNetworkRequest.Priority
     HighPriority = 0
     NormalPriority = 0
     LowPriority = 0
 
     # Enum QNetworkRequest.LoadControl
     Automatic = 0
     Manual = 0
 
     # Enum QNetworkRequest.CacheLoadControl
     AlwaysNetwork = 0
     PreferNetwork = 0
     PreferCache = 0
     AlwaysCache = 0
 
     # Enum QNetworkRequest.Attribute
     HttpStatusCodeAttribute = 0
     HttpReasonPhraseAttribute = 0
     RedirectionTargetAttribute = 0
     ConnectionEncryptedAttribute = 0
     CacheLoadControlAttribute = 0
     CacheSaveControlAttribute = 0
     SourceIsFromCacheAttribute = 0
     DoNotBufferUploadDataAttribute = 0
     HttpPipeliningAllowedAttribute = 0
     HttpPipeliningWasUsedAttribute = 0
     CustomVerbAttribute = 0
     CookieLoadControlAttribute = 0
     AuthenticationReuseAttribute = 0
     CookieSaveControlAttribute = 0
     BackgroundRequestAttribute = 0
     SpdyAllowedAttribute = 0
     SpdyWasUsedAttribute = 0
     EmitAllUploadProgressSignalsAttribute = 0
     User = 0
     UserMax = 0
 
     # Enum QNetworkRequest.KnownHeaders
     ContentTypeHeader = 0
     ContentLengthHeader = 0
     LocationHeader = 0
     LastModifiedHeader = 0
     CookieHeader = 0
     SetCookieHeader = 0
     ContentDispositionHeader = 0
     UserAgentHeader = 0
     ServerHeader = 0
 
     def __init__(self, url = QUrl()):
         '''void QNetworkRequest.__init__(QUrl url = QUrl())'''
     def __init__(self, other):
         '''void QNetworkRequest.__init__(QNetworkRequest other)'''
     def swap(self, other):
         '''void QNetworkRequest.swap(QNetworkRequest other)'''
     def setPriority(self, priority):
         '''void QNetworkRequest.setPriority(QNetworkRequest.Priority priority)'''
     def priority(self):
         '''QNetworkRequest.Priority QNetworkRequest.priority()'''
         return QNetworkRequest.Priority()
     def originatingObject(self):
         '''QObject QNetworkRequest.originatingObject()'''
         return QObject()
     def setOriginatingObject(self, object):
         '''void QNetworkRequest.setOriginatingObject(QObject object)'''
     def __ne__(self, other):
         '''bool QNetworkRequest.__ne__(QNetworkRequest other)'''
         return bool()
     def __eq__(self, other):
         '''bool QNetworkRequest.__eq__(QNetworkRequest other)'''
         return bool()
     def setSslConfiguration(self, configuration):
         '''void QNetworkRequest.setSslConfiguration(QSslConfiguration configuration)'''
     def sslConfiguration(self):
         '''QSslConfiguration QNetworkRequest.sslConfiguration()'''
         return QSslConfiguration()
     def setAttribute(self, code, value):
         '''void QNetworkRequest.setAttribute(QNetworkRequest.Attribute code, QVariant value)'''
     def attribute(self, code, defaultValue = None):
         '''QVariant QNetworkRequest.attribute(QNetworkRequest.Attribute code, QVariant defaultValue = None)'''
         return QVariant()
     def setRawHeader(self, headerName, value):
         '''void QNetworkRequest.setRawHeader(QByteArray headerName, QByteArray value)'''
     def rawHeader(self, headerName):
         '''QByteArray QNetworkRequest.rawHeader(QByteArray headerName)'''
         return QByteArray()
     def rawHeaderList(self):
         '''list-of-QByteArray QNetworkRequest.rawHeaderList()'''
         return [QByteArray()]
     def hasRawHeader(self, headerName):
         '''bool QNetworkRequest.hasRawHeader(QByteArray headerName)'''
         return bool()
     def setHeader(self, header, value):
         '''void QNetworkRequest.setHeader(QNetworkRequest.KnownHeaders header, QVariant value)'''
     def header(self, header):
         '''QVariant QNetworkRequest.header(QNetworkRequest.KnownHeaders header)'''
         return QVariant()
     def setUrl(self, url):
         '''void QNetworkRequest.setUrl(QUrl url)'''
     def url(self):
         '''QUrl QNetworkRequest.url()'''
         return QUrl()
 
 
 class QNetworkSession(QObject):
     """"""
     # Enum QNetworkSession.UsagePolicy
     NoPolicy = 0
     NoBackgroundTrafficPolicy = 0
 
     # Enum QNetworkSession.SessionError
     UnknownSessionError = 0
     SessionAbortedError = 0
     RoamingError = 0
     OperationNotSupportedError = 0
     InvalidConfigurationError = 0
 
     # Enum QNetworkSession.State
     Invalid = 0
     NotAvailable = 0
     Connecting = 0
     Connected = 0
     Closing = 0
     Disconnected = 0
     Roaming = 0
 
     def __init__(self, connConfig, parent = None):
         '''void QNetworkSession.__init__(QNetworkConfiguration connConfig, QObject parent = None)'''
     usagePoliciesChanged = pyqtSignal() # void usagePoliciesChanged(QNetworkSession::UsagePolicies) - signal
     def usagePolicies(self):
         '''QNetworkSession.UsagePolicies QNetworkSession.usagePolicies()'''
         return QNetworkSession.UsagePolicies()
     def disconnectNotify(self, signal):
         '''void QNetworkSession.disconnectNotify(QMetaMethod signal)'''
     def connectNotify(self, signal):
         '''void QNetworkSession.connectNotify(QMetaMethod signal)'''
     newConfigurationActivated = pyqtSignal() # void newConfigurationActivated() - signal
     preferredConfigurationChanged = pyqtSignal() # void preferredConfigurationChanged(const QNetworkConfigurationamp;,bool) - signal
     closed = pyqtSignal() # void closed() - signal
     opened = pyqtSignal() # void opened() - signal
     stateChanged = pyqtSignal() # void stateChanged(QNetworkSession::State) - signal
     def reject(self):
         '''void QNetworkSession.reject()'''
     def accept(self):
         '''void QNetworkSession.accept()'''
     def ignore(self):
         '''void QNetworkSession.ignore()'''
     def migrate(self):
         '''void QNetworkSession.migrate()'''
     def stop(self):
         '''void QNetworkSession.stop()'''
     def close(self):
         '''void QNetworkSession.close()'''
     def open(self):
         '''void QNetworkSession.open()'''
     def waitForOpened(self, msecs = 30000):
         '''bool QNetworkSession.waitForOpened(int msecs = 30000)'''
         return bool()
     def activeTime(self):
         '''int QNetworkSession.activeTime()'''
         return int()
     def bytesReceived(self):
         '''int QNetworkSession.bytesReceived()'''
         return int()
     def bytesWritten(self):
         '''int QNetworkSession.bytesWritten()'''
         return int()
     def setSessionProperty(self, key, value):
         '''void QNetworkSession.setSessionProperty(str key, QVariant value)'''
     def sessionProperty(self, key):
         '''QVariant QNetworkSession.sessionProperty(str key)'''
         return QVariant()
     def errorString(self):
         '''str QNetworkSession.errorString()'''
         return str()
     def error(self):
         '''QNetworkSession.SessionError QNetworkSession.error()'''
         return QNetworkSession.SessionError()
     error = pyqtSignal() # void error(QNetworkSession::SessionError) - signal
     def state(self):
         '''QNetworkSession.State QNetworkSession.state()'''
         return QNetworkSession.State()
     def interface(self):
         '''QNetworkInterface QNetworkSession.interface()'''
         return QNetworkInterface()
     def configuration(self):
         '''QNetworkConfiguration QNetworkSession.configuration()'''
         return QNetworkConfiguration()
     def isOpen(self):
         '''bool QNetworkSession.isOpen()'''
         return bool()
     class UsagePolicies():
         """"""
         def __init__(self):
             '''QNetworkSession.UsagePolicies QNetworkSession.UsagePolicies.__init__()'''
             return QNetworkSession.UsagePolicies()
         def __init__(self):
             '''int QNetworkSession.UsagePolicies.__init__()'''
             return int()
         def __init__(self):
             '''void QNetworkSession.UsagePolicies.__init__()'''
         def __bool__(self):
             '''int QNetworkSession.UsagePolicies.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool QNetworkSession.UsagePolicies.__ne__(QNetworkSession.UsagePolicies f)'''
             return bool()
         def __eq__(self, f):
             '''bool QNetworkSession.UsagePolicies.__eq__(QNetworkSession.UsagePolicies f)'''
             return bool()
         def __invert__(self):
             '''QNetworkSession.UsagePolicies QNetworkSession.UsagePolicies.__invert__()'''
             return QNetworkSession.UsagePolicies()
         def __and__(self, mask):
             '''QNetworkSession.UsagePolicies QNetworkSession.UsagePolicies.__and__(int mask)'''
             return QNetworkSession.UsagePolicies()
         def __xor__(self, f):
             '''QNetworkSession.UsagePolicies QNetworkSession.UsagePolicies.__xor__(QNetworkSession.UsagePolicies f)'''
             return QNetworkSession.UsagePolicies()
         def __xor__(self, f):
             '''QNetworkSession.UsagePolicies QNetworkSession.UsagePolicies.__xor__(int f)'''
             return QNetworkSession.UsagePolicies()
         def __or__(self, f):
             '''QNetworkSession.UsagePolicies QNetworkSession.UsagePolicies.__or__(QNetworkSession.UsagePolicies f)'''
             return QNetworkSession.UsagePolicies()
         def __or__(self, f):
             '''QNetworkSession.UsagePolicies QNetworkSession.UsagePolicies.__or__(int f)'''
             return QNetworkSession.UsagePolicies()
         def __int__(self):
             '''int QNetworkSession.UsagePolicies.__int__()'''
             return int()
         def __ixor__(self, f):
             '''QNetworkSession.UsagePolicies QNetworkSession.UsagePolicies.__ixor__(QNetworkSession.UsagePolicies f)'''
             return QNetworkSession.UsagePolicies()
         def __ior__(self, f):
             '''QNetworkSession.UsagePolicies QNetworkSession.UsagePolicies.__ior__(QNetworkSession.UsagePolicies f)'''
             return QNetworkSession.UsagePolicies()
         def __iand__(self, mask):
             '''QNetworkSession.UsagePolicies QNetworkSession.UsagePolicies.__iand__(int mask)'''
             return QNetworkSession.UsagePolicies()
 
 
 class QSsl():
     """"""
     # Enum QSsl.SslOption
     SslOptionDisableEmptyFragments = 0
     SslOptionDisableSessionTickets = 0
     SslOptionDisableCompression = 0
     SslOptionDisableServerNameIndication = 0
     SslOptionDisableLegacyRenegotiation = 0
     SslOptionDisableSessionSharing = 0
     SslOptionDisableSessionPersistence = 0
 
     # Enum QSsl.SslProtocol
     UnknownProtocol = 0
     SslV3 = 0
     SslV2 = 0
     TlsV1_0 = 0
     TlsV1_0OrLater = 0
     TlsV1_1 = 0
     TlsV1_1OrLater = 0
     TlsV1_2 = 0
     TlsV1_2OrLater = 0
     AnyProtocol = 0
     TlsV1SslV3 = 0
     SecureProtocols = 0
 
     # Enum QSsl.AlternativeNameEntryType
     EmailEntry = 0
     DnsEntry = 0
 
     # Enum QSsl.KeyAlgorithm
     Opaque = 0
     Rsa = 0
     Dsa = 0
     Ec = 0
 
     # Enum QSsl.EncodingFormat
     Pem = 0
     Der = 0
 
     # Enum QSsl.KeyType
     PrivateKey = 0
     PublicKey = 0
 
     class SslOptions():
         """"""
         def __init__(self):
             '''QSsl.SslOptions QSsl.SslOptions.__init__()'''
             return QSsl.SslOptions()
         def __init__(self):
             '''int QSsl.SslOptions.__init__()'''
             return int()
         def __init__(self):
             '''void QSsl.SslOptions.__init__()'''
         def __bool__(self):
             '''int QSsl.SslOptions.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool QSsl.SslOptions.__ne__(QSsl.SslOptions f)'''
             return bool()
         def __eq__(self, f):
             '''bool QSsl.SslOptions.__eq__(QSsl.SslOptions f)'''
             return bool()
         def __invert__(self):
             '''QSsl.SslOptions QSsl.SslOptions.__invert__()'''
             return QSsl.SslOptions()
         def __and__(self, mask):
             '''QSsl.SslOptions QSsl.SslOptions.__and__(int mask)'''
             return QSsl.SslOptions()
         def __xor__(self, f):
             '''QSsl.SslOptions QSsl.SslOptions.__xor__(QSsl.SslOptions f)'''
             return QSsl.SslOptions()
         def __xor__(self, f):
             '''QSsl.SslOptions QSsl.SslOptions.__xor__(int f)'''
             return QSsl.SslOptions()
         def __or__(self, f):
             '''QSsl.SslOptions QSsl.SslOptions.__or__(QSsl.SslOptions f)'''
             return QSsl.SslOptions()
         def __or__(self, f):
             '''QSsl.SslOptions QSsl.SslOptions.__or__(int f)'''
             return QSsl.SslOptions()
         def __int__(self):
             '''int QSsl.SslOptions.__int__()'''
             return int()
         def __ixor__(self, f):
             '''QSsl.SslOptions QSsl.SslOptions.__ixor__(QSsl.SslOptions f)'''
             return QSsl.SslOptions()
         def __ior__(self, f):
             '''QSsl.SslOptions QSsl.SslOptions.__ior__(QSsl.SslOptions f)'''
             return QSsl.SslOptions()
         def __iand__(self, mask):
             '''QSsl.SslOptions QSsl.SslOptions.__iand__(int mask)'''
             return QSsl.SslOptions()
 
 
 class QSslCertificate():
     """"""
     # Enum QSslCertificate.SubjectInfo
     Organization = 0
     CommonName = 0
     LocalityName = 0
     OrganizationalUnitName = 0
     CountryName = 0
     StateOrProvinceName = 0
     DistinguishedNameQualifier = 0
     SerialNumber = 0
     EmailAddress = 0
 
     def __init__(self, device, format = None):
         '''void QSslCertificate.__init__(QIODevice device, QSsl.EncodingFormat format = QSsl.Pem)'''
     def __init__(self, data = QByteArray(), format = None):
         '''void QSslCertificate.__init__(QByteArray data = QByteArray(), QSsl.EncodingFormat format = QSsl.Pem)'''
     def __init__(self, other):
         '''void QSslCertificate.__init__(QSslCertificate other)'''
     def importPkcs12(self, device, key, certificate, caCertificates = None, passPhrase = QByteArray()):
         '''static bool QSslCertificate.importPkcs12(QIODevice device, QSslKey key, QSslCertificate certificate, list-of-QSslCertificate caCertificates = None, QByteArray passPhrase = QByteArray())'''
         return bool()
     def __hash__(self):
         '''int QSslCertificate.__hash__()'''
         return int()
     def isSelfSigned(self):
         '''bool QSslCertificate.isSelfSigned()'''
         return bool()
     def verify(self, certificateChain, hostName = str()):
         '''static list-of-QSslError QSslCertificate.verify(list-of-QSslCertificate certificateChain, str hostName = str())'''
         return [QSslError()]
     def toText(self):
         '''str QSslCertificate.toText()'''
         return str()
     def extensions(self):
         '''list-of-QSslCertificateExtension QSslCertificate.extensions()'''
         return [QSslCertificateExtension()]
     def issuerInfoAttributes(self):
         '''list-of-QByteArray QSslCertificate.issuerInfoAttributes()'''
         return [QByteArray()]
     def subjectInfoAttributes(self):
         '''list-of-QByteArray QSslCertificate.subjectInfoAttributes()'''
         return [QByteArray()]
     def isBlacklisted(self):
         '''bool QSslCertificate.isBlacklisted()'''
         return bool()
     def swap(self, other):
         '''void QSslCertificate.swap(QSslCertificate other)'''
     def handle(self):
         '''sip.voidptr QSslCertificate.handle()'''
         return sip.voidptr()
     def fromData(self, data, format = None):
         '''static list-of-QSslCertificate QSslCertificate.fromData(QByteArray data, QSsl.EncodingFormat format = QSsl.Pem)'''
         return [QSslCertificate()]
     def fromDevice(self, device, format = None):
         '''static list-of-QSslCertificate QSslCertificate.fromDevice(QIODevice device, QSsl.EncodingFormat format = QSsl.Pem)'''
         return [QSslCertificate()]
     def fromPath(self, path, format = None, syntax = None):
         '''static list-of-QSslCertificate QSslCertificate.fromPath(str path, QSsl.EncodingFormat format = QSsl.Pem, QRegExp.PatternSyntax syntax = QRegExp.FixedString)'''
         return [QSslCertificate()]
     def toDer(self):
         '''QByteArray QSslCertificate.toDer()'''
         return QByteArray()
     def toPem(self):
         '''QByteArray QSslCertificate.toPem()'''
         return QByteArray()
     def publicKey(self):
         '''QSslKey QSslCertificate.publicKey()'''
         return QSslKey()
     def expiryDate(self):
         '''QDateTime QSslCertificate.expiryDate()'''
         return QDateTime()
     def effectiveDate(self):
         '''QDateTime QSslCertificate.effectiveDate()'''
         return QDateTime()
     def subjectAlternativeNames(self):
         '''dict-of-QSsl.AlternativeNameEntryType-list-of-str QSslCertificate.subjectAlternativeNames()'''
         return {QSsl.AlternativeNameEntryType():list()}
     def subjectInfo(self, info):
         '''list-of-str QSslCertificate.subjectInfo(QSslCertificate.SubjectInfo info)'''
         return [str()]
     def subjectInfo(self, attribute):
         '''list-of-str QSslCertificate.subjectInfo(QByteArray attribute)'''
         return [str()]
     def issuerInfo(self, info):
         '''list-of-str QSslCertificate.issuerInfo(QSslCertificate.SubjectInfo info)'''
         return [str()]
     def issuerInfo(self, attribute):
         '''list-of-str QSslCertificate.issuerInfo(QByteArray attribute)'''
         return [str()]
     def digest(self, algorithm = None):
         '''QByteArray QSslCertificate.digest(QCryptographicHash.Algorithm algorithm = QCryptographicHash.Md5)'''
         return QByteArray()
     def serialNumber(self):
         '''QByteArray QSslCertificate.serialNumber()'''
         return QByteArray()
     def version(self):
         '''QByteArray QSslCertificate.version()'''
         return QByteArray()
     def clear(self):
         '''void QSslCertificate.clear()'''
     def isNull(self):
         '''bool QSslCertificate.isNull()'''
         return bool()
     def __ne__(self, other):
         '''bool QSslCertificate.__ne__(QSslCertificate other)'''
         return bool()
     def __eq__(self, other):
         '''bool QSslCertificate.__eq__(QSslCertificate other)'''
         return bool()
 
 
 class QSslCertificateExtension():
     """"""
     def __init__(self):
         '''void QSslCertificateExtension.__init__()'''
     def __init__(self, other):
         '''void QSslCertificateExtension.__init__(QSslCertificateExtension other)'''
     def isSupported(self):
         '''bool QSslCertificateExtension.isSupported()'''
         return bool()
     def isCritical(self):
         '''bool QSslCertificateExtension.isCritical()'''
         return bool()
     def value(self):
         '''QVariant QSslCertificateExtension.value()'''
         return QVariant()
     def name(self):
         '''str QSslCertificateExtension.name()'''
         return str()
     def oid(self):
         '''str QSslCertificateExtension.oid()'''
         return str()
     def swap(self, other):
         '''void QSslCertificateExtension.swap(QSslCertificateExtension other)'''
 
 
 class QSslConfiguration():
     """"""
     # Enum QSslConfiguration.NextProtocolNegotiationStatus
     NextProtocolNegotiationNone = 0
     NextProtocolNegotiationNegotiated = 0
     NextProtocolNegotiationUnsupported = 0
 
     NextProtocolHttp1_1 = None # str - member
     NextProtocolSpdy3_0 = None # str - member
     def __init__(self):
         '''void QSslConfiguration.__init__()'''
     def __init__(self, other):
         '''void QSslConfiguration.__init__(QSslConfiguration other)'''
     def supportedEllipticCurves(self):
         '''static list-of-QSslEllipticCurve QSslConfiguration.supportedEllipticCurves()'''
         return [QSslEllipticCurve()]
     def setEllipticCurves(self, curves):
         '''void QSslConfiguration.setEllipticCurves(list-of-QSslEllipticCurve curves)'''
     def ellipticCurves(self):
         '''list-of-QSslEllipticCurve QSslConfiguration.ellipticCurves()'''
         return [QSslEllipticCurve()]
     def systemCaCertificates(self):
         '''static list-of-QSslCertificate QSslConfiguration.systemCaCertificates()'''
         return [QSslCertificate()]
     def supportedCiphers(self):
         '''static list-of-QSslCipher QSslConfiguration.supportedCiphers()'''
         return [QSslCipher()]
     def sessionProtocol(self):
         '''QSsl.SslProtocol QSslConfiguration.sessionProtocol()'''
         return QSsl.SslProtocol()
     def nextProtocolNegotiationStatus(self):
         '''QSslConfiguration.NextProtocolNegotiationStatus QSslConfiguration.nextProtocolNegotiationStatus()'''
         return QSslConfiguration.NextProtocolNegotiationStatus()
     def nextNegotiatedProtocol(self):
         '''QByteArray QSslConfiguration.nextNegotiatedProtocol()'''
         return QByteArray()
     def allowedNextProtocols(self):
         '''list-of-QByteArray QSslConfiguration.allowedNextProtocols()'''
         return [QByteArray()]
     def setAllowedNextProtocols(self, protocols):
         '''void QSslConfiguration.setAllowedNextProtocols(list-of-QByteArray protocols)'''
     def sessionTicketLifeTimeHint(self):
         '''int QSslConfiguration.sessionTicketLifeTimeHint()'''
         return int()
     def setSessionTicket(self, sessionTicket):
         '''void QSslConfiguration.setSessionTicket(QByteArray sessionTicket)'''
     def sessionTicket(self):
         '''QByteArray QSslConfiguration.sessionTicket()'''
         return QByteArray()
     def setLocalCertificateChain(self, localChain):
         '''void QSslConfiguration.setLocalCertificateChain(list-of-QSslCertificate localChain)'''
     def localCertificateChain(self):
         '''list-of-QSslCertificate QSslConfiguration.localCertificateChain()'''
         return [QSslCertificate()]
     def swap(self, other):
         '''void QSslConfiguration.swap(QSslConfiguration other)'''
     def testSslOption(self, option):
         '''bool QSslConfiguration.testSslOption(QSsl.SslOption option)'''
         return bool()
     def setSslOption(self, option, on):
         '''void QSslConfiguration.setSslOption(QSsl.SslOption option, bool on)'''
     def __ne__(self, other):
         '''bool QSslConfiguration.__ne__(QSslConfiguration other)'''
         return bool()
     def __eq__(self, other):
         '''bool QSslConfiguration.__eq__(QSslConfiguration other)'''
         return bool()
     def setDefaultConfiguration(self, configuration):
         '''static void QSslConfiguration.setDefaultConfiguration(QSslConfiguration configuration)'''
     def defaultConfiguration(self):
         '''static QSslConfiguration QSslConfiguration.defaultConfiguration()'''
         return QSslConfiguration()
     def setCaCertificates(self, certificates):
         '''void QSslConfiguration.setCaCertificates(list-of-QSslCertificate certificates)'''
     def caCertificates(self):
         '''list-of-QSslCertificate QSslConfiguration.caCertificates()'''
         return [QSslCertificate()]
     def setCiphers(self, ciphers):
         '''void QSslConfiguration.setCiphers(list-of-QSslCipher ciphers)'''
     def ciphers(self):
         '''list-of-QSslCipher QSslConfiguration.ciphers()'''
         return [QSslCipher()]
     def setPrivateKey(self, key):
         '''void QSslConfiguration.setPrivateKey(QSslKey key)'''
     def privateKey(self):
         '''QSslKey QSslConfiguration.privateKey()'''
         return QSslKey()
     def sessionCipher(self):
         '''QSslCipher QSslConfiguration.sessionCipher()'''
         return QSslCipher()
     def peerCertificateChain(self):
         '''list-of-QSslCertificate QSslConfiguration.peerCertificateChain()'''
         return [QSslCertificate()]
     def peerCertificate(self):
         '''QSslCertificate QSslConfiguration.peerCertificate()'''
         return QSslCertificate()
     def setLocalCertificate(self, certificate):
         '''void QSslConfiguration.setLocalCertificate(QSslCertificate certificate)'''
     def localCertificate(self):
         '''QSslCertificate QSslConfiguration.localCertificate()'''
         return QSslCertificate()
     def setPeerVerifyDepth(self, depth):
         '''void QSslConfiguration.setPeerVerifyDepth(int depth)'''
     def peerVerifyDepth(self):
         '''int QSslConfiguration.peerVerifyDepth()'''
         return int()
     def setPeerVerifyMode(self, mode):
         '''void QSslConfiguration.setPeerVerifyMode(QSslSocket.PeerVerifyMode mode)'''
     def peerVerifyMode(self):
         '''QSslSocket.PeerVerifyMode QSslConfiguration.peerVerifyMode()'''
         return QSslSocket.PeerVerifyMode()
     def setProtocol(self, protocol):
         '''void QSslConfiguration.setProtocol(QSsl.SslProtocol protocol)'''
     def protocol(self):
         '''QSsl.SslProtocol QSslConfiguration.protocol()'''
         return QSsl.SslProtocol()
     def isNull(self):
         '''bool QSslConfiguration.isNull()'''
         return bool()
 
 
 class QSslCipher():
     """"""
     def __init__(self):
         '''void QSslCipher.__init__()'''
     def __init__(self, name):
         '''void QSslCipher.__init__(str name)'''
     def __init__(self, name, protocol):
         '''void QSslCipher.__init__(str name, QSsl.SslProtocol protocol)'''
     def __init__(self, other):
         '''void QSslCipher.__init__(QSslCipher other)'''
     def swap(self, other):
         '''void QSslCipher.swap(QSslCipher other)'''
     def protocol(self):
         '''QSsl.SslProtocol QSslCipher.protocol()'''
         return QSsl.SslProtocol()
     def protocolString(self):
         '''str QSslCipher.protocolString()'''
         return str()
     def encryptionMethod(self):
         '''str QSslCipher.encryptionMethod()'''
         return str()
     def authenticationMethod(self):
         '''str QSslCipher.authenticationMethod()'''
         return str()
     def keyExchangeMethod(self):
         '''str QSslCipher.keyExchangeMethod()'''
         return str()
     def usedBits(self):
         '''int QSslCipher.usedBits()'''
         return int()
     def supportedBits(self):
         '''int QSslCipher.supportedBits()'''
         return int()
     def name(self):
         '''str QSslCipher.name()'''
         return str()
     def isNull(self):
         '''bool QSslCipher.isNull()'''
         return bool()
     def __ne__(self, other):
         '''bool QSslCipher.__ne__(QSslCipher other)'''
         return bool()
     def __eq__(self, other):
         '''bool QSslCipher.__eq__(QSslCipher other)'''
         return bool()
 
 
 class QSslEllipticCurve():
     """"""
     def __init__(self):
         '''void QSslEllipticCurve.__init__()'''
     def __init__(self):
         '''QSslEllipticCurve QSslEllipticCurve.__init__()'''
         return QSslEllipticCurve()
     def __eq__(self, rhs):
         '''bool QSslEllipticCurve.__eq__(QSslEllipticCurve rhs)'''
         return bool()
     def __ne__(self, rhs):
         '''bool QSslEllipticCurve.__ne__(QSslEllipticCurve rhs)'''
         return bool()
     def __hash__(self):
         '''int QSslEllipticCurve.__hash__()'''
         return int()
     def isTlsNamedCurve(self):
         '''bool QSslEllipticCurve.isTlsNamedCurve()'''
         return bool()
     def isValid(self):
         '''bool QSslEllipticCurve.isValid()'''
         return bool()
     def longName(self):
         '''str QSslEllipticCurve.longName()'''
         return str()
     def shortName(self):
         '''str QSslEllipticCurve.shortName()'''
         return str()
     def fromLongName(self, name):
         '''static QSslEllipticCurve QSslEllipticCurve.fromLongName(str name)'''
         return QSslEllipticCurve()
     def fromShortName(self, name):
         '''static QSslEllipticCurve QSslEllipticCurve.fromShortName(str name)'''
         return QSslEllipticCurve()
 
 
 class QSslError():
     """"""
     # Enum QSslError.SslError
     UnspecifiedError = 0
     NoError = 0
     UnableToGetIssuerCertificate = 0
     UnableToDecryptCertificateSignature = 0
     UnableToDecodeIssuerPublicKey = 0
     CertificateSignatureFailed = 0
     CertificateNotYetValid = 0
     CertificateExpired = 0
     InvalidNotBeforeField = 0
     InvalidNotAfterField = 0
     SelfSignedCertificate = 0
     SelfSignedCertificateInChain = 0
     UnableToGetLocalIssuerCertificate = 0
     UnableToVerifyFirstCertificate = 0
     CertificateRevoked = 0
     InvalidCaCertificate = 0
     PathLengthExceeded = 0
     InvalidPurpose = 0
     CertificateUntrusted = 0
     CertificateRejected = 0
     SubjectIssuerMismatch = 0
     AuthorityIssuerSerialNumberMismatch = 0
     NoPeerCertificate = 0
     HostNameMismatch = 0
     NoSslSupport = 0
     CertificateBlacklisted = 0
 
     def __init__(self):
         '''void QSslError.__init__()'''
     def __init__(self, error):
         '''void QSslError.__init__(QSslError.SslError error)'''
     def __init__(self, error, certificate):
         '''void QSslError.__init__(QSslError.SslError error, QSslCertificate certificate)'''
     def __init__(self, other):
         '''void QSslError.__init__(QSslError other)'''
     def __hash__(self):
         '''int QSslError.__hash__()'''
         return int()
     def swap(self, other):
         '''void QSslError.swap(QSslError other)'''
     def __ne__(self, other):
         '''bool QSslError.__ne__(QSslError other)'''
         return bool()
     def __eq__(self, other):
         '''bool QSslError.__eq__(QSslError other)'''
         return bool()
     def certificate(self):
         '''QSslCertificate QSslError.certificate()'''
         return QSslCertificate()
     def errorString(self):
         '''str QSslError.errorString()'''
         return str()
     def error(self):
         '''QSslError.SslError QSslError.error()'''
         return QSslError.SslError()
 
 
 class QSslKey():
     """"""
     def __init__(self):
         '''void QSslKey.__init__()'''
     def __init__(self, encoded, algorithm, encoding = None, type = None, passPhrase = QByteArray()):
         '''void QSslKey.__init__(QByteArray encoded, QSsl.KeyAlgorithm algorithm, QSsl.EncodingFormat encoding = QSsl.Pem, QSsl.KeyType type = QSsl.PrivateKey, QByteArray passPhrase = QByteArray())'''
     def __init__(self, device, algorithm, encoding = None, type = None, passPhrase = QByteArray()):
         '''void QSslKey.__init__(QIODevice device, QSsl.KeyAlgorithm algorithm, QSsl.EncodingFormat encoding = QSsl.Pem, QSsl.KeyType type = QSsl.PrivateKey, QByteArray passPhrase = QByteArray())'''
     def __init__(self, handle, type = None):
         '''void QSslKey.__init__(sip.voidptr handle, QSsl.KeyType type = QSsl.PrivateKey)'''
     def __init__(self, other):
         '''void QSslKey.__init__(QSslKey other)'''
     def swap(self, other):
         '''void QSslKey.swap(QSslKey other)'''
     def __ne__(self, key):
         '''bool QSslKey.__ne__(QSslKey key)'''
         return bool()
     def __eq__(self, key):
         '''bool QSslKey.__eq__(QSslKey key)'''
         return bool()
     def handle(self):
         '''sip.voidptr QSslKey.handle()'''
         return sip.voidptr()
     def toDer(self, passPhrase = QByteArray()):
         '''QByteArray QSslKey.toDer(QByteArray passPhrase = QByteArray())'''
         return QByteArray()
     def toPem(self, passPhrase = QByteArray()):
         '''QByteArray QSslKey.toPem(QByteArray passPhrase = QByteArray())'''
         return QByteArray()
     def algorithm(self):
         '''QSsl.KeyAlgorithm QSslKey.algorithm()'''
         return QSsl.KeyAlgorithm()
     def type(self):
         '''QSsl.KeyType QSslKey.type()'''
         return QSsl.KeyType()
     def length(self):
         '''int QSslKey.length()'''
         return int()
     def clear(self):
         '''void QSslKey.clear()'''
     def isNull(self):
         '''bool QSslKey.isNull()'''
         return bool()
 
 
 class QSslPreSharedKeyAuthenticator():
     """"""
     def __init__(self):
         '''void QSslPreSharedKeyAuthenticator.__init__()'''
     def __init__(self, authenticator):
         '''void QSslPreSharedKeyAuthenticator.__init__(QSslPreSharedKeyAuthenticator authenticator)'''
     def __eq__(self, rhs):
         '''bool QSslPreSharedKeyAuthenticator.__eq__(QSslPreSharedKeyAuthenticator rhs)'''
         return bool()
     def __ne__(self, rhs):
         '''bool QSslPreSharedKeyAuthenticator.__ne__(QSslPreSharedKeyAuthenticator rhs)'''
         return bool()
     def maximumPreSharedKeyLength(self):
         '''int QSslPreSharedKeyAuthenticator.maximumPreSharedKeyLength()'''
         return int()
     def preSharedKey(self):
         '''QByteArray QSslPreSharedKeyAuthenticator.preSharedKey()'''
         return QByteArray()
     def setPreSharedKey(self, preSharedKey):
         '''void QSslPreSharedKeyAuthenticator.setPreSharedKey(QByteArray preSharedKey)'''
     def maximumIdentityLength(self):
         '''int QSslPreSharedKeyAuthenticator.maximumIdentityLength()'''
         return int()
     def identity(self):
         '''QByteArray QSslPreSharedKeyAuthenticator.identity()'''
         return QByteArray()
     def setIdentity(self, identity):
         '''void QSslPreSharedKeyAuthenticator.setIdentity(QByteArray identity)'''
     def identityHint(self):
         '''QByteArray QSslPreSharedKeyAuthenticator.identityHint()'''
         return QByteArray()
     def swap(self, authenticator):
         '''void QSslPreSharedKeyAuthenticator.swap(QSslPreSharedKeyAuthenticator authenticator)'''
 
 
 class QTcpSocket(QAbstractSocket):
     """"""
     def __init__(self, parent = None):
         '''void QTcpSocket.__init__(QObject parent = None)'''
 
 
 class QSslSocket(QTcpSocket):
     """"""
     # Enum QSslSocket.PeerVerifyMode
     VerifyNone = 0
     QueryPeer = 0
     VerifyPeer = 0
     AutoVerifyPeer = 0
 
     # Enum QSslSocket.SslMode
     UnencryptedMode = 0
     SslClientMode = 0
     SslServerMode = 0
 
     def __init__(self, parent = None):
         '''void QSslSocket.__init__(QObject parent = None)'''
     def sslLibraryBuildVersionString(self):
         '''static str QSslSocket.sslLibraryBuildVersionString()'''
         return str()
     def sslLibraryBuildVersionNumber(self):
         '''static int QSslSocket.sslLibraryBuildVersionNumber()'''
         return int()
     def sessionProtocol(self):
         '''QSsl.SslProtocol QSslSocket.sessionProtocol()'''
         return QSsl.SslProtocol()
     def localCertificateChain(self):
         '''list-of-QSslCertificate QSslSocket.localCertificateChain()'''
         return [QSslCertificate()]
     def setLocalCertificateChain(self, localChain):
         '''void QSslSocket.setLocalCertificateChain(list-of-QSslCertificate localChain)'''
     def sslLibraryVersionString(self):
         '''static str QSslSocket.sslLibraryVersionString()'''
         return str()
     def sslLibraryVersionNumber(self):
         '''static int QSslSocket.sslLibraryVersionNumber()'''
         return int()
     def disconnectFromHost(self):
         '''void QSslSocket.disconnectFromHost()'''
     def connectToHost(self, hostName, port, mode = None, protocol = None):
         '''void QSslSocket.connectToHost(str hostName, int port, QIODevice.OpenMode mode = QIODevice.ReadWrite, QAbstractSocket.NetworkLayerProtocol protocol = QAbstractSocket.AnyIPProtocol)'''
     def resume(self):
         '''void QSslSocket.resume()'''
     def setPeerVerifyName(self, hostName):
         '''void QSslSocket.setPeerVerifyName(str hostName)'''
     def peerVerifyName(self):
         '''str QSslSocket.peerVerifyName()'''
         return str()
     def socketOption(self, option):
         '''QVariant QSslSocket.socketOption(QAbstractSocket.SocketOption option)'''
         return QVariant()
     def setSocketOption(self, option, value):
         '''void QSslSocket.setSocketOption(QAbstractSocket.SocketOption option, QVariant value)'''
     encryptedBytesWritten = pyqtSignal() # void encryptedBytesWritten(qint64) - signal
     peerVerifyError = pyqtSignal() # void peerVerifyError(const QSslErroramp;) - signal
     def setSslConfiguration(self, config):
         '''void QSslSocket.setSslConfiguration(QSslConfiguration config)'''
     def sslConfiguration(self):
         '''QSslConfiguration QSslSocket.sslConfiguration()'''
         return QSslConfiguration()
     def encryptedBytesToWrite(self):
         '''int QSslSocket.encryptedBytesToWrite()'''
         return int()
     def encryptedBytesAvailable(self):
         '''int QSslSocket.encryptedBytesAvailable()'''
         return int()
     def setReadBufferSize(self, size):
         '''void QSslSocket.setReadBufferSize(int size)'''
     def setPeerVerifyDepth(self, depth):
         '''void QSslSocket.setPeerVerifyDepth(int depth)'''
     def peerVerifyDepth(self):
         '''int QSslSocket.peerVerifyDepth()'''
         return int()
     def setPeerVerifyMode(self, mode):
         '''void QSslSocket.setPeerVerifyMode(QSslSocket.PeerVerifyMode mode)'''
     def peerVerifyMode(self):
         '''QSslSocket.PeerVerifyMode QSslSocket.peerVerifyMode()'''
         return QSslSocket.PeerVerifyMode()
     def writeData(self, data):
         '''int QSslSocket.writeData(str data)'''
         return int()
     def readData(self, maxlen):
         '''str QSslSocket.readData(int maxlen)'''
         return str()
     preSharedKeyAuthenticationRequired = pyqtSignal() # void preSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator*) - signal
     modeChanged = pyqtSignal() # void modeChanged(QSslSocket::SslMode) - signal
     encrypted = pyqtSignal() # void encrypted() - signal
     def ignoreSslErrors(self):
         '''void QSslSocket.ignoreSslErrors()'''
     def ignoreSslErrors(self, errors):
         '''void QSslSocket.ignoreSslErrors(list-of-QSslError errors)'''
     def startServerEncryption(self):
         '''void QSslSocket.startServerEncryption()'''
     def startClientEncryption(self):
         '''void QSslSocket.startClientEncryption()'''
     def supportsSsl(self):
         '''static bool QSslSocket.supportsSsl()'''
         return bool()
     def sslErrors(self):
         '''list-of-QSslError QSslSocket.sslErrors()'''
         return [QSslError()]
     sslErrors = pyqtSignal() # void sslErrors(const QListlt;QSslErrorgt;amp;) - signal
     def waitForDisconnected(self, msecs = 30000):
         '''bool QSslSocket.waitForDisconnected(int msecs = 30000)'''
         return bool()
     def waitForBytesWritten(self, msecs = 30000):
         '''bool QSslSocket.waitForBytesWritten(int msecs = 30000)'''
         return bool()
     def waitForReadyRead(self, msecs = 30000):
         '''bool QSslSocket.waitForReadyRead(int msecs = 30000)'''
         return bool()
     def waitForEncrypted(self, msecs = 30000):
         '''bool QSslSocket.waitForEncrypted(int msecs = 30000)'''
         return bool()
     def waitForConnected(self, msecs = 30000):
         '''bool QSslSocket.waitForConnected(int msecs = 30000)'''
         return bool()
     def systemCaCertificates(self):
         '''static list-of-QSslCertificate QSslSocket.systemCaCertificates()'''
         return [QSslCertificate()]
     def defaultCaCertificates(self):
         '''static list-of-QSslCertificate QSslSocket.defaultCaCertificates()'''
         return [QSslCertificate()]
     def setDefaultCaCertificates(self, certificates):
         '''static void QSslSocket.setDefaultCaCertificates(list-of-QSslCertificate certificates)'''
     def addDefaultCaCertificate(self, certificate):
         '''static void QSslSocket.addDefaultCaCertificate(QSslCertificate certificate)'''
     def addDefaultCaCertificates(self, path, format = None, syntax = None):
         '''static bool QSslSocket.addDefaultCaCertificates(str path, QSsl.EncodingFormat format = QSsl.Pem, QRegExp.PatternSyntax syntax = QRegExp.FixedString)'''
         return bool()
     def addDefaultCaCertificates(self, certificates):
         '''static void QSslSocket.addDefaultCaCertificates(list-of-QSslCertificate certificates)'''
     def caCertificates(self):
         '''list-of-QSslCertificate QSslSocket.caCertificates()'''
         return [QSslCertificate()]
     def setCaCertificates(self, certificates):
         '''void QSslSocket.setCaCertificates(list-of-QSslCertificate certificates)'''
     def addCaCertificate(self, certificate):
         '''void QSslSocket.addCaCertificate(QSslCertificate certificate)'''
     def addCaCertificates(self, path, format = None, syntax = None):
         '''bool QSslSocket.addCaCertificates(str path, QSsl.EncodingFormat format = QSsl.Pem, QRegExp.PatternSyntax syntax = QRegExp.FixedString)'''
         return bool()
     def addCaCertificates(self, certificates):
         '''void QSslSocket.addCaCertificates(list-of-QSslCertificate certificates)'''
     def supportedCiphers(self):
         '''static list-of-QSslCipher QSslSocket.supportedCiphers()'''
         return [QSslCipher()]
     def defaultCiphers(self):
         '''static list-of-QSslCipher QSslSocket.defaultCiphers()'''
         return [QSslCipher()]
     def setDefaultCiphers(self, ciphers):
         '''static void QSslSocket.setDefaultCiphers(list-of-QSslCipher ciphers)'''
     def setCiphers(self, ciphers):
         '''void QSslSocket.setCiphers(list-of-QSslCipher ciphers)'''
     def setCiphers(self, ciphers):
         '''void QSslSocket.setCiphers(str ciphers)'''
     def ciphers(self):
         '''list-of-QSslCipher QSslSocket.ciphers()'''
         return [QSslCipher()]
     def privateKey(self):
         '''QSslKey QSslSocket.privateKey()'''
         return QSslKey()
     def setPrivateKey(self, key):
         '''void QSslSocket.setPrivateKey(QSslKey key)'''
     def setPrivateKey(self, fileName, algorithm = None, format = None, passPhrase = QByteArray()):
         '''void QSslSocket.setPrivateKey(str fileName, QSsl.KeyAlgorithm algorithm = QSsl.Rsa, QSsl.EncodingFormat format = QSsl.Pem, QByteArray passPhrase = QByteArray())'''
     def sessionCipher(self):
         '''QSslCipher QSslSocket.sessionCipher()'''
         return QSslCipher()
     def peerCertificateChain(self):
         '''list-of-QSslCertificate QSslSocket.peerCertificateChain()'''
         return [QSslCertificate()]
     def peerCertificate(self):
         '''QSslCertificate QSslSocket.peerCertificate()'''
         return QSslCertificate()
     def localCertificate(self):
         '''QSslCertificate QSslSocket.localCertificate()'''
         return QSslCertificate()
     def setLocalCertificate(self, certificate):
         '''void QSslSocket.setLocalCertificate(QSslCertificate certificate)'''
     def setLocalCertificate(self, path, format = None):
         '''void QSslSocket.setLocalCertificate(str path, QSsl.EncodingFormat format = QSsl.Pem)'''
     def abort(self):
         '''void QSslSocket.abort()'''
     def flush(self):
         '''bool QSslSocket.flush()'''
         return bool()
     def atEnd(self):
         '''bool QSslSocket.atEnd()'''
         return bool()
     def close(self):
         '''void QSslSocket.close()'''
     def canReadLine(self):
         '''bool QSslSocket.canReadLine()'''
         return bool()
     def bytesToWrite(self):
         '''int QSslSocket.bytesToWrite()'''
         return int()
     def bytesAvailable(self):
         '''int QSslSocket.bytesAvailable()'''
         return int()
     def setProtocol(self, protocol):
         '''void QSslSocket.setProtocol(QSsl.SslProtocol protocol)'''
     def protocol(self):
         '''QSsl.SslProtocol QSslSocket.protocol()'''
         return QSsl.SslProtocol()
     def isEncrypted(self):
         '''bool QSslSocket.isEncrypted()'''
         return bool()
     def mode(self):
         '''QSslSocket.SslMode QSslSocket.mode()'''
         return QSslSocket.SslMode()
     def setSocketDescriptor(self, socketDescriptor, state = None, mode = None):
         '''bool QSslSocket.setSocketDescriptor(sip.voidptr socketDescriptor, QAbstractSocket.SocketState state = QAbstractSocket.ConnectedState, QIODevice.OpenMode mode = QIODevice.ReadWrite)'''
         return bool()
     def connectToHostEncrypted(self, hostName, port, mode = None, protocol = None):
         '''void QSslSocket.connectToHostEncrypted(str hostName, int port, QIODevice.OpenMode mode = QIODevice.ReadWrite, QAbstractSocket.NetworkLayerProtocol protocol = QAbstractSocket.AnyIPProtocol)'''
     def connectToHostEncrypted(self, hostName, port, sslPeerName, mode = None, protocol = None):
         '''void QSslSocket.connectToHostEncrypted(str hostName, int port, str sslPeerName, QIODevice.OpenMode mode = QIODevice.ReadWrite, QAbstractSocket.NetworkLayerProtocol protocol = QAbstractSocket.AnyIPProtocol)'''
 
 
 class QTcpServer(QObject):
     """"""
     def __init__(self, parent = None):
         '''void QTcpServer.__init__(QObject parent = None)'''
     acceptError = pyqtSignal() # void acceptError(QAbstractSocket::SocketError) - signal
     newConnection = pyqtSignal() # void newConnection() - signal
     def addPendingConnection(self, socket):
         '''void QTcpServer.addPendingConnection(QTcpSocket socket)'''
     def incomingConnection(self, handle):
         '''void QTcpServer.incomingConnection(sip.voidptr handle)'''
     def resumeAccepting(self):
         '''void QTcpServer.resumeAccepting()'''
     def pauseAccepting(self):
         '''void QTcpServer.pauseAccepting()'''
     def proxy(self):
         '''QNetworkProxy QTcpServer.proxy()'''
         return QNetworkProxy()
     def setProxy(self, networkProxy):
         '''void QTcpServer.setProxy(QNetworkProxy networkProxy)'''
     def errorString(self):
         '''str QTcpServer.errorString()'''
         return str()
     def serverError(self):
         '''QAbstractSocket.SocketError QTcpServer.serverError()'''
         return QAbstractSocket.SocketError()
     def nextPendingConnection(self):
         '''QTcpSocket QTcpServer.nextPendingConnection()'''
         return QTcpSocket()
     def hasPendingConnections(self):
         '''bool QTcpServer.hasPendingConnections()'''
         return bool()
     def waitForNewConnection(self, msecs = 0, timedOut = None):
         '''bool QTcpServer.waitForNewConnection(int msecs = 0, bool timedOut)'''
         return bool()
     def setSocketDescriptor(self, socketDescriptor):
         '''bool QTcpServer.setSocketDescriptor(sip.voidptr socketDescriptor)'''
         return bool()
     def socketDescriptor(self):
         '''sip.voidptr QTcpServer.socketDescriptor()'''
         return sip.voidptr()
     def serverAddress(self):
         '''QHostAddress QTcpServer.serverAddress()'''
         return QHostAddress()
     def serverPort(self):
         '''int QTcpServer.serverPort()'''
         return int()
     def maxPendingConnections(self):
         '''int QTcpServer.maxPendingConnections()'''
         return int()
     def setMaxPendingConnections(self, numConnections):
         '''void QTcpServer.setMaxPendingConnections(int numConnections)'''
     def isListening(self):
         '''bool QTcpServer.isListening()'''
         return bool()
     def close(self):
         '''void QTcpServer.close()'''
     def listen(self, address = None, port = 0):
         '''bool QTcpServer.listen(QHostAddress address = QHostAddress.Any, int port = 0)'''
         return bool()
 
 
 class QUdpSocket(QAbstractSocket):
     """"""
     def __init__(self, parent = None):
         '''void QUdpSocket.__init__(QObject parent = None)'''
     def setMulticastInterface(self, iface):
         '''void QUdpSocket.setMulticastInterface(QNetworkInterface iface)'''
     def multicastInterface(self):
         '''QNetworkInterface QUdpSocket.multicastInterface()'''
         return QNetworkInterface()
     def leaveMulticastGroup(self, groupAddress):
         '''bool QUdpSocket.leaveMulticastGroup(QHostAddress groupAddress)'''
         return bool()
     def leaveMulticastGroup(self, groupAddress, iface):
         '''bool QUdpSocket.leaveMulticastGroup(QHostAddress groupAddress, QNetworkInterface iface)'''
         return bool()
     def joinMulticastGroup(self, groupAddress):
         '''bool QUdpSocket.joinMulticastGroup(QHostAddress groupAddress)'''
         return bool()
     def joinMulticastGroup(self, groupAddress, iface):
         '''bool QUdpSocket.joinMulticastGroup(QHostAddress groupAddress, QNetworkInterface iface)'''
         return bool()
     def writeDatagram(self, data, host, port):
         '''int QUdpSocket.writeDatagram(str data, QHostAddress host, int port)'''
         return int()
     def writeDatagram(self, datagram, host, port):
         '''int QUdpSocket.writeDatagram(QByteArray datagram, QHostAddress host, int port)'''
         return int()
     def readDatagram(self, maxlen, host, port):
         '''str QUdpSocket.readDatagram(int maxlen, QHostAddress host, int port)'''
         return str()
     def pendingDatagramSize(self):
         '''int QUdpSocket.pendingDatagramSize()'''
         return int()
     def hasPendingDatagrams(self):
         '''bool QUdpSocket.hasPendingDatagrams()'''
         return bool()