mapped qbytearray to string

bluetooth/bluetooth.cpp

@@ -64,6 +64,7 @@ void QBluetoothAddress_DestroyQBluetoothAddress(void* ptr){
 class MyQBluetoothDeviceDiscoveryAgent: public QBluetoothDeviceDiscoveryAgent {
 public:
 	void Signal_Canceled() { callbackQBluetoothDeviceDiscoveryAgentCanceled(this, this->objectName().toUtf8().data()); };
+	void Signal_DeviceDiscovered(const QBluetoothDeviceInfo & info) { callbackQBluetoothDeviceDiscoveryAgentDeviceDiscovered(this, this->objectName().toUtf8().data(), new QBluetoothDeviceInfo(info)); };
 	void Signal_Error2(QBluetoothDeviceDiscoveryAgent::Error error) { callbackQBluetoothDeviceDiscoveryAgentError2(this, this->objectName().toUtf8().data(), error); };
 	void Signal_Finished() { callbackQBluetoothDeviceDiscoveryAgentFinished(this, this->objectName().toUtf8().data()); };
 	void timerEvent(QTimerEvent * event) { callbackQBluetoothDeviceDiscoveryAgentTimerEvent(this, this->objectName().toUtf8().data(), event); };
@@ -83,6 +84,18 @@ void QBluetoothDeviceDiscoveryAgent_Canceled(void* ptr){
 	static_cast<QBluetoothDeviceDiscoveryAgent*>(ptr)->canceled();
 }
 
+void QBluetoothDeviceDiscoveryAgent_ConnectDeviceDiscovered(void* ptr){
+	QObject::connect(static_cast<QBluetoothDeviceDiscoveryAgent*>(ptr), static_cast<void (QBluetoothDeviceDiscoveryAgent::*)(const QBluetoothDeviceInfo &)>(&QBluetoothDeviceDiscoveryAgent::deviceDiscovered), static_cast<MyQBluetoothDeviceDiscoveryAgent*>(ptr), static_cast<void (MyQBluetoothDeviceDiscoveryAgent::*)(const QBluetoothDeviceInfo &)>(&MyQBluetoothDeviceDiscoveryAgent::Signal_DeviceDiscovered));;
+}
+
+void QBluetoothDeviceDiscoveryAgent_DisconnectDeviceDiscovered(void* ptr){
+	QObject::disconnect(static_cast<QBluetoothDeviceDiscoveryAgent*>(ptr), static_cast<void (QBluetoothDeviceDiscoveryAgent::*)(const QBluetoothDeviceInfo &)>(&QBluetoothDeviceDiscoveryAgent::deviceDiscovered), static_cast<MyQBluetoothDeviceDiscoveryAgent*>(ptr), static_cast<void (MyQBluetoothDeviceDiscoveryAgent::*)(const QBluetoothDeviceInfo &)>(&MyQBluetoothDeviceDiscoveryAgent::Signal_DeviceDiscovered));;
+}
+
+void QBluetoothDeviceDiscoveryAgent_DeviceDiscovered(void* ptr, void* info){
+	static_cast<QBluetoothDeviceDiscoveryAgent*>(ptr)->deviceDiscovered(*static_cast<QBluetoothDeviceInfo*>(info));
+}
+
 void QBluetoothDeviceDiscoveryAgent_ConnectError2(void* ptr){
 	QObject::connect(static_cast<QBluetoothDeviceDiscoveryAgent*>(ptr), static_cast<void (QBluetoothDeviceDiscoveryAgent::*)(QBluetoothDeviceDiscoveryAgent::Error)>(&QBluetoothDeviceDiscoveryAgent::error), static_cast<MyQBluetoothDeviceDiscoveryAgent*>(ptr), static_cast<void (MyQBluetoothDeviceDiscoveryAgent::*)(QBluetoothDeviceDiscoveryAgent::Error)>(&MyQBluetoothDeviceDiscoveryAgent::Signal_Error2));;
 }
@@ -179,10 +192,18 @@ void* QBluetoothDeviceInfo_NewQBluetoothDeviceInfo4(void* other){
 	return new QBluetoothDeviceInfo(*static_cast<QBluetoothDeviceInfo*>(other));
 }
 
+void* QBluetoothDeviceInfo_Address(void* ptr){
+	return new QBluetoothAddress(static_cast<QBluetoothDeviceInfo*>(ptr)->address());
+}
+
 int QBluetoothDeviceInfo_CoreConfigurations(void* ptr){
 	return static_cast<QBluetoothDeviceInfo*>(ptr)->coreConfigurations();
 }
 
+void* QBluetoothDeviceInfo_DeviceUuid(void* ptr){
+	return new QBluetoothUuid(static_cast<QBluetoothDeviceInfo*>(ptr)->deviceUuid());
+}
+
 int QBluetoothDeviceInfo_IsCached(void* ptr){
 	return static_cast<QBluetoothDeviceInfo*>(ptr)->isCached();
 }
@@ -231,6 +252,10 @@ void* QBluetoothHostInfo_NewQBluetoothHostInfo2(void* other){
 	return new QBluetoothHostInfo(*static_cast<QBluetoothHostInfo*>(other));
 }
 
+void* QBluetoothHostInfo_Address(void* ptr){
+	return new QBluetoothAddress(static_cast<QBluetoothHostInfo*>(ptr)->address());
+}
+
 char* QBluetoothHostInfo_Name(void* ptr){
 	return static_cast<QBluetoothHostInfo*>(ptr)->name().toUtf8().data();
 }
@@ -251,13 +276,42 @@ class MyQBluetoothLocalDevice: public QBluetoothLocalDevice {
 public:
 	MyQBluetoothLocalDevice(QObject *parent) : QBluetoothLocalDevice(parent) {};
 	MyQBluetoothLocalDevice(const QBluetoothAddress &address, QObject *parent) : QBluetoothLocalDevice(address, parent) {};
+	void Signal_DeviceConnected(const QBluetoothAddress & address) { callbackQBluetoothLocalDeviceDeviceConnected(this, this->objectName().toUtf8().data(), new QBluetoothAddress(address)); };
+	void Signal_DeviceDisconnected(const QBluetoothAddress & address) { callbackQBluetoothLocalDeviceDeviceDisconnected(this, this->objectName().toUtf8().data(), new QBluetoothAddress(address)); };
 	void Signal_Error(QBluetoothLocalDevice::Error error) { callbackQBluetoothLocalDeviceError(this, this->objectName().toUtf8().data(), error); };
 	void Signal_HostModeStateChanged(QBluetoothLocalDevice::HostMode state) { callbackQBluetoothLocalDeviceHostModeStateChanged(this, this->objectName().toUtf8().data(), state); };
+	void Signal_PairingDisplayConfirmation(const QBluetoothAddress & address, QString pin) { callbackQBluetoothLocalDevicePairingDisplayConfirmation(this, this->objectName().toUtf8().data(), new QBluetoothAddress(address), pin.toUtf8().data()); };
+	void Signal_PairingDisplayPinCode(const QBluetoothAddress & address, QString pin) { callbackQBluetoothLocalDevicePairingDisplayPinCode(this, this->objectName().toUtf8().data(), new QBluetoothAddress(address), pin.toUtf8().data()); };
+	void Signal_PairingFinished(const QBluetoothAddress & address, QBluetoothLocalDevice::Pairing pairing) { callbackQBluetoothLocalDevicePairingFinished(this, this->objectName().toUtf8().data(), new QBluetoothAddress(address), pairing); };
 	void timerEvent(QTimerEvent * event) { callbackQBluetoothLocalDeviceTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQBluetoothLocalDeviceChildEvent(this, this->objectName().toUtf8().data(), event); };
 	void customEvent(QEvent * event) { callbackQBluetoothLocalDeviceCustomEvent(this, this->objectName().toUtf8().data(), event); };
 };
 
+void QBluetoothLocalDevice_ConnectDeviceConnected(void* ptr){
+	QObject::connect(static_cast<QBluetoothLocalDevice*>(ptr), static_cast<void (QBluetoothLocalDevice::*)(const QBluetoothAddress &)>(&QBluetoothLocalDevice::deviceConnected), static_cast<MyQBluetoothLocalDevice*>(ptr), static_cast<void (MyQBluetoothLocalDevice::*)(const QBluetoothAddress &)>(&MyQBluetoothLocalDevice::Signal_DeviceConnected));;
+}
+
+void QBluetoothLocalDevice_DisconnectDeviceConnected(void* ptr){
+	QObject::disconnect(static_cast<QBluetoothLocalDevice*>(ptr), static_cast<void (QBluetoothLocalDevice::*)(const QBluetoothAddress &)>(&QBluetoothLocalDevice::deviceConnected), static_cast<MyQBluetoothLocalDevice*>(ptr), static_cast<void (MyQBluetoothLocalDevice::*)(const QBluetoothAddress &)>(&MyQBluetoothLocalDevice::Signal_DeviceConnected));;
+}
+
+void QBluetoothLocalDevice_DeviceConnected(void* ptr, void* address){
+	static_cast<QBluetoothLocalDevice*>(ptr)->deviceConnected(*static_cast<QBluetoothAddress*>(address));
+}
+
+void QBluetoothLocalDevice_ConnectDeviceDisconnected(void* ptr){
+	QObject::connect(static_cast<QBluetoothLocalDevice*>(ptr), static_cast<void (QBluetoothLocalDevice::*)(const QBluetoothAddress &)>(&QBluetoothLocalDevice::deviceDisconnected), static_cast<MyQBluetoothLocalDevice*>(ptr), static_cast<void (MyQBluetoothLocalDevice::*)(const QBluetoothAddress &)>(&MyQBluetoothLocalDevice::Signal_DeviceDisconnected));;
+}
+
+void QBluetoothLocalDevice_DisconnectDeviceDisconnected(void* ptr){
+	QObject::disconnect(static_cast<QBluetoothLocalDevice*>(ptr), static_cast<void (QBluetoothLocalDevice::*)(const QBluetoothAddress &)>(&QBluetoothLocalDevice::deviceDisconnected), static_cast<MyQBluetoothLocalDevice*>(ptr), static_cast<void (MyQBluetoothLocalDevice::*)(const QBluetoothAddress &)>(&MyQBluetoothLocalDevice::Signal_DeviceDisconnected));;
+}
+
+void QBluetoothLocalDevice_DeviceDisconnected(void* ptr, void* address){
+	static_cast<QBluetoothLocalDevice*>(ptr)->deviceDisconnected(*static_cast<QBluetoothAddress*>(address));
+}
+
 void QBluetoothLocalDevice_ConnectError(void* ptr){
 	QObject::connect(static_cast<QBluetoothLocalDevice*>(ptr), static_cast<void (QBluetoothLocalDevice::*)(QBluetoothLocalDevice::Error)>(&QBluetoothLocalDevice::error), static_cast<MyQBluetoothLocalDevice*>(ptr), static_cast<void (MyQBluetoothLocalDevice::*)(QBluetoothLocalDevice::Error)>(&MyQBluetoothLocalDevice::Signal_Error));;
 }
@@ -282,6 +336,42 @@ void QBluetoothLocalDevice_HostModeStateChanged(void* ptr, int state){
 	static_cast<QBluetoothLocalDevice*>(ptr)->hostModeStateChanged(static_cast<QBluetoothLocalDevice::HostMode>(state));
 }
 
+void QBluetoothLocalDevice_ConnectPairingDisplayConfirmation(void* ptr){
+	QObject::connect(static_cast<QBluetoothLocalDevice*>(ptr), static_cast<void (QBluetoothLocalDevice::*)(const QBluetoothAddress &, QString)>(&QBluetoothLocalDevice::pairingDisplayConfirmation), static_cast<MyQBluetoothLocalDevice*>(ptr), static_cast<void (MyQBluetoothLocalDevice::*)(const QBluetoothAddress &, QString)>(&MyQBluetoothLocalDevice::Signal_PairingDisplayConfirmation));;
+}
+
+void QBluetoothLocalDevice_DisconnectPairingDisplayConfirmation(void* ptr){
+	QObject::disconnect(static_cast<QBluetoothLocalDevice*>(ptr), static_cast<void (QBluetoothLocalDevice::*)(const QBluetoothAddress &, QString)>(&QBluetoothLocalDevice::pairingDisplayConfirmation), static_cast<MyQBluetoothLocalDevice*>(ptr), static_cast<void (MyQBluetoothLocalDevice::*)(const QBluetoothAddress &, QString)>(&MyQBluetoothLocalDevice::Signal_PairingDisplayConfirmation));;
+}
+
+void QBluetoothLocalDevice_PairingDisplayConfirmation(void* ptr, void* address, char* pin){
+	static_cast<QBluetoothLocalDevice*>(ptr)->pairingDisplayConfirmation(*static_cast<QBluetoothAddress*>(address), QString(pin));
+}
+
+void QBluetoothLocalDevice_ConnectPairingDisplayPinCode(void* ptr){
+	QObject::connect(static_cast<QBluetoothLocalDevice*>(ptr), static_cast<void (QBluetoothLocalDevice::*)(const QBluetoothAddress &, QString)>(&QBluetoothLocalDevice::pairingDisplayPinCode), static_cast<MyQBluetoothLocalDevice*>(ptr), static_cast<void (MyQBluetoothLocalDevice::*)(const QBluetoothAddress &, QString)>(&MyQBluetoothLocalDevice::Signal_PairingDisplayPinCode));;
+}
+
+void QBluetoothLocalDevice_DisconnectPairingDisplayPinCode(void* ptr){
+	QObject::disconnect(static_cast<QBluetoothLocalDevice*>(ptr), static_cast<void (QBluetoothLocalDevice::*)(const QBluetoothAddress &, QString)>(&QBluetoothLocalDevice::pairingDisplayPinCode), static_cast<MyQBluetoothLocalDevice*>(ptr), static_cast<void (MyQBluetoothLocalDevice::*)(const QBluetoothAddress &, QString)>(&MyQBluetoothLocalDevice::Signal_PairingDisplayPinCode));;
+}
+
+void QBluetoothLocalDevice_PairingDisplayPinCode(void* ptr, void* address, char* pin){
+	static_cast<QBluetoothLocalDevice*>(ptr)->pairingDisplayPinCode(*static_cast<QBluetoothAddress*>(address), QString(pin));
+}
+
+void QBluetoothLocalDevice_ConnectPairingFinished(void* ptr){
+	QObject::connect(static_cast<QBluetoothLocalDevice*>(ptr), static_cast<void (QBluetoothLocalDevice::*)(const QBluetoothAddress &, QBluetoothLocalDevice::Pairing)>(&QBluetoothLocalDevice::pairingFinished), static_cast<MyQBluetoothLocalDevice*>(ptr), static_cast<void (MyQBluetoothLocalDevice::*)(const QBluetoothAddress &, QBluetoothLocalDevice::Pairing)>(&MyQBluetoothLocalDevice::Signal_PairingFinished));;
+}
+
+void QBluetoothLocalDevice_DisconnectPairingFinished(void* ptr){
+	QObject::disconnect(static_cast<QBluetoothLocalDevice*>(ptr), static_cast<void (QBluetoothLocalDevice::*)(const QBluetoothAddress &, QBluetoothLocalDevice::Pairing)>(&QBluetoothLocalDevice::pairingFinished), static_cast<MyQBluetoothLocalDevice*>(ptr), static_cast<void (MyQBluetoothLocalDevice::*)(const QBluetoothAddress &, QBluetoothLocalDevice::Pairing)>(&MyQBluetoothLocalDevice::Signal_PairingFinished));;
+}
+
+void QBluetoothLocalDevice_PairingFinished(void* ptr, void* address, int pairing){
+	static_cast<QBluetoothLocalDevice*>(ptr)->pairingFinished(*static_cast<QBluetoothAddress*>(address), static_cast<QBluetoothLocalDevice::Pairing>(pairing));
+}
+
 int QBluetoothLocalDevice_IsValid(void* ptr){
 	return static_cast<QBluetoothLocalDevice*>(ptr)->isValid();
 }
@@ -298,6 +388,10 @@ void* QBluetoothLocalDevice_NewQBluetoothLocalDevice2(void* address, void* paren
 	return new MyQBluetoothLocalDevice(*static_cast<QBluetoothAddress*>(address), static_cast<QObject*>(parent));
 }
 
+void* QBluetoothLocalDevice_Address(void* ptr){
+	return new QBluetoothAddress(static_cast<QBluetoothLocalDevice*>(ptr)->address());
+}
+
 int QBluetoothLocalDevice_HostMode(void* ptr){
 	return static_cast<QBluetoothLocalDevice*>(ptr)->hostMode();
 }
@@ -395,6 +489,10 @@ int QBluetoothServer_IsListening(void* ptr){
 	return static_cast<QBluetoothServer*>(ptr)->isListening();
 }
 
+void* QBluetoothServer_Listen2(void* ptr, void* uuid, char* serviceName){
+	return new QBluetoothServiceInfo(static_cast<QBluetoothServer*>(ptr)->listen(*static_cast<QBluetoothUuid*>(uuid), QString(serviceName)));
+}
+
 int QBluetoothServer_MaxPendingConnections(void* ptr){
 	return static_cast<QBluetoothServer*>(ptr)->maxPendingConnections();
 }
@@ -419,6 +517,10 @@ void* QBluetoothServer_NextPendingConnection(void* ptr){
 	return static_cast<QBluetoothServer*>(ptr)->nextPendingConnection();
 }
 
+void* QBluetoothServer_ServerAddress(void* ptr){
+	return new QBluetoothAddress(static_cast<QBluetoothServer*>(ptr)->serverAddress());
+}
+
 void QBluetoothServer_SetMaxPendingConnections(void* ptr, int numConnections){
 	static_cast<QBluetoothServer*>(ptr)->setMaxPendingConnections(numConnections);
 }
@@ -452,6 +554,7 @@ public:
 	void Signal_Canceled() { callbackQBluetoothServiceDiscoveryAgentCanceled(this, this->objectName().toUtf8().data()); };
 	void Signal_Error2(QBluetoothServiceDiscoveryAgent::Error error) { callbackQBluetoothServiceDiscoveryAgentError2(this, this->objectName().toUtf8().data(), error); };
 	void Signal_Finished() { callbackQBluetoothServiceDiscoveryAgentFinished(this, this->objectName().toUtf8().data()); };
+	void Signal_ServiceDiscovered(const QBluetoothServiceInfo & info) { callbackQBluetoothServiceDiscoveryAgentServiceDiscovered(this, this->objectName().toUtf8().data(), new QBluetoothServiceInfo(info)); };
 	void timerEvent(QTimerEvent * event) { callbackQBluetoothServiceDiscoveryAgentTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQBluetoothServiceDiscoveryAgentChildEvent(this, this->objectName().toUtf8().data(), event); };
 	void customEvent(QEvent * event) { callbackQBluetoothServiceDiscoveryAgentCustomEvent(this, this->objectName().toUtf8().data(), event); };
@@ -493,6 +596,18 @@ void QBluetoothServiceDiscoveryAgent_Finished(void* ptr){
 	static_cast<QBluetoothServiceDiscoveryAgent*>(ptr)->finished();
 }
 
+void QBluetoothServiceDiscoveryAgent_ConnectServiceDiscovered(void* ptr){
+	QObject::connect(static_cast<QBluetoothServiceDiscoveryAgent*>(ptr), static_cast<void (QBluetoothServiceDiscoveryAgent::*)(const QBluetoothServiceInfo &)>(&QBluetoothServiceDiscoveryAgent::serviceDiscovered), static_cast<MyQBluetoothServiceDiscoveryAgent*>(ptr), static_cast<void (MyQBluetoothServiceDiscoveryAgent::*)(const QBluetoothServiceInfo &)>(&MyQBluetoothServiceDiscoveryAgent::Signal_ServiceDiscovered));;
+}
+
+void QBluetoothServiceDiscoveryAgent_DisconnectServiceDiscovered(void* ptr){
+	QObject::disconnect(static_cast<QBluetoothServiceDiscoveryAgent*>(ptr), static_cast<void (QBluetoothServiceDiscoveryAgent::*)(const QBluetoothServiceInfo &)>(&QBluetoothServiceDiscoveryAgent::serviceDiscovered), static_cast<MyQBluetoothServiceDiscoveryAgent*>(ptr), static_cast<void (MyQBluetoothServiceDiscoveryAgent::*)(const QBluetoothServiceInfo &)>(&MyQBluetoothServiceDiscoveryAgent::Signal_ServiceDiscovered));;
+}
+
+void QBluetoothServiceDiscoveryAgent_ServiceDiscovered(void* ptr, void* info){
+	static_cast<QBluetoothServiceDiscoveryAgent*>(ptr)->serviceDiscovered(*static_cast<QBluetoothServiceInfo*>(info));
+}
+
 void* QBluetoothServiceDiscoveryAgent_NewQBluetoothServiceDiscoveryAgent(void* parent){
 	return new QBluetoothServiceDiscoveryAgent(static_cast<QObject*>(parent));
 }
@@ -517,6 +632,10 @@ int QBluetoothServiceDiscoveryAgent_IsActive(void* ptr){
 	return static_cast<QBluetoothServiceDiscoveryAgent*>(ptr)->isActive();
 }
 
+void* QBluetoothServiceDiscoveryAgent_RemoteAddress(void* ptr){
+	return new QBluetoothAddress(static_cast<QBluetoothServiceDiscoveryAgent*>(ptr)->remoteAddress());
+}
+
 int QBluetoothServiceDiscoveryAgent_SetRemoteAddress(void* ptr, void* address){
 	return static_cast<QBluetoothServiceDiscoveryAgent*>(ptr)->setRemoteAddress(*static_cast<QBluetoothAddress*>(address));
 }
@@ -585,6 +704,10 @@ char* QBluetoothServiceInfo_ServiceProvider(void* ptr){
 	return static_cast<QBluetoothServiceInfo*>(ptr)->serviceProvider().toUtf8().data();
 }
 
+void* QBluetoothServiceInfo_ServiceUuid(void* ptr){
+	return new QBluetoothUuid(static_cast<QBluetoothServiceInfo*>(ptr)->serviceUuid());
+}
+
 void QBluetoothServiceInfo_SetServiceDescription(void* ptr, char* description){
 	static_cast<QBluetoothServiceInfo*>(ptr)->setServiceDescription(QString(description));
 }
@@ -609,6 +732,10 @@ void* QBluetoothServiceInfo_NewQBluetoothServiceInfo2(void* other){
 	return new QBluetoothServiceInfo(*static_cast<QBluetoothServiceInfo*>(other));
 }
 
+void* QBluetoothServiceInfo_Device(void* ptr){
+	return new QBluetoothDeviceInfo(static_cast<QBluetoothServiceInfo*>(ptr)->device());
+}
+
 int QBluetoothServiceInfo_IsComplete(void* ptr){
 	return static_cast<QBluetoothServiceInfo*>(ptr)->isComplete();
 }
@@ -767,10 +894,18 @@ int QBluetoothSocket_IsSequential(void* ptr){
 	return static_cast<QBluetoothSocket*>(ptr)->isSequential();
 }
 
+void* QBluetoothSocket_LocalAddress(void* ptr){
+	return new QBluetoothAddress(static_cast<QBluetoothSocket*>(ptr)->localAddress());
+}
+
 char* QBluetoothSocket_LocalName(void* ptr){
 	return static_cast<QBluetoothSocket*>(ptr)->localName().toUtf8().data();
 }
 
+void* QBluetoothSocket_PeerAddress(void* ptr){
+	return new QBluetoothAddress(static_cast<QBluetoothSocket*>(ptr)->peerAddress());
+}
+
 char* QBluetoothSocket_PeerName(void* ptr){
 	return static_cast<QBluetoothSocket*>(ptr)->peerName().toUtf8().data();
 }
@@ -941,6 +1076,10 @@ void* QBluetoothTransferReply_Manager(void* ptr){
 	return static_cast<QBluetoothTransferReply*>(ptr)->manager();
 }
 
+void* QBluetoothTransferReply_Request(void* ptr){
+	return new QBluetoothTransferRequest(static_cast<QBluetoothTransferReply*>(ptr)->request());
+}
+
 void QBluetoothTransferReply_ConnectTransferProgress(void* ptr){
 	QObject::connect(static_cast<QBluetoothTransferReply*>(ptr), static_cast<void (QBluetoothTransferReply::*)(qint64, qint64)>(&QBluetoothTransferReply::transferProgress), static_cast<MyQBluetoothTransferReply*>(ptr), static_cast<void (MyQBluetoothTransferReply::*)(qint64, qint64)>(&MyQBluetoothTransferReply::Signal_TransferProgress));;
 }
@@ -989,6 +1128,10 @@ void* QBluetoothTransferRequest_NewQBluetoothTransferRequest2(void* other){
 	return new QBluetoothTransferRequest(*static_cast<QBluetoothTransferRequest*>(other));
 }
 
+void* QBluetoothTransferRequest_Address(void* ptr){
+	return new QBluetoothAddress(static_cast<QBluetoothTransferRequest*>(ptr)->address());
+}
+
 void* QBluetoothTransferRequest_Attribute(void* ptr, int code, void* defaultValue){
 	return new QVariant(static_cast<QBluetoothTransferRequest*>(ptr)->attribute(static_cast<QBluetoothTransferRequest::Attribute>(code), *static_cast<QVariant*>(defaultValue)));
 }
@@ -1065,6 +1208,10 @@ void* QLowEnergyCharacteristic_NewQLowEnergyCharacteristic2(void* other){
 	return new QLowEnergyCharacteristic(*static_cast<QLowEnergyCharacteristic*>(other));
 }
 
+void* QLowEnergyCharacteristic_Descriptor(void* ptr, void* uuid){
+	return new QLowEnergyDescriptor(static_cast<QLowEnergyCharacteristic*>(ptr)->descriptor(*static_cast<QBluetoothUuid*>(uuid)));
+}
+
 int QLowEnergyCharacteristic_IsValid(void* ptr){
 	return static_cast<QLowEnergyCharacteristic*>(ptr)->isValid();
 }
@@ -1077,8 +1224,12 @@ int QLowEnergyCharacteristic_Properties(void* ptr){
 	return static_cast<QLowEnergyCharacteristic*>(ptr)->properties();
 }
 
-void* QLowEnergyCharacteristic_Value(void* ptr){
-	return new QByteArray(static_cast<QLowEnergyCharacteristic*>(ptr)->value());
+void* QLowEnergyCharacteristic_Uuid(void* ptr){
+	return new QBluetoothUuid(static_cast<QLowEnergyCharacteristic*>(ptr)->uuid());
+}
+
+char* QLowEnergyCharacteristic_Value(void* ptr){
+	return QString(static_cast<QLowEnergyCharacteristic*>(ptr)->value()).toUtf8().data();
 }
 
 void QLowEnergyCharacteristic_DestroyQLowEnergyCharacteristic(void* ptr){
@@ -1091,6 +1242,7 @@ public:
 	void Signal_Disconnected() { callbackQLowEnergyControllerDisconnected(this, this->objectName().toUtf8().data()); };
 	void Signal_DiscoveryFinished() { callbackQLowEnergyControllerDiscoveryFinished(this, this->objectName().toUtf8().data()); };
 	void Signal_Error2(QLowEnergyController::Error newError) { callbackQLowEnergyControllerError2(this, this->objectName().toUtf8().data(), newError); };
+	void Signal_ServiceDiscovered(const QBluetoothUuid & newService) { callbackQLowEnergyControllerServiceDiscovered(this, this->objectName().toUtf8().data(), new QBluetoothUuid(newService)); };
 	void Signal_StateChanged(QLowEnergyController::ControllerState state) { callbackQLowEnergyControllerStateChanged(this, this->objectName().toUtf8().data(), state); };
 	void timerEvent(QTimerEvent * event) { callbackQLowEnergyControllerTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQLowEnergyControllerChildEvent(this, this->objectName().toUtf8().data(), event); };
@@ -1145,6 +1297,18 @@ void QLowEnergyController_Error2(void* ptr, int newError){
 	static_cast<QLowEnergyController*>(ptr)->error(static_cast<QLowEnergyController::Error>(newError));
 }
 
+void QLowEnergyController_ConnectServiceDiscovered(void* ptr){
+	QObject::connect(static_cast<QLowEnergyController*>(ptr), static_cast<void (QLowEnergyController::*)(const QBluetoothUuid &)>(&QLowEnergyController::serviceDiscovered), static_cast<MyQLowEnergyController*>(ptr), static_cast<void (MyQLowEnergyController::*)(const QBluetoothUuid &)>(&MyQLowEnergyController::Signal_ServiceDiscovered));;
+}
+
+void QLowEnergyController_DisconnectServiceDiscovered(void* ptr){
+	QObject::disconnect(static_cast<QLowEnergyController*>(ptr), static_cast<void (QLowEnergyController::*)(const QBluetoothUuid &)>(&QLowEnergyController::serviceDiscovered), static_cast<MyQLowEnergyController*>(ptr), static_cast<void (MyQLowEnergyController::*)(const QBluetoothUuid &)>(&MyQLowEnergyController::Signal_ServiceDiscovered));;
+}
+
+void QLowEnergyController_ServiceDiscovered(void* ptr, void* newService){
+	static_cast<QLowEnergyController*>(ptr)->serviceDiscovered(*static_cast<QBluetoothUuid*>(newService));
+}
+
 void QLowEnergyController_ConnectStateChanged(void* ptr){
 	QObject::connect(static_cast<QLowEnergyController*>(ptr), static_cast<void (QLowEnergyController::*)(QLowEnergyController::ControllerState)>(&QLowEnergyController::stateChanged), static_cast<MyQLowEnergyController*>(ptr), static_cast<void (MyQLowEnergyController::*)(QLowEnergyController::ControllerState)>(&MyQLowEnergyController::Signal_StateChanged));;
 }
@@ -1185,6 +1349,14 @@ char* QLowEnergyController_ErrorString(void* ptr){
 	return static_cast<QLowEnergyController*>(ptr)->errorString().toUtf8().data();
 }
 
+void* QLowEnergyController_LocalAddress(void* ptr){
+	return new QBluetoothAddress(static_cast<QLowEnergyController*>(ptr)->localAddress());
+}
+
+void* QLowEnergyController_RemoteAddress(void* ptr){
+	return new QBluetoothAddress(static_cast<QLowEnergyController*>(ptr)->remoteAddress());
+}
+
 int QLowEnergyController_RemoteAddressType(void* ptr){
 	return static_cast<QLowEnergyController*>(ptr)->remoteAddressType();
 }
@@ -1249,8 +1421,12 @@ int QLowEnergyDescriptor_Type(void* ptr){
 	return static_cast<QLowEnergyDescriptor*>(ptr)->type();
 }
 
-void* QLowEnergyDescriptor_Value(void* ptr){
-	return new QByteArray(static_cast<QLowEnergyDescriptor*>(ptr)->value());
+void* QLowEnergyDescriptor_Uuid(void* ptr){
+	return new QBluetoothUuid(static_cast<QLowEnergyDescriptor*>(ptr)->uuid());
+}
+
+char* QLowEnergyDescriptor_Value(void* ptr){
+	return QString(static_cast<QLowEnergyDescriptor*>(ptr)->value()).toUtf8().data();
 }
 
 void QLowEnergyDescriptor_DestroyQLowEnergyDescriptor(void* ptr){
@@ -1259,6 +1435,11 @@ void QLowEnergyDescriptor_DestroyQLowEnergyDescriptor(void* ptr){
 
 class MyQLowEnergyService: public QLowEnergyService {
 public:
+	void Signal_CharacteristicChanged(const QLowEnergyCharacteristic & characteristic, const QByteArray & newValue) { callbackQLowEnergyServiceCharacteristicChanged(this, this->objectName().toUtf8().data(), new QLowEnergyCharacteristic(characteristic), QString(newValue).toUtf8().data()); };
+	void Signal_CharacteristicRead(const QLowEnergyCharacteristic & characteristic, const QByteArray & value) { callbackQLowEnergyServiceCharacteristicRead(this, this->objectName().toUtf8().data(), new QLowEnergyCharacteristic(characteristic), QString(value).toUtf8().data()); };
+	void Signal_CharacteristicWritten(const QLowEnergyCharacteristic & characteristic, const QByteArray & newValue) { callbackQLowEnergyServiceCharacteristicWritten(this, this->objectName().toUtf8().data(), new QLowEnergyCharacteristic(characteristic), QString(newValue).toUtf8().data()); };
+	void Signal_DescriptorRead(const QLowEnergyDescriptor & descriptor, const QByteArray & value) { callbackQLowEnergyServiceDescriptorRead(this, this->objectName().toUtf8().data(), new QLowEnergyDescriptor(descriptor), QString(value).toUtf8().data()); };
+	void Signal_DescriptorWritten(const QLowEnergyDescriptor & descriptor, const QByteArray & newValue) { callbackQLowEnergyServiceDescriptorWritten(this, this->objectName().toUtf8().data(), new QLowEnergyDescriptor(descriptor), QString(newValue).toUtf8().data()); };
 	void Signal_Error2(QLowEnergyService::ServiceError newError) { callbackQLowEnergyServiceError2(this, this->objectName().toUtf8().data(), newError); };
 	void Signal_StateChanged(QLowEnergyService::ServiceState newState) { callbackQLowEnergyServiceStateChanged(this, this->objectName().toUtf8().data(), newState); };
 	void timerEvent(QTimerEvent * event) { callbackQLowEnergyServiceTimerEvent(this, this->objectName().toUtf8().data(), event); };
@@ -1266,6 +1447,66 @@ public:
 	void customEvent(QEvent * event) { callbackQLowEnergyServiceCustomEvent(this, this->objectName().toUtf8().data(), event); };
 };
 
+void QLowEnergyService_ConnectCharacteristicChanged(void* ptr){
+	QObject::connect(static_cast<QLowEnergyService*>(ptr), static_cast<void (QLowEnergyService::*)(const QLowEnergyCharacteristic &, const QByteArray &)>(&QLowEnergyService::characteristicChanged), static_cast<MyQLowEnergyService*>(ptr), static_cast<void (MyQLowEnergyService::*)(const QLowEnergyCharacteristic &, const QByteArray &)>(&MyQLowEnergyService::Signal_CharacteristicChanged));;
+}
+
+void QLowEnergyService_DisconnectCharacteristicChanged(void* ptr){
+	QObject::disconnect(static_cast<QLowEnergyService*>(ptr), static_cast<void (QLowEnergyService::*)(const QLowEnergyCharacteristic &, const QByteArray &)>(&QLowEnergyService::characteristicChanged), static_cast<MyQLowEnergyService*>(ptr), static_cast<void (MyQLowEnergyService::*)(const QLowEnergyCharacteristic &, const QByteArray &)>(&MyQLowEnergyService::Signal_CharacteristicChanged));;
+}
+
+void QLowEnergyService_CharacteristicChanged(void* ptr, void* characteristic, char* newValue){
+	static_cast<QLowEnergyService*>(ptr)->characteristicChanged(*static_cast<QLowEnergyCharacteristic*>(characteristic), QByteArray(newValue));
+}
+
+void QLowEnergyService_ConnectCharacteristicRead(void* ptr){
+	QObject::connect(static_cast<QLowEnergyService*>(ptr), static_cast<void (QLowEnergyService::*)(const QLowEnergyCharacteristic &, const QByteArray &)>(&QLowEnergyService::characteristicRead), static_cast<MyQLowEnergyService*>(ptr), static_cast<void (MyQLowEnergyService::*)(const QLowEnergyCharacteristic &, const QByteArray &)>(&MyQLowEnergyService::Signal_CharacteristicRead));;
+}
+
+void QLowEnergyService_DisconnectCharacteristicRead(void* ptr){
+	QObject::disconnect(static_cast<QLowEnergyService*>(ptr), static_cast<void (QLowEnergyService::*)(const QLowEnergyCharacteristic &, const QByteArray &)>(&QLowEnergyService::characteristicRead), static_cast<MyQLowEnergyService*>(ptr), static_cast<void (MyQLowEnergyService::*)(const QLowEnergyCharacteristic &, const QByteArray &)>(&MyQLowEnergyService::Signal_CharacteristicRead));;
+}
+
+void QLowEnergyService_CharacteristicRead(void* ptr, void* characteristic, char* value){
+	static_cast<QLowEnergyService*>(ptr)->characteristicRead(*static_cast<QLowEnergyCharacteristic*>(characteristic), QByteArray(value));
+}
+
+void QLowEnergyService_ConnectCharacteristicWritten(void* ptr){
+	QObject::connect(static_cast<QLowEnergyService*>(ptr), static_cast<void (QLowEnergyService::*)(const QLowEnergyCharacteristic &, const QByteArray &)>(&QLowEnergyService::characteristicWritten), static_cast<MyQLowEnergyService*>(ptr), static_cast<void (MyQLowEnergyService::*)(const QLowEnergyCharacteristic &, const QByteArray &)>(&MyQLowEnergyService::Signal_CharacteristicWritten));;
+}
+
+void QLowEnergyService_DisconnectCharacteristicWritten(void* ptr){
+	QObject::disconnect(static_cast<QLowEnergyService*>(ptr), static_cast<void (QLowEnergyService::*)(const QLowEnergyCharacteristic &, const QByteArray &)>(&QLowEnergyService::characteristicWritten), static_cast<MyQLowEnergyService*>(ptr), static_cast<void (MyQLowEnergyService::*)(const QLowEnergyCharacteristic &, const QByteArray &)>(&MyQLowEnergyService::Signal_CharacteristicWritten));;
+}
+
+void QLowEnergyService_CharacteristicWritten(void* ptr, void* characteristic, char* newValue){
+	static_cast<QLowEnergyService*>(ptr)->characteristicWritten(*static_cast<QLowEnergyCharacteristic*>(characteristic), QByteArray(newValue));
+}
+
+void QLowEnergyService_ConnectDescriptorRead(void* ptr){
+	QObject::connect(static_cast<QLowEnergyService*>(ptr), static_cast<void (QLowEnergyService::*)(const QLowEnergyDescriptor &, const QByteArray &)>(&QLowEnergyService::descriptorRead), static_cast<MyQLowEnergyService*>(ptr), static_cast<void (MyQLowEnergyService::*)(const QLowEnergyDescriptor &, const QByteArray &)>(&MyQLowEnergyService::Signal_DescriptorRead));;
+}
+
+void QLowEnergyService_DisconnectDescriptorRead(void* ptr){
+	QObject::disconnect(static_cast<QLowEnergyService*>(ptr), static_cast<void (QLowEnergyService::*)(const QLowEnergyDescriptor &, const QByteArray &)>(&QLowEnergyService::descriptorRead), static_cast<MyQLowEnergyService*>(ptr), static_cast<void (MyQLowEnergyService::*)(const QLowEnergyDescriptor &, const QByteArray &)>(&MyQLowEnergyService::Signal_DescriptorRead));;
+}
+
+void QLowEnergyService_DescriptorRead(void* ptr, void* descriptor, char* value){
+	static_cast<QLowEnergyService*>(ptr)->descriptorRead(*static_cast<QLowEnergyDescriptor*>(descriptor), QByteArray(value));
+}
+
+void QLowEnergyService_ConnectDescriptorWritten(void* ptr){
+	QObject::connect(static_cast<QLowEnergyService*>(ptr), static_cast<void (QLowEnergyService::*)(const QLowEnergyDescriptor &, const QByteArray &)>(&QLowEnergyService::descriptorWritten), static_cast<MyQLowEnergyService*>(ptr), static_cast<void (MyQLowEnergyService::*)(const QLowEnergyDescriptor &, const QByteArray &)>(&MyQLowEnergyService::Signal_DescriptorWritten));;
+}
+
+void QLowEnergyService_DisconnectDescriptorWritten(void* ptr){
+	QObject::disconnect(static_cast<QLowEnergyService*>(ptr), static_cast<void (QLowEnergyService::*)(const QLowEnergyDescriptor &, const QByteArray &)>(&QLowEnergyService::descriptorWritten), static_cast<MyQLowEnergyService*>(ptr), static_cast<void (MyQLowEnergyService::*)(const QLowEnergyDescriptor &, const QByteArray &)>(&MyQLowEnergyService::Signal_DescriptorWritten));;
+}
+
+void QLowEnergyService_DescriptorWritten(void* ptr, void* descriptor, char* newValue){
+	static_cast<QLowEnergyService*>(ptr)->descriptorWritten(*static_cast<QLowEnergyDescriptor*>(descriptor), QByteArray(newValue));
+}
+
 void QLowEnergyService_ConnectError2(void* ptr){
 	QObject::connect(static_cast<QLowEnergyService*>(ptr), static_cast<void (QLowEnergyService::*)(QLowEnergyService::ServiceError)>(&QLowEnergyService::error), static_cast<MyQLowEnergyService*>(ptr), static_cast<void (MyQLowEnergyService::*)(QLowEnergyService::ServiceError)>(&MyQLowEnergyService::Signal_Error2));;
 }
@@ -1290,6 +1531,10 @@ void QLowEnergyService_StateChanged(void* ptr, int newState){
 	static_cast<QLowEnergyService*>(ptr)->stateChanged(static_cast<QLowEnergyService::ServiceState>(newState));
 }
 
+void* QLowEnergyService_Characteristic(void* ptr, void* uuid){
+	return new QLowEnergyCharacteristic(static_cast<QLowEnergyService*>(ptr)->characteristic(*static_cast<QBluetoothUuid*>(uuid)));
+}
+
 int QLowEnergyService_Contains(void* ptr, void* characteristic){
 	return static_cast<QLowEnergyService*>(ptr)->contains(*static_cast<QLowEnergyCharacteristic*>(characteristic));
 }
@@ -1318,6 +1563,10 @@ char* QLowEnergyService_ServiceName(void* ptr){
 	return static_cast<QLowEnergyService*>(ptr)->serviceName().toUtf8().data();
 }
 
+void* QLowEnergyService_ServiceUuid(void* ptr){
+	return new QBluetoothUuid(static_cast<QLowEnergyService*>(ptr)->serviceUuid());
+}
+
 int QLowEnergyService_State(void* ptr){
 	return static_cast<QLowEnergyService*>(ptr)->state();
 }
@@ -1326,12 +1575,12 @@ int QLowEnergyService_Type(void* ptr){
 	return static_cast<QLowEnergyService*>(ptr)->type();
 }
 
-void QLowEnergyService_WriteCharacteristic(void* ptr, void* characteristic, void* newValue, int mode){
-	static_cast<QLowEnergyService*>(ptr)->writeCharacteristic(*static_cast<QLowEnergyCharacteristic*>(characteristic), *static_cast<QByteArray*>(newValue), static_cast<QLowEnergyService::WriteMode>(mode));
+void QLowEnergyService_WriteCharacteristic(void* ptr, void* characteristic, char* newValue, int mode){
+	static_cast<QLowEnergyService*>(ptr)->writeCharacteristic(*static_cast<QLowEnergyCharacteristic*>(characteristic), QByteArray(newValue), static_cast<QLowEnergyService::WriteMode>(mode));
 }
 
-void QLowEnergyService_WriteDescriptor(void* ptr, void* descriptor, void* newValue){
-	static_cast<QLowEnergyService*>(ptr)->writeDescriptor(*static_cast<QLowEnergyDescriptor*>(descriptor), *static_cast<QByteArray*>(newValue));
+void QLowEnergyService_WriteDescriptor(void* ptr, void* descriptor, char* newValue){
+	static_cast<QLowEnergyService*>(ptr)->writeDescriptor(*static_cast<QLowEnergyDescriptor*>(descriptor), QByteArray(newValue));
 }
 
 void QLowEnergyService_DestroyQLowEnergyService(void* ptr){

bluetooth/bluetooth.go

@@ -189,6 +189,42 @@ func (ptr *QBluetoothDeviceDiscoveryAgent) Canceled() {
 	}
 }
 
+func (ptr *QBluetoothDeviceDiscoveryAgent) ConnectDeviceDiscovered(f func(info *QBluetoothDeviceInfo)) {
+	defer qt.Recovering("connect QBluetoothDeviceDiscoveryAgent::deviceDiscovered")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothDeviceDiscoveryAgent_ConnectDeviceDiscovered(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "deviceDiscovered", f)
+	}
+}
+
+func (ptr *QBluetoothDeviceDiscoveryAgent) DisconnectDeviceDiscovered() {
+	defer qt.Recovering("disconnect QBluetoothDeviceDiscoveryAgent::deviceDiscovered")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothDeviceDiscoveryAgent_DisconnectDeviceDiscovered(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "deviceDiscovered")
+	}
+}
+
+//export callbackQBluetoothDeviceDiscoveryAgentDeviceDiscovered
+func callbackQBluetoothDeviceDiscoveryAgentDeviceDiscovered(ptr unsafe.Pointer, ptrName *C.char, info unsafe.Pointer) {
+	defer qt.Recovering("callback QBluetoothDeviceDiscoveryAgent::deviceDiscovered")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "deviceDiscovered"); signal != nil {
+		signal.(func(*QBluetoothDeviceInfo))(NewQBluetoothDeviceInfoFromPointer(info))
+	}
+
+}
+
+func (ptr *QBluetoothDeviceDiscoveryAgent) DeviceDiscovered(info QBluetoothDeviceInfo_ITF) {
+	defer qt.Recovering("QBluetoothDeviceDiscoveryAgent::deviceDiscovered")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothDeviceDiscoveryAgent_DeviceDiscovered(ptr.Pointer(), PointerFromQBluetoothDeviceInfo(info))
+	}
+}
+
 func (ptr *QBluetoothDeviceDiscoveryAgent) ConnectError2(f func(error QBluetoothDeviceDiscoveryAgent__Error)) {
 	defer qt.Recovering("connect QBluetoothDeviceDiscoveryAgent::error")
 
@@ -713,6 +749,15 @@ func NewQBluetoothDeviceInfo4(other QBluetoothDeviceInfo_ITF) *QBluetoothDeviceI
 	return newQBluetoothDeviceInfoFromPointer(C.QBluetoothDeviceInfo_NewQBluetoothDeviceInfo4(PointerFromQBluetoothDeviceInfo(other)))
 }
 
+func (ptr *QBluetoothDeviceInfo) Address() *QBluetoothAddress {
+	defer qt.Recovering("QBluetoothDeviceInfo::address")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothAddressFromPointer(C.QBluetoothDeviceInfo_Address(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QBluetoothDeviceInfo) CoreConfigurations() QBluetoothDeviceInfo__CoreConfiguration {
 	defer qt.Recovering("QBluetoothDeviceInfo::coreConfigurations")
 
@@ -722,6 +767,15 @@ func (ptr *QBluetoothDeviceInfo) CoreConfigurations() QBluetoothDeviceInfo__Core
 	return 0
 }
 
+func (ptr *QBluetoothDeviceInfo) DeviceUuid() *QBluetoothUuid {
+	defer qt.Recovering("QBluetoothDeviceInfo::deviceUuid")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothUuidFromPointer(C.QBluetoothDeviceInfo_DeviceUuid(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QBluetoothDeviceInfo) IsCached() bool {
 	defer qt.Recovering("QBluetoothDeviceInfo::isCached")
 
@@ -858,6 +912,15 @@ func NewQBluetoothHostInfo2(other QBluetoothHostInfo_ITF) *QBluetoothHostInfo {
 	return newQBluetoothHostInfoFromPointer(C.QBluetoothHostInfo_NewQBluetoothHostInfo2(PointerFromQBluetoothHostInfo(other)))
 }
 
+func (ptr *QBluetoothHostInfo) Address() *QBluetoothAddress {
+	defer qt.Recovering("QBluetoothHostInfo::address")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothAddressFromPointer(C.QBluetoothHostInfo_Address(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QBluetoothHostInfo) Name() string {
 	defer qt.Recovering("QBluetoothHostInfo::name")
 
@@ -953,6 +1016,78 @@ const (
 	QBluetoothLocalDevice__AuthorizedPaired = QBluetoothLocalDevice__Pairing(2)
 )
 
+func (ptr *QBluetoothLocalDevice) ConnectDeviceConnected(f func(address *QBluetoothAddress)) {
+	defer qt.Recovering("connect QBluetoothLocalDevice::deviceConnected")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothLocalDevice_ConnectDeviceConnected(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "deviceConnected", f)
+	}
+}
+
+func (ptr *QBluetoothLocalDevice) DisconnectDeviceConnected() {
+	defer qt.Recovering("disconnect QBluetoothLocalDevice::deviceConnected")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothLocalDevice_DisconnectDeviceConnected(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "deviceConnected")
+	}
+}
+
+//export callbackQBluetoothLocalDeviceDeviceConnected
+func callbackQBluetoothLocalDeviceDeviceConnected(ptr unsafe.Pointer, ptrName *C.char, address unsafe.Pointer) {
+	defer qt.Recovering("callback QBluetoothLocalDevice::deviceConnected")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "deviceConnected"); signal != nil {
+		signal.(func(*QBluetoothAddress))(NewQBluetoothAddressFromPointer(address))
+	}
+
+}
+
+func (ptr *QBluetoothLocalDevice) DeviceConnected(address QBluetoothAddress_ITF) {
+	defer qt.Recovering("QBluetoothLocalDevice::deviceConnected")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothLocalDevice_DeviceConnected(ptr.Pointer(), PointerFromQBluetoothAddress(address))
+	}
+}
+
+func (ptr *QBluetoothLocalDevice) ConnectDeviceDisconnected(f func(address *QBluetoothAddress)) {
+	defer qt.Recovering("connect QBluetoothLocalDevice::deviceDisconnected")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothLocalDevice_ConnectDeviceDisconnected(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "deviceDisconnected", f)
+	}
+}
+
+func (ptr *QBluetoothLocalDevice) DisconnectDeviceDisconnected() {
+	defer qt.Recovering("disconnect QBluetoothLocalDevice::deviceDisconnected")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothLocalDevice_DisconnectDeviceDisconnected(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "deviceDisconnected")
+	}
+}
+
+//export callbackQBluetoothLocalDeviceDeviceDisconnected
+func callbackQBluetoothLocalDeviceDeviceDisconnected(ptr unsafe.Pointer, ptrName *C.char, address unsafe.Pointer) {
+	defer qt.Recovering("callback QBluetoothLocalDevice::deviceDisconnected")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "deviceDisconnected"); signal != nil {
+		signal.(func(*QBluetoothAddress))(NewQBluetoothAddressFromPointer(address))
+	}
+
+}
+
+func (ptr *QBluetoothLocalDevice) DeviceDisconnected(address QBluetoothAddress_ITF) {
+	defer qt.Recovering("QBluetoothLocalDevice::deviceDisconnected")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothLocalDevice_DeviceDisconnected(ptr.Pointer(), PointerFromQBluetoothAddress(address))
+	}
+}
+
 func (ptr *QBluetoothLocalDevice) ConnectError(f func(error QBluetoothLocalDevice__Error)) {
 	defer qt.Recovering("connect QBluetoothLocalDevice::error")
 
@@ -1025,6 +1160,114 @@ func (ptr *QBluetoothLocalDevice) HostModeStateChanged(state QBluetoothLocalDevi
 	}
 }
 
+func (ptr *QBluetoothLocalDevice) ConnectPairingDisplayConfirmation(f func(address *QBluetoothAddress, pin string)) {
+	defer qt.Recovering("connect QBluetoothLocalDevice::pairingDisplayConfirmation")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothLocalDevice_ConnectPairingDisplayConfirmation(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "pairingDisplayConfirmation", f)
+	}
+}
+
+func (ptr *QBluetoothLocalDevice) DisconnectPairingDisplayConfirmation() {
+	defer qt.Recovering("disconnect QBluetoothLocalDevice::pairingDisplayConfirmation")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothLocalDevice_DisconnectPairingDisplayConfirmation(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "pairingDisplayConfirmation")
+	}
+}
+
+//export callbackQBluetoothLocalDevicePairingDisplayConfirmation
+func callbackQBluetoothLocalDevicePairingDisplayConfirmation(ptr unsafe.Pointer, ptrName *C.char, address unsafe.Pointer, pin *C.char) {
+	defer qt.Recovering("callback QBluetoothLocalDevice::pairingDisplayConfirmation")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "pairingDisplayConfirmation"); signal != nil {
+		signal.(func(*QBluetoothAddress, string))(NewQBluetoothAddressFromPointer(address), C.GoString(pin))
+	}
+
+}
+
+func (ptr *QBluetoothLocalDevice) PairingDisplayConfirmation(address QBluetoothAddress_ITF, pin string) {
+	defer qt.Recovering("QBluetoothLocalDevice::pairingDisplayConfirmation")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothLocalDevice_PairingDisplayConfirmation(ptr.Pointer(), PointerFromQBluetoothAddress(address), C.CString(pin))
+	}
+}
+
+func (ptr *QBluetoothLocalDevice) ConnectPairingDisplayPinCode(f func(address *QBluetoothAddress, pin string)) {
+	defer qt.Recovering("connect QBluetoothLocalDevice::pairingDisplayPinCode")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothLocalDevice_ConnectPairingDisplayPinCode(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "pairingDisplayPinCode", f)
+	}
+}
+
+func (ptr *QBluetoothLocalDevice) DisconnectPairingDisplayPinCode() {
+	defer qt.Recovering("disconnect QBluetoothLocalDevice::pairingDisplayPinCode")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothLocalDevice_DisconnectPairingDisplayPinCode(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "pairingDisplayPinCode")
+	}
+}
+
+//export callbackQBluetoothLocalDevicePairingDisplayPinCode
+func callbackQBluetoothLocalDevicePairingDisplayPinCode(ptr unsafe.Pointer, ptrName *C.char, address unsafe.Pointer, pin *C.char) {
+	defer qt.Recovering("callback QBluetoothLocalDevice::pairingDisplayPinCode")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "pairingDisplayPinCode"); signal != nil {
+		signal.(func(*QBluetoothAddress, string))(NewQBluetoothAddressFromPointer(address), C.GoString(pin))
+	}
+
+}
+
+func (ptr *QBluetoothLocalDevice) PairingDisplayPinCode(address QBluetoothAddress_ITF, pin string) {
+	defer qt.Recovering("QBluetoothLocalDevice::pairingDisplayPinCode")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothLocalDevice_PairingDisplayPinCode(ptr.Pointer(), PointerFromQBluetoothAddress(address), C.CString(pin))
+	}
+}
+
+func (ptr *QBluetoothLocalDevice) ConnectPairingFinished(f func(address *QBluetoothAddress, pairing QBluetoothLocalDevice__Pairing)) {
+	defer qt.Recovering("connect QBluetoothLocalDevice::pairingFinished")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothLocalDevice_ConnectPairingFinished(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "pairingFinished", f)
+	}
+}
+
+func (ptr *QBluetoothLocalDevice) DisconnectPairingFinished() {
+	defer qt.Recovering("disconnect QBluetoothLocalDevice::pairingFinished")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothLocalDevice_DisconnectPairingFinished(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "pairingFinished")
+	}
+}
+
+//export callbackQBluetoothLocalDevicePairingFinished
+func callbackQBluetoothLocalDevicePairingFinished(ptr unsafe.Pointer, ptrName *C.char, address unsafe.Pointer, pairing C.int) {
+	defer qt.Recovering("callback QBluetoothLocalDevice::pairingFinished")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "pairingFinished"); signal != nil {
+		signal.(func(*QBluetoothAddress, QBluetoothLocalDevice__Pairing))(NewQBluetoothAddressFromPointer(address), QBluetoothLocalDevice__Pairing(pairing))
+	}
+
+}
+
+func (ptr *QBluetoothLocalDevice) PairingFinished(address QBluetoothAddress_ITF, pairing QBluetoothLocalDevice__Pairing) {
+	defer qt.Recovering("QBluetoothLocalDevice::pairingFinished")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothLocalDevice_PairingFinished(ptr.Pointer(), PointerFromQBluetoothAddress(address), C.int(pairing))
+	}
+}
+
 func (ptr *QBluetoothLocalDevice) IsValid() bool {
 	defer qt.Recovering("QBluetoothLocalDevice::isValid")
 
@@ -1055,6 +1298,15 @@ func NewQBluetoothLocalDevice2(address QBluetoothAddress_ITF, parent core.QObjec
 	return newQBluetoothLocalDeviceFromPointer(C.QBluetoothLocalDevice_NewQBluetoothLocalDevice2(PointerFromQBluetoothAddress(address), core.PointerFromQObject(parent)))
 }
 
+func (ptr *QBluetoothLocalDevice) Address() *QBluetoothAddress {
+	defer qt.Recovering("QBluetoothLocalDevice::address")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothAddressFromPointer(C.QBluetoothLocalDevice_Address(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QBluetoothLocalDevice) HostMode() QBluetoothLocalDevice__HostMode {
 	defer qt.Recovering("QBluetoothLocalDevice::hostMode")
 
@@ -1391,6 +1643,15 @@ func (ptr *QBluetoothServer) IsListening() bool {
 	return false
 }
 
+func (ptr *QBluetoothServer) Listen2(uuid QBluetoothUuid_ITF, serviceName string) *QBluetoothServiceInfo {
+	defer qt.Recovering("QBluetoothServer::listen")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothServiceInfoFromPointer(C.QBluetoothServer_Listen2(ptr.Pointer(), PointerFromQBluetoothUuid(uuid), C.CString(serviceName)))
+	}
+	return nil
+}
+
 func (ptr *QBluetoothServer) MaxPendingConnections() int {
 	defer qt.Recovering("QBluetoothServer::maxPendingConnections")
 
@@ -1444,6 +1705,15 @@ func (ptr *QBluetoothServer) NextPendingConnection() *QBluetoothSocket {
 	return nil
 }
 
+func (ptr *QBluetoothServer) ServerAddress() *QBluetoothAddress {
+	defer qt.Recovering("QBluetoothServer::serverAddress")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothAddressFromPointer(C.QBluetoothServer_ServerAddress(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QBluetoothServer) SetMaxPendingConnections(numConnections int) {
 	defer qt.Recovering("QBluetoothServer::setMaxPendingConnections")
 
@@ -1748,6 +2018,42 @@ func (ptr *QBluetoothServiceDiscoveryAgent) Finished() {
 	}
 }
 
+func (ptr *QBluetoothServiceDiscoveryAgent) ConnectServiceDiscovered(f func(info *QBluetoothServiceInfo)) {
+	defer qt.Recovering("connect QBluetoothServiceDiscoveryAgent::serviceDiscovered")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothServiceDiscoveryAgent_ConnectServiceDiscovered(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "serviceDiscovered", f)
+	}
+}
+
+func (ptr *QBluetoothServiceDiscoveryAgent) DisconnectServiceDiscovered() {
+	defer qt.Recovering("disconnect QBluetoothServiceDiscoveryAgent::serviceDiscovered")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothServiceDiscoveryAgent_DisconnectServiceDiscovered(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "serviceDiscovered")
+	}
+}
+
+//export callbackQBluetoothServiceDiscoveryAgentServiceDiscovered
+func callbackQBluetoothServiceDiscoveryAgentServiceDiscovered(ptr unsafe.Pointer, ptrName *C.char, info unsafe.Pointer) {
+	defer qt.Recovering("callback QBluetoothServiceDiscoveryAgent::serviceDiscovered")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "serviceDiscovered"); signal != nil {
+		signal.(func(*QBluetoothServiceInfo))(NewQBluetoothServiceInfoFromPointer(info))
+	}
+
+}
+
+func (ptr *QBluetoothServiceDiscoveryAgent) ServiceDiscovered(info QBluetoothServiceInfo_ITF) {
+	defer qt.Recovering("QBluetoothServiceDiscoveryAgent::serviceDiscovered")
+
+	if ptr.Pointer() != nil {
+		C.QBluetoothServiceDiscoveryAgent_ServiceDiscovered(ptr.Pointer(), PointerFromQBluetoothServiceInfo(info))
+	}
+}
+
 func NewQBluetoothServiceDiscoveryAgent(parent core.QObject_ITF) *QBluetoothServiceDiscoveryAgent {
 	defer qt.Recovering("QBluetoothServiceDiscoveryAgent::QBluetoothServiceDiscoveryAgent")
 
@@ -1795,6 +2101,15 @@ func (ptr *QBluetoothServiceDiscoveryAgent) IsActive() bool {
 	return false
 }
 
+func (ptr *QBluetoothServiceDiscoveryAgent) RemoteAddress() *QBluetoothAddress {
+	defer qt.Recovering("QBluetoothServiceDiscoveryAgent::remoteAddress")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothAddressFromPointer(C.QBluetoothServiceDiscoveryAgent_RemoteAddress(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QBluetoothServiceDiscoveryAgent) SetRemoteAddress(address QBluetoothAddress_ITF) bool {
 	defer qt.Recovering("QBluetoothServiceDiscoveryAgent::setRemoteAddress")
 
@@ -2070,6 +2385,15 @@ func (ptr *QBluetoothServiceInfo) ServiceProvider() string {
 	return ""
 }
 
+func (ptr *QBluetoothServiceInfo) ServiceUuid() *QBluetoothUuid {
+	defer qt.Recovering("QBluetoothServiceInfo::serviceUuid")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothUuidFromPointer(C.QBluetoothServiceInfo_ServiceUuid(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QBluetoothServiceInfo) SetServiceDescription(description string) {
 	defer qt.Recovering("QBluetoothServiceInfo::setServiceDescription")
 
@@ -2114,6 +2438,15 @@ func NewQBluetoothServiceInfo2(other QBluetoothServiceInfo_ITF) *QBluetoothServi
 	return newQBluetoothServiceInfoFromPointer(C.QBluetoothServiceInfo_NewQBluetoothServiceInfo2(PointerFromQBluetoothServiceInfo(other)))
 }
 
+func (ptr *QBluetoothServiceInfo) Device() *QBluetoothDeviceInfo {
+	defer qt.Recovering("QBluetoothServiceInfo::device")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothDeviceInfoFromPointer(C.QBluetoothServiceInfo_Device(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QBluetoothServiceInfo) IsComplete() bool {
 	defer qt.Recovering("QBluetoothServiceInfo::isComplete")
 
@@ -2549,6 +2882,15 @@ func (ptr *QBluetoothSocket) IsSequential() bool {
 	return false
 }
 
+func (ptr *QBluetoothSocket) LocalAddress() *QBluetoothAddress {
+	defer qt.Recovering("QBluetoothSocket::localAddress")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothAddressFromPointer(C.QBluetoothSocket_LocalAddress(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QBluetoothSocket) LocalName() string {
 	defer qt.Recovering("QBluetoothSocket::localName")
 
@@ -2558,6 +2900,15 @@ func (ptr *QBluetoothSocket) LocalName() string {
 	return ""
 }
 
+func (ptr *QBluetoothSocket) PeerAddress() *QBluetoothAddress {
+	defer qt.Recovering("QBluetoothSocket::peerAddress")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothAddressFromPointer(C.QBluetoothSocket_PeerAddress(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QBluetoothSocket) PeerName() string {
 	defer qt.Recovering("QBluetoothSocket::peerName")
 
@@ -3167,6 +3518,15 @@ func (ptr *QBluetoothTransferReply) Manager() *QBluetoothTransferManager {
 	return nil
 }
 
+func (ptr *QBluetoothTransferReply) Request() *QBluetoothTransferRequest {
+	defer qt.Recovering("QBluetoothTransferReply::request")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothTransferRequestFromPointer(C.QBluetoothTransferReply_Request(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QBluetoothTransferReply) ConnectTransferProgress(f func(bytesTransferred int64, bytesTotal int64)) {
 	defer qt.Recovering("connect QBluetoothTransferReply::transferProgress")
 
@@ -3408,6 +3768,15 @@ func NewQBluetoothTransferRequest2(other QBluetoothTransferRequest_ITF) *QBlueto
 	return newQBluetoothTransferRequestFromPointer(C.QBluetoothTransferRequest_NewQBluetoothTransferRequest2(PointerFromQBluetoothTransferRequest(other)))
 }
 
+func (ptr *QBluetoothTransferRequest) Address() *QBluetoothAddress {
+	defer qt.Recovering("QBluetoothTransferRequest::address")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothAddressFromPointer(C.QBluetoothTransferRequest_Address(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QBluetoothTransferRequest) Attribute(code QBluetoothTransferRequest__Attribute, defaultValue core.QVariant_ITF) *core.QVariant {
 	defer qt.Recovering("QBluetoothTransferRequest::attribute")
 
@@ -3908,6 +4277,15 @@ func NewQLowEnergyCharacteristic2(other QLowEnergyCharacteristic_ITF) *QLowEnerg
 	return newQLowEnergyCharacteristicFromPointer(C.QLowEnergyCharacteristic_NewQLowEnergyCharacteristic2(PointerFromQLowEnergyCharacteristic(other)))
 }
 
+func (ptr *QLowEnergyCharacteristic) Descriptor(uuid QBluetoothUuid_ITF) *QLowEnergyDescriptor {
+	defer qt.Recovering("QLowEnergyCharacteristic::descriptor")
+
+	if ptr.Pointer() != nil {
+		return NewQLowEnergyDescriptorFromPointer(C.QLowEnergyCharacteristic_Descriptor(ptr.Pointer(), PointerFromQBluetoothUuid(uuid)))
+	}
+	return nil
+}
+
 func (ptr *QLowEnergyCharacteristic) IsValid() bool {
 	defer qt.Recovering("QLowEnergyCharacteristic::isValid")
 
@@ -3935,13 +4313,22 @@ func (ptr *QLowEnergyCharacteristic) Properties() QLowEnergyCharacteristic__Prop
 	return 0
 }
 
-func (ptr *QLowEnergyCharacteristic) Value() *core.QByteArray {
+func (ptr *QLowEnergyCharacteristic) Uuid() *QBluetoothUuid {
+	defer qt.Recovering("QLowEnergyCharacteristic::uuid")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothUuidFromPointer(C.QLowEnergyCharacteristic_Uuid(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QLowEnergyCharacteristic) Value() string {
 	defer qt.Recovering("QLowEnergyCharacteristic::value")
 
 	if ptr.Pointer() != nil {
-		return core.NewQByteArrayFromPointer(C.QLowEnergyCharacteristic_Value(ptr.Pointer()))
+		return C.GoString(C.QLowEnergyCharacteristic_Value(ptr.Pointer()))
 	}
-	return nil
+	return ""
 }
 
 func (ptr *QLowEnergyCharacteristic) DestroyQLowEnergyCharacteristic() {
@@ -4162,6 +4549,42 @@ func (ptr *QLowEnergyController) Error2(newError QLowEnergyController__Error) {
 	}
 }
 
+func (ptr *QLowEnergyController) ConnectServiceDiscovered(f func(newService *QBluetoothUuid)) {
+	defer qt.Recovering("connect QLowEnergyController::serviceDiscovered")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyController_ConnectServiceDiscovered(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "serviceDiscovered", f)
+	}
+}
+
+func (ptr *QLowEnergyController) DisconnectServiceDiscovered() {
+	defer qt.Recovering("disconnect QLowEnergyController::serviceDiscovered")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyController_DisconnectServiceDiscovered(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "serviceDiscovered")
+	}
+}
+
+//export callbackQLowEnergyControllerServiceDiscovered
+func callbackQLowEnergyControllerServiceDiscovered(ptr unsafe.Pointer, ptrName *C.char, newService unsafe.Pointer) {
+	defer qt.Recovering("callback QLowEnergyController::serviceDiscovered")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "serviceDiscovered"); signal != nil {
+		signal.(func(*QBluetoothUuid))(NewQBluetoothUuidFromPointer(newService))
+	}
+
+}
+
+func (ptr *QLowEnergyController) ServiceDiscovered(newService QBluetoothUuid_ITF) {
+	defer qt.Recovering("QLowEnergyController::serviceDiscovered")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyController_ServiceDiscovered(ptr.Pointer(), PointerFromQBluetoothUuid(newService))
+	}
+}
+
 func (ptr *QLowEnergyController) ConnectStateChanged(f func(state QLowEnergyController__ControllerState)) {
 	defer qt.Recovering("connect QLowEnergyController::stateChanged")
 
@@ -4255,6 +4678,24 @@ func (ptr *QLowEnergyController) ErrorString() string {
 	return ""
 }
 
+func (ptr *QLowEnergyController) LocalAddress() *QBluetoothAddress {
+	defer qt.Recovering("QLowEnergyController::localAddress")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothAddressFromPointer(C.QLowEnergyController_LocalAddress(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QLowEnergyController) RemoteAddress() *QBluetoothAddress {
+	defer qt.Recovering("QLowEnergyController::remoteAddress")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothAddressFromPointer(C.QLowEnergyController_RemoteAddress(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QLowEnergyController) RemoteAddressType() QLowEnergyController__RemoteAddressType {
 	defer qt.Recovering("QLowEnergyController::remoteAddressType")
 
@@ -4511,13 +4952,22 @@ func (ptr *QLowEnergyDescriptor) Type() QBluetoothUuid__DescriptorType {
 	return 0
 }
 
-func (ptr *QLowEnergyDescriptor) Value() *core.QByteArray {
+func (ptr *QLowEnergyDescriptor) Uuid() *QBluetoothUuid {
+	defer qt.Recovering("QLowEnergyDescriptor::uuid")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothUuidFromPointer(C.QLowEnergyDescriptor_Uuid(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QLowEnergyDescriptor) Value() string {
 	defer qt.Recovering("QLowEnergyDescriptor::value")
 
 	if ptr.Pointer() != nil {
-		return core.NewQByteArrayFromPointer(C.QLowEnergyDescriptor_Value(ptr.Pointer()))
+		return C.GoString(C.QLowEnergyDescriptor_Value(ptr.Pointer()))
 	}
-	return nil
+	return ""
 }
 
 func (ptr *QLowEnergyDescriptor) DestroyQLowEnergyDescriptor() {
@@ -4601,6 +5051,186 @@ const (
 	QLowEnergyService__WriteWithoutResponse = QLowEnergyService__WriteMode(1)
 )
 
+func (ptr *QLowEnergyService) ConnectCharacteristicChanged(f func(characteristic *QLowEnergyCharacteristic, newValue string)) {
+	defer qt.Recovering("connect QLowEnergyService::characteristicChanged")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyService_ConnectCharacteristicChanged(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "characteristicChanged", f)
+	}
+}
+
+func (ptr *QLowEnergyService) DisconnectCharacteristicChanged() {
+	defer qt.Recovering("disconnect QLowEnergyService::characteristicChanged")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyService_DisconnectCharacteristicChanged(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "characteristicChanged")
+	}
+}
+
+//export callbackQLowEnergyServiceCharacteristicChanged
+func callbackQLowEnergyServiceCharacteristicChanged(ptr unsafe.Pointer, ptrName *C.char, characteristic unsafe.Pointer, newValue *C.char) {
+	defer qt.Recovering("callback QLowEnergyService::characteristicChanged")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "characteristicChanged"); signal != nil {
+		signal.(func(*QLowEnergyCharacteristic, string))(NewQLowEnergyCharacteristicFromPointer(characteristic), C.GoString(newValue))
+	}
+
+}
+
+func (ptr *QLowEnergyService) CharacteristicChanged(characteristic QLowEnergyCharacteristic_ITF, newValue string) {
+	defer qt.Recovering("QLowEnergyService::characteristicChanged")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyService_CharacteristicChanged(ptr.Pointer(), PointerFromQLowEnergyCharacteristic(characteristic), C.CString(newValue))
+	}
+}
+
+func (ptr *QLowEnergyService) ConnectCharacteristicRead(f func(characteristic *QLowEnergyCharacteristic, value string)) {
+	defer qt.Recovering("connect QLowEnergyService::characteristicRead")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyService_ConnectCharacteristicRead(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "characteristicRead", f)
+	}
+}
+
+func (ptr *QLowEnergyService) DisconnectCharacteristicRead() {
+	defer qt.Recovering("disconnect QLowEnergyService::characteristicRead")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyService_DisconnectCharacteristicRead(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "characteristicRead")
+	}
+}
+
+//export callbackQLowEnergyServiceCharacteristicRead
+func callbackQLowEnergyServiceCharacteristicRead(ptr unsafe.Pointer, ptrName *C.char, characteristic unsafe.Pointer, value *C.char) {
+	defer qt.Recovering("callback QLowEnergyService::characteristicRead")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "characteristicRead"); signal != nil {
+		signal.(func(*QLowEnergyCharacteristic, string))(NewQLowEnergyCharacteristicFromPointer(characteristic), C.GoString(value))
+	}
+
+}
+
+func (ptr *QLowEnergyService) CharacteristicRead(characteristic QLowEnergyCharacteristic_ITF, value string) {
+	defer qt.Recovering("QLowEnergyService::characteristicRead")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyService_CharacteristicRead(ptr.Pointer(), PointerFromQLowEnergyCharacteristic(characteristic), C.CString(value))
+	}
+}
+
+func (ptr *QLowEnergyService) ConnectCharacteristicWritten(f func(characteristic *QLowEnergyCharacteristic, newValue string)) {
+	defer qt.Recovering("connect QLowEnergyService::characteristicWritten")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyService_ConnectCharacteristicWritten(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "characteristicWritten", f)
+	}
+}
+
+func (ptr *QLowEnergyService) DisconnectCharacteristicWritten() {
+	defer qt.Recovering("disconnect QLowEnergyService::characteristicWritten")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyService_DisconnectCharacteristicWritten(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "characteristicWritten")
+	}
+}
+
+//export callbackQLowEnergyServiceCharacteristicWritten
+func callbackQLowEnergyServiceCharacteristicWritten(ptr unsafe.Pointer, ptrName *C.char, characteristic unsafe.Pointer, newValue *C.char) {
+	defer qt.Recovering("callback QLowEnergyService::characteristicWritten")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "characteristicWritten"); signal != nil {
+		signal.(func(*QLowEnergyCharacteristic, string))(NewQLowEnergyCharacteristicFromPointer(characteristic), C.GoString(newValue))
+	}
+
+}
+
+func (ptr *QLowEnergyService) CharacteristicWritten(characteristic QLowEnergyCharacteristic_ITF, newValue string) {
+	defer qt.Recovering("QLowEnergyService::characteristicWritten")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyService_CharacteristicWritten(ptr.Pointer(), PointerFromQLowEnergyCharacteristic(characteristic), C.CString(newValue))
+	}
+}
+
+func (ptr *QLowEnergyService) ConnectDescriptorRead(f func(descriptor *QLowEnergyDescriptor, value string)) {
+	defer qt.Recovering("connect QLowEnergyService::descriptorRead")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyService_ConnectDescriptorRead(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "descriptorRead", f)
+	}
+}
+
+func (ptr *QLowEnergyService) DisconnectDescriptorRead() {
+	defer qt.Recovering("disconnect QLowEnergyService::descriptorRead")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyService_DisconnectDescriptorRead(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "descriptorRead")
+	}
+}
+
+//export callbackQLowEnergyServiceDescriptorRead
+func callbackQLowEnergyServiceDescriptorRead(ptr unsafe.Pointer, ptrName *C.char, descriptor unsafe.Pointer, value *C.char) {
+	defer qt.Recovering("callback QLowEnergyService::descriptorRead")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "descriptorRead"); signal != nil {
+		signal.(func(*QLowEnergyDescriptor, string))(NewQLowEnergyDescriptorFromPointer(descriptor), C.GoString(value))
+	}
+
+}
+
+func (ptr *QLowEnergyService) DescriptorRead(descriptor QLowEnergyDescriptor_ITF, value string) {
+	defer qt.Recovering("QLowEnergyService::descriptorRead")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyService_DescriptorRead(ptr.Pointer(), PointerFromQLowEnergyDescriptor(descriptor), C.CString(value))
+	}
+}
+
+func (ptr *QLowEnergyService) ConnectDescriptorWritten(f func(descriptor *QLowEnergyDescriptor, newValue string)) {
+	defer qt.Recovering("connect QLowEnergyService::descriptorWritten")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyService_ConnectDescriptorWritten(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "descriptorWritten", f)
+	}
+}
+
+func (ptr *QLowEnergyService) DisconnectDescriptorWritten() {
+	defer qt.Recovering("disconnect QLowEnergyService::descriptorWritten")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyService_DisconnectDescriptorWritten(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "descriptorWritten")
+	}
+}
+
+//export callbackQLowEnergyServiceDescriptorWritten
+func callbackQLowEnergyServiceDescriptorWritten(ptr unsafe.Pointer, ptrName *C.char, descriptor unsafe.Pointer, newValue *C.char) {
+	defer qt.Recovering("callback QLowEnergyService::descriptorWritten")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "descriptorWritten"); signal != nil {
+		signal.(func(*QLowEnergyDescriptor, string))(NewQLowEnergyDescriptorFromPointer(descriptor), C.GoString(newValue))
+	}
+
+}
+
+func (ptr *QLowEnergyService) DescriptorWritten(descriptor QLowEnergyDescriptor_ITF, newValue string) {
+	defer qt.Recovering("QLowEnergyService::descriptorWritten")
+
+	if ptr.Pointer() != nil {
+		C.QLowEnergyService_DescriptorWritten(ptr.Pointer(), PointerFromQLowEnergyDescriptor(descriptor), C.CString(newValue))
+	}
+}
+
 func (ptr *QLowEnergyService) ConnectError2(f func(newError QLowEnergyService__ServiceError)) {
 	defer qt.Recovering("connect QLowEnergyService::error")
 
@@ -4673,6 +5303,15 @@ func (ptr *QLowEnergyService) StateChanged(newState QLowEnergyService__ServiceSt
 	}
 }
 
+func (ptr *QLowEnergyService) Characteristic(uuid QBluetoothUuid_ITF) *QLowEnergyCharacteristic {
+	defer qt.Recovering("QLowEnergyService::characteristic")
+
+	if ptr.Pointer() != nil {
+		return NewQLowEnergyCharacteristicFromPointer(C.QLowEnergyService_Characteristic(ptr.Pointer(), PointerFromQBluetoothUuid(uuid)))
+	}
+	return nil
+}
+
 func (ptr *QLowEnergyService) Contains(characteristic QLowEnergyCharacteristic_ITF) bool {
 	defer qt.Recovering("QLowEnergyService::contains")
 
@@ -4733,6 +5372,15 @@ func (ptr *QLowEnergyService) ServiceName() string {
 	return ""
 }
 
+func (ptr *QLowEnergyService) ServiceUuid() *QBluetoothUuid {
+	defer qt.Recovering("QLowEnergyService::serviceUuid")
+
+	if ptr.Pointer() != nil {
+		return NewQBluetoothUuidFromPointer(C.QLowEnergyService_ServiceUuid(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QLowEnergyService) State() QLowEnergyService__ServiceState {
 	defer qt.Recovering("QLowEnergyService::state")
 
@@ -4751,19 +5399,19 @@ func (ptr *QLowEnergyService) Type() QLowEnergyService__ServiceType {
 	return 0
 }
 
-func (ptr *QLowEnergyService) WriteCharacteristic(characteristic QLowEnergyCharacteristic_ITF, newValue core.QByteArray_ITF, mode QLowEnergyService__WriteMode) {
+func (ptr *QLowEnergyService) WriteCharacteristic(characteristic QLowEnergyCharacteristic_ITF, newValue string, mode QLowEnergyService__WriteMode) {
 	defer qt.Recovering("QLowEnergyService::writeCharacteristic")
 
 	if ptr.Pointer() != nil {
-		C.QLowEnergyService_WriteCharacteristic(ptr.Pointer(), PointerFromQLowEnergyCharacteristic(characteristic), core.PointerFromQByteArray(newValue), C.int(mode))
+		C.QLowEnergyService_WriteCharacteristic(ptr.Pointer(), PointerFromQLowEnergyCharacteristic(characteristic), C.CString(newValue), C.int(mode))
 	}
 }
 
-func (ptr *QLowEnergyService) WriteDescriptor(descriptor QLowEnergyDescriptor_ITF, newValue core.QByteArray_ITF) {
+func (ptr *QLowEnergyService) WriteDescriptor(descriptor QLowEnergyDescriptor_ITF, newValue string) {
 	defer qt.Recovering("QLowEnergyService::writeDescriptor")
 
 	if ptr.Pointer() != nil {
-		C.QLowEnergyService_WriteDescriptor(ptr.Pointer(), PointerFromQLowEnergyDescriptor(descriptor), core.PointerFromQByteArray(newValue))
+		C.QLowEnergyService_WriteDescriptor(ptr.Pointer(), PointerFromQLowEnergyDescriptor(descriptor), C.CString(newValue))
 	}
 }
 

bluetooth/bluetooth.h

@@ -17,6 +17,9 @@ void QBluetoothAddress_DestroyQBluetoothAddress(void* ptr);
 void QBluetoothDeviceDiscoveryAgent_ConnectCanceled(void* ptr);
 void QBluetoothDeviceDiscoveryAgent_DisconnectCanceled(void* ptr);
 void QBluetoothDeviceDiscoveryAgent_Canceled(void* ptr);
+void QBluetoothDeviceDiscoveryAgent_ConnectDeviceDiscovered(void* ptr);
+void QBluetoothDeviceDiscoveryAgent_DisconnectDeviceDiscovered(void* ptr);
+void QBluetoothDeviceDiscoveryAgent_DeviceDiscovered(void* ptr, void* info);
 void QBluetoothDeviceDiscoveryAgent_ConnectError2(void* ptr);
 void QBluetoothDeviceDiscoveryAgent_DisconnectError2(void* ptr);
 void QBluetoothDeviceDiscoveryAgent_Error2(void* ptr, int error);
@@ -41,7 +44,9 @@ void QBluetoothDeviceDiscoveryAgent_CustomEvent(void* ptr, void* event);
 void QBluetoothDeviceDiscoveryAgent_CustomEventDefault(void* ptr, void* event);
 void* QBluetoothDeviceInfo_NewQBluetoothDeviceInfo();
 void* QBluetoothDeviceInfo_NewQBluetoothDeviceInfo4(void* other);
+void* QBluetoothDeviceInfo_Address(void* ptr);
 int QBluetoothDeviceInfo_CoreConfigurations(void* ptr);
+void* QBluetoothDeviceInfo_DeviceUuid(void* ptr);
 int QBluetoothDeviceInfo_IsCached(void* ptr);
 int QBluetoothDeviceInfo_IsValid(void* ptr);
 int QBluetoothDeviceInfo_MajorDeviceClass(void* ptr);
@@ -54,20 +59,37 @@ void QBluetoothDeviceInfo_SetDeviceUuid(void* ptr, void* uuid);
 void QBluetoothDeviceInfo_DestroyQBluetoothDeviceInfo(void* ptr);
 void* QBluetoothHostInfo_NewQBluetoothHostInfo();
 void* QBluetoothHostInfo_NewQBluetoothHostInfo2(void* other);
+void* QBluetoothHostInfo_Address(void* ptr);
 char* QBluetoothHostInfo_Name(void* ptr);
 void QBluetoothHostInfo_SetAddress(void* ptr, void* address);
 void QBluetoothHostInfo_SetName(void* ptr, char* name);
 void QBluetoothHostInfo_DestroyQBluetoothHostInfo(void* ptr);
+void QBluetoothLocalDevice_ConnectDeviceConnected(void* ptr);
+void QBluetoothLocalDevice_DisconnectDeviceConnected(void* ptr);
+void QBluetoothLocalDevice_DeviceConnected(void* ptr, void* address);
+void QBluetoothLocalDevice_ConnectDeviceDisconnected(void* ptr);
+void QBluetoothLocalDevice_DisconnectDeviceDisconnected(void* ptr);
+void QBluetoothLocalDevice_DeviceDisconnected(void* ptr, void* address);
 void QBluetoothLocalDevice_ConnectError(void* ptr);
 void QBluetoothLocalDevice_DisconnectError(void* ptr);
 void QBluetoothLocalDevice_Error(void* ptr, int error);
 void QBluetoothLocalDevice_ConnectHostModeStateChanged(void* ptr);
 void QBluetoothLocalDevice_DisconnectHostModeStateChanged(void* ptr);
 void QBluetoothLocalDevice_HostModeStateChanged(void* ptr, int state);
+void QBluetoothLocalDevice_ConnectPairingDisplayConfirmation(void* ptr);
+void QBluetoothLocalDevice_DisconnectPairingDisplayConfirmation(void* ptr);
+void QBluetoothLocalDevice_PairingDisplayConfirmation(void* ptr, void* address, char* pin);
+void QBluetoothLocalDevice_ConnectPairingDisplayPinCode(void* ptr);
+void QBluetoothLocalDevice_DisconnectPairingDisplayPinCode(void* ptr);
+void QBluetoothLocalDevice_PairingDisplayPinCode(void* ptr, void* address, char* pin);
+void QBluetoothLocalDevice_ConnectPairingFinished(void* ptr);
+void QBluetoothLocalDevice_DisconnectPairingFinished(void* ptr);
+void QBluetoothLocalDevice_PairingFinished(void* ptr, void* address, int pairing);
 int QBluetoothLocalDevice_IsValid(void* ptr);
 void QBluetoothLocalDevice_DestroyQBluetoothLocalDevice(void* ptr);
 void* QBluetoothLocalDevice_NewQBluetoothLocalDevice(void* parent);
 void* QBluetoothLocalDevice_NewQBluetoothLocalDevice2(void* address, void* parent);
+void* QBluetoothLocalDevice_Address(void* ptr);
 int QBluetoothLocalDevice_HostMode(void* ptr);
 char* QBluetoothLocalDevice_Name(void* ptr);
 void QBluetoothLocalDevice_PairingConfirmation(void* ptr, int accept);
@@ -90,12 +112,14 @@ void QBluetoothServer_DisconnectNewConnection(void* ptr);
 void QBluetoothServer_NewConnection(void* ptr);
 int QBluetoothServer_Error(void* ptr);
 int QBluetoothServer_IsListening(void* ptr);
+void* QBluetoothServer_Listen2(void* ptr, void* uuid, char* serviceName);
 int QBluetoothServer_MaxPendingConnections(void* ptr);
 int QBluetoothServer_ServerType(void* ptr);
 void QBluetoothServer_DestroyQBluetoothServer(void* ptr);
 void QBluetoothServer_Close(void* ptr);
 int QBluetoothServer_HasPendingConnections(void* ptr);
 void* QBluetoothServer_NextPendingConnection(void* ptr);
+void* QBluetoothServer_ServerAddress(void* ptr);
 void QBluetoothServer_SetMaxPendingConnections(void* ptr, int numConnections);
 void QBluetoothServer_TimerEvent(void* ptr, void* event);
 void QBluetoothServer_TimerEventDefault(void* ptr, void* event);
@@ -112,12 +136,16 @@ void QBluetoothServiceDiscoveryAgent_Error2(void* ptr, int error);
 void QBluetoothServiceDiscoveryAgent_ConnectFinished(void* ptr);
 void QBluetoothServiceDiscoveryAgent_DisconnectFinished(void* ptr);
 void QBluetoothServiceDiscoveryAgent_Finished(void* ptr);
+void QBluetoothServiceDiscoveryAgent_ConnectServiceDiscovered(void* ptr);
+void QBluetoothServiceDiscoveryAgent_DisconnectServiceDiscovered(void* ptr);
+void QBluetoothServiceDiscoveryAgent_ServiceDiscovered(void* ptr, void* info);
 void* QBluetoothServiceDiscoveryAgent_NewQBluetoothServiceDiscoveryAgent(void* parent);
 void* QBluetoothServiceDiscoveryAgent_NewQBluetoothServiceDiscoveryAgent2(void* deviceAdapter, void* parent);
 void QBluetoothServiceDiscoveryAgent_Clear(void* ptr);
 int QBluetoothServiceDiscoveryAgent_Error(void* ptr);
 char* QBluetoothServiceDiscoveryAgent_ErrorString(void* ptr);
 int QBluetoothServiceDiscoveryAgent_IsActive(void* ptr);
+void* QBluetoothServiceDiscoveryAgent_RemoteAddress(void* ptr);
 int QBluetoothServiceDiscoveryAgent_SetRemoteAddress(void* ptr, void* address);
 void QBluetoothServiceDiscoveryAgent_SetUuidFilter2(void* ptr, void* uuid);
 void QBluetoothServiceDiscoveryAgent_Start(void* ptr, int mode);
@@ -135,12 +163,14 @@ int QBluetoothServiceInfo_ServiceProvider_Type();
 char* QBluetoothServiceInfo_ServiceDescription(void* ptr);
 char* QBluetoothServiceInfo_ServiceName(void* ptr);
 char* QBluetoothServiceInfo_ServiceProvider(void* ptr);
+void* QBluetoothServiceInfo_ServiceUuid(void* ptr);
 void QBluetoothServiceInfo_SetServiceDescription(void* ptr, char* description);
 void QBluetoothServiceInfo_SetServiceName(void* ptr, char* name);
 void QBluetoothServiceInfo_SetServiceProvider(void* ptr, char* provider);
 void QBluetoothServiceInfo_SetServiceUuid(void* ptr, void* uuid);
 void* QBluetoothServiceInfo_NewQBluetoothServiceInfo();
 void* QBluetoothServiceInfo_NewQBluetoothServiceInfo2(void* other);
+void* QBluetoothServiceInfo_Device(void* ptr);
 int QBluetoothServiceInfo_IsComplete(void* ptr);
 int QBluetoothServiceInfo_IsRegistered(void* ptr);
 int QBluetoothServiceInfo_IsValid(void* ptr);
@@ -181,7 +211,9 @@ int QBluetoothSocket_Error(void* ptr);
 char* QBluetoothSocket_ErrorString(void* ptr);
 int QBluetoothSocket_IsSequential(void* ptr);
 int QBluetoothSocket_IsSequentialDefault(void* ptr);
+void* QBluetoothSocket_LocalAddress(void* ptr);
 char* QBluetoothSocket_LocalName(void* ptr);
+void* QBluetoothSocket_PeerAddress(void* ptr);
 char* QBluetoothSocket_PeerName(void* ptr);
 long long QBluetoothSocket_ReadData(void* ptr, char* data, long long maxSize);
 long long QBluetoothSocket_ReadDataDefault(void* ptr, char* data, long long maxSize);
@@ -222,6 +254,7 @@ void QBluetoothTransferReply_Finished(void* ptr, void* reply);
 int QBluetoothTransferReply_IsFinished(void* ptr);
 int QBluetoothTransferReply_IsRunning(void* ptr);
 void* QBluetoothTransferReply_Manager(void* ptr);
+void* QBluetoothTransferReply_Request(void* ptr);
 void QBluetoothTransferReply_ConnectTransferProgress(void* ptr);
 void QBluetoothTransferReply_DisconnectTransferProgress(void* ptr);
 void QBluetoothTransferReply_TransferProgress(void* ptr, long long bytesTransferred, long long bytesTotal);
@@ -234,6 +267,7 @@ void QBluetoothTransferReply_CustomEvent(void* ptr, void* event);
 void QBluetoothTransferReply_CustomEventDefault(void* ptr, void* event);
 void* QBluetoothTransferRequest_NewQBluetoothTransferRequest(void* address);
 void* QBluetoothTransferRequest_NewQBluetoothTransferRequest2(void* other);
+void* QBluetoothTransferRequest_Address(void* ptr);
 void* QBluetoothTransferRequest_Attribute(void* ptr, int code, void* defaultValue);
 void QBluetoothTransferRequest_SetAttribute(void* ptr, int code, void* value);
 void QBluetoothTransferRequest_DestroyQBluetoothTransferRequest(void* ptr);
@@ -253,10 +287,12 @@ char* QBluetoothUuid_QBluetoothUuid_ServiceClassToString(int uuid);
 void QBluetoothUuid_DestroyQBluetoothUuid(void* ptr);
 void* QLowEnergyCharacteristic_NewQLowEnergyCharacteristic();
 void* QLowEnergyCharacteristic_NewQLowEnergyCharacteristic2(void* other);
+void* QLowEnergyCharacteristic_Descriptor(void* ptr, void* uuid);
 int QLowEnergyCharacteristic_IsValid(void* ptr);
 char* QLowEnergyCharacteristic_Name(void* ptr);
 int QLowEnergyCharacteristic_Properties(void* ptr);
-void* QLowEnergyCharacteristic_Value(void* ptr);
+void* QLowEnergyCharacteristic_Uuid(void* ptr);
+char* QLowEnergyCharacteristic_Value(void* ptr);
 void QLowEnergyCharacteristic_DestroyQLowEnergyCharacteristic(void* ptr);
 void QLowEnergyController_ConnectConnected(void* ptr);
 void QLowEnergyController_DisconnectConnected(void* ptr);
@@ -270,6 +306,9 @@ void QLowEnergyController_DiscoveryFinished(void* ptr);
 void QLowEnergyController_ConnectError2(void* ptr);
 void QLowEnergyController_DisconnectError2(void* ptr);
 void QLowEnergyController_Error2(void* ptr, int newError);
+void QLowEnergyController_ConnectServiceDiscovered(void* ptr);
+void QLowEnergyController_DisconnectServiceDiscovered(void* ptr);
+void QLowEnergyController_ServiceDiscovered(void* ptr, void* newService);
 void QLowEnergyController_ConnectStateChanged(void* ptr);
 void QLowEnergyController_DisconnectStateChanged(void* ptr);
 void QLowEnergyController_StateChanged(void* ptr, int state);
@@ -280,6 +319,8 @@ void QLowEnergyController_DisconnectFromDevice(void* ptr);
 void QLowEnergyController_DiscoverServices(void* ptr);
 int QLowEnergyController_Error(void* ptr);
 char* QLowEnergyController_ErrorString(void* ptr);
+void* QLowEnergyController_LocalAddress(void* ptr);
+void* QLowEnergyController_RemoteAddress(void* ptr);
 int QLowEnergyController_RemoteAddressType(void* ptr);
 char* QLowEnergyController_RemoteName(void* ptr);
 void QLowEnergyController_SetRemoteAddressType(void* ptr, int ty);
@@ -296,14 +337,31 @@ void* QLowEnergyDescriptor_NewQLowEnergyDescriptor2(void* other);
 int QLowEnergyDescriptor_IsValid(void* ptr);
 char* QLowEnergyDescriptor_Name(void* ptr);
 int QLowEnergyDescriptor_Type(void* ptr);
-void* QLowEnergyDescriptor_Value(void* ptr);
+void* QLowEnergyDescriptor_Uuid(void* ptr);
+char* QLowEnergyDescriptor_Value(void* ptr);
 void QLowEnergyDescriptor_DestroyQLowEnergyDescriptor(void* ptr);
+void QLowEnergyService_ConnectCharacteristicChanged(void* ptr);
+void QLowEnergyService_DisconnectCharacteristicChanged(void* ptr);
+void QLowEnergyService_CharacteristicChanged(void* ptr, void* characteristic, char* newValue);
+void QLowEnergyService_ConnectCharacteristicRead(void* ptr);
+void QLowEnergyService_DisconnectCharacteristicRead(void* ptr);
+void QLowEnergyService_CharacteristicRead(void* ptr, void* characteristic, char* value);
+void QLowEnergyService_ConnectCharacteristicWritten(void* ptr);
+void QLowEnergyService_DisconnectCharacteristicWritten(void* ptr);
+void QLowEnergyService_CharacteristicWritten(void* ptr, void* characteristic, char* newValue);
+void QLowEnergyService_ConnectDescriptorRead(void* ptr);
+void QLowEnergyService_DisconnectDescriptorRead(void* ptr);
+void QLowEnergyService_DescriptorRead(void* ptr, void* descriptor, char* value);
+void QLowEnergyService_ConnectDescriptorWritten(void* ptr);
+void QLowEnergyService_DisconnectDescriptorWritten(void* ptr);
+void QLowEnergyService_DescriptorWritten(void* ptr, void* descriptor, char* newValue);
 void QLowEnergyService_ConnectError2(void* ptr);
 void QLowEnergyService_DisconnectError2(void* ptr);
 void QLowEnergyService_Error2(void* ptr, int newError);
 void QLowEnergyService_ConnectStateChanged(void* ptr);
 void QLowEnergyService_DisconnectStateChanged(void* ptr);
 void QLowEnergyService_StateChanged(void* ptr, int newState);
+void* QLowEnergyService_Characteristic(void* ptr, void* uuid);
 int QLowEnergyService_Contains(void* ptr, void* characteristic);
 int QLowEnergyService_Contains2(void* ptr, void* descriptor);
 void QLowEnergyService_DiscoverDetails(void* ptr);
@@ -311,10 +369,11 @@ int QLowEnergyService_Error(void* ptr);
 void QLowEnergyService_ReadCharacteristic(void* ptr, void* characteristic);
 void QLowEnergyService_ReadDescriptor(void* ptr, void* descriptor);
 char* QLowEnergyService_ServiceName(void* ptr);
+void* QLowEnergyService_ServiceUuid(void* ptr);
 int QLowEnergyService_State(void* ptr);
 int QLowEnergyService_Type(void* ptr);
-void QLowEnergyService_WriteCharacteristic(void* ptr, void* characteristic, void* newValue, int mode);
-void QLowEnergyService_WriteDescriptor(void* ptr, void* descriptor, void* newValue);
+void QLowEnergyService_WriteCharacteristic(void* ptr, void* characteristic, char* newValue, int mode);
+void QLowEnergyService_WriteDescriptor(void* ptr, void* descriptor, char* newValue);
 void QLowEnergyService_DestroyQLowEnergyService(void* ptr);
 void QLowEnergyService_TimerEvent(void* ptr, void* event);
 void QLowEnergyService_TimerEventDefault(void* ptr, void* event);

core/core.h

@@ -74,32 +74,14 @@ void QAbstractEventDispatcher_ChildEvent(void* ptr, void* event);
 void QAbstractEventDispatcher_ChildEventDefault(void* ptr, void* event);
 void QAbstractEventDispatcher_CustomEvent(void* ptr, void* event);
 void QAbstractEventDispatcher_CustomEventDefault(void* ptr, void* event);
-void* QAbstractItemModel_Sibling(void* ptr, int row, int column, void* index);
-void* QAbstractItemModel_SiblingDefault(void* ptr, int row, int column, void* index);
-void* QAbstractItemModel_Buddy(void* ptr, void* index);
-void* QAbstractItemModel_BuddyDefault(void* ptr, void* index);
 int QAbstractItemModel_CanDropMimeData(void* ptr, void* data, int action, int row, int column, void* parent);
 int QAbstractItemModel_CanDropMimeDataDefault(void* ptr, void* data, int action, int row, int column, void* parent);
 int QAbstractItemModel_CanFetchMore(void* ptr, void* parent);
 int QAbstractItemModel_CanFetchMoreDefault(void* ptr, void* parent);
 int QAbstractItemModel_ColumnCount(void* ptr, void* parent);
-void QAbstractItemModel_ConnectColumnsAboutToBeInserted(void* ptr);
-void QAbstractItemModel_DisconnectColumnsAboutToBeInserted(void* ptr);
-void QAbstractItemModel_ConnectColumnsAboutToBeMoved(void* ptr);
-void QAbstractItemModel_DisconnectColumnsAboutToBeMoved(void* ptr);
-void QAbstractItemModel_ConnectColumnsAboutToBeRemoved(void* ptr);
-void QAbstractItemModel_DisconnectColumnsAboutToBeRemoved(void* ptr);
-void QAbstractItemModel_ConnectColumnsInserted(void* ptr);
-void QAbstractItemModel_DisconnectColumnsInserted(void* ptr);
-void QAbstractItemModel_ConnectColumnsMoved(void* ptr);
-void QAbstractItemModel_DisconnectColumnsMoved(void* ptr);
-void QAbstractItemModel_ConnectColumnsRemoved(void* ptr);
-void QAbstractItemModel_DisconnectColumnsRemoved(void* ptr);
 void* QAbstractItemModel_Data(void* ptr, void* index, int role);
 int QAbstractItemModel_DropMimeData(void* ptr, void* data, int action, int row, int column, void* parent);
 int QAbstractItemModel_DropMimeDataDefault(void* ptr, void* data, int action, int row, int column, void* parent);
-void QAbstractItemModel_FetchMore(void* ptr, void* parent);
-void QAbstractItemModel_FetchMoreDefault(void* ptr, void* parent);
 int QAbstractItemModel_Flags(void* ptr, void* index);
 int QAbstractItemModel_FlagsDefault(void* ptr, void* index);
 int QAbstractItemModel_HasChildren(void* ptr, void* parent);
@@ -110,7 +92,6 @@ void* QAbstractItemModel_HeaderDataDefault(void* ptr, int section, int orientati
 void QAbstractItemModel_ConnectHeaderDataChanged(void* ptr);
 void QAbstractItemModel_DisconnectHeaderDataChanged(void* ptr);
 void QAbstractItemModel_HeaderDataChanged(void* ptr, int orientation, int first, int last);
-void* QAbstractItemModel_Index(void* ptr, int row, int column, void* parent);
 int QAbstractItemModel_InsertColumn(void* ptr, int column, void* parent);
 int QAbstractItemModel_InsertColumns(void* ptr, int column, int count, void* parent);
 int QAbstractItemModel_InsertColumnsDefault(void* ptr, int column, int count, void* parent);
@@ -129,7 +110,6 @@ int QAbstractItemModel_MoveColumnsDefault(void* ptr, void* sourceParent, int sou
 int QAbstractItemModel_MoveRow(void* ptr, void* sourceParent, int sourceRow, void* destinationParent, int destinationChild);
 int QAbstractItemModel_MoveRows(void* ptr, void* sourceParent, int sourceRow, int count, void* destinationParent, int destinationChild);
 int QAbstractItemModel_MoveRowsDefault(void* ptr, void* sourceParent, int sourceRow, int count, void* destinationParent, int destinationChild);
-void* QAbstractItemModel_Parent(void* ptr, void* index);
 int QAbstractItemModel_RemoveColumn(void* ptr, int column, void* parent);
 int QAbstractItemModel_RemoveColumns(void* ptr, int column, int count, void* parent);
 int QAbstractItemModel_RemoveColumnsDefault(void* ptr, int column, int count, void* parent);
@@ -139,18 +119,6 @@ int QAbstractItemModel_RemoveRowsDefault(void* ptr, int row, int count, void* pa
 void QAbstractItemModel_Revert(void* ptr);
 void QAbstractItemModel_RevertDefault(void* ptr);
 int QAbstractItemModel_RowCount(void* ptr, void* parent);
-void QAbstractItemModel_ConnectRowsAboutToBeInserted(void* ptr);
-void QAbstractItemModel_DisconnectRowsAboutToBeInserted(void* ptr);
-void QAbstractItemModel_ConnectRowsAboutToBeMoved(void* ptr);
-void QAbstractItemModel_DisconnectRowsAboutToBeMoved(void* ptr);
-void QAbstractItemModel_ConnectRowsAboutToBeRemoved(void* ptr);
-void QAbstractItemModel_DisconnectRowsAboutToBeRemoved(void* ptr);
-void QAbstractItemModel_ConnectRowsInserted(void* ptr);
-void QAbstractItemModel_DisconnectRowsInserted(void* ptr);
-void QAbstractItemModel_ConnectRowsMoved(void* ptr);
-void QAbstractItemModel_DisconnectRowsMoved(void* ptr);
-void QAbstractItemModel_ConnectRowsRemoved(void* ptr);
-void QAbstractItemModel_DisconnectRowsRemoved(void* ptr);
 int QAbstractItemModel_SetData(void* ptr, void* index, void* value, int role);
 int QAbstractItemModel_SetDataDefault(void* ptr, void* index, void* value, int role);
 int QAbstractItemModel_SetHeaderData(void* ptr, int section, int orientation, void* value, int role);
@@ -172,17 +140,11 @@ void QAbstractItemModel_ChildEvent(void* ptr, void* event);
 void QAbstractItemModel_ChildEventDefault(void* ptr, void* event);
 void QAbstractItemModel_CustomEvent(void* ptr, void* event);
 void QAbstractItemModel_CustomEventDefault(void* ptr, void* event);
-void* QAbstractListModel_Index(void* ptr, int row, int column, void* parent);
-void* QAbstractListModel_IndexDefault(void* ptr, int row, int column, void* parent);
 int QAbstractListModel_DropMimeData(void* ptr, void* data, int action, int row, int column, void* parent);
 int QAbstractListModel_DropMimeDataDefault(void* ptr, void* data, int action, int row, int column, void* parent);
 int QAbstractListModel_Flags(void* ptr, void* index);
 int QAbstractListModel_FlagsDefault(void* ptr, void* index);
-void* QAbstractListModel_Sibling(void* ptr, int row, int column, void* idx);
-void* QAbstractListModel_SiblingDefault(void* ptr, int row, int column, void* idx);
 void QAbstractListModel_DestroyQAbstractListModel(void* ptr);
-void QAbstractListModel_FetchMore(void* ptr, void* parent);
-void QAbstractListModel_FetchMoreDefault(void* ptr, void* parent);
 void QAbstractListModel_Revert(void* ptr);
 void QAbstractListModel_RevertDefault(void* ptr);
 void QAbstractListModel_Sort(void* ptr, int column, int order);
@@ -196,8 +158,6 @@ void QAbstractListModel_CustomEventDefault(void* ptr, void* event);
 void QAbstractNativeEventFilter_DestroyQAbstractNativeEventFilter(void* ptr);
 char* QAbstractNativeEventFilter_ObjectNameAbs(void* ptr);
 void QAbstractNativeEventFilter_SetObjectNameAbs(void* ptr, char* name);
-void* QAbstractProxyModel_Buddy(void* ptr, void* index);
-void* QAbstractProxyModel_BuddyDefault(void* ptr, void* index);
 int QAbstractProxyModel_CanDropMimeData(void* ptr, void* data, int action, int row, int column, void* parent);
 int QAbstractProxyModel_CanDropMimeDataDefault(void* ptr, void* data, int action, int row, int column, void* parent);
 int QAbstractProxyModel_CanFetchMore(void* ptr, void* parent);
@@ -206,16 +166,12 @@ void* QAbstractProxyModel_Data(void* ptr, void* proxyIndex, int role);
 void* QAbstractProxyModel_DataDefault(void* ptr, void* proxyIndex, int role);
 int QAbstractProxyModel_DropMimeData(void* ptr, void* data, int action, int row, int column, void* parent);
 int QAbstractProxyModel_DropMimeDataDefault(void* ptr, void* data, int action, int row, int column, void* parent);
-void QAbstractProxyModel_FetchMore(void* ptr, void* parent);
-void QAbstractProxyModel_FetchMoreDefault(void* ptr, void* parent);
 int QAbstractProxyModel_Flags(void* ptr, void* index);
 int QAbstractProxyModel_FlagsDefault(void* ptr, void* index);
 int QAbstractProxyModel_HasChildren(void* ptr, void* parent);
 int QAbstractProxyModel_HasChildrenDefault(void* ptr, void* parent);
 void* QAbstractProxyModel_HeaderData(void* ptr, int section, int orientation, int role);
 void* QAbstractProxyModel_HeaderDataDefault(void* ptr, int section, int orientation, int role);
-void* QAbstractProxyModel_MapFromSource(void* ptr, void* sourceIndex);
-void* QAbstractProxyModel_MapToSource(void* ptr, void* proxyIndex);
 char* QAbstractProxyModel_MimeTypes(void* ptr);
 char* QAbstractProxyModel_MimeTypesDefault(void* ptr);
 void QAbstractProxyModel_Revert(void* ptr);
@@ -226,8 +182,6 @@ int QAbstractProxyModel_SetHeaderData(void* ptr, int section, int orientation, v
 int QAbstractProxyModel_SetHeaderDataDefault(void* ptr, int section, int orientation, void* value, int role);
 void QAbstractProxyModel_SetSourceModel(void* ptr, void* sourceModel);
 void QAbstractProxyModel_SetSourceModelDefault(void* ptr, void* sourceModel);
-void* QAbstractProxyModel_Sibling(void* ptr, int row, int column, void* idx);
-void* QAbstractProxyModel_SiblingDefault(void* ptr, int row, int column, void* idx);
 void QAbstractProxyModel_Sort(void* ptr, int column, int order);
 void QAbstractProxyModel_SortDefault(void* ptr, int column, int order);
 void* QAbstractProxyModel_SourceModel(void* ptr);
@@ -267,17 +221,11 @@ void QAbstractState_ChildEvent(void* ptr, void* event);
 void QAbstractState_ChildEventDefault(void* ptr, void* event);
 void QAbstractState_CustomEvent(void* ptr, void* event);
 void QAbstractState_CustomEventDefault(void* ptr, void* event);
-void* QAbstractTableModel_Index(void* ptr, int row, int column, void* parent);
-void* QAbstractTableModel_IndexDefault(void* ptr, int row, int column, void* parent);
 int QAbstractTableModel_DropMimeData(void* ptr, void* data, int action, int row, int column, void* parent);
 int QAbstractTableModel_DropMimeDataDefault(void* ptr, void* data, int action, int row, int column, void* parent);
 int QAbstractTableModel_Flags(void* ptr, void* index);
 int QAbstractTableModel_FlagsDefault(void* ptr, void* index);
-void* QAbstractTableModel_Sibling(void* ptr, int row, int column, void* idx);
-void* QAbstractTableModel_SiblingDefault(void* ptr, int row, int column, void* idx);
 void QAbstractTableModel_DestroyQAbstractTableModel(void* ptr);
-void QAbstractTableModel_FetchMore(void* ptr, void* parent);
-void QAbstractTableModel_FetchMoreDefault(void* ptr, void* parent);
 void QAbstractTableModel_Revert(void* ptr);
 void QAbstractTableModel_RevertDefault(void* ptr);
 void QAbstractTableModel_Sort(void* ptr, int column, int order);
@@ -351,17 +299,17 @@ void QBitArray_Swap(void* ptr, void* other);
 int QBitArray_TestBit(void* ptr, int i);
 int QBitArray_ToggleBit(void* ptr, int i);
 void QBitArray_Truncate(void* ptr, int pos);
-void* QBuffer_NewQBuffer2(void* byteArray, void* parent);
+void* QBuffer_NewQBuffer2(char* byteArray, void* parent);
 void* QBuffer_NewQBuffer(void* parent);
 int QBuffer_AtEnd(void* ptr);
 int QBuffer_AtEndDefault(void* ptr);
-void* QBuffer_Buffer(void* ptr);
-void* QBuffer_Buffer2(void* ptr);
+char* QBuffer_Buffer(void* ptr);
+char* QBuffer_Buffer2(void* ptr);
 int QBuffer_CanReadLine(void* ptr);
 int QBuffer_CanReadLineDefault(void* ptr);
 void QBuffer_Close(void* ptr);
 void QBuffer_CloseDefault(void* ptr);
-void* QBuffer_Data(void* ptr);
+char* QBuffer_Data(void* ptr);
 int QBuffer_Open(void* ptr, int flags);
 int QBuffer_OpenDefault(void* ptr, int flags);
 long long QBuffer_Pos(void* ptr);
@@ -370,8 +318,8 @@ long long QBuffer_ReadData(void* ptr, char* data, long long len);
 long long QBuffer_ReadDataDefault(void* ptr, char* data, long long len);
 int QBuffer_Seek(void* ptr, long long pos);
 int QBuffer_SeekDefault(void* ptr, long long pos);
-void QBuffer_SetBuffer(void* ptr, void* byteArray);
-void QBuffer_SetData(void* ptr, void* data);
+void QBuffer_SetBuffer(void* ptr, char* byteArray);
+void QBuffer_SetData(void* ptr, char* data);
 void QBuffer_SetData2(void* ptr, char* data, int size);
 long long QBuffer_Size(void* ptr);
 long long QBuffer_SizeDefault(void* ptr);
@@ -384,94 +332,17 @@ void QBuffer_ChildEvent(void* ptr, void* event);
 void QBuffer_ChildEventDefault(void* ptr, void* event);
 void QBuffer_CustomEvent(void* ptr, void* event);
 void QBuffer_CustomEventDefault(void* ptr, void* event);
-void QByteArray_Clear(void* ptr);
-int QByteArray_IndexOf3(void* ptr, char* str, int from);
-int QByteArray_IsNull(void* ptr);
-int QByteArray_LastIndexOf(void* ptr, void* ba, int from);
-int QByteArray_LastIndexOf3(void* ptr, char* str, int from);
-void* QByteArray_NewQByteArray();
-void* QByteArray_NewQByteArray6(void* other);
-void* QByteArray_NewQByteArray5(void* other);
-void* QByteArray_NewQByteArray2(char* data, int size);
-void* QByteArray_NewQByteArray3(int size, char* ch);
-void* QByteArray_Append5(void* ptr, char* ch);
-void* QByteArray_Append(void* ptr, void* ba);
-void* QByteArray_Append2(void* ptr, char* str);
-void* QByteArray_Append3(void* ptr, char* str);
-void* QByteArray_Append4(void* ptr, char* str, int len);
-int QByteArray_Capacity(void* ptr);
-void QByteArray_Chop(void* ptr, int n);
-int QByteArray_Contains3(void* ptr, char* ch);
-int QByteArray_Contains(void* ptr, void* ba);
-int QByteArray_Contains2(void* ptr, char* str);
-int QByteArray_Count4(void* ptr);
-int QByteArray_Count3(void* ptr, char* ch);
-int QByteArray_Count(void* ptr, void* ba);
-int QByteArray_Count2(void* ptr, char* str);
-int QByteArray_EndsWith3(void* ptr, char* ch);
-int QByteArray_EndsWith(void* ptr, void* ba);
-int QByteArray_EndsWith2(void* ptr, char* str);
-void* QByteArray_Fill(void* ptr, char* ch, int size);
-void* QByteArray_QByteArray_FromBase64(void* base64);
-void* QByteArray_QByteArray_FromBase642(void* base64, int options);
-void* QByteArray_QByteArray_FromHex(void* hexEncoded);
-void* QByteArray_QByteArray_FromPercentEncoding(void* input, char* percent);
-void* QByteArray_QByteArray_FromRawData(char* data, int size);
-int QByteArray_IndexOf4(void* ptr, char* ch, int from);
-int QByteArray_IndexOf(void* ptr, void* ba, int from);
-int QByteArray_IndexOf2(void* ptr, char* str, int from);
-int QByteArray_IsEmpty(void* ptr);
-int QByteArray_LastIndexOf4(void* ptr, char* ch, int from);
-int QByteArray_LastIndexOf2(void* ptr, char* str, int from);
-void* QByteArray_Left(void* ptr, int len);
-void* QByteArray_LeftJustified(void* ptr, int width, char* fill, int truncate);
-int QByteArray_Length(void* ptr);
-void* QByteArray_Mid(void* ptr, int pos, int len);
-void* QByteArray_QByteArray_Number(int n, int base);
-void* QByteArray_Prepend4(void* ptr, char* ch);
-void* QByteArray_Prepend(void* ptr, void* ba);
-void* QByteArray_Prepend2(void* ptr, char* str);
-void* QByteArray_Prepend3(void* ptr, char* str, int len);
-void QByteArray_Push_back3(void* ptr, char* ch);
-void QByteArray_Push_back(void* ptr, void* other);
-void QByteArray_Push_back2(void* ptr, char* str);
-void QByteArray_Push_front3(void* ptr, char* ch);
-void QByteArray_Push_front(void* ptr, void* other);
-void QByteArray_Push_front2(void* ptr, char* str);
-void* QByteArray_Repeated(void* ptr, int times);
-void QByteArray_Reserve(void* ptr, int size);
-void QByteArray_Resize(void* ptr, int size);
-void* QByteArray_Right(void* ptr, int len);
-void* QByteArray_RightJustified(void* ptr, int width, char* fill, int truncate);
-void* QByteArray_SetNum(void* ptr, int n, int base);
-int QByteArray_Size(void* ptr);
-void QByteArray_Squeeze(void* ptr);
-int QByteArray_StartsWith3(void* ptr, char* ch);
-int QByteArray_StartsWith(void* ptr, void* ba);
-int QByteArray_StartsWith2(void* ptr, char* str);
-void QByteArray_Swap(void* ptr, void* other);
-void* QByteArray_ToBase64(void* ptr);
-void* QByteArray_ToBase642(void* ptr, int options);
-void* QByteArray_ToHex(void* ptr);
-int QByteArray_ToInt(void* ptr, int ok, int base);
-void* QByteArray_ToPercentEncoding(void* ptr, void* exclude, void* include, char* percent);
-void QByteArray_Truncate(void* ptr, int pos);
-void QByteArray_DestroyQByteArray(void* ptr);
-void* QByteArray_Simplified(void* ptr);
-void* QByteArray_ToLower(void* ptr);
-void* QByteArray_ToUpper(void* ptr);
-void* QByteArray_Trimmed(void* ptr);
-void* QByteArrayList_Join(void* ptr);
-void* QByteArrayList_Join3(void* ptr, char* separator);
-void* QByteArrayList_Join2(void* ptr, void* separator);
+char* QByteArrayList_Join(void* ptr);
+char* QByteArrayList_Join3(void* ptr, char* separator);
+char* QByteArrayList_Join2(void* ptr, char* separator);
 void* QByteArrayMatcher_NewQByteArrayMatcher();
-void* QByteArrayMatcher_NewQByteArrayMatcher2(void* pattern);
+void* QByteArrayMatcher_NewQByteArrayMatcher2(char* pattern);
 void* QByteArrayMatcher_NewQByteArrayMatcher4(void* other);
 void* QByteArrayMatcher_NewQByteArrayMatcher3(char* pattern, int length);
-int QByteArrayMatcher_IndexIn(void* ptr, void* ba, int from);
+int QByteArrayMatcher_IndexIn(void* ptr, char* ba, int from);
 int QByteArrayMatcher_IndexIn2(void* ptr, char* str, int len, int from);
-void* QByteArrayMatcher_Pattern(void* ptr);
-void QByteArrayMatcher_SetPattern(void* ptr, void* pattern);
+char* QByteArrayMatcher_Pattern(void* ptr);
+void QByteArrayMatcher_SetPattern(void* ptr, char* pattern);
 void QByteArrayMatcher_DestroyQByteArrayMatcher(void* ptr);
 void* QChar_NewQChar();
 void* QChar_NewQChar8(void* ch);
@@ -519,12 +390,14 @@ void QCollator_SetNumericMode(void* ptr, int on);
 void* QCollator_NewQCollator3(void* other);
 void* QCollator_NewQCollator2(void* other);
 void* QCollator_NewQCollator(void* locale);
+void* QCollator_Locale(void* ptr);
 void QCollator_SetLocale(void* ptr, void* locale);
 void QCollator_Swap(void* ptr, void* other);
 void QCollator_DestroyQCollator(void* ptr);
 int QCollator_Compare3(void* ptr, void* s1, int len1, void* s2, int len2);
 int QCollator_Compare(void* ptr, char* s1, char* s2);
 int QCollator_Compare2(void* ptr, void* s1, void* s2);
+void* QCollator_SortKey(void* ptr, char* stri);
 void* QCollatorSortKey_NewQCollatorSortKey(void* other);
 void QCollatorSortKey_Swap(void* ptr, void* other);
 void QCollatorSortKey_DestroyQCollatorSortKey(void* ptr);
@@ -628,17 +501,17 @@ void QCoreApplication_CustomEvent(void* ptr, void* event);
 void QCoreApplication_CustomEventDefault(void* ptr, void* event);
 void* QCryptographicHash_NewQCryptographicHash(int method);
 int QCryptographicHash_AddData2(void* ptr, void* device);
-void QCryptographicHash_AddData3(void* ptr, void* data);
+void QCryptographicHash_AddData3(void* ptr, char* data);
 void QCryptographicHash_AddData(void* ptr, char* data, int length);
-void* QCryptographicHash_QCryptographicHash_Hash(void* data, int method);
+char* QCryptographicHash_QCryptographicHash_Hash(char* data, int method);
 void QCryptographicHash_Reset(void* ptr);
-void* QCryptographicHash_Result(void* ptr);
+char* QCryptographicHash_Result(void* ptr);
 void QCryptographicHash_DestroyQCryptographicHash(void* ptr);
-void* QDataStream_NewQDataStream3(void* a, int mode);
+void* QDataStream_NewQDataStream3(char* a, int mode);
 int QDataStream_AtEnd(void* ptr);
 void* QDataStream_NewQDataStream();
 void* QDataStream_NewQDataStream2(void* d);
-void* QDataStream_NewQDataStream4(void* a);
+void* QDataStream_NewQDataStream4(char* a);
 int QDataStream_ByteOrder(void* ptr);
 void* QDataStream_Device(void* ptr);
 int QDataStream_FloatingPointPrecision(void* ptr);
@@ -781,8 +654,8 @@ void* QDir_QDir_Temp();
 char* QDir_QDir_TempPath();
 char* QDir_QDir_ToNativeSeparators(char* pathName);
 void QDir_DestroyQDir(void* ptr);
-void* QDynamicPropertyChangeEvent_NewQDynamicPropertyChangeEvent(void* name);
-void* QDynamicPropertyChangeEvent_PropertyName(void* ptr);
+void* QDynamicPropertyChangeEvent_NewQDynamicPropertyChangeEvent(char* name);
+char* QDynamicPropertyChangeEvent_PropertyName(void* ptr);
 void* QEasingCurve_NewQEasingCurve3(void* other);
 void* QEasingCurve_NewQEasingCurve(int ty);
 void* QEasingCurve_NewQEasingCurve2(void* other);
@@ -868,9 +741,9 @@ void* QFile_NewQFile(char* name);
 void* QFile_NewQFile4(char* name, void* parent);
 int QFile_QFile_Copy2(char* fileName, char* newName);
 int QFile_Copy(void* ptr, char* newName);
-char* QFile_QFile_DecodeName(void* localFileName);
+char* QFile_QFile_DecodeName(char* localFileName);
 char* QFile_QFile_DecodeName2(char* localFileName);
-void* QFile_QFile_EncodeName(char* fileName);
+char* QFile_QFile_EncodeName(char* fileName);
 int QFile_QFile_Exists(char* fileName);
 int QFile_Exists2(void* ptr);
 char* QFile_FileName(void* ptr);
@@ -1098,17 +971,17 @@ int QIODevice_IsWritable(void* ptr);
 int QIODevice_Open(void* ptr, int mode);
 int QIODevice_OpenDefault(void* ptr, int mode);
 int QIODevice_OpenMode(void* ptr);
-void* QIODevice_Peek2(void* ptr, long long maxSize);
+char* QIODevice_Peek2(void* ptr, long long maxSize);
 long long QIODevice_Peek(void* ptr, char* data, long long maxSize);
 long long QIODevice_Pos(void* ptr);
 long long QIODevice_PosDefault(void* ptr);
-void* QIODevice_Read2(void* ptr, long long maxSize);
+char* QIODevice_Read2(void* ptr, long long maxSize);
 long long QIODevice_Read(void* ptr, char* data, long long maxSize);
-void* QIODevice_ReadAll(void* ptr);
+char* QIODevice_ReadAll(void* ptr);
 void QIODevice_ConnectReadChannelFinished(void* ptr);
 void QIODevice_DisconnectReadChannelFinished(void* ptr);
 void QIODevice_ReadChannelFinished(void* ptr);
-void* QIODevice_ReadLine2(void* ptr, long long maxSize);
+char* QIODevice_ReadLine2(void* ptr, long long maxSize);
 long long QIODevice_ReadLine(void* ptr, char* data, long long maxSize);
 long long QIODevice_ReadLineData(void* ptr, char* data, long long maxSize);
 long long QIODevice_ReadLineDataDefault(void* ptr, char* data, long long maxSize);
@@ -1127,7 +1000,7 @@ int QIODevice_WaitForBytesWritten(void* ptr, int msecs);
 int QIODevice_WaitForBytesWrittenDefault(void* ptr, int msecs);
 int QIODevice_WaitForReadyRead(void* ptr, int msecs);
 int QIODevice_WaitForReadyReadDefault(void* ptr, int msecs);
-long long QIODevice_Write3(void* ptr, void* byteArray);
+long long QIODevice_Write3(void* ptr, char* byteArray);
 long long QIODevice_Write2(void* ptr, char* data);
 long long QIODevice_Write(void* ptr, char* data, long long maxSize);
 void QIODevice_DestroyQIODevice(void* ptr);
@@ -1144,18 +1017,10 @@ int QIdentityProxyModel_DropMimeData(void* ptr, void* data, int action, int row,
 int QIdentityProxyModel_DropMimeDataDefault(void* ptr, void* data, int action, int row, int column, void* parent);
 void* QIdentityProxyModel_HeaderData(void* ptr, int section, int orientation, int role);
 void* QIdentityProxyModel_HeaderDataDefault(void* ptr, int section, int orientation, int role);
-void* QIdentityProxyModel_Index(void* ptr, int row, int column, void* parent);
-void* QIdentityProxyModel_IndexDefault(void* ptr, int row, int column, void* parent);
 int QIdentityProxyModel_InsertColumns(void* ptr, int column, int count, void* parent);
 int QIdentityProxyModel_InsertColumnsDefault(void* ptr, int column, int count, void* parent);
 int QIdentityProxyModel_InsertRows(void* ptr, int row, int count, void* parent);
 int QIdentityProxyModel_InsertRowsDefault(void* ptr, int row, int count, void* parent);
-void* QIdentityProxyModel_MapFromSource(void* ptr, void* sourceIndex);
-void* QIdentityProxyModel_MapFromSourceDefault(void* ptr, void* sourceIndex);
-void* QIdentityProxyModel_MapToSource(void* ptr, void* proxyIndex);
-void* QIdentityProxyModel_MapToSourceDefault(void* ptr, void* proxyIndex);
-void* QIdentityProxyModel_Parent(void* ptr, void* child);
-void* QIdentityProxyModel_ParentDefault(void* ptr, void* child);
 int QIdentityProxyModel_RemoveColumns(void* ptr, int column, int count, void* parent);
 int QIdentityProxyModel_RemoveColumnsDefault(void* ptr, int column, int count, void* parent);
 int QIdentityProxyModel_RemoveRows(void* ptr, int row, int count, void* parent);
@@ -1164,11 +1029,7 @@ int QIdentityProxyModel_RowCount(void* ptr, void* parent);
 int QIdentityProxyModel_RowCountDefault(void* ptr, void* parent);
 void QIdentityProxyModel_SetSourceModel(void* ptr, void* newSourceModel);
 void QIdentityProxyModel_SetSourceModelDefault(void* ptr, void* newSourceModel);
-void* QIdentityProxyModel_Sibling(void* ptr, int row, int column, void* idx);
-void* QIdentityProxyModel_SiblingDefault(void* ptr, int row, int column, void* idx);
 void QIdentityProxyModel_DestroyQIdentityProxyModel(void* ptr);
-void QIdentityProxyModel_FetchMore(void* ptr, void* parent);
-void QIdentityProxyModel_FetchMoreDefault(void* ptr, void* parent);
 void QIdentityProxyModel_Revert(void* ptr);
 void QIdentityProxyModel_RevertDefault(void* ptr);
 void QIdentityProxyModel_Sort(void* ptr, int column, int order);
@@ -1193,16 +1054,6 @@ void QItemSelectionModel_ClearCurrentIndex(void* ptr);
 void QItemSelectionModel_ClearCurrentIndexDefault(void* ptr);
 void QItemSelectionModel_ClearSelection(void* ptr);
 int QItemSelectionModel_ColumnIntersectsSelection(void* ptr, int column, void* parent);
-void QItemSelectionModel_ConnectCurrentChanged(void* ptr);
-void QItemSelectionModel_DisconnectCurrentChanged(void* ptr);
-void QItemSelectionModel_CurrentChanged(void* ptr, void* current, void* previous);
-void QItemSelectionModel_ConnectCurrentColumnChanged(void* ptr);
-void QItemSelectionModel_DisconnectCurrentColumnChanged(void* ptr);
-void QItemSelectionModel_CurrentColumnChanged(void* ptr, void* current, void* previous);
-void* QItemSelectionModel_CurrentIndex(void* ptr);
-void QItemSelectionModel_ConnectCurrentRowChanged(void* ptr);
-void QItemSelectionModel_DisconnectCurrentRowChanged(void* ptr);
-void QItemSelectionModel_CurrentRowChanged(void* ptr, void* current, void* previous);
 int QItemSelectionModel_HasSelection(void* ptr);
 int QItemSelectionModel_IsColumnSelected(void* ptr, int column, void* parent);
 int QItemSelectionModel_IsRowSelected(void* ptr, int row, void* parent);
@@ -1215,10 +1066,6 @@ void QItemSelectionModel_ModelChanged(void* ptr, void* model);
 void QItemSelectionModel_Reset(void* ptr);
 void QItemSelectionModel_ResetDefault(void* ptr);
 int QItemSelectionModel_RowIntersectsSelection(void* ptr, int row, void* parent);
-void QItemSelectionModel_Select(void* ptr, void* index, int command);
-void QItemSelectionModel_SelectDefault(void* ptr, void* index, int command);
-void QItemSelectionModel_SetCurrentIndex(void* ptr, void* index, int command);
-void QItemSelectionModel_SetCurrentIndexDefault(void* ptr, void* index, int command);
 void QItemSelectionModel_SetModel(void* ptr, void* model);
 void QItemSelectionModel_DestroyQItemSelectionModel(void* ptr);
 void QItemSelectionModel_TimerEvent(void* ptr, void* event);
@@ -1227,12 +1074,14 @@ void QItemSelectionModel_ChildEvent(void* ptr, void* event);
 void QItemSelectionModel_ChildEventDefault(void* ptr, void* event);
 void QItemSelectionModel_CustomEvent(void* ptr, void* event);
 void QItemSelectionModel_CustomEventDefault(void* ptr, void* event);
+void* QItemSelectionRange_Intersected(void* ptr, void* other);
 int QItemSelectionRange_Intersects(void* ptr, void* other);
 void* QItemSelectionRange_NewQItemSelectionRange();
 void* QItemSelectionRange_NewQItemSelectionRange2(void* other);
 void* QItemSelectionRange_NewQItemSelectionRange4(void* index);
 void* QItemSelectionRange_NewQItemSelectionRange3(void* topLeft, void* bottomRight);
 int QItemSelectionRange_Bottom(void* ptr);
+void* QItemSelectionRange_BottomRight(void* ptr);
 int QItemSelectionRange_Contains(void* ptr, void* index);
 int QItemSelectionRange_Contains2(void* ptr, int row, int column, void* parentIndex);
 int QItemSelectionRange_Height(void* ptr);
@@ -1240,16 +1089,19 @@ int QItemSelectionRange_IsEmpty(void* ptr);
 int QItemSelectionRange_IsValid(void* ptr);
 int QItemSelectionRange_Left(void* ptr);
 void* QItemSelectionRange_Model(void* ptr);
-void* QItemSelectionRange_Parent(void* ptr);
 int QItemSelectionRange_Right(void* ptr);
 int QItemSelectionRange_Top(void* ptr);
+void* QItemSelectionRange_TopLeft(void* ptr);
 int QItemSelectionRange_Width(void* ptr);
 void QJsonArray_Append(void* ptr, void* value);
+void* QJsonArray_At(void* ptr, int i);
 int QJsonArray_Contains(void* ptr, void* value);
 int QJsonArray_Count(void* ptr);
 int QJsonArray_Empty(void* ptr);
+void* QJsonArray_First(void* ptr);
 void* QJsonArray_QJsonArray_FromStringList(char* list);
 int QJsonArray_IsEmpty(void* ptr);
+void* QJsonArray_Last(void* ptr);
 void QJsonArray_Pop_back(void* ptr);
 void QJsonArray_Pop_front(void* ptr);
 void QJsonArray_Prepend(void* ptr, void* value);
@@ -1259,14 +1111,15 @@ void QJsonArray_RemoveAt(void* ptr, int i);
 void QJsonArray_RemoveFirst(void* ptr);
 void QJsonArray_RemoveLast(void* ptr);
 int QJsonArray_Size(void* ptr);
+void* QJsonArray_TakeAt(void* ptr, int i);
 void QJsonArray_DestroyQJsonArray(void* ptr);
 void* QJsonDocument_NewQJsonDocument();
 void* QJsonDocument_NewQJsonDocument3(void* array);
 void* QJsonDocument_NewQJsonDocument4(void* other);
 void* QJsonDocument_NewQJsonDocument2(void* object);
 void* QJsonDocument_Array(void* ptr);
-void* QJsonDocument_QJsonDocument_FromBinaryData(void* data, int validation);
-void* QJsonDocument_QJsonDocument_FromJson(void* json, void* error);
+void* QJsonDocument_QJsonDocument_FromBinaryData(char* data, int validation);
+void* QJsonDocument_QJsonDocument_FromJson(char* json, void* error);
 void* QJsonDocument_QJsonDocument_FromRawData(char* data, int size, int validation);
 void* QJsonDocument_QJsonDocument_FromVariant(void* variant);
 int QJsonDocument_IsArray(void* ptr);
@@ -1276,8 +1129,8 @@ int QJsonDocument_IsObject(void* ptr);
 void* QJsonDocument_Object(void* ptr);
 void QJsonDocument_SetArray(void* ptr, void* array);
 void QJsonDocument_SetObject(void* ptr, void* object);
-void* QJsonDocument_ToBinaryData(void* ptr);
-void* QJsonDocument_ToJson(void* ptr, int format);
+char* QJsonDocument_ToBinaryData(void* ptr);
+char* QJsonDocument_ToJson(void* ptr, int format);
 void* QJsonDocument_ToVariant(void* ptr);
 void QJsonDocument_DestroyQJsonDocument(void* ptr);
 int QJsonObject_Contains(void* ptr, char* key);
@@ -1287,6 +1140,8 @@ int QJsonObject_IsEmpty(void* ptr);
 char* QJsonObject_Keys(void* ptr);
 int QJsonObject_Length(void* ptr);
 int QJsonObject_Size(void* ptr);
+void* QJsonObject_Take(void* ptr, char* key);
+void* QJsonObject_Value(void* ptr, char* key);
 void QJsonObject_DestroyQJsonObject(void* ptr);
 char* QJsonParseError_ErrorString(void* ptr);
 void* QJsonValue_NewQJsonValue5(void* s);
@@ -1299,6 +1154,7 @@ void* QJsonValue_NewQJsonValue4(char* s);
 void* QJsonValue_NewQJsonValue6(char* s);
 void* QJsonValue_NewQJsonValue12(int n);
 void* QJsonValue_NewQJsonValue13(long long n);
+void* QJsonValue_QJsonValue_FromVariant(void* variant);
 int QJsonValue_IsArray(void* ptr);
 int QJsonValue_IsBool(void* ptr);
 int QJsonValue_IsDouble(void* ptr);
@@ -1317,7 +1173,7 @@ void* QJsonValue_ToVariant(void* ptr);
 int QJsonValue_Type(void* ptr);
 void QJsonValue_DestroyQJsonValue(void* ptr);
 void* QLatin1Char_NewQLatin1Char(char* c);
-void* QLatin1String_NewQLatin1String3(void* str);
+void* QLatin1String_NewQLatin1String3(char* str);
 void* QLatin1String_NewQLatin1String(char* str);
 void* QLatin1String_NewQLatin1String2(char* str, int size);
 int QLatin1String_Size(void* ptr);
@@ -1395,6 +1251,7 @@ void* QLocale_NewQLocale5(void* other);
 void* QLocale_NewQLocale2(char* name);
 char* QLocale_AmText(void* ptr);
 char* QLocale_Bcp47Name(void* ptr);
+void* QLocale_QLocale_C();
 int QLocale_Country(void* ptr);
 char* QLocale_QLocale_CountryToString(int country);
 char* QLocale_CreateSeparatedList(void* ptr, char* list);
@@ -1420,6 +1277,7 @@ void QLocale_QLocale_SetDefault(void* locale);
 void QLocale_SetNumberOptions(void* ptr, int options);
 char* QLocale_StandaloneDayName(void* ptr, int day, int ty);
 char* QLocale_StandaloneMonthName(void* ptr, int month, int ty);
+void* QLocale_QLocale_System();
 int QLocale_TextDirection(void* ptr);
 char* QLocale_TimeFormat(void* ptr, int format);
 char* QLocale_ToCurrencyString6(void* ptr, int value, char* symbol);
@@ -1479,25 +1337,33 @@ void QMarginsF_SetLeft(void* ptr, double left);
 void QMarginsF_SetRight(void* ptr, double right);
 void QMarginsF_SetTop(void* ptr, double Top);
 double QMarginsF_Top(void* ptr);
-void* QMessageAuthenticationCode_NewQMessageAuthenticationCode(int method, void* key);
+void* QMessageAuthenticationCode_NewQMessageAuthenticationCode(int method, char* key);
 int QMessageAuthenticationCode_AddData2(void* ptr, void* device);
-void QMessageAuthenticationCode_AddData3(void* ptr, void* data);
+void QMessageAuthenticationCode_AddData3(void* ptr, char* data);
 void QMessageAuthenticationCode_AddData(void* ptr, char* data, int length);
-void* QMessageAuthenticationCode_QMessageAuthenticationCode_Hash(void* message, void* key, int method);
+char* QMessageAuthenticationCode_QMessageAuthenticationCode_Hash(char* message, char* key, int method);
 void QMessageAuthenticationCode_Reset(void* ptr);
-void* QMessageAuthenticationCode_Result(void* ptr);
-void QMessageAuthenticationCode_SetKey(void* ptr, void* key);
+char* QMessageAuthenticationCode_Result(void* ptr);
+void QMessageAuthenticationCode_SetKey(void* ptr, char* key);
 void QMessageAuthenticationCode_DestroyQMessageAuthenticationCode(void* ptr);
 void* QMessageLogger_NewQMessageLogger();
 void* QMessageLogger_NewQMessageLogger2(char* file, int line, char* function);
 void* QMessageLogger_NewQMessageLogger3(char* file, int line, char* function, char* category);
+void* QMessageLogger_Critical4(void* ptr);
+void* QMessageLogger_Critical5(void* ptr, void* cat);
+void* QMessageLogger_Debug4(void* ptr);
+void* QMessageLogger_Debug5(void* ptr, void* cat);
+void* QMessageLogger_Info3(void* ptr);
+void* QMessageLogger_Info4(void* ptr, void* cat);
+void* QMessageLogger_Warning4(void* ptr);
+void* QMessageLogger_Warning5(void* ptr, void* cat);
 int QMetaEnum_IsFlag(void* ptr);
 int QMetaEnum_IsValid(void* ptr);
 int QMetaEnum_KeyCount(void* ptr);
 int QMetaEnum_KeyToValue(void* ptr, char* key, int ok);
 int QMetaEnum_KeysToValue(void* ptr, char* keys, int ok);
 int QMetaEnum_Value(void* ptr, int index);
-void* QMetaEnum_ValueToKeys(void* ptr, int value);
+char* QMetaEnum_ValueToKeys(void* ptr, int value);
 int QMetaMethod_Access(void* ptr);
 int QMetaMethod_Invoke4(void* ptr, void* object, void* val0, void* val1, void* val2, void* val3, void* val4, void* val5, void* val6, void* val7, void* val8, void* val9);
 int QMetaMethod_Invoke2(void* ptr, void* object, void* returnValue, void* val0, void* val1, void* val2, void* val3, void* val4, void* val5, void* val6, void* val7, void* val8, void* val9);
@@ -1507,9 +1373,9 @@ int QMetaMethod_InvokeOnGadget2(void* ptr, void* gadget, void* val0, void* val1,
 int QMetaMethod_InvokeOnGadget(void* ptr, void* gadget, void* returnValue, void* val0, void* val1, void* val2, void* val3, void* val4, void* val5, void* val6, void* val7, void* val8, void* val9);
 int QMetaMethod_IsValid(void* ptr);
 int QMetaMethod_MethodIndex(void* ptr);
-void* QMetaMethod_MethodSignature(void* ptr);
+char* QMetaMethod_MethodSignature(void* ptr);
 int QMetaMethod_MethodType(void* ptr);
-void* QMetaMethod_Name(void* ptr);
+char* QMetaMethod_Name(void* ptr);
 int QMetaMethod_ParameterCount(void* ptr);
 int QMetaMethod_ParameterType(void* ptr, int index);
 int QMetaMethod_ReturnType(void* ptr);
@@ -1536,8 +1402,8 @@ int QMetaObject_QMetaObject_InvokeMethod(void* obj, char* member, int ty, void*
 int QMetaObject_MethodCount(void* ptr);
 int QMetaObject_MethodOffset(void* ptr);
 void* QMetaObject_NewInstance(void* ptr, void* val0, void* val1, void* val2, void* val3, void* val4, void* val5, void* val6, void* val7, void* val8, void* val9);
-void* QMetaObject_QMetaObject_NormalizedSignature(char* method);
-void* QMetaObject_QMetaObject_NormalizedType(char* ty);
+char* QMetaObject_QMetaObject_NormalizedSignature(char* method);
+char* QMetaObject_QMetaObject_NormalizedType(char* ty);
 int QMetaObject_PropertyCount(void* ptr);
 int QMetaObject_PropertyOffset(void* ptr);
 void* QMetaObject_SuperClass(void* ptr);
@@ -1587,14 +1453,14 @@ void* QMetaType_QMetaType_MetaObjectForType(int ty);
 int QMetaType_QMetaType_Save(void* stream, int ty, void* data);
 int QMetaType_QMetaType_SizeOf(int ty);
 int QMetaType_SizeOf2(void* ptr);
-int QMetaType_QMetaType_Type2(void* typeName);
+int QMetaType_QMetaType_Type2(char* typeName);
 int QMetaType_QMetaType_Type(char* typeName);
 int QMetaType_QMetaType_TypeFlags(int ty);
 void QMetaType_DestroyQMetaType(void* ptr);
 void* QMimeData_NewQMimeData();
 void QMimeData_Clear(void* ptr);
 void* QMimeData_ColorData(void* ptr);
-void* QMimeData_Data(void* ptr, char* mimeType);
+char* QMimeData_Data(void* ptr, char* mimeType);
 char* QMimeData_Formats(void* ptr);
 char* QMimeData_FormatsDefault(void* ptr);
 int QMimeData_HasColor(void* ptr);
@@ -1608,7 +1474,7 @@ char* QMimeData_Html(void* ptr);
 void* QMimeData_ImageData(void* ptr);
 void QMimeData_RemoveFormat(void* ptr, char* mimeType);
 void QMimeData_SetColorData(void* ptr, void* color);
-void QMimeData_SetData(void* ptr, char* mimeType, void* data);
+void QMimeData_SetData(void* ptr, char* mimeType, char* data);
 void QMimeData_SetHtml(void* ptr, char* html);
 void QMimeData_SetImageData(void* ptr, void* image);
 void QMimeData_SetText(void* ptr, char* text);
@@ -1621,7 +1487,15 @@ void QMimeData_ChildEventDefault(void* ptr, void* event);
 void QMimeData_CustomEvent(void* ptr, void* event);
 void QMimeData_CustomEventDefault(void* ptr, void* event);
 void* QMimeDatabase_NewQMimeDatabase();
+void* QMimeDatabase_MimeTypeForName(void* ptr, char* nameOrAlias);
 void QMimeDatabase_DestroyQMimeDatabase(void* ptr);
+void* QMimeDatabase_MimeTypeForData2(void* ptr, void* device);
+void* QMimeDatabase_MimeTypeForData(void* ptr, char* data);
+void* QMimeDatabase_MimeTypeForFile(void* ptr, void* fileInfo, int mode);
+void* QMimeDatabase_MimeTypeForFile2(void* ptr, char* fileName, int mode);
+void* QMimeDatabase_MimeTypeForFileNameAndData(void* ptr, char* fileName, void* device);
+void* QMimeDatabase_MimeTypeForFileNameAndData2(void* ptr, char* fileName, char* data);
+void* QMimeDatabase_MimeTypeForUrl(void* ptr, void* url);
 char* QMimeDatabase_SuffixForFileName(void* ptr, char* fileName);
 void* QMimeType_NewQMimeType();
 void* QMimeType_NewQMimeType2(void* other);
@@ -1642,16 +1516,13 @@ char* QMimeType_PreferredSuffix(void* ptr);
 char* QMimeType_Suffixes(void* ptr);
 void QMimeType_Swap(void* ptr, void* other);
 void* QModelIndex_NewQModelIndex();
-void* QModelIndex_Child(void* ptr, int row, int column);
 int QModelIndex_Column(void* ptr);
 void* QModelIndex_Data(void* ptr, int role);
 int QModelIndex_Flags(void* ptr);
 void* QModelIndex_InternalPointer(void* ptr);
 int QModelIndex_IsValid(void* ptr);
 void* QModelIndex_Model(void* ptr);
-void* QModelIndex_Parent(void* ptr);
 int QModelIndex_Row(void* ptr);
-void* QModelIndex_Sibling(void* ptr, int row, int column);
 void QMutex_Lock(void* ptr);
 int QMutex_TryLock(void* ptr, int timeout);
 void QMutex_Unlock(void* ptr);
@@ -1757,12 +1628,9 @@ int QPersistentModelIndex_IsValid(void* ptr);
 int QPersistentModelIndex_Row(void* ptr);
 void* QPersistentModelIndex_NewQPersistentModelIndex4(void* other);
 void* QPersistentModelIndex_NewQPersistentModelIndex(void* index);
-void* QPersistentModelIndex_Child(void* ptr, int row, int column);
 void* QPersistentModelIndex_Data(void* ptr, int role);
 int QPersistentModelIndex_Flags(void* ptr);
 void* QPersistentModelIndex_Model(void* ptr);
-void* QPersistentModelIndex_Parent(void* ptr);
-void* QPersistentModelIndex_Sibling(void* ptr, int row, int column);
 void QPersistentModelIndex_Swap(void* ptr, void* other);
 char* QPluginLoader_FileName(void* ptr);
 int QPluginLoader_LoadHints(void* ptr);
@@ -1840,10 +1708,11 @@ char* QProcess_QProcess_NullDevice();
 int QProcess_Open(void* ptr, int mode);
 int QProcess_OpenDefault(void* ptr, int mode);
 int QProcess_ProcessChannelMode(void* ptr);
+void* QProcess_ProcessEnvironment(void* ptr);
 long long QProcess_ProcessId(void* ptr);
 char* QProcess_Program(void* ptr);
-void* QProcess_ReadAllStandardError(void* ptr);
-void* QProcess_ReadAllStandardOutput(void* ptr);
+char* QProcess_ReadAllStandardError(void* ptr);
+char* QProcess_ReadAllStandardOutput(void* ptr);
 int QProcess_ReadChannel(void* ptr);
 long long QProcess_ReadData(void* ptr, char* data, long long maxlen);
 long long QProcess_ReadDataDefault(void* ptr, char* data, long long maxlen);
@@ -1901,12 +1770,13 @@ void QProcessEnvironment_Swap(void* ptr, void* other);
 char* QProcessEnvironment_ToStringList(void* ptr);
 char* QProcessEnvironment_Value(void* ptr, char* name, char* defaultValue);
 void QProcessEnvironment_DestroyQProcessEnvironment(void* ptr);
-void* QPropertyAnimation_PropertyName(void* ptr);
-void QPropertyAnimation_SetPropertyName(void* ptr, void* propertyName);
+void* QProcessEnvironment_QProcessEnvironment_SystemEnvironment();
+char* QPropertyAnimation_PropertyName(void* ptr);
+void QPropertyAnimation_SetPropertyName(void* ptr, char* propertyName);
 void QPropertyAnimation_SetTargetObject(void* ptr, void* target);
 void* QPropertyAnimation_TargetObject(void* ptr);
 void* QPropertyAnimation_NewQPropertyAnimation(void* parent);
-void* QPropertyAnimation_NewQPropertyAnimation2(void* target, void* propertyName, void* parent);
+void* QPropertyAnimation_NewQPropertyAnimation2(void* target, char* propertyName, void* parent);
 int QPropertyAnimation_Event(void* ptr, void* event);
 int QPropertyAnimation_EventDefault(void* ptr, void* event);
 void QPropertyAnimation_UpdateCurrentValue(void* ptr, void* value);
@@ -2128,6 +1998,7 @@ char* QResource_AbsoluteFilePath(void* ptr);
 char* QResource_FileName(void* ptr);
 int QResource_IsCompressed(void* ptr);
 int QResource_IsValid(void* ptr);
+void* QResource_Locale(void* ptr);
 void QResource_SetFileName(void* ptr, char* file);
 void QResource_SetLocale(void* ptr, void* locale);
 long long QResource_Size(void* ptr);
@@ -2309,8 +2180,8 @@ void* QSignalTransition_SenderObject(void* ptr);
 void QSignalTransition_ConnectSenderObjectChanged(void* ptr);
 void QSignalTransition_DisconnectSenderObjectChanged(void* ptr);
 void QSignalTransition_SetSenderObject(void* ptr, void* sender);
-void QSignalTransition_SetSignal(void* ptr, void* signal);
-void* QSignalTransition_Signal(void* ptr);
+void QSignalTransition_SetSignal(void* ptr, char* signal);
+char* QSignalTransition_Signal(void* ptr);
 void QSignalTransition_ConnectSignalChanged(void* ptr);
 void QSignalTransition_DisconnectSignalChanged(void* ptr);
 void QSignalTransition_DestroyQSignalTransition(void* ptr);
@@ -2386,8 +2257,6 @@ void QSortFilterProxyModel_SetSortRole(void* ptr, int role);
 int QSortFilterProxyModel_SortCaseSensitivity(void* ptr);
 int QSortFilterProxyModel_SortRole(void* ptr);
 void* QSortFilterProxyModel_NewQSortFilterProxyModel(void* parent);
-void* QSortFilterProxyModel_Buddy(void* ptr, void* index);
-void* QSortFilterProxyModel_BuddyDefault(void* ptr, void* index);
 int QSortFilterProxyModel_CanFetchMore(void* ptr, void* parent);
 int QSortFilterProxyModel_CanFetchMoreDefault(void* ptr, void* parent);
 int QSortFilterProxyModel_ColumnCount(void* ptr, void* parent);
@@ -2396,8 +2265,6 @@ void* QSortFilterProxyModel_Data(void* ptr, void* index, int role);
 void* QSortFilterProxyModel_DataDefault(void* ptr, void* index, int role);
 int QSortFilterProxyModel_DropMimeData(void* ptr, void* data, int action, int row, int column, void* parent);
 int QSortFilterProxyModel_DropMimeDataDefault(void* ptr, void* data, int action, int row, int column, void* parent);
-void QSortFilterProxyModel_FetchMore(void* ptr, void* parent);
-void QSortFilterProxyModel_FetchMoreDefault(void* ptr, void* parent);
 int QSortFilterProxyModel_FilterAcceptsColumn(void* ptr, int source_column, void* source_parent);
 int QSortFilterProxyModel_FilterAcceptsColumnDefault(void* ptr, int source_column, void* source_parent);
 int QSortFilterProxyModel_FilterAcceptsRow(void* ptr, int source_row, void* source_parent);
@@ -2408,8 +2275,6 @@ int QSortFilterProxyModel_HasChildren(void* ptr, void* parent);
 int QSortFilterProxyModel_HasChildrenDefault(void* ptr, void* parent);
 void* QSortFilterProxyModel_HeaderData(void* ptr, int section, int orientation, int role);
 void* QSortFilterProxyModel_HeaderDataDefault(void* ptr, int section, int orientation, int role);
-void* QSortFilterProxyModel_Index(void* ptr, int row, int column, void* parent);
-void* QSortFilterProxyModel_IndexDefault(void* ptr, int row, int column, void* parent);
 int QSortFilterProxyModel_InsertColumns(void* ptr, int column, int count, void* parent);
 int QSortFilterProxyModel_InsertColumnsDefault(void* ptr, int column, int count, void* parent);
 int QSortFilterProxyModel_InsertRows(void* ptr, int row, int count, void* parent);
@@ -2417,14 +2282,8 @@ int QSortFilterProxyModel_InsertRowsDefault(void* ptr, int row, int count, void*
 void QSortFilterProxyModel_Invalidate(void* ptr);
 int QSortFilterProxyModel_LessThan(void* ptr, void* source_left, void* source_right);
 int QSortFilterProxyModel_LessThanDefault(void* ptr, void* source_left, void* source_right);
-void* QSortFilterProxyModel_MapFromSource(void* ptr, void* sourceIndex);
-void* QSortFilterProxyModel_MapFromSourceDefault(void* ptr, void* sourceIndex);
-void* QSortFilterProxyModel_MapToSource(void* ptr, void* proxyIndex);
-void* QSortFilterProxyModel_MapToSourceDefault(void* ptr, void* proxyIndex);
 char* QSortFilterProxyModel_MimeTypes(void* ptr);
 char* QSortFilterProxyModel_MimeTypesDefault(void* ptr);
-void* QSortFilterProxyModel_Parent(void* ptr, void* child);
-void* QSortFilterProxyModel_ParentDefault(void* ptr, void* child);
 int QSortFilterProxyModel_RemoveColumns(void* ptr, int column, int count, void* parent);
 int QSortFilterProxyModel_RemoveColumnsDefault(void* ptr, int column, int count, void* parent);
 int QSortFilterProxyModel_RemoveRows(void* ptr, int row, int count, void* parent);
@@ -2440,8 +2299,6 @@ int QSortFilterProxyModel_SetHeaderData(void* ptr, int section, int orientation,
 int QSortFilterProxyModel_SetHeaderDataDefault(void* ptr, int section, int orientation, void* value, int role);
 void QSortFilterProxyModel_SetSourceModel(void* ptr, void* sourceModel);
 void QSortFilterProxyModel_SetSourceModelDefault(void* ptr, void* sourceModel);
-void* QSortFilterProxyModel_Sibling(void* ptr, int row, int column, void* idx);
-void* QSortFilterProxyModel_SiblingDefault(void* ptr, int row, int column, void* idx);
 void QSortFilterProxyModel_Sort(void* ptr, int column, int order);
 void QSortFilterProxyModel_SortDefault(void* ptr, int column, int order);
 int QSortFilterProxyModel_SortColumn(void* ptr);
@@ -2553,15 +2410,16 @@ void* QStorageInfo_NewQStorageInfo2(char* path);
 long long QStorageInfo_BytesAvailable(void* ptr);
 long long QStorageInfo_BytesFree(void* ptr);
 long long QStorageInfo_BytesTotal(void* ptr);
-void* QStorageInfo_Device(void* ptr);
+char* QStorageInfo_Device(void* ptr);
 char* QStorageInfo_DisplayName(void* ptr);
-void* QStorageInfo_FileSystemType(void* ptr);
+char* QStorageInfo_FileSystemType(void* ptr);
 int QStorageInfo_IsReadOnly(void* ptr);
 int QStorageInfo_IsReady(void* ptr);
 int QStorageInfo_IsRoot(void* ptr);
 int QStorageInfo_IsValid(void* ptr);
 char* QStorageInfo_Name(void* ptr);
 void QStorageInfo_Refresh(void* ptr);
+void* QStorageInfo_QStorageInfo_Root();
 char* QStorageInfo_RootPath(void* ptr);
 void QStorageInfo_SetPath(void* ptr, char* path);
 void QStorageInfo_Swap(void* ptr, void* other);
@@ -2579,15 +2437,11 @@ int QStringListModel_RowCountDefault(void* ptr, void* parent);
 int QStringListModel_SetData(void* ptr, void* index, void* value, int role);
 int QStringListModel_SetDataDefault(void* ptr, void* index, void* value, int role);
 void QStringListModel_SetStringList(void* ptr, char* strin);
-void* QStringListModel_Sibling(void* ptr, int row, int column, void* idx);
-void* QStringListModel_SiblingDefault(void* ptr, int row, int column, void* idx);
 void QStringListModel_Sort(void* ptr, int column, int order);
 void QStringListModel_SortDefault(void* ptr, int column, int order);
 char* QStringListModel_StringList(void* ptr);
 int QStringListModel_SupportedDropActions(void* ptr);
 int QStringListModel_SupportedDropActionsDefault(void* ptr);
-void QStringListModel_FetchMore(void* ptr, void* parent);
-void QStringListModel_FetchMoreDefault(void* ptr, void* parent);
 void QStringListModel_Revert(void* ptr);
 void QStringListModel_RevertDefault(void* ptr);
 void QStringListModel_TimerEvent(void* ptr, void* event);
@@ -2659,10 +2513,10 @@ int QStringRef_StartsWith(void* ptr, char* str, int cs);
 int QStringRef_StartsWith3(void* ptr, void* str, int cs);
 char* QStringRef_String(void* ptr);
 int QStringRef_ToInt(void* ptr, int ok, int base);
-void* QStringRef_ToLatin1(void* ptr);
-void* QStringRef_ToLocal8Bit(void* ptr);
+char* QStringRef_ToLatin1(void* ptr);
+char* QStringRef_ToLocal8Bit(void* ptr);
 char* QStringRef_ToString(void* ptr);
-void* QStringRef_ToUtf8(void* ptr);
+char* QStringRef_ToUtf8(void* ptr);
 void* QStringRef_Trimmed(void* ptr);
 void* QStringRef_Unicode(void* ptr);
 void QStringRef_DestroyQStringRef(void* ptr);
@@ -2746,19 +2600,19 @@ int QTextBoundaryFinder_Type(void* ptr);
 void QTextBoundaryFinder_DestroyQTextBoundaryFinder(void* ptr);
 int QTextCodec_CanEncode(void* ptr, void* ch);
 int QTextCodec_CanEncode2(void* ptr, char* s);
-void* QTextCodec_QTextCodec_CodecForHtml2(void* ba);
-void* QTextCodec_QTextCodec_CodecForHtml(void* ba, void* defaultCodec);
+void* QTextCodec_QTextCodec_CodecForHtml2(char* ba);
+void* QTextCodec_QTextCodec_CodecForHtml(char* ba, void* defaultCodec);
 void* QTextCodec_QTextCodec_CodecForLocale();
 void* QTextCodec_QTextCodec_CodecForMib(int mib);
-void* QTextCodec_QTextCodec_CodecForName(void* name);
+void* QTextCodec_QTextCodec_CodecForName(char* name);
 void* QTextCodec_QTextCodec_CodecForName2(char* name);
-void* QTextCodec_QTextCodec_CodecForUtfText2(void* ba);
-void* QTextCodec_QTextCodec_CodecForUtfText(void* ba, void* defaultCodec);
-void* QTextCodec_FromUnicode(void* ptr, char* str);
+void* QTextCodec_QTextCodec_CodecForUtfText2(char* ba);
+void* QTextCodec_QTextCodec_CodecForUtfText(char* ba, void* defaultCodec);
+char* QTextCodec_FromUnicode(void* ptr, char* str);
 void* QTextCodec_MakeDecoder(void* ptr, int flags);
 void* QTextCodec_MakeEncoder(void* ptr, int flags);
 int QTextCodec_MibEnum(void* ptr);
-void* QTextCodec_Name(void* ptr);
+char* QTextCodec_Name(void* ptr);
 void QTextCodec_QTextCodec_SetCodecForLocale(void* c);
 void QTextCodec_DestroyQTextCodec(void* ptr);
 char* QTextCodec_ObjectNameAbs(void* ptr);
@@ -2768,8 +2622,8 @@ void* QTextDecoder_NewQTextDecoder2(void* codec, int flags);
 void QTextDecoder_DestroyQTextDecoder(void* ptr);
 void* QTextEncoder_NewQTextEncoder(void* codec);
 void* QTextEncoder_NewQTextEncoder2(void* codec, int flags);
-void* QTextEncoder_FromUnicode2(void* ptr, void* uc, int len);
-void* QTextEncoder_FromUnicode(void* ptr, char* str);
+char* QTextEncoder_FromUnicode2(void* ptr, void* uc, int len);
+char* QTextEncoder_FromUnicode(void* ptr, char* str);
 void QTextEncoder_DestroyQTextEncoder(void* ptr);
 int QTextStream_AtEnd(void* ptr);
 int QTextStream_AutoDetectUnicode(void* ptr);
@@ -2780,6 +2634,7 @@ int QTextStream_FieldWidth(void* ptr);
 void QTextStream_Flush(void* ptr);
 int QTextStream_GenerateByteOrderMark(void* ptr);
 int QTextStream_IntegerBase(void* ptr);
+void* QTextStream_Locale(void* ptr);
 int QTextStream_NumberFlags(void* ptr);
 long long QTextStream_Pos(void* ptr);
 char* QTextStream_Read(void* ptr, long long maxlen);
@@ -2930,8 +2785,8 @@ void QTimeLine_ChildEventDefault(void* ptr, void* event);
 void QTimeLine_CustomEvent(void* ptr, void* event);
 void QTimeLine_CustomEventDefault(void* ptr, void* event);
 void* QTimeZone_NewQTimeZone();
-void* QTimeZone_NewQTimeZone2(void* ianaId);
-void* QTimeZone_NewQTimeZone4(void* ianaId, int offsetSeconds, char* name, char* abbreviation, int country, char* comment);
+void* QTimeZone_NewQTimeZone2(char* ianaId);
+void* QTimeZone_NewQTimeZone4(char* ianaId, int offsetSeconds, char* name, char* abbreviation, int country, char* comment);
 void* QTimeZone_NewQTimeZone5(void* other);
 void* QTimeZone_NewQTimeZone3(int offsetSeconds);
 char* QTimeZone_Abbreviation(void* ptr, void* atDateTime);
@@ -2942,19 +2797,19 @@ char* QTimeZone_DisplayName2(void* ptr, int timeType, int nameType, void* locale
 char* QTimeZone_DisplayName(void* ptr, void* atDateTime, int nameType, void* locale);
 int QTimeZone_HasDaylightTime(void* ptr);
 int QTimeZone_HasTransitions(void* ptr);
-void* QTimeZone_QTimeZone_IanaIdToWindowsId(void* ianaId);
-void* QTimeZone_Id(void* ptr);
+char* QTimeZone_QTimeZone_IanaIdToWindowsId(char* ianaId);
+char* QTimeZone_Id(void* ptr);
 int QTimeZone_IsDaylightTime(void* ptr, void* atDateTime);
-int QTimeZone_QTimeZone_IsTimeZoneIdAvailable(void* ianaId);
+int QTimeZone_QTimeZone_IsTimeZoneIdAvailable(char* ianaId);
 int QTimeZone_IsValid(void* ptr);
 int QTimeZone_OffsetFromUtc(void* ptr, void* atDateTime);
 int QTimeZone_StandardTimeOffset(void* ptr, void* atDateTime);
 void QTimeZone_Swap(void* ptr, void* other);
 void* QTimeZone_QTimeZone_SystemTimeZone();
-void* QTimeZone_QTimeZone_SystemTimeZoneId();
+char* QTimeZone_QTimeZone_SystemTimeZoneId();
 void* QTimeZone_QTimeZone_Utc();
-void* QTimeZone_QTimeZone_WindowsIdToDefaultIanaId(void* windowsId);
-void* QTimeZone_QTimeZone_WindowsIdToDefaultIanaId2(void* windowsId, int country);
+char* QTimeZone_QTimeZone_WindowsIdToDefaultIanaId(char* windowsId);
+char* QTimeZone_QTimeZone_WindowsIdToDefaultIanaId2(char* windowsId, int country);
 void QTimeZone_DestroyQTimeZone(void* ptr);
 int QTimer_RemainingTime(void* ptr);
 void QTimer_SetInterval(void* ptr, int msec);
@@ -2996,7 +2851,7 @@ void QTranslator_ChildEvent(void* ptr, void* event);
 void QTranslator_ChildEventDefault(void* ptr, void* event);
 void QTranslator_CustomEvent(void* ptr, void* event);
 void QTranslator_CustomEventDefault(void* ptr, void* event);
-void* QUrl_QUrl_FromEncoded(void* input, int parsingMode);
+void* QUrl_QUrl_FromEncoded(char* input, int parsingMode);
 void* QUrl_NewQUrl();
 void* QUrl_NewQUrl4(void* other);
 void* QUrl_NewQUrl3(char* url, int parsingMode);
@@ -3007,9 +2862,9 @@ void QUrl_Clear(void* ptr);
 char* QUrl_ErrorString(void* ptr);
 char* QUrl_FileName(void* ptr, int options);
 char* QUrl_Fragment(void* ptr, int options);
-char* QUrl_QUrl_FromAce(void* domain);
+char* QUrl_QUrl_FromAce(char* domain);
 void* QUrl_QUrl_FromLocalFile(char* localFile);
-char* QUrl_QUrl_FromPercentEncoding(void* input);
+char* QUrl_QUrl_FromPercentEncoding(char* input);
 void* QUrl_QUrl_FromUserInput(char* userInput);
 void* QUrl_QUrl_FromUserInput2(char* userInput, char* workingDirectory, int options);
 int QUrl_HasFragment(void* ptr);
@@ -3042,11 +2897,11 @@ void QUrl_SetUrl(void* ptr, char* url, int parsingMode);
 void QUrl_SetUserInfo(void* ptr, char* userInfo, int mode);
 void QUrl_SetUserName(void* ptr, char* userName, int mode);
 void QUrl_Swap(void* ptr, void* other);
-void* QUrl_QUrl_ToAce(char* domain);
+char* QUrl_QUrl_ToAce(char* domain);
 char* QUrl_ToDisplayString(void* ptr, int options);
-void* QUrl_ToEncoded(void* ptr, int options);
+char* QUrl_ToEncoded(void* ptr, int options);
 char* QUrl_ToLocalFile(void* ptr);
-void* QUrl_QUrl_ToPercentEncoding(char* input, void* exclude, void* include);
+char* QUrl_QUrl_ToPercentEncoding(char* input, char* exclude, char* include);
 char* QUrl_ToString(void* ptr, int options);
 char* QUrl_TopLevelDomain(void* ptr, int options);
 char* QUrl_Url(void* ptr, int options);
@@ -3072,17 +2927,17 @@ void QUrlQuery_DestroyQUrlQuery(void* ptr);
 int QUuid_Variant(void* ptr);
 int QUuid_Version(void* ptr);
 void* QUuid_NewQUuid();
-void* QUuid_NewQUuid5(void* text);
+void* QUuid_NewQUuid5(char* text);
 void* QUuid_NewQUuid3(char* text);
 int QUuid_IsNull(void* ptr);
-void* QUuid_ToByteArray(void* ptr);
-void* QUuid_ToRfc4122(void* ptr);
+char* QUuid_ToByteArray(void* ptr);
+char* QUuid_ToRfc4122(void* ptr);
 char* QUuid_ToString(void* ptr);
 void* QVariant_NewQVariant20(void* c);
 void* QVariant_NewQVariant18(void* val);
 void* QVariant_NewQVariant11(int val);
 void* QVariant_NewQVariant16(void* val);
-void* QVariant_NewQVariant15(void* val);
+void* QVariant_NewQVariant15(char* val);
 void* QVariant_NewQVariant21(void* val);
 void* QVariant_NewQVariant23(void* val);
 void* QVariant_NewQVariant39(void* val);
@@ -3112,9 +2967,10 @@ void* QVariant_NewQVariant5(void* p);
 void* QVariant_NewQVariant14(char* val);
 void* QVariant_NewQVariant3(int typeId, void* copy);
 void* QVariant_NewQVariant7(int val);
-void* QVariant_ToByteArray(void* ptr);
+char* QVariant_ToByteArray(void* ptr);
 void* QVariant_ToDateTime(void* ptr);
 void* QVariant_ToEasingCurve(void* ptr);
+void* QVariant_ToLocale(void* ptr);
 void* QVariant_ToPoint(void* ptr);
 void* QVariant_ToRect(void* ptr);
 void* QVariant_ToRegExp(void* ptr);
@@ -3131,12 +2987,14 @@ int QVariant_Convert(void* ptr, int targetTypeId);
 int QVariant_IsNull(void* ptr);
 int QVariant_IsValid(void* ptr);
 void QVariant_Swap(void* ptr, void* other);
+void* QVariant_ToBitArray(void* ptr);
 int QVariant_ToBool(void* ptr);
 int QVariant_ToInt(void* ptr, int ok);
 void* QVariant_ToJsonArray(void* ptr);
 void* QVariant_ToJsonDocument(void* ptr);
 void* QVariant_ToJsonObject(void* ptr);
-void* QVariant_ToModelIndex(void* ptr);
+void* QVariant_ToJsonValue(void* ptr);
+void* QVariant_ToPersistentModelIndex(void* ptr);
 double QVariant_ToReal(void* ptr, int ok);
 char* QVariant_ToString(void* ptr);
 int QVariant_UserType(void* ptr);
@@ -3241,10 +3099,10 @@ int QXmlStreamReader_NamespaceProcessing(void* ptr);
 void QXmlStreamReader_SetNamespaceProcessing(void* ptr, int v);
 void* QXmlStreamReader_NewQXmlStreamReader();
 void* QXmlStreamReader_NewQXmlStreamReader2(void* device);
-void* QXmlStreamReader_NewQXmlStreamReader3(void* data);
+void* QXmlStreamReader_NewQXmlStreamReader3(char* data);
 void* QXmlStreamReader_NewQXmlStreamReader4(char* data);
 void* QXmlStreamReader_NewQXmlStreamReader5(char* data);
-void QXmlStreamReader_AddData(void* ptr, void* data);
+void QXmlStreamReader_AddData(void* ptr, char* data);
 void QXmlStreamReader_AddData2(void* ptr, char* data);
 void QXmlStreamReader_AddData3(void* ptr, char* data);
 void QXmlStreamReader_AddExtraNamespaceDeclaration(void* ptr, void* extraNamespaceDeclaration);

dbus/dbus.cpp

@@ -3,7 +3,6 @@
 #include "dbus.h"
 #include "_cgo_export.h"
 
-#include <QByteArray>
 #include <QChildEvent>
 #include <QDBusAbstractAdaptor>
 #include <QDBusAbstractInterface>
@@ -67,6 +66,18 @@ public:
 	void customEvent(QEvent * event) { callbackQDBusAbstractInterfaceCustomEvent(this, this->objectName().toUtf8().data(), event); };
 };
 
+void* QDBusAbstractInterface_AsyncCall(void* ptr, char* method, void* arg1, void* arg2, void* arg3, void* arg4, void* arg5, void* arg6, void* arg7, void* arg8){
+	return new QDBusPendingCall(static_cast<QDBusAbstractInterface*>(ptr)->asyncCall(QString(method), *static_cast<QVariant*>(arg1), *static_cast<QVariant*>(arg2), *static_cast<QVariant*>(arg3), *static_cast<QVariant*>(arg4), *static_cast<QVariant*>(arg5), *static_cast<QVariant*>(arg6), *static_cast<QVariant*>(arg7), *static_cast<QVariant*>(arg8)));
+}
+
+void* QDBusAbstractInterface_Call(void* ptr, char* method, void* arg1, void* arg2, void* arg3, void* arg4, void* arg5, void* arg6, void* arg7, void* arg8){
+	return new QDBusMessage(static_cast<QDBusAbstractInterface*>(ptr)->call(QString(method), *static_cast<QVariant*>(arg1), *static_cast<QVariant*>(arg2), *static_cast<QVariant*>(arg3), *static_cast<QVariant*>(arg4), *static_cast<QVariant*>(arg5), *static_cast<QVariant*>(arg6), *static_cast<QVariant*>(arg7), *static_cast<QVariant*>(arg8)));
+}
+
+void* QDBusAbstractInterface_Connection(void* ptr){
+	return new QDBusConnection(static_cast<QDBusAbstractInterface*>(ptr)->connection());
+}
+
 char* QDBusAbstractInterface_Interface(void* ptr){
 	return static_cast<QDBusAbstractInterface*>(ptr)->interface().toUtf8().data();
 }
@@ -207,6 +218,14 @@ void QDBusArgument_DestroyQDBusArgument(void* ptr){
 	static_cast<QDBusArgument*>(ptr)->~QDBusArgument();
 }
 
+void* QDBusConnection_QDBusConnection_SessionBus(){
+	return new QDBusConnection(QDBusConnection::sessionBus());
+}
+
+void* QDBusConnection_QDBusConnection_SystemBus(){
+	return new QDBusConnection(QDBusConnection::systemBus());
+}
+
 void* QDBusConnection_NewQDBusConnection2(void* other){
 	return new QDBusConnection(*static_cast<QDBusConnection*>(other));
 }
@@ -219,6 +238,18 @@ char* QDBusConnection_BaseService(void* ptr){
 	return static_cast<QDBusConnection*>(ptr)->baseService().toUtf8().data();
 }
 
+void* QDBusConnection_QDBusConnection_ConnectToBus(int ty, char* name){
+	return new QDBusConnection(QDBusConnection::connectToBus(static_cast<QDBusConnection::BusType>(ty), QString(name)));
+}
+
+void* QDBusConnection_QDBusConnection_ConnectToBus2(char* address, char* name){
+	return new QDBusConnection(QDBusConnection::connectToBus(QString(address), QString(name)));
+}
+
+void* QDBusConnection_AsyncCall(void* ptr, void* message, int timeout){
+	return new QDBusPendingCall(static_cast<QDBusConnection*>(ptr)->asyncCall(*static_cast<QDBusMessage*>(message), timeout));
+}
+
 int QDBusConnection_CallWithCallback(void* ptr, void* message, void* receiver, char* returnMethod, char* errorMethod, int timeout){
 	return static_cast<QDBusConnection*>(ptr)->callWithCallback(*static_cast<QDBusMessage*>(message), static_cast<QObject*>(receiver), const_cast<const char*>(returnMethod), const_cast<const char*>(errorMethod), timeout);
 }
@@ -235,6 +266,10 @@ int QDBusConnection_Connect3(void* ptr, char* service, char* path, char* interfa
 	return static_cast<QDBusConnection*>(ptr)->connect(QString(service), QString(path), QString(interfa), QString(name), QString(argumentMatch).split("|", QString::SkipEmptyParts), QString(signature), static_cast<QObject*>(receiver), const_cast<const char*>(slot));
 }
 
+void* QDBusConnection_QDBusConnection_ConnectToPeer(char* address, char* name){
+	return new QDBusConnection(QDBusConnection::connectToPeer(QString(address), QString(name)));
+}
+
 int QDBusConnection_ConnectionCapabilities(void* ptr){
 	return static_cast<QDBusConnection*>(ptr)->connectionCapabilities();
 }
@@ -255,8 +290,8 @@ int QDBusConnection_IsConnected(void* ptr){
 	return static_cast<QDBusConnection*>(ptr)->isConnected();
 }
 
-void* QDBusConnection_QDBusConnection_LocalMachineId(){
-	return new QByteArray(QDBusConnection::localMachineId());
+char* QDBusConnection_QDBusConnection_LocalMachineId(){
+	return QString(QDBusConnection::localMachineId()).toUtf8().data();
 }
 
 char* QDBusConnection_Name(void* ptr){
@@ -360,10 +395,18 @@ int QDBusContext_CalledFromDBus(void* ptr){
 	return static_cast<QDBusContext*>(ptr)->calledFromDBus();
 }
 
+void* QDBusContext_Connection(void* ptr){
+	return new QDBusConnection(static_cast<QDBusContext*>(ptr)->connection());
+}
+
 int QDBusContext_IsDelayedReply(void* ptr){
 	return static_cast<QDBusContext*>(ptr)->isDelayedReply();
 }
 
+void* QDBusContext_Message(void* ptr){
+	return new QDBusMessage(static_cast<QDBusContext*>(ptr)->message());
+}
+
 void QDBusContext_SendErrorReply2(void* ptr, int ty, char* msg){
 	static_cast<QDBusContext*>(ptr)->sendErrorReply(static_cast<QDBusError::ErrorType>(ty), QString(msg));
 }
@@ -432,6 +475,10 @@ void QDBusInterface_CustomEventDefault(void* ptr, void* event){
 	static_cast<QDBusInterface*>(ptr)->QDBusInterface::customEvent(static_cast<QEvent*>(event));
 }
 
+void* QDBusMessage_CreateErrorReply3(void* ptr, int ty, char* msg){
+	return new QDBusMessage(static_cast<QDBusMessage*>(ptr)->createErrorReply(static_cast<QDBusError::ErrorType>(ty), QString(msg)));
+}
+
 void* QDBusMessage_NewQDBusMessage(){
 	return new QDBusMessage();
 }
@@ -444,6 +491,38 @@ int QDBusMessage_AutoStartService(void* ptr){
 	return static_cast<QDBusMessage*>(ptr)->autoStartService();
 }
 
+void* QDBusMessage_QDBusMessage_CreateError3(int ty, char* msg){
+	return new QDBusMessage(QDBusMessage::createError(static_cast<QDBusError::ErrorType>(ty), QString(msg)));
+}
+
+void* QDBusMessage_QDBusMessage_CreateError2(void* error){
+	return new QDBusMessage(QDBusMessage::createError(*static_cast<QDBusError*>(error)));
+}
+
+void* QDBusMessage_QDBusMessage_CreateError(char* name, char* msg){
+	return new QDBusMessage(QDBusMessage::createError(QString(name), QString(msg)));
+}
+
+void* QDBusMessage_CreateErrorReply2(void* ptr, void* error){
+	return new QDBusMessage(static_cast<QDBusMessage*>(ptr)->createErrorReply(*static_cast<QDBusError*>(error)));
+}
+
+void* QDBusMessage_CreateErrorReply(void* ptr, char* name, char* msg){
+	return new QDBusMessage(static_cast<QDBusMessage*>(ptr)->createErrorReply(QString(name), QString(msg)));
+}
+
+void* QDBusMessage_QDBusMessage_CreateMethodCall(char* service, char* path, char* interfa, char* method){
+	return new QDBusMessage(QDBusMessage::createMethodCall(QString(service), QString(path), QString(interfa), QString(method)));
+}
+
+void* QDBusMessage_CreateReply2(void* ptr, void* argument){
+	return new QDBusMessage(static_cast<QDBusMessage*>(ptr)->createReply(*static_cast<QVariant*>(argument)));
+}
+
+void* QDBusMessage_QDBusMessage_CreateSignal(char* path, char* interfa, char* name){
+	return new QDBusMessage(QDBusMessage::createSignal(QString(path), QString(interfa), QString(name)));
+}
+
 char* QDBusMessage_ErrorMessage(void* ptr){
 	return static_cast<QDBusMessage*>(ptr)->errorMessage().toUtf8().data();
 }
@@ -524,6 +603,14 @@ void* QDBusPendingCall_NewQDBusPendingCall(void* other){
 	return new QDBusPendingCall(*static_cast<QDBusPendingCall*>(other));
 }
 
+void* QDBusPendingCall_QDBusPendingCall_FromCompletedCall(void* msg){
+	return new QDBusPendingCall(QDBusPendingCall::fromCompletedCall(*static_cast<QDBusMessage*>(msg)));
+}
+
+void* QDBusPendingCall_QDBusPendingCall_FromError(void* error){
+	return new QDBusPendingCall(QDBusPendingCall::fromError(*static_cast<QDBusError*>(error)));
+}
+
 void QDBusPendingCall_Swap(void* ptr, void* other){
 	static_cast<QDBusPendingCall*>(ptr)->swap(*static_cast<QDBusPendingCall*>(other));
 }
@@ -596,6 +683,7 @@ class MyQDBusServer: public QDBusServer {
 public:
 	MyQDBusServer(QObject *parent) : QDBusServer(parent) {};
 	MyQDBusServer(const QString &address, QObject *parent) : QDBusServer(address, parent) {};
+	void Signal_NewConnection(const QDBusConnection & connection) { callbackQDBusServerNewConnection(this, this->objectName().toUtf8().data(), new QDBusConnection(connection)); };
 	void timerEvent(QTimerEvent * event) { callbackQDBusServerTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQDBusServerChildEvent(this, this->objectName().toUtf8().data(), event); };
 	void customEvent(QEvent * event) { callbackQDBusServerCustomEvent(this, this->objectName().toUtf8().data(), event); };
@@ -621,6 +709,18 @@ int QDBusServer_IsConnected(void* ptr){
 	return static_cast<QDBusServer*>(ptr)->isConnected();
 }
 
+void QDBusServer_ConnectNewConnection(void* ptr){
+	QObject::connect(static_cast<QDBusServer*>(ptr), static_cast<void (QDBusServer::*)(const QDBusConnection &)>(&QDBusServer::newConnection), static_cast<MyQDBusServer*>(ptr), static_cast<void (MyQDBusServer::*)(const QDBusConnection &)>(&MyQDBusServer::Signal_NewConnection));;
+}
+
+void QDBusServer_DisconnectNewConnection(void* ptr){
+	QObject::disconnect(static_cast<QDBusServer*>(ptr), static_cast<void (QDBusServer::*)(const QDBusConnection &)>(&QDBusServer::newConnection), static_cast<MyQDBusServer*>(ptr), static_cast<void (MyQDBusServer::*)(const QDBusConnection &)>(&MyQDBusServer::Signal_NewConnection));;
+}
+
+void QDBusServer_NewConnection(void* ptr, void* connection){
+	static_cast<QDBusServer*>(ptr)->newConnection(*static_cast<QDBusConnection*>(connection));
+}
+
 void QDBusServer_SetAnonymousAuthenticationAllowed(void* ptr, int value){
 	static_cast<QDBusServer*>(ptr)->setAnonymousAuthenticationAllowed(value != 0);
 }
@@ -683,6 +783,10 @@ void QDBusServiceWatcher_AddWatchedService(void* ptr, char* newService){
 	static_cast<QDBusServiceWatcher*>(ptr)->addWatchedService(QString(newService));
 }
 
+void* QDBusServiceWatcher_Connection(void* ptr){
+	return new QDBusConnection(static_cast<QDBusServiceWatcher*>(ptr)->connection());
+}
+
 int QDBusServiceWatcher_RemoveWatchedService(void* ptr, char* service){
 	return static_cast<QDBusServiceWatcher*>(ptr)->removeWatchedService(QString(service));
 }

dbus/dbus.go

@@ -221,6 +221,33 @@ func (ptr *QDBusAbstractInterface) QDBusAbstractInterface_PTR() *QDBusAbstractIn
 	return ptr
 }
 
+func (ptr *QDBusAbstractInterface) AsyncCall(method string, arg1 core.QVariant_ITF, arg2 core.QVariant_ITF, arg3 core.QVariant_ITF, arg4 core.QVariant_ITF, arg5 core.QVariant_ITF, arg6 core.QVariant_ITF, arg7 core.QVariant_ITF, arg8 core.QVariant_ITF) *QDBusPendingCall {
+	defer qt.Recovering("QDBusAbstractInterface::asyncCall")
+
+	if ptr.Pointer() != nil {
+		return NewQDBusPendingCallFromPointer(C.QDBusAbstractInterface_AsyncCall(ptr.Pointer(), C.CString(method), core.PointerFromQVariant(arg1), core.PointerFromQVariant(arg2), core.PointerFromQVariant(arg3), core.PointerFromQVariant(arg4), core.PointerFromQVariant(arg5), core.PointerFromQVariant(arg6), core.PointerFromQVariant(arg7), core.PointerFromQVariant(arg8)))
+	}
+	return nil
+}
+
+func (ptr *QDBusAbstractInterface) Call(method string, arg1 core.QVariant_ITF, arg2 core.QVariant_ITF, arg3 core.QVariant_ITF, arg4 core.QVariant_ITF, arg5 core.QVariant_ITF, arg6 core.QVariant_ITF, arg7 core.QVariant_ITF, arg8 core.QVariant_ITF) *QDBusMessage {
+	defer qt.Recovering("QDBusAbstractInterface::call")
+
+	if ptr.Pointer() != nil {
+		return NewQDBusMessageFromPointer(C.QDBusAbstractInterface_Call(ptr.Pointer(), C.CString(method), core.PointerFromQVariant(arg1), core.PointerFromQVariant(arg2), core.PointerFromQVariant(arg3), core.PointerFromQVariant(arg4), core.PointerFromQVariant(arg5), core.PointerFromQVariant(arg6), core.PointerFromQVariant(arg7), core.PointerFromQVariant(arg8)))
+	}
+	return nil
+}
+
+func (ptr *QDBusAbstractInterface) Connection() *QDBusConnection {
+	defer qt.Recovering("QDBusAbstractInterface::connection")
+
+	if ptr.Pointer() != nil {
+		return NewQDBusConnectionFromPointer(C.QDBusAbstractInterface_Connection(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QDBusAbstractInterface) Interface() string {
 	defer qt.Recovering("QDBusAbstractInterface::interface")
 
@@ -729,6 +756,18 @@ const (
 	QDBusConnection__UnregisterTree = QDBusConnection__UnregisterMode(1)
 )
 
+func QDBusConnection_SessionBus() *QDBusConnection {
+	defer qt.Recovering("QDBusConnection::sessionBus")
+
+	return NewQDBusConnectionFromPointer(C.QDBusConnection_QDBusConnection_SessionBus())
+}
+
+func QDBusConnection_SystemBus() *QDBusConnection {
+	defer qt.Recovering("QDBusConnection::systemBus")
+
+	return NewQDBusConnectionFromPointer(C.QDBusConnection_QDBusConnection_SystemBus())
+}
+
 func NewQDBusConnection2(other QDBusConnection_ITF) *QDBusConnection {
 	defer qt.Recovering("QDBusConnection::QDBusConnection")
 
@@ -750,6 +789,27 @@ func (ptr *QDBusConnection) BaseService() string {
 	return ""
 }
 
+func QDBusConnection_ConnectToBus(ty QDBusConnection__BusType, name string) *QDBusConnection {
+	defer qt.Recovering("QDBusConnection::connectToBus")
+
+	return NewQDBusConnectionFromPointer(C.QDBusConnection_QDBusConnection_ConnectToBus(C.int(ty), C.CString(name)))
+}
+
+func QDBusConnection_ConnectToBus2(address string, name string) *QDBusConnection {
+	defer qt.Recovering("QDBusConnection::connectToBus")
+
+	return NewQDBusConnectionFromPointer(C.QDBusConnection_QDBusConnection_ConnectToBus2(C.CString(address), C.CString(name)))
+}
+
+func (ptr *QDBusConnection) AsyncCall(message QDBusMessage_ITF, timeout int) *QDBusPendingCall {
+	defer qt.Recovering("QDBusConnection::asyncCall")
+
+	if ptr.Pointer() != nil {
+		return NewQDBusPendingCallFromPointer(C.QDBusConnection_AsyncCall(ptr.Pointer(), PointerFromQDBusMessage(message), C.int(timeout)))
+	}
+	return nil
+}
+
 func (ptr *QDBusConnection) CallWithCallback(message QDBusMessage_ITF, receiver core.QObject_ITF, returnMethod string, errorMethod string, timeout int) bool {
 	defer qt.Recovering("QDBusConnection::callWithCallback")
 
@@ -786,6 +846,12 @@ func (ptr *QDBusConnection) Connect3(service string, path string, interfa string
 	return false
 }
 
+func QDBusConnection_ConnectToPeer(address string, name string) *QDBusConnection {
+	defer qt.Recovering("QDBusConnection::connectToPeer")
+
+	return NewQDBusConnectionFromPointer(C.QDBusConnection_QDBusConnection_ConnectToPeer(C.CString(address), C.CString(name)))
+}
+
 func (ptr *QDBusConnection) ConnectionCapabilities() QDBusConnection__ConnectionCapability {
 	defer qt.Recovering("QDBusConnection::connectionCapabilities")
 
@@ -825,10 +891,10 @@ func (ptr *QDBusConnection) IsConnected() bool {
 	return false
 }
 
-func QDBusConnection_LocalMachineId() *core.QByteArray {
+func QDBusConnection_LocalMachineId() string {
 	defer qt.Recovering("QDBusConnection::localMachineId")
 
-	return core.NewQByteArrayFromPointer(C.QDBusConnection_QDBusConnection_LocalMachineId())
+	return C.GoString(C.QDBusConnection_QDBusConnection_LocalMachineId())
 }
 
 func (ptr *QDBusConnection) Name() string {
@@ -1230,6 +1296,15 @@ func (ptr *QDBusContext) CalledFromDBus() bool {
 	return false
 }
 
+func (ptr *QDBusContext) Connection() *QDBusConnection {
+	defer qt.Recovering("QDBusContext::connection")
+
+	if ptr.Pointer() != nil {
+		return NewQDBusConnectionFromPointer(C.QDBusContext_Connection(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QDBusContext) IsDelayedReply() bool {
 	defer qt.Recovering("QDBusContext::isDelayedReply")
 
@@ -1239,6 +1314,15 @@ func (ptr *QDBusContext) IsDelayedReply() bool {
 	return false
 }
 
+func (ptr *QDBusContext) Message() *QDBusMessage {
+	defer qt.Recovering("QDBusContext::message")
+
+	if ptr.Pointer() != nil {
+		return NewQDBusMessageFromPointer(C.QDBusContext_Message(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QDBusContext) SendErrorReply2(ty QDBusError__ErrorType, msg string) {
 	defer qt.Recovering("QDBusContext::sendErrorReply")
 
@@ -1618,6 +1702,15 @@ const (
 	QDBusMessage__SignalMessage     = QDBusMessage__MessageType(4)
 )
 
+func (ptr *QDBusMessage) CreateErrorReply3(ty QDBusError__ErrorType, msg string) *QDBusMessage {
+	defer qt.Recovering("QDBusMessage::createErrorReply")
+
+	if ptr.Pointer() != nil {
+		return NewQDBusMessageFromPointer(C.QDBusMessage_CreateErrorReply3(ptr.Pointer(), C.int(ty), C.CString(msg)))
+	}
+	return nil
+}
+
 func NewQDBusMessage() *QDBusMessage {
 	defer qt.Recovering("QDBusMessage::QDBusMessage")
 
@@ -1639,6 +1732,63 @@ func (ptr *QDBusMessage) AutoStartService() bool {
 	return false
 }
 
+func QDBusMessage_CreateError3(ty QDBusError__ErrorType, msg string) *QDBusMessage {
+	defer qt.Recovering("QDBusMessage::createError")
+
+	return NewQDBusMessageFromPointer(C.QDBusMessage_QDBusMessage_CreateError3(C.int(ty), C.CString(msg)))
+}
+
+func QDBusMessage_CreateError2(error QDBusError_ITF) *QDBusMessage {
+	defer qt.Recovering("QDBusMessage::createError")
+
+	return NewQDBusMessageFromPointer(C.QDBusMessage_QDBusMessage_CreateError2(PointerFromQDBusError(error)))
+}
+
+func QDBusMessage_CreateError(name string, msg string) *QDBusMessage {
+	defer qt.Recovering("QDBusMessage::createError")
+
+	return NewQDBusMessageFromPointer(C.QDBusMessage_QDBusMessage_CreateError(C.CString(name), C.CString(msg)))
+}
+
+func (ptr *QDBusMessage) CreateErrorReply2(error QDBusError_ITF) *QDBusMessage {
+	defer qt.Recovering("QDBusMessage::createErrorReply")
+
+	if ptr.Pointer() != nil {
+		return NewQDBusMessageFromPointer(C.QDBusMessage_CreateErrorReply2(ptr.Pointer(), PointerFromQDBusError(error)))
+	}
+	return nil
+}
+
+func (ptr *QDBusMessage) CreateErrorReply(name string, msg string) *QDBusMessage {
+	defer qt.Recovering("QDBusMessage::createErrorReply")
+
+	if ptr.Pointer() != nil {
+		return NewQDBusMessageFromPointer(C.QDBusMessage_CreateErrorReply(ptr.Pointer(), C.CString(name), C.CString(msg)))
+	}
+	return nil
+}
+
+func QDBusMessage_CreateMethodCall(service string, path string, interfa string, method string) *QDBusMessage {
+	defer qt.Recovering("QDBusMessage::createMethodCall")
+
+	return NewQDBusMessageFromPointer(C.QDBusMessage_QDBusMessage_CreateMethodCall(C.CString(service), C.CString(path), C.CString(interfa), C.CString(method)))
+}
+
+func (ptr *QDBusMessage) CreateReply2(argument core.QVariant_ITF) *QDBusMessage {
+	defer qt.Recovering("QDBusMessage::createReply")
+
+	if ptr.Pointer() != nil {
+		return NewQDBusMessageFromPointer(C.QDBusMessage_CreateReply2(ptr.Pointer(), core.PointerFromQVariant(argument)))
+	}
+	return nil
+}
+
+func QDBusMessage_CreateSignal(path string, interfa string, name string) *QDBusMessage {
+	defer qt.Recovering("QDBusMessage::createSignal")
+
+	return NewQDBusMessageFromPointer(C.QDBusMessage_QDBusMessage_CreateSignal(C.CString(path), C.CString(interfa), C.CString(name)))
+}
+
 func (ptr *QDBusMessage) ErrorMessage() string {
 	defer qt.Recovering("QDBusMessage::errorMessage")
 
@@ -1876,6 +2026,18 @@ func NewQDBusPendingCall(other QDBusPendingCall_ITF) *QDBusPendingCall {
 	return newQDBusPendingCallFromPointer(C.QDBusPendingCall_NewQDBusPendingCall(PointerFromQDBusPendingCall(other)))
 }
 
+func QDBusPendingCall_FromCompletedCall(msg QDBusMessage_ITF) *QDBusPendingCall {
+	defer qt.Recovering("QDBusPendingCall::fromCompletedCall")
+
+	return NewQDBusPendingCallFromPointer(C.QDBusPendingCall_QDBusPendingCall_FromCompletedCall(PointerFromQDBusMessage(msg)))
+}
+
+func QDBusPendingCall_FromError(error QDBusError_ITF) *QDBusPendingCall {
+	defer qt.Recovering("QDBusPendingCall::fromError")
+
+	return NewQDBusPendingCallFromPointer(C.QDBusPendingCall_QDBusPendingCall_FromError(PointerFromQDBusError(error)))
+}
+
 func (ptr *QDBusPendingCall) Swap(other QDBusPendingCall_ITF) {
 	defer qt.Recovering("QDBusPendingCall::swap")
 
@@ -2282,6 +2444,42 @@ func (ptr *QDBusServer) IsConnected() bool {
 	return false
 }
 
+func (ptr *QDBusServer) ConnectNewConnection(f func(connection *QDBusConnection)) {
+	defer qt.Recovering("connect QDBusServer::newConnection")
+
+	if ptr.Pointer() != nil {
+		C.QDBusServer_ConnectNewConnection(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "newConnection", f)
+	}
+}
+
+func (ptr *QDBusServer) DisconnectNewConnection() {
+	defer qt.Recovering("disconnect QDBusServer::newConnection")
+
+	if ptr.Pointer() != nil {
+		C.QDBusServer_DisconnectNewConnection(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "newConnection")
+	}
+}
+
+//export callbackQDBusServerNewConnection
+func callbackQDBusServerNewConnection(ptr unsafe.Pointer, ptrName *C.char, connection unsafe.Pointer) {
+	defer qt.Recovering("callback QDBusServer::newConnection")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "newConnection"); signal != nil {
+		signal.(func(*QDBusConnection))(NewQDBusConnectionFromPointer(connection))
+	}
+
+}
+
+func (ptr *QDBusServer) NewConnection(connection QDBusConnection_ITF) {
+	defer qt.Recovering("QDBusServer::newConnection")
+
+	if ptr.Pointer() != nil {
+		C.QDBusServer_NewConnection(ptr.Pointer(), PointerFromQDBusConnection(connection))
+	}
+}
+
 func (ptr *QDBusServer) SetAnonymousAuthenticationAllowed(value bool) {
 	defer qt.Recovering("QDBusServer::setAnonymousAuthenticationAllowed")
 
@@ -2514,6 +2712,15 @@ func (ptr *QDBusServiceWatcher) AddWatchedService(newService string) {
 	}
 }
 
+func (ptr *QDBusServiceWatcher) Connection() *QDBusConnection {
+	defer qt.Recovering("QDBusServiceWatcher::connection")
+
+	if ptr.Pointer() != nil {
+		return NewQDBusConnectionFromPointer(C.QDBusServiceWatcher_Connection(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QDBusServiceWatcher) RemoveWatchedService(service string) bool {
 	defer qt.Recovering("QDBusServiceWatcher::removeWatchedService")
 

dbus/dbus.h

@@ -14,6 +14,9 @@ void QDBusAbstractAdaptor_ChildEvent(void* ptr, void* event);
 void QDBusAbstractAdaptor_ChildEventDefault(void* ptr, void* event);
 void QDBusAbstractAdaptor_CustomEvent(void* ptr, void* event);
 void QDBusAbstractAdaptor_CustomEventDefault(void* ptr, void* event);
+void* QDBusAbstractInterface_AsyncCall(void* ptr, char* method, void* arg1, void* arg2, void* arg3, void* arg4, void* arg5, void* arg6, void* arg7, void* arg8);
+void* QDBusAbstractInterface_Call(void* ptr, char* method, void* arg1, void* arg2, void* arg3, void* arg4, void* arg5, void* arg6, void* arg7, void* arg8);
+void* QDBusAbstractInterface_Connection(void* ptr);
 char* QDBusAbstractInterface_Interface(void* ptr);
 int QDBusAbstractInterface_IsValid(void* ptr);
 char* QDBusAbstractInterface_Path(void* ptr);
@@ -49,19 +52,25 @@ void QDBusArgument_EndMapEntry2(void* ptr);
 void QDBusArgument_EndStructure(void* ptr);
 void QDBusArgument_EndStructure2(void* ptr);
 void QDBusArgument_DestroyQDBusArgument(void* ptr);
+void* QDBusConnection_QDBusConnection_SessionBus();
+void* QDBusConnection_QDBusConnection_SystemBus();
 void* QDBusConnection_NewQDBusConnection2(void* other);
 void* QDBusConnection_NewQDBusConnection(char* name);
 char* QDBusConnection_BaseService(void* ptr);
+void* QDBusConnection_QDBusConnection_ConnectToBus(int ty, char* name);
+void* QDBusConnection_QDBusConnection_ConnectToBus2(char* address, char* name);
+void* QDBusConnection_AsyncCall(void* ptr, void* message, int timeout);
 int QDBusConnection_CallWithCallback(void* ptr, void* message, void* receiver, char* returnMethod, char* errorMethod, int timeout);
 int QDBusConnection_Connect(void* ptr, char* service, char* path, char* interfa, char* name, void* receiver, char* slot);
 int QDBusConnection_Connect2(void* ptr, char* service, char* path, char* interfa, char* name, char* signature, void* receiver, char* slot);
 int QDBusConnection_Connect3(void* ptr, char* service, char* path, char* interfa, char* name, char* argumentMatch, char* signature, void* receiver, char* slot);
+void* QDBusConnection_QDBusConnection_ConnectToPeer(char* address, char* name);
 int QDBusConnection_ConnectionCapabilities(void* ptr);
 void QDBusConnection_QDBusConnection_DisconnectFromBus(char* name);
 void QDBusConnection_QDBusConnection_DisconnectFromPeer(char* name);
 void* QDBusConnection_Interface(void* ptr);
 int QDBusConnection_IsConnected(void* ptr);
-void* QDBusConnection_QDBusConnection_LocalMachineId();
+char* QDBusConnection_QDBusConnection_LocalMachineId();
 char* QDBusConnection_Name(void* ptr);
 void* QDBusConnection_ObjectRegisteredAt(void* ptr, char* path);
 int QDBusConnection_RegisterObject(void* ptr, char* path, void* object, int options);
@@ -85,7 +94,9 @@ void QDBusConnectionInterface_CustomEvent(void* ptr, void* event);
 void QDBusConnectionInterface_CustomEventDefault(void* ptr, void* event);
 void* QDBusContext_NewQDBusContext();
 int QDBusContext_CalledFromDBus(void* ptr);
+void* QDBusContext_Connection(void* ptr);
 int QDBusContext_IsDelayedReply(void* ptr);
+void* QDBusContext_Message(void* ptr);
 void QDBusContext_SendErrorReply2(void* ptr, int ty, char* msg);
 void QDBusContext_SendErrorReply(void* ptr, char* name, char* msg);
 void QDBusContext_SetDelayedReply(void* ptr, int enable);
@@ -103,9 +114,18 @@ void QDBusInterface_ChildEvent(void* ptr, void* event);
 void QDBusInterface_ChildEventDefault(void* ptr, void* event);
 void QDBusInterface_CustomEvent(void* ptr, void* event);
 void QDBusInterface_CustomEventDefault(void* ptr, void* event);
+void* QDBusMessage_CreateErrorReply3(void* ptr, int ty, char* msg);
 void* QDBusMessage_NewQDBusMessage();
 void* QDBusMessage_NewQDBusMessage2(void* other);
 int QDBusMessage_AutoStartService(void* ptr);
+void* QDBusMessage_QDBusMessage_CreateError3(int ty, char* msg);
+void* QDBusMessage_QDBusMessage_CreateError2(void* error);
+void* QDBusMessage_QDBusMessage_CreateError(char* name, char* msg);
+void* QDBusMessage_CreateErrorReply2(void* ptr, void* error);
+void* QDBusMessage_CreateErrorReply(void* ptr, char* name, char* msg);
+void* QDBusMessage_QDBusMessage_CreateMethodCall(char* service, char* path, char* interfa, char* method);
+void* QDBusMessage_CreateReply2(void* ptr, void* argument);
+void* QDBusMessage_QDBusMessage_CreateSignal(char* path, char* interfa, char* name);
 char* QDBusMessage_ErrorMessage(void* ptr);
 char* QDBusMessage_ErrorName(void* ptr);
 char* QDBusMessage_Interface(void* ptr);
@@ -126,6 +146,8 @@ void* QDBusObjectPath_NewQDBusObjectPath2(char* path);
 char* QDBusObjectPath_Path(void* ptr);
 void QDBusObjectPath_SetPath(void* ptr, char* path);
 void* QDBusPendingCall_NewQDBusPendingCall(void* other);
+void* QDBusPendingCall_QDBusPendingCall_FromCompletedCall(void* msg);
+void* QDBusPendingCall_QDBusPendingCall_FromError(void* error);
 void QDBusPendingCall_Swap(void* ptr, void* other);
 void QDBusPendingCall_DestroyQDBusPendingCall(void* ptr);
 void QDBusPendingCallWatcher_WaitForFinished(void* ptr);
@@ -146,6 +168,9 @@ void* QDBusServer_NewQDBusServer(char* address, void* parent);
 char* QDBusServer_Address(void* ptr);
 int QDBusServer_IsAnonymousAuthenticationAllowed(void* ptr);
 int QDBusServer_IsConnected(void* ptr);
+void QDBusServer_ConnectNewConnection(void* ptr);
+void QDBusServer_DisconnectNewConnection(void* ptr);
+void QDBusServer_NewConnection(void* ptr, void* connection);
 void QDBusServer_SetAnonymousAuthenticationAllowed(void* ptr, int value);
 void QDBusServer_DestroyQDBusServer(void* ptr);
 void QDBusServer_TimerEvent(void* ptr, void* event);
@@ -159,6 +184,7 @@ int QDBusServiceWatcher_WatchMode(void* ptr);
 void* QDBusServiceWatcher_NewQDBusServiceWatcher(void* parent);
 void* QDBusServiceWatcher_NewQDBusServiceWatcher2(char* service, void* connection, int watchMode, void* parent);
 void QDBusServiceWatcher_AddWatchedService(void* ptr, char* newService);
+void* QDBusServiceWatcher_Connection(void* ptr);
 int QDBusServiceWatcher_RemoveWatchedService(void* ptr, char* service);
 void QDBusServiceWatcher_ConnectServiceOwnerChanged(void* ptr);
 void QDBusServiceWatcher_DisconnectServiceOwnerChanged(void* ptr);

gui/gui.h

@@ -18,6 +18,9 @@ void* QAbstractTextDocumentLayout_PaintDevice(void* ptr);
 void QAbstractTextDocumentLayout_RegisterHandler(void* ptr, int objectType, void* component);
 void QAbstractTextDocumentLayout_SetPaintDevice(void* ptr, void* device);
 void QAbstractTextDocumentLayout_UnregisterHandler(void* ptr, int objectType, void* component);
+void QAbstractTextDocumentLayout_ConnectUpdateBlock(void* ptr);
+void QAbstractTextDocumentLayout_DisconnectUpdateBlock(void* ptr);
+void QAbstractTextDocumentLayout_UpdateBlock(void* ptr, void* block);
 void QAbstractTextDocumentLayout_TimerEvent(void* ptr, void* event);
 void QAbstractTextDocumentLayout_TimerEventDefault(void* ptr, void* event);
 void QAbstractTextDocumentLayout_ChildEvent(void* ptr, void* event);
@@ -239,6 +242,7 @@ void QBitmap_Swap(void* ptr, void* other);
 void QBitmap_DestroyQBitmap(void* ptr);
 void* QBrush_NewQBrush4(int color, int style);
 void QBrush_SetColor(void* ptr, void* color);
+void* QBrush_Texture(void* ptr);
 void* QBrush_NewQBrush();
 void* QBrush_NewQBrush2(int style);
 void* QBrush_NewQBrush6(int color, void* pixmap);
@@ -258,6 +262,7 @@ void QBrush_SetTextureImage(void* ptr, void* image);
 void QBrush_SetTransform(void* ptr, void* matrix);
 int QBrush_Style(void* ptr);
 void QBrush_Swap(void* ptr, void* other);
+void* QBrush_TextureImage(void* ptr);
 void QBrush_DestroyQBrush(void* ptr);
 void QClipboard_Clear(void* ptr, int mode);
 void* QClipboard_MimeData(void* ptr, int mode);
@@ -271,9 +276,11 @@ void QClipboard_DataChanged(void* ptr);
 void QClipboard_ConnectFindBufferChanged(void* ptr);
 void QClipboard_DisconnectFindBufferChanged(void* ptr);
 void QClipboard_FindBufferChanged(void* ptr);
+void* QClipboard_Image(void* ptr, int mode);
 int QClipboard_OwnsClipboard(void* ptr);
 int QClipboard_OwnsFindBuffer(void* ptr);
 int QClipboard_OwnsSelection(void* ptr);
+void* QClipboard_Pixmap(void* ptr, int mode);
 void QClipboard_ConnectSelectionChanged(void* ptr);
 void QClipboard_DisconnectSelectionChanged(void* ptr);
 void QClipboard_SelectionChanged(void* ptr);
@@ -400,6 +407,7 @@ void* QCursor_NewQCursor4(void* pixmap, int hotX, int hotY);
 void* QCursor_Bitmap(void* ptr);
 void* QCursor_HotSpot(void* ptr);
 void* QCursor_Mask(void* ptr);
+void* QCursor_Pixmap(void* ptr);
 void QCursor_QCursor_SetPos4(void* screen, void* p);
 void QCursor_QCursor_SetPos3(void* p);
 void QCursor_SetShape(void* ptr, int shape);
@@ -424,10 +432,12 @@ void* QDrag_NewQDrag(void* dragSource);
 void QDrag_ConnectActionChanged(void* ptr);
 void QDrag_DisconnectActionChanged(void* ptr);
 void QDrag_ActionChanged(void* ptr, int action);
+void* QDrag_DragCursor(void* ptr, int action);
 int QDrag_Exec(void* ptr, int supportedActions);
 int QDrag_Exec2(void* ptr, int supportedActions, int defaultDropAction);
 void* QDrag_HotSpot(void* ptr);
 void* QDrag_MimeData(void* ptr);
+void* QDrag_Pixmap(void* ptr);
 void QDrag_SetDragCursor(void* ptr, void* cursor, int action);
 void QDrag_SetHotSpot(void* ptr, void* hotspot);
 void QDrag_SetMimeData(void* ptr, void* data);
@@ -516,6 +526,7 @@ int QFont_PixelSize(void* ptr);
 int QFont_PointSize(void* ptr);
 double QFont_PointSizeF(void* ptr);
 void QFont_QFont_RemoveSubstitutions(char* familyName);
+void* QFont_Resolve(void* ptr, void* other);
 void QFont_SetBold(void* ptr, int enable);
 void QFont_SetCapitalization(void* ptr, int caps);
 void QFont_SetFamily(void* ptr, char* family);
@@ -560,10 +571,11 @@ int QFontDatabase_QFontDatabase_RemoveAllApplicationFonts();
 int QFontDatabase_QFontDatabase_RemoveApplicationFont(int id);
 void* QFontDatabase_NewQFontDatabase();
 int QFontDatabase_QFontDatabase_AddApplicationFont(char* fileName);
-int QFontDatabase_QFontDatabase_AddApplicationFontFromData(void* fontData);
+int QFontDatabase_QFontDatabase_AddApplicationFontFromData(char* fontData);
 char* QFontDatabase_QFontDatabase_ApplicationFontFamilies(int id);
 int QFontDatabase_Bold(void* ptr, char* family, char* style);
 char* QFontDatabase_Families(void* ptr, int writingSystem);
+void* QFontDatabase_Font(void* ptr, char* family, char* style, int pointSize);
 int QFontDatabase_IsBitmapScalable(void* ptr, char* family, char* style);
 int QFontDatabase_IsFixedPitch(void* ptr, char* family, char* style);
 int QFontDatabase_IsPrivateFamily(void* ptr, char* family);
@@ -573,6 +585,7 @@ int QFontDatabase_Italic(void* ptr, char* family, char* style);
 char* QFontDatabase_StyleString(void* ptr, void* font);
 char* QFontDatabase_StyleString2(void* ptr, void* fontInfo);
 char* QFontDatabase_Styles(void* ptr, char* family);
+void* QFontDatabase_QFontDatabase_SystemFont(int ty);
 int QFontDatabase_Weight(void* ptr, char* family, char* style);
 char* QFontDatabase_QFontDatabase_WritingSystemName(int writingSystem);
 char* QFontDatabase_QFontDatabase_WritingSystemSample(int writingSystem);
@@ -664,6 +677,7 @@ int QGlyphRun_Flags(void* ptr);
 int QGlyphRun_IsEmpty(void* ptr);
 int QGlyphRun_IsRightToLeft(void* ptr);
 int QGlyphRun_Overline(void* ptr);
+void* QGlyphRun_RawFont(void* ptr);
 void QGlyphRun_SetBoundingRect(void* ptr, void* boundingRect);
 void QGlyphRun_SetFlag(void* ptr, int flag, int enabled);
 void QGlyphRun_SetFlags(void* ptr, int flags);
@@ -719,6 +733,7 @@ void* QGuiApplication_QGuiApplication_FocusWindow();
 void QGuiApplication_ConnectFocusWindowChanged(void* ptr);
 void QGuiApplication_DisconnectFocusWindowChanged(void* ptr);
 void QGuiApplication_FocusWindowChanged(void* ptr, void* focusWindow);
+void* QGuiApplication_QGuiApplication_Font();
 void QGuiApplication_ConnectFontDatabaseChanged(void* ptr);
 void QGuiApplication_DisconnectFontDatabaseChanged(void* ptr);
 void QGuiApplication_FontDatabaseChanged(void* ptr);
@@ -736,6 +751,10 @@ void* QGuiApplication_QGuiApplication_ModalWindow();
 int QGuiApplication_QGuiApplication_MouseButtons();
 int QGuiApplication_Notify(void* ptr, void* object, void* event);
 int QGuiApplication_NotifyDefault(void* ptr, void* object, void* event);
+void* QGuiApplication_QGuiApplication_Palette();
+void QGuiApplication_ConnectPaletteChanged(void* ptr);
+void QGuiApplication_DisconnectPaletteChanged(void* ptr);
+void QGuiApplication_PaletteChanged(void* ptr, void* palette);
 void* QGuiApplication_QGuiApplication_PrimaryScreen();
 void QGuiApplication_ConnectScreenAdded(void* ptr);
 void QGuiApplication_DisconnectScreenAdded(void* ptr);
@@ -784,6 +803,10 @@ int QIcon_IsNull(void* ptr);
 char* QIcon_Name(void* ptr);
 void QIcon_Paint(void* ptr, void* painter, void* rect, int alignment, int mode, int state);
 void QIcon_Paint2(void* ptr, void* painter, int x, int y, int w, int h, int alignment, int mode, int state);
+void* QIcon_Pixmap2(void* ptr, void* window, void* size, int mode, int state);
+void* QIcon_Pixmap(void* ptr, void* size, int mode, int state);
+void* QIcon_Pixmap4(void* ptr, int extent, int mode, int state);
+void* QIcon_Pixmap3(void* ptr, int w, int h, int mode, int state);
 void QIcon_QIcon_SetThemeName(char* name);
 void QIcon_QIcon_SetThemeSearchPaths(char* paths);
 void QIcon_Swap(void* ptr, void* other);
@@ -795,12 +818,16 @@ void* QIconEngine_ActualSize(void* ptr, void* size, int mode, int state);
 void* QIconEngine_ActualSizeDefault(void* ptr, void* size, int mode, int state);
 void QIconEngine_AddFile(void* ptr, char* fileName, void* size, int mode, int state);
 void QIconEngine_AddFileDefault(void* ptr, char* fileName, void* size, int mode, int state);
+void QIconEngine_AddPixmap(void* ptr, void* pixmap, int mode, int state);
+void QIconEngine_AddPixmapDefault(void* ptr, void* pixmap, int mode, int state);
 void* QIconEngine_Clone(void* ptr);
 char* QIconEngine_IconName(void* ptr);
 char* QIconEngine_IconNameDefault(void* ptr);
 char* QIconEngine_Key(void* ptr);
 char* QIconEngine_KeyDefault(void* ptr);
 void QIconEngine_Paint(void* ptr, void* painter, void* rect, int mode, int state);
+void* QIconEngine_Pixmap(void* ptr, void* size, int mode, int state);
+void* QIconEngine_PixmapDefault(void* ptr, void* size, int mode, int state);
 int QIconEngine_Read(void* ptr, void* in);
 int QIconEngine_ReadDefault(void* ptr, void* in);
 void QIconEngine_Virtual_hook(void* ptr, int id, void* data);
@@ -817,12 +844,16 @@ void QIconEnginePlugin_ChildEventDefault(void* ptr, void* event);
 void QIconEnginePlugin_CustomEvent(void* ptr, void* event);
 void QIconEnginePlugin_CustomEventDefault(void* ptr, void* event);
 int QImage_ColorCount(void* ptr);
+void* QImage_Copy(void* ptr, void* rectangle);
 void QImage_Fill2(void* ptr, int color);
 void QImage_Fill3(void* ptr, void* color);
 int QImage_Height(void* ptr);
 int QImage_IsNull(void* ptr);
 void* QImage_Offset(void* ptr);
 void* QImage_Rect(void* ptr);
+void* QImage_Scaled(void* ptr, void* size, int aspectRatioMode, int transformMode);
+void* QImage_ScaledToHeight(void* ptr, int height, int mode);
+void* QImage_ScaledToWidth(void* ptr, int width, int mode);
 void QImage_SetOffset(void* ptr, void* offset);
 void QImage_SetText(void* ptr, char* key, char* text);
 void* QImage_Size(void* ptr);
@@ -838,21 +869,26 @@ int QImage_BitPlaneCount(void* ptr);
 int QImage_ByteCount(void* ptr);
 int QImage_BytesPerLine(void* ptr);
 long long QImage_CacheKey(void* ptr);
+void* QImage_Copy2(void* ptr, int x, int y, int width, int height);
+void* QImage_CreateAlphaMask(void* ptr, int flags);
+void* QImage_CreateHeuristicMask(void* ptr, int clipTight);
 int QImage_Depth(void* ptr);
 double QImage_DevicePixelRatio(void* ptr);
 int QImage_DotsPerMeterX(void* ptr);
 int QImage_DotsPerMeterY(void* ptr);
 int QImage_Format(void* ptr);
+void* QImage_QImage_FromData2(char* data, char* format);
 int QImage_HasAlphaChannel(void* ptr);
 void QImage_InvertPixels(void* ptr, int mode);
 int QImage_IsGrayscale(void* ptr);
 int QImage_Load2(void* ptr, void* device, char* format);
 int QImage_Load(void* ptr, char* fileName, char* format);
-int QImage_LoadFromData2(void* ptr, void* data, char* format);
+int QImage_LoadFromData2(void* ptr, char* data, char* format);
 int QImage_PixelIndex(void* ptr, void* position);
 int QImage_PixelIndex2(void* ptr, int x, int y);
 int QImage_Save2(void* ptr, void* device, char* format, int quality);
 int QImage_Save(void* ptr, char* fileName, char* format, int quality);
+void* QImage_Scaled2(void* ptr, int width, int height, int aspectRatioMode, int transformMode);
 void QImage_SetColorCount(void* ptr, int colorCount);
 void QImage_SetDevicePixelRatio(void* ptr, double scaleFactor);
 void QImage_SetDotsPerMeterX(void* ptr, int x);
@@ -861,9 +897,13 @@ void QImage_Swap(void* ptr, void* other);
 char* QImage_Text(void* ptr, char* key);
 char* QImage_TextKeys(void* ptr);
 int QImage_QImage_ToImageFormat(void* format);
+void* QImage_Transformed2(void* ptr, void* matrix, int mode);
 int QImage_Valid(void* ptr, void* pos);
 int QImage_Valid2(void* ptr, int x, int y);
 void QImage_DestroyQImage(void* ptr);
+void* QImage_ConvertToFormat(void* ptr, int format, int flags);
+void* QImage_Mirrored(void* ptr, int horizontal, int vertical);
+void* QImage_RgbSwapped(void* ptr);
 void QImageIOPlugin_TimerEvent(void* ptr, void* event);
 void QImageIOPlugin_TimerEventDefault(void* ptr, void* event);
 void QImageIOPlugin_ChildEvent(void* ptr, void* event);
@@ -871,8 +911,8 @@ void QImageIOPlugin_ChildEventDefault(void* ptr, void* event);
 void QImageIOPlugin_CustomEvent(void* ptr, void* event);
 void QImageIOPlugin_CustomEventDefault(void* ptr, void* event);
 void* QImageReader_NewQImageReader();
-void* QImageReader_NewQImageReader2(void* device, void* format);
-void* QImageReader_NewQImageReader3(char* fileName, void* format);
+void* QImageReader_NewQImageReader2(void* device, char* format);
+void* QImageReader_NewQImageReader3(char* fileName, char* format);
 int QImageReader_AutoDetectImageFormat(void* ptr);
 int QImageReader_AutoTransform(void* ptr);
 void* QImageReader_BackgroundColor(void* ptr);
@@ -885,16 +925,17 @@ void* QImageReader_Device(void* ptr);
 int QImageReader_Error(void* ptr);
 char* QImageReader_ErrorString(void* ptr);
 char* QImageReader_FileName(void* ptr);
-void* QImageReader_Format(void* ptr);
+char* QImageReader_Format(void* ptr);
 int QImageReader_ImageCount(void* ptr);
-void* QImageReader_QImageReader_ImageFormat3(void* device);
-void* QImageReader_QImageReader_ImageFormat2(char* fileName);
+char* QImageReader_QImageReader_ImageFormat3(void* device);
+char* QImageReader_QImageReader_ImageFormat2(char* fileName);
 int QImageReader_ImageFormat(void* ptr);
 int QImageReader_JumpToImage(void* ptr, int imageNumber);
 int QImageReader_JumpToNextImage(void* ptr);
 int QImageReader_LoopCount(void* ptr);
 int QImageReader_NextImageDelay(void* ptr);
 int QImageReader_Quality(void* ptr);
+void* QImageReader_Read(void* ptr);
 int QImageReader_Read2(void* ptr, void* image);
 void* QImageReader_ScaledClipRect(void* ptr);
 void* QImageReader_ScaledSize(void* ptr);
@@ -905,12 +946,12 @@ void QImageReader_SetClipRect(void* ptr, void* rect);
 void QImageReader_SetDecideFormatFromContent(void* ptr, int ignored);
 void QImageReader_SetDevice(void* ptr, void* device);
 void QImageReader_SetFileName(void* ptr, char* fileName);
-void QImageReader_SetFormat(void* ptr, void* format);
+void QImageReader_SetFormat(void* ptr, char* format);
 void QImageReader_SetQuality(void* ptr, int quality);
 void QImageReader_SetScaledClipRect(void* ptr, void* rect);
 void QImageReader_SetScaledSize(void* ptr, void* size);
 void* QImageReader_Size(void* ptr);
-void* QImageReader_SubType(void* ptr);
+char* QImageReader_SubType(void* ptr);
 int QImageReader_SupportsAnimation(void* ptr);
 int QImageReader_SupportsOption(void* ptr, int option);
 char* QImageReader_Text(void* ptr, char* key);
@@ -918,29 +959,29 @@ char* QImageReader_TextKeys(void* ptr);
 int QImageReader_Transformation(void* ptr);
 void QImageReader_DestroyQImageReader(void* ptr);
 void* QImageWriter_NewQImageWriter();
-void* QImageWriter_NewQImageWriter2(void* device, void* format);
-void* QImageWriter_NewQImageWriter3(char* fileName, void* format);
+void* QImageWriter_NewQImageWriter2(void* device, char* format);
+void* QImageWriter_NewQImageWriter3(char* fileName, char* format);
 int QImageWriter_CanWrite(void* ptr);
 int QImageWriter_Compression(void* ptr);
 void* QImageWriter_Device(void* ptr);
 int QImageWriter_Error(void* ptr);
 char* QImageWriter_ErrorString(void* ptr);
 char* QImageWriter_FileName(void* ptr);
-void* QImageWriter_Format(void* ptr);
+char* QImageWriter_Format(void* ptr);
 int QImageWriter_OptimizedWrite(void* ptr);
 int QImageWriter_ProgressiveScanWrite(void* ptr);
 int QImageWriter_Quality(void* ptr);
 void QImageWriter_SetCompression(void* ptr, int compression);
 void QImageWriter_SetDevice(void* ptr, void* device);
 void QImageWriter_SetFileName(void* ptr, char* fileName);
-void QImageWriter_SetFormat(void* ptr, void* format);
+void QImageWriter_SetFormat(void* ptr, char* format);
 void QImageWriter_SetOptimizedWrite(void* ptr, int optimize);
 void QImageWriter_SetProgressiveScanWrite(void* ptr, int progressive);
 void QImageWriter_SetQuality(void* ptr, int quality);
-void QImageWriter_SetSubType(void* ptr, void* ty);
+void QImageWriter_SetSubType(void* ptr, char* ty);
 void QImageWriter_SetText(void* ptr, char* key, char* text);
 void QImageWriter_SetTransformation(void* ptr, int transform);
-void* QImageWriter_SubType(void* ptr);
+char* QImageWriter_SubType(void* ptr);
 int QImageWriter_SupportsOption(void* ptr, int option);
 int QImageWriter_Transformation(void* ptr);
 int QImageWriter_Write(void* ptr, void* image);
@@ -949,6 +990,7 @@ int QInputEvent_Modifiers(void* ptr);
 int QInputMethod_InputDirection(void* ptr);
 int QInputMethod_IsAnimating(void* ptr);
 int QInputMethod_IsVisible(void* ptr);
+void* QInputMethod_Locale(void* ptr);
 void QInputMethod_ConnectAnimatingChanged(void* ptr);
 void QInputMethod_DisconnectAnimatingChanged(void* ptr);
 void QInputMethod_AnimatingChanged(void* ptr);
@@ -1021,8 +1063,10 @@ void* QKeySequence_NewQKeySequence4(void* keysequence);
 void* QKeySequence_NewQKeySequence2(char* key, int format);
 void* QKeySequence_NewQKeySequence3(int k1, int k2, int k3, int k4);
 int QKeySequence_Count(void* ptr);
+void* QKeySequence_QKeySequence_FromString(char* str, int format);
 int QKeySequence_IsEmpty(void* ptr);
 int QKeySequence_Matches(void* ptr, void* seq);
+void* QKeySequence_QKeySequence_Mnemonic(char* text);
 void QKeySequence_Swap(void* ptr, void* other);
 char* QKeySequence_ToString(void* ptr, int format);
 void QKeySequence_DestroyQKeySequence(void* ptr);
@@ -1070,11 +1114,13 @@ int QMovie_CacheMode(void* ptr);
 void QMovie_SetCacheMode(void* ptr, int mode);
 void QMovie_SetSpeed(void* ptr, int percentSpeed);
 int QMovie_Speed(void* ptr);
-void* QMovie_NewQMovie2(void* device, void* format, void* parent);
+void* QMovie_NewQMovie2(void* device, char* format, void* parent);
 void* QMovie_NewQMovie(void* parent);
-void* QMovie_NewQMovie3(char* fileName, void* format, void* parent);
+void* QMovie_NewQMovie3(char* fileName, char* format, void* parent);
 void* QMovie_BackgroundColor(void* ptr);
 int QMovie_CurrentFrameNumber(void* ptr);
+void* QMovie_CurrentImage(void* ptr);
+void* QMovie_CurrentPixmap(void* ptr);
 void* QMovie_Device(void* ptr);
 void QMovie_ConnectError(void* ptr);
 void QMovie_DisconnectError(void* ptr);
@@ -1083,7 +1129,7 @@ char* QMovie_FileName(void* ptr);
 void QMovie_ConnectFinished(void* ptr);
 void QMovie_DisconnectFinished(void* ptr);
 void QMovie_Finished(void* ptr);
-void* QMovie_Format(void* ptr);
+char* QMovie_Format(void* ptr);
 void QMovie_ConnectFrameChanged(void* ptr);
 void QMovie_DisconnectFrameChanged(void* ptr);
 void QMovie_FrameChanged(void* ptr, int frameNumber);
@@ -1101,7 +1147,7 @@ void* QMovie_ScaledSize(void* ptr);
 void QMovie_SetBackgroundColor(void* ptr, void* color);
 void QMovie_SetDevice(void* ptr, void* device);
 void QMovie_SetFileName(void* ptr, char* fileName);
-void QMovie_SetFormat(void* ptr, void* format);
+void QMovie_SetFormat(void* ptr, char* format);
 void QMovie_SetPaused(void* ptr, int paused);
 void QMovie_SetScaledSize(void* ptr, void* size);
 void QMovie_Start(void* ptr);
@@ -1130,7 +1176,10 @@ double QNativeGestureEvent_Value(void* ptr);
 void* QOffscreenSurface_NewQOffscreenSurface(void* targetScreen);
 void QOffscreenSurface_Create(void* ptr);
 void QOffscreenSurface_Destroy(void* ptr);
+void* QOffscreenSurface_Format(void* ptr);
+void* QOffscreenSurface_FormatDefault(void* ptr);
 int QOffscreenSurface_IsValid(void* ptr);
+void* QOffscreenSurface_RequestedFormat(void* ptr);
 void* QOffscreenSurface_Screen(void* ptr);
 void QOffscreenSurface_ConnectScreenChanged(void* ptr);
 void QOffscreenSurface_DisconnectScreenChanged(void* ptr);
@@ -1245,6 +1294,7 @@ int QPageLayout_IsEquivalentTo(void* ptr, void* other);
 int QPageLayout_IsValid(void* ptr);
 int QPageLayout_Mode(void* ptr);
 int QPageLayout_Orientation(void* ptr);
+void* QPageLayout_PageSize(void* ptr);
 void* QPageLayout_PaintRectPixels(void* ptr, int resolution);
 void* QPageLayout_PaintRectPoints(void* ptr);
 int QPageLayout_SetBottomMargin(void* ptr, double bottomMargin);
@@ -1288,6 +1338,7 @@ int QPageSize_QPageSize_WindowsId2(int pageSizeId);
 int QPageSize_WindowsId(void* ptr);
 void QPageSize_DestroyQPageSize(void* ptr);
 int QPagedPaintDevice_NewPage(void* ptr);
+void* QPagedPaintDevice_PageLayout(void* ptr);
 int QPagedPaintDevice_PageSize(void* ptr);
 int QPagedPaintDevice_SetPageLayout(void* ptr, void* newPageLayout);
 int QPagedPaintDevice_SetPageMargins(void* ptr, void* margins);
@@ -1363,6 +1414,8 @@ void QPaintEngine_DrawPolygonDefault(void* ptr, void* points, int pointCount, in
 int QPaintEngine_Begin(void* ptr, void* pdev);
 void QPaintEngine_DrawLines(void* ptr, void* lines, int lineCount);
 void QPaintEngine_DrawLinesDefault(void* ptr, void* lines, int lineCount);
+void QPaintEngine_DrawPath(void* ptr, void* path);
+void QPaintEngine_DrawPathDefault(void* ptr, void* path);
 void QPaintEngine_DrawPixmap(void* ptr, void* r, void* pm, void* sr);
 void QPaintEngine_DrawPoints(void* ptr, void* points, int pointCount);
 void QPaintEngine_DrawPointsDefault(void* ptr, void* points, int pointCount);
@@ -1384,11 +1437,14 @@ int QPaintEngineState_BackgroundMode(void* ptr);
 void* QPaintEngineState_Brush(void* ptr);
 int QPaintEngineState_BrushNeedsResolving(void* ptr);
 int QPaintEngineState_ClipOperation(void* ptr);
+void* QPaintEngineState_ClipPath(void* ptr);
 void* QPaintEngineState_ClipRegion(void* ptr);
 int QPaintEngineState_CompositionMode(void* ptr);
+void* QPaintEngineState_Font(void* ptr);
 int QPaintEngineState_IsClipEnabled(void* ptr);
 double QPaintEngineState_Opacity(void* ptr);
 void* QPaintEngineState_Painter(void* ptr);
+void* QPaintEngineState_Pen(void* ptr);
 int QPaintEngineState_PenNeedsResolving(void* ptr);
 int QPaintEngineState_RenderHints(void* ptr);
 int QPaintEngineState_State(void* ptr);
@@ -1441,6 +1497,7 @@ void QPainter_BeginNativePainting(void* ptr);
 void* QPainter_BoundingRect3(void* ptr, int x, int y, int w, int h, int flags, char* text);
 void* QPainter_Brush(void* ptr);
 void* QPainter_BrushOrigin(void* ptr);
+void* QPainter_ClipPath(void* ptr);
 void* QPainter_ClipRegion(void* ptr);
 int QPainter_CompositionMode(void* ptr);
 void* QPainter_Device(void* ptr);
@@ -1524,11 +1581,15 @@ void QPainter_FillRect2(void* ptr, int x, int y, int width, int height, int styl
 void QPainter_FillRect10(void* ptr, int x, int y, int width, int height, int color);
 void QPainter_FillRect8(void* ptr, int x, int y, int width, int height, void* brush);
 void QPainter_FillRect9(void* ptr, int x, int y, int width, int height, void* color);
+void* QPainter_Font(void* ptr);
+void* QPainter_FontInfo(void* ptr);
+void* QPainter_FontMetrics(void* ptr);
 int QPainter_HasClipping(void* ptr);
 int QPainter_IsActive(void* ptr);
 int QPainter_LayoutDirection(void* ptr);
 double QPainter_Opacity(void* ptr);
 void* QPainter_PaintEngine(void* ptr);
+void* QPainter_Pen(void* ptr);
 int QPainter_RenderHints(void* ptr);
 void QPainter_ResetTransform(void* ptr);
 void QPainter_Restore(void* ptr);
@@ -1603,20 +1664,29 @@ void QPainterPath_CloseSubpath(void* ptr);
 int QPainterPath_Contains3(void* ptr, void* p);
 void QPainterPath_CubicTo2(void* ptr, double c1X, double c1Y, double c2X, double c2Y, double endPointX, double endPointY);
 int QPainterPath_FillRule(void* ptr);
+void* QPainterPath_Intersected(void* ptr, void* p);
 int QPainterPath_Intersects2(void* ptr, void* p);
 double QPainterPath_Length(void* ptr);
 void QPainterPath_LineTo2(void* ptr, double x, double y);
 void QPainterPath_MoveTo2(void* ptr, double x, double y);
 double QPainterPath_PercentAtLength(void* ptr, double len);
 void QPainterPath_QuadTo2(void* ptr, double cx, double cy, double endPointX, double endPointY);
+void* QPainterPath_Simplified(void* ptr);
 double QPainterPath_SlopeAtPercent(void* ptr, double t);
+void* QPainterPath_Subtracted(void* ptr, void* p);
 void QPainterPath_Swap(void* ptr, void* other);
+void* QPainterPath_ToFillPolygon(void* ptr, void* matrix);
+void* QPainterPath_ToReversed(void* ptr);
 void QPainterPath_Translate2(void* ptr, void* offset);
 void QPainterPath_Translate(void* ptr, double dx, double dy);
+void* QPainterPath_Translated2(void* ptr, void* offset);
+void* QPainterPath_Translated(void* ptr, double dx, double dy);
+void* QPainterPath_United(void* ptr, void* p);
 void QPainterPath_DestroyQPainterPath(void* ptr);
 void* QPainterPathStroker_NewQPainterPathStroker();
 void* QPainterPathStroker_NewQPainterPathStroker2(void* pen);
 int QPainterPathStroker_CapStyle(void* ptr);
+void* QPainterPathStroker_CreateStroke(void* ptr, void* path);
 double QPainterPathStroker_CurveThreshold(void* ptr);
 double QPainterPathStroker_DashOffset(void* ptr);
 int QPainterPathStroker_JoinStyle(void* ptr);
@@ -1661,6 +1731,7 @@ void* QPalette_Link(void* ptr);
 void* QPalette_LinkVisited(void* ptr);
 void* QPalette_Mid(void* ptr);
 void* QPalette_Midlight(void* ptr);
+void* QPalette_Resolve(void* ptr, void* other);
 void QPalette_SetBrush(void* ptr, int role, void* brush);
 void QPalette_SetColor(void* ptr, int group, int role, void* color);
 void QPalette_SetColor2(void* ptr, int role, void* color);
@@ -1679,6 +1750,7 @@ void* QPdfWriter_NewQPdfWriter(char* filename);
 char* QPdfWriter_Creator(void* ptr);
 int QPdfWriter_NewPage(void* ptr);
 int QPdfWriter_NewPageDefault(void* ptr);
+void* QPdfWriter_PageLayout(void* ptr);
 void* QPdfWriter_PaintEngine(void* ptr);
 void* QPdfWriter_PaintEngineDefault(void* ptr);
 int QPdfWriter_Resolution(void* ptr);
@@ -1750,11 +1822,17 @@ int QPixelFormat_Premultiplied(void* ptr);
 int QPixelFormat_TypeInterpretation(void* ptr);
 int QPixelFormat_YuvLayout(void* ptr);
 void* QPixmap_NewQPixmap3(int width, int height);
+void* QPixmap_Copy(void* ptr, void* rectangle);
 int QPixmap_Depth(void* ptr);
+void* QPixmap_QPixmap_FromImage(void* image, int flags);
+void* QPixmap_QPixmap_FromImageReader(void* imageReader, int flags);
 int QPixmap_Height(void* ptr);
 int QPixmap_IsNull(void* ptr);
 int QPixmap_IsQBitmap(void* ptr);
 void* QPixmap_Rect(void* ptr);
+void* QPixmap_Scaled(void* ptr, void* size, int aspectRatioMode, int transformMode);
+void* QPixmap_ScaledToHeight(void* ptr, int height, int mode);
+void* QPixmap_ScaledToWidth(void* ptr, int width, int mode);
 void* QPixmap_Size(void* ptr);
 int QPixmap_Width(void* ptr);
 void* QPixmap_NewQPixmap();
@@ -1763,21 +1841,26 @@ void* QPixmap_NewQPixmap8(void* size);
 void* QPixmap_NewQPixmap4(char* fileName, char* format, int flags);
 long long QPixmap_CacheKey(void* ptr);
 int QPixmap_ConvertFromImage(void* ptr, void* image, int flags);
+void* QPixmap_Copy2(void* ptr, int x, int y, int width, int height);
 int QPixmap_QPixmap_DefaultDepth();
 void QPixmap_Detach(void* ptr);
 double QPixmap_DevicePixelRatio(void* ptr);
 void QPixmap_Fill(void* ptr, void* color);
+void* QPixmap_QPixmap_FromImage2(void* image, int flags);
 int QPixmap_HasAlpha(void* ptr);
 int QPixmap_HasAlphaChannel(void* ptr);
 int QPixmap_Load(void* ptr, char* fileName, char* format, int flags);
-int QPixmap_LoadFromData2(void* ptr, void* data, char* format, int flags);
+int QPixmap_LoadFromData2(void* ptr, char* data, char* format, int flags);
 int QPixmap_Save2(void* ptr, void* device, char* format, int quality);
 int QPixmap_Save(void* ptr, char* fileName, char* format, int quality);
+void* QPixmap_Scaled2(void* ptr, int width, int height, int aspectRatioMode, int transformMode);
 void QPixmap_Scroll2(void* ptr, int dx, int dy, void* rect, void* exposed);
 void QPixmap_Scroll(void* ptr, int dx, int dy, int x, int y, int width, int height, void* exposed);
 void QPixmap_SetDevicePixelRatio(void* ptr, double scaleFactor);
 void QPixmap_SetMask(void* ptr, void* mask);
 void QPixmap_Swap(void* ptr, void* other);
+void* QPixmap_ToImage(void* ptr);
+void* QPixmap_Transformed(void* ptr, void* transform, int mode);
 void QPixmap_DestroyQPixmap(void* ptr);
 int QPixmapCache_QPixmapCache_CacheLimit();
 void QPixmapCache_QPixmapCache_Clear();
@@ -1803,14 +1886,19 @@ void* QPolygon_NewQPolygon();
 void* QPolygon_NewQPolygon3(void* polygon);
 void* QPolygon_NewQPolygon2(int size);
 void* QPolygon_BoundingRect(void* ptr);
+void* QPolygon_Intersected(void* ptr, void* r);
 void* QPolygon_Point2(void* ptr, int index);
 void QPolygon_Point(void* ptr, int index, int x, int y);
 void QPolygon_SetPoint2(void* ptr, int index, void* point);
 void QPolygon_SetPoint(void* ptr, int index, int x, int y);
 void QPolygon_SetPoints(void* ptr, int nPoints, int points);
+void* QPolygon_Subtracted(void* ptr, void* r);
 void QPolygon_Swap(void* ptr, void* other);
 void QPolygon_Translate2(void* ptr, void* offset);
 void QPolygon_Translate(void* ptr, int dx, int dy);
+void* QPolygon_Translated2(void* ptr, void* offset);
+void* QPolygon_Translated(void* ptr, int dx, int dy);
+void* QPolygon_United(void* ptr, void* r);
 void QPolygon_DestroyQPolygon(void* ptr);
 void* QPolygonF_NewQPolygonF6(void* polygon);
 void* QPolygonF_NewQPolygonF5(void* rectangle);
@@ -1818,10 +1906,16 @@ int QPolygonF_ContainsPoint(void* ptr, void* point, int fillRule);
 void* QPolygonF_NewQPolygonF();
 void* QPolygonF_NewQPolygonF3(void* polygon);
 void* QPolygonF_NewQPolygonF2(int size);
+void* QPolygonF_Intersected(void* ptr, void* r);
 int QPolygonF_IsClosed(void* ptr);
+void* QPolygonF_Subtracted(void* ptr, void* r);
 void QPolygonF_Swap(void* ptr, void* other);
+void* QPolygonF_ToPolygon(void* ptr);
 void QPolygonF_Translate(void* ptr, void* offset);
 void QPolygonF_Translate2(void* ptr, double dx, double dy);
+void* QPolygonF_Translated(void* ptr, void* offset);
+void* QPolygonF_Translated2(void* ptr, double dx, double dy);
+void* QPolygonF_United(void* ptr, void* r);
 void QPolygonF_DestroyQPolygonF(void* ptr);
 void* QQuaternion_NewQQuaternion();
 void* QQuaternion_NewQQuaternion5(void* vector);
@@ -1851,6 +1945,8 @@ void QRasterPaintEngine_DrawPolygon(void* ptr, void* points, int pointCount, int
 void QRasterPaintEngine_DrawPolygonDefault(void* ptr, void* points, int pointCount, int mode);
 void QRasterPaintEngine_DrawLines(void* ptr, void* lines, int lineCount);
 void QRasterPaintEngine_DrawLinesDefault(void* ptr, void* lines, int lineCount);
+void QRasterPaintEngine_DrawPath(void* ptr, void* path);
+void QRasterPaintEngine_DrawPathDefault(void* ptr, void* path);
 void QRasterPaintEngine_DrawPoints(void* ptr, void* points, int pointCount);
 void QRasterPaintEngine_DrawPointsDefault(void* ptr, void* points, int pointCount);
 void QRasterPaintEngine_DrawRects(void* ptr, void* rects, int rectCount);
@@ -1897,19 +1993,20 @@ void QRasterWindow_ChildEventDefault(void* ptr, void* event);
 void QRasterWindow_CustomEvent(void* ptr, void* event);
 void QRasterWindow_CustomEventDefault(void* ptr, void* event);
 void* QRawFont_NewQRawFont();
-void* QRawFont_NewQRawFont3(void* fontData, double pixelSize, int hintingPreference);
+void* QRawFont_NewQRawFont3(char* fontData, double pixelSize, int hintingPreference);
 void* QRawFont_NewQRawFont4(void* other);
 void* QRawFont_NewQRawFont2(char* fileName, double pixelSize, int hintingPreference);
 double QRawFont_Ascent(void* ptr);
 double QRawFont_AverageCharWidth(void* ptr);
 double QRawFont_Descent(void* ptr);
 char* QRawFont_FamilyName(void* ptr);
-void* QRawFont_FontTable(void* ptr, char* tagName);
+char* QRawFont_FontTable(void* ptr, char* tagName);
+void* QRawFont_QRawFont_FromFont(void* font, int writingSystem);
 int QRawFont_HintingPreference(void* ptr);
 int QRawFont_IsValid(void* ptr);
 double QRawFont_Leading(void* ptr);
 double QRawFont_LineThickness(void* ptr);
-void QRawFont_LoadFromData(void* ptr, void* fontData, double pixelSize, int hintingPreference);
+void QRawFont_LoadFromData(void* ptr, char* fontData, double pixelSize, int hintingPreference);
 void QRawFont_LoadFromFile(void* ptr, char* fileName, double pixelSize, int hintingPreference);
 double QRawFont_MaxCharWidth(void* ptr);
 double QRawFont_PixelSize(void* ptr);
@@ -2005,6 +2102,7 @@ void QScreen_AvailableGeometryChanged(void* ptr, void* geometry);
 void QScreen_ConnectGeometryChanged(void* ptr);
 void QScreen_DisconnectGeometryChanged(void* ptr);
 void QScreen_GeometryChanged(void* ptr, void* geometry);
+void* QScreen_GrabWindow(void* ptr, unsigned long long window, int x, int y, int width, int height);
 int QScreen_IsLandscape(void* ptr, int o);
 int QScreen_IsPortrait(void* ptr, int o);
 void QScreen_ConnectLogicalDotsPerInchChanged(void* ptr);
@@ -2067,6 +2165,7 @@ void QSessionManager_CustomEvent(void* ptr, void* event);
 void QSessionManager_CustomEventDefault(void* ptr, void* event);
 void* QShortcutEvent_NewQShortcutEvent(void* key, int id, int ambiguous);
 int QShortcutEvent_IsAmbiguous(void* ptr);
+void* QShortcutEvent_Key(void* ptr);
 int QShortcutEvent_ShortcutId(void* ptr);
 void QShortcutEvent_DestroyQShortcutEvent(void* ptr);
 void* QShowEvent_NewQShowEvent();
@@ -2087,10 +2186,10 @@ int QStandardItem_ColumnCount(void* ptr);
 void* QStandardItem_Data(void* ptr, int role);
 void* QStandardItem_DataDefault(void* ptr, int role);
 int QStandardItem_Flags(void* ptr);
+void* QStandardItem_Font(void* ptr);
 void* QStandardItem_Foreground(void* ptr);
 int QStandardItem_HasChildren(void* ptr);
 void* QStandardItem_Icon(void* ptr);
-void* QStandardItem_Index(void* ptr);
 void QStandardItem_InsertColumns(void* ptr, int column, int count);
 void QStandardItem_InsertRow2(void* ptr, int row, void* item);
 void QStandardItem_InsertRows2(void* ptr, int row, int count);
@@ -2168,9 +2267,6 @@ int QStandardItemModel_HasChildrenDefault(void* ptr, void* parent);
 void* QStandardItemModel_HeaderData(void* ptr, int section, int orientation, int role);
 void* QStandardItemModel_HeaderDataDefault(void* ptr, int section, int orientation, int role);
 void* QStandardItemModel_HorizontalHeaderItem(void* ptr, int column);
-void* QStandardItemModel_Index(void* ptr, int row, int column, void* parent);
-void* QStandardItemModel_IndexDefault(void* ptr, int row, int column, void* parent);
-void* QStandardItemModel_IndexFromItem(void* ptr, void* item);
 int QStandardItemModel_InsertColumn2(void* ptr, int column, void* parent);
 int QStandardItemModel_InsertColumns(void* ptr, int column, int count, void* parent);
 int QStandardItemModel_InsertColumnsDefault(void* ptr, int column, int count, void* parent);
@@ -2187,8 +2283,6 @@ void* QStandardItemModel_ItemFromIndex(void* ptr, void* index);
 void* QStandardItemModel_ItemPrototype(void* ptr);
 char* QStandardItemModel_MimeTypes(void* ptr);
 char* QStandardItemModel_MimeTypesDefault(void* ptr);
-void* QStandardItemModel_Parent(void* ptr, void* child);
-void* QStandardItemModel_ParentDefault(void* ptr, void* child);
 int QStandardItemModel_RemoveColumns(void* ptr, int column, int count, void* parent);
 int QStandardItemModel_RemoveColumnsDefault(void* ptr, int column, int count, void* parent);
 int QStandardItemModel_RemoveRows(void* ptr, int row, int count, void* parent);
@@ -2208,8 +2302,6 @@ void QStandardItemModel_SetItemPrototype(void* ptr, void* item);
 void QStandardItemModel_SetRowCount(void* ptr, int rows);
 void QStandardItemModel_SetVerticalHeaderItem(void* ptr, int row, void* item);
 void QStandardItemModel_SetVerticalHeaderLabels(void* ptr, char* labels);
-void* QStandardItemModel_Sibling(void* ptr, int row, int column, void* idx);
-void* QStandardItemModel_SiblingDefault(void* ptr, int row, int column, void* idx);
 void QStandardItemModel_Sort(void* ptr, int column, int order);
 void QStandardItemModel_SortDefault(void* ptr, int column, int order);
 int QStandardItemModel_SupportedDropActions(void* ptr);
@@ -2219,8 +2311,6 @@ void* QStandardItemModel_TakeItem(void* ptr, int row, int column);
 void* QStandardItemModel_TakeVerticalHeaderItem(void* ptr, int row);
 void* QStandardItemModel_VerticalHeaderItem(void* ptr, int row);
 void QStandardItemModel_DestroyQStandardItemModel(void* ptr);
-void QStandardItemModel_FetchMore(void* ptr, void* parent);
-void QStandardItemModel_FetchMoreDefault(void* ptr, void* parent);
 void QStandardItemModel_Revert(void* ptr);
 void QStandardItemModel_RevertDefault(void* ptr);
 void QStandardItemModel_TimerEvent(void* ptr, void* event);
@@ -2242,6 +2332,7 @@ void QStaticText_SetTextWidth(void* ptr, double textWidth);
 void QStaticText_Swap(void* ptr, void* other);
 char* QStaticText_Text(void* ptr);
 int QStaticText_TextFormat(void* ptr);
+void* QStaticText_TextOption(void* ptr);
 double QStaticText_TextWidth(void* ptr);
 void QStaticText_DestroyQStaticText(void* ptr);
 void* QStatusTipEvent_NewQStatusTipEvent(char* tip);
@@ -2282,6 +2373,7 @@ void QStyleHints_ChildEvent(void* ptr, void* event);
 void QStyleHints_ChildEventDefault(void* ptr, void* event);
 void QStyleHints_CustomEvent(void* ptr, void* event);
 void QStyleHints_CustomEventDefault(void* ptr, void* event);
+void* QSurface_Format(void* ptr);
 void* QSurface_Size(void* ptr);
 int QSurface_SupportsOpenGL(void* ptr);
 int QSurface_SurfaceClass(void* ptr);
@@ -2294,6 +2386,7 @@ void* QSurfaceFormat_NewQSurfaceFormat2(int options);
 void* QSurfaceFormat_NewQSurfaceFormat3(void* other);
 int QSurfaceFormat_AlphaBufferSize(void* ptr);
 int QSurfaceFormat_BlueBufferSize(void* ptr);
+void* QSurfaceFormat_QSurfaceFormat_DefaultFormat();
 int QSurfaceFormat_DepthBufferSize(void* ptr);
 int QSurfaceFormat_GreenBufferSize(void* ptr);
 int QSurfaceFormat_HasAlpha(void* ptr);
@@ -2372,7 +2465,9 @@ int QTextBlock_IsVisible(void* ptr);
 void* QTextBlock_Layout(void* ptr);
 int QTextBlock_Length(void* ptr);
 int QTextBlock_LineCount(void* ptr);
+void* QTextBlock_Next(void* ptr);
 int QTextBlock_Position(void* ptr);
+void* QTextBlock_Previous(void* ptr);
 int QTextBlock_Revision(void* ptr);
 void QTextBlock_SetLineCount(void* ptr, int count);
 void QTextBlock_SetRevision(void* ptr, int rev);
@@ -2408,6 +2503,12 @@ void QTextBlockFormat_SetTextIndent(void* ptr, double indent);
 void QTextBlockFormat_SetTopMargin(void* ptr, double margin);
 double QTextBlockFormat_TextIndent(void* ptr);
 double QTextBlockFormat_TopMargin(void* ptr);
+void QTextBlockGroup_BlockFormatChanged(void* ptr, void* block);
+void QTextBlockGroup_BlockFormatChangedDefault(void* ptr, void* block);
+void QTextBlockGroup_BlockInserted(void* ptr, void* block);
+void QTextBlockGroup_BlockInsertedDefault(void* ptr, void* block);
+void QTextBlockGroup_BlockRemoved(void* ptr, void* block);
+void QTextBlockGroup_BlockRemovedDefault(void* ptr, void* block);
 void QTextBlockGroup_TimerEvent(void* ptr, void* event);
 void QTextBlockGroup_TimerEventDefault(void* ptr, void* event);
 void QTextBlockGroup_ChildEvent(void* ptr, void* event);
@@ -2422,6 +2523,7 @@ char* QTextCharFormat_AnchorNames(void* ptr);
 int QTextCharFormat_FontUnderline(void* ptr);
 void QTextCharFormat_SetUnderlineStyle(void* ptr, int style);
 char* QTextCharFormat_AnchorHref(void* ptr);
+void* QTextCharFormat_Font(void* ptr);
 int QTextCharFormat_FontCapitalization(void* ptr);
 char* QTextCharFormat_FontFamily(void* ptr);
 int QTextCharFormat_FontFixedPitch(void* ptr);
@@ -2466,6 +2568,7 @@ void QTextCharFormat_SetTextOutline(void* ptr, void* pen);
 void QTextCharFormat_SetToolTip(void* ptr, char* text);
 void QTextCharFormat_SetUnderlineColor(void* ptr, void* color);
 void QTextCharFormat_SetVerticalAlignment(void* ptr, int alignment);
+void* QTextCharFormat_TextOutline(void* ptr);
 char* QTextCharFormat_ToolTip(void* ptr);
 void* QTextCharFormat_UnderlineColor(void* ptr);
 int QTextCharFormat_UnderlineStyle(void* ptr);
@@ -2486,6 +2589,7 @@ int QTextCursor_AtBlockStart(void* ptr);
 int QTextCursor_AtEnd(void* ptr);
 int QTextCursor_AtStart(void* ptr);
 void QTextCursor_BeginEditBlock(void* ptr);
+void* QTextCursor_Block(void* ptr);
 int QTextCursor_BlockNumber(void* ptr);
 void QTextCursor_ClearSelection(void* ptr);
 int QTextCursor_ColumnNumber(void* ptr);
@@ -2525,6 +2629,7 @@ void QTextCursor_RemoveSelectedText(void* ptr);
 void QTextCursor_Select(void* ptr, int selection);
 void QTextCursor_SelectedTableCells(void* ptr, int firstRow, int numRows, int firstColumn, int numColumns);
 char* QTextCursor_SelectedText(void* ptr);
+void* QTextCursor_Selection(void* ptr);
 int QTextCursor_SelectionEnd(void* ptr);
 int QTextCursor_SelectionStart(void* ptr);
 void QTextCursor_SetBlockCharFormat(void* ptr, void* format);
@@ -2569,6 +2674,7 @@ int QTextDocument_AvailableUndoSteps(void* ptr);
 void QTextDocument_ConnectBaseUrlChanged(void* ptr);
 void QTextDocument_DisconnectBaseUrlChanged(void* ptr);
 void QTextDocument_BaseUrlChanged(void* ptr, void* url);
+void* QTextDocument_Begin(void* ptr);
 void QTextDocument_ConnectBlockCountChanged(void* ptr);
 void QTextDocument_DisconnectBlockCountChanged(void* ptr);
 void QTextDocument_BlockCountChanged(void* ptr, int newBlockCount);
@@ -2583,16 +2689,27 @@ void QTextDocument_ContentsChange(void* ptr, int position, int charsRemoved, int
 void QTextDocument_ConnectContentsChanged(void* ptr);
 void QTextDocument_DisconnectContentsChanged(void* ptr);
 void QTextDocument_ContentsChanged(void* ptr);
+void QTextDocument_ConnectCursorPositionChanged(void* ptr);
+void QTextDocument_DisconnectCursorPositionChanged(void* ptr);
+void QTextDocument_CursorPositionChanged(void* ptr, void* cursor);
 int QTextDocument_DefaultCursorMoveStyle(void* ptr);
+void* QTextDocument_DefaultFont(void* ptr);
+void* QTextDocument_DefaultTextOption(void* ptr);
 void* QTextDocument_DocumentLayout(void* ptr);
 void QTextDocument_ConnectDocumentLayoutChanged(void* ptr);
 void QTextDocument_DisconnectDocumentLayoutChanged(void* ptr);
 void QTextDocument_DocumentLayoutChanged(void* ptr);
 void QTextDocument_DrawContents(void* ptr, void* p, void* rect);
+void* QTextDocument_End(void* ptr);
+void* QTextDocument_FindBlock(void* ptr, int pos);
+void* QTextDocument_FindBlockByLineNumber(void* ptr, int lineNumber);
+void* QTextDocument_FindBlockByNumber(void* ptr, int blockNumber);
+void* QTextDocument_FirstBlock(void* ptr);
 double QTextDocument_IdealWidth(void* ptr);
 int QTextDocument_IsEmpty(void* ptr);
 int QTextDocument_IsRedoAvailable(void* ptr);
 int QTextDocument_IsUndoAvailable(void* ptr);
+void* QTextDocument_LastBlock(void* ptr);
 int QTextDocument_LineCount(void* ptr);
 void* QTextDocument_LoadResource(void* ptr, int ty, void* name);
 void* QTextDocument_LoadResourceDefault(void* ptr, int ty, void* name);
@@ -2620,7 +2737,7 @@ void QTextDocument_SetHtml(void* ptr, char* html);
 void QTextDocument_SetIndentWidth(void* ptr, double width);
 void QTextDocument_SetMetaInformation(void* ptr, int info, char* stri);
 void QTextDocument_SetPlainText(void* ptr, char* text);
-char* QTextDocument_ToHtml(void* ptr, void* encoding);
+char* QTextDocument_ToHtml(void* ptr, char* encoding);
 char* QTextDocument_ToPlainText(void* ptr);
 void QTextDocument_Undo2(void* ptr);
 void QTextDocument_Undo(void* ptr, void* cursor);
@@ -2638,24 +2755,27 @@ void QTextDocument_ChildEventDefault(void* ptr, void* event);
 void QTextDocument_CustomEvent(void* ptr, void* event);
 void QTextDocument_CustomEventDefault(void* ptr, void* event);
 void* QTextDocumentFragment_NewQTextDocumentFragment4(void* other);
+void* QTextDocumentFragment_QTextDocumentFragment_FromHtml(char* text);
+void* QTextDocumentFragment_QTextDocumentFragment_FromHtml2(char* text, void* resourceProvider);
 void* QTextDocumentFragment_NewQTextDocumentFragment();
 void* QTextDocumentFragment_NewQTextDocumentFragment3(void* cursor);
 void* QTextDocumentFragment_NewQTextDocumentFragment2(void* document);
+void* QTextDocumentFragment_QTextDocumentFragment_FromPlainText(char* plainText);
 int QTextDocumentFragment_IsEmpty(void* ptr);
-char* QTextDocumentFragment_ToHtml(void* ptr, void* encoding);
+char* QTextDocumentFragment_ToHtml(void* ptr, char* encoding);
 char* QTextDocumentFragment_ToPlainText(void* ptr);
 void QTextDocumentFragment_DestroyQTextDocumentFragment(void* ptr);
 void* QTextDocumentWriter_NewQTextDocumentWriter();
-void* QTextDocumentWriter_NewQTextDocumentWriter2(void* device, void* format);
-void* QTextDocumentWriter_NewQTextDocumentWriter3(char* fileName, void* format);
+void* QTextDocumentWriter_NewQTextDocumentWriter2(void* device, char* format);
+void* QTextDocumentWriter_NewQTextDocumentWriter3(char* fileName, char* format);
 void* QTextDocumentWriter_Codec(void* ptr);
 void* QTextDocumentWriter_Device(void* ptr);
 char* QTextDocumentWriter_FileName(void* ptr);
-void* QTextDocumentWriter_Format(void* ptr);
+char* QTextDocumentWriter_Format(void* ptr);
 void QTextDocumentWriter_SetCodec(void* ptr, void* codec);
 void QTextDocumentWriter_SetDevice(void* ptr, void* device);
 void QTextDocumentWriter_SetFileName(void* ptr, char* fileName);
-void QTextDocumentWriter_SetFormat(void* ptr, void* format);
+void QTextDocumentWriter_SetFormat(void* ptr, char* format);
 int QTextDocumentWriter_Write(void* ptr, void* document);
 int QTextDocumentWriter_Write2(void* ptr, void* fragment);
 void QTextDocumentWriter_DestroyQTextDocumentWriter(void* ptr);
@@ -2687,6 +2807,7 @@ int QTextFormat_LayoutDirection(void* ptr);
 void QTextFormat_Merge(void* ptr, void* other);
 int QTextFormat_ObjectIndex(void* ptr);
 int QTextFormat_ObjectType(void* ptr);
+void* QTextFormat_PenProperty(void* ptr, int propertyId);
 void* QTextFormat_Property(void* ptr, int propertyId);
 int QTextFormat_PropertyCount(void* ptr);
 void QTextFormat_SetBackground(void* ptr, void* brush);
@@ -2707,7 +2828,9 @@ int QTextFragment_Length(void* ptr);
 int QTextFragment_Position(void* ptr);
 char* QTextFragment_Text(void* ptr);
 void* QTextFrame_NewQTextFrame(void* document);
+void* QTextFrame_FirstCursorPosition(void* ptr);
 int QTextFrame_FirstPosition(void* ptr);
+void* QTextFrame_LastCursorPosition(void* ptr);
 int QTextFrame_LastPosition(void* ptr);
 void* QTextFrame_ParentFrame(void* ptr);
 void QTextFrame_SetFrameFormat(void* ptr, void* format);
@@ -2756,6 +2879,7 @@ void QTextImageFormat_SetWidth(void* ptr, double width);
 double QTextImageFormat_Width(void* ptr);
 double QTextInlineObject_Ascent(void* ptr);
 double QTextInlineObject_Descent(void* ptr);
+void* QTextInlineObject_Format(void* ptr);
 int QTextInlineObject_FormatIndex(void* ptr);
 double QTextInlineObject_Height(void* ptr);
 int QTextInlineObject_IsValid(void* ptr);
@@ -2767,6 +2891,7 @@ int QTextInlineObject_TextPosition(void* ptr);
 double QTextInlineObject_Width(void* ptr);
 double QTextItem_Ascent(void* ptr);
 double QTextItem_Descent(void* ptr);
+void* QTextItem_Font(void* ptr);
 int QTextItem_RenderFlags(void* ptr);
 char* QTextItem_Text(void* ptr);
 double QTextItem_Width(void* ptr);
@@ -2781,6 +2906,7 @@ void QTextLayout_ClearAdditionalFormats(void* ptr);
 void QTextLayout_ClearLayout(void* ptr);
 int QTextLayout_CursorMoveStyle(void* ptr);
 void QTextLayout_EndLayout(void* ptr);
+void* QTextLayout_Font(void* ptr);
 int QTextLayout_IsValidCursorPosition(void* ptr, int pos);
 int QTextLayout_LeftCursorPosition(void* ptr, int oldPos);
 int QTextLayout_LineCount(void* ptr);
@@ -2799,6 +2925,7 @@ void QTextLayout_SetPreeditArea(void* ptr, int position, char* text);
 void QTextLayout_SetText(void* ptr, char* stri);
 void QTextLayout_SetTextOption(void* ptr, void* option);
 char* QTextLayout_Text(void* ptr);
+void* QTextLayout_TextOption(void* ptr);
 void QTextLayout_DestroyQTextLayout(void* ptr);
 void* QTextLength_NewQTextLength();
 void* QTextLength_NewQTextLength2(int ty, double value);
@@ -2832,8 +2959,15 @@ int QTextList_ItemNumber(void* ptr, void* block);
 char* QTextList_ItemText(void* ptr, void* block);
 void QTextList_Add(void* ptr, void* block);
 int QTextList_Count(void* ptr);
+void* QTextList_Item(void* ptr, int i);
 void QTextList_RemoveItem(void* ptr, int i);
 void QTextList_SetFormat(void* ptr, void* format);
+void QTextList_BlockFormatChanged(void* ptr, void* block);
+void QTextList_BlockFormatChangedDefault(void* ptr, void* block);
+void QTextList_BlockInserted(void* ptr, void* block);
+void QTextList_BlockInsertedDefault(void* ptr, void* block);
+void QTextList_BlockRemoved(void* ptr, void* block);
+void QTextList_BlockRemovedDefault(void* ptr, void* block);
 void QTextList_TimerEvent(void* ptr, void* event);
 void QTextList_TimerEventDefault(void* ptr, void* event);
 void QTextList_ChildEvent(void* ptr, void* event);
@@ -2851,6 +2985,7 @@ void QTextListFormat_SetNumberSuffix(void* ptr, char* numberSuffix);
 void QTextListFormat_SetStyle(void* ptr, int style);
 int QTextListFormat_Style(void* ptr);
 void* QTextObject_Document(void* ptr);
+void* QTextObject_Format(void* ptr);
 int QTextObject_FormatIndex(void* ptr);
 int QTextObject_ObjectIndex(void* ptr);
 void QTextObject_TimerEvent(void* ptr, void* event);
@@ -2879,14 +3014,19 @@ int QTextOption_TextDirection(void* ptr);
 int QTextOption_UseDesignMetrics(void* ptr);
 int QTextOption_WrapMode(void* ptr);
 void QTextOption_DestroyQTextOption(void* ptr);
+void* QTextTable_CellAt3(void* ptr, void* cursor);
+void* QTextTable_CellAt(void* ptr, int row, int column);
 void QTextTable_InsertColumns(void* ptr, int index, int columns);
 void QTextTable_InsertRows(void* ptr, int index, int rows);
 void QTextTable_RemoveColumns(void* ptr, int index, int columns);
 void QTextTable_RemoveRows(void* ptr, int index, int rows);
 void QTextTable_Resize(void* ptr, int rows, int columns);
+void* QTextTable_RowEnd(void* ptr, void* cursor);
+void* QTextTable_RowStart(void* ptr, void* cursor);
 void QTextTable_SetFormat(void* ptr, void* format);
 void QTextTable_AppendColumns(void* ptr, int count);
 void QTextTable_AppendRows(void* ptr, int count);
+void* QTextTable_CellAt2(void* ptr, int position);
 int QTextTable_Columns(void* ptr);
 void QTextTable_MergeCells2(void* ptr, void* cursor);
 void QTextTable_MergeCells(void* ptr, int row, int column, int numRows, int numCols);
@@ -2902,7 +3042,9 @@ void* QTextTableCell_NewQTextTableCell();
 void* QTextTableCell_NewQTextTableCell2(void* other);
 int QTextTableCell_Column(void* ptr);
 int QTextTableCell_ColumnSpan(void* ptr);
+void* QTextTableCell_FirstCursorPosition(void* ptr);
 int QTextTableCell_IsValid(void* ptr);
+void* QTextTableCell_LastCursorPosition(void* ptr);
 int QTextTableCell_Row(void* ptr);
 int QTextTableCell_RowSpan(void* ptr);
 void QTextTableCell_SetFormat(void* ptr, void* format);
@@ -2949,8 +3091,11 @@ void QTouchEvent_DestroyQTouchEvent(void* ptr);
 void* QTransform_NewQTransform3(double m11, double m12, double m13, double m21, double m22, double m23, double m31, double m32, double m33);
 void* QTransform_NewQTransform4(double m11, double m12, double m21, double m22, double dx, double dy);
 void* QTransform_Map3(void* ptr, void* point);
+void* QTransform_Map7(void* ptr, void* polygon);
+void* QTransform_Map6(void* ptr, void* polygon);
 void* QTransform_Map8(void* ptr, void* region);
 void* QTransform_MapRect2(void* ptr, void* rectangle);
+void* QTransform_MapToPolygon(void* ptr, void* rectangle);
 int QTransform_QTransform_QuadToSquare(void* quad, void* trans);
 void* QTransform_NewQTransform();
 double QTransform_Determinant(void* ptr);
@@ -2971,6 +3116,7 @@ double QTransform_M23(void* ptr);
 double QTransform_M31(void* ptr);
 double QTransform_M32(void* ptr);
 double QTransform_M33(void* ptr);
+void* QTransform_Map9(void* ptr, void* path);
 void QTransform_Map10(void* ptr, int x, int y, int tx, int ty);
 int QTransform_QTransform_QuadToQuad(void* one, void* two, void* trans);
 void QTransform_Reset(void* ptr);
@@ -2980,6 +3126,7 @@ int QTransform_Type(void* ptr);
 void QValidator_ConnectChanged(void* ptr);
 void QValidator_DisconnectChanged(void* ptr);
 void QValidator_Changed(void* ptr);
+void* QValidator_Locale(void* ptr);
 void QValidator_SetLocale(void* ptr, void* locale);
 void QValidator_DestroyQValidator(void* ptr);
 void QValidator_TimerEvent(void* ptr, void* event);
@@ -3064,6 +3211,7 @@ void QWindow_ConnectContentOrientationChanged(void* ptr);
 void QWindow_DisconnectContentOrientationChanged(void* ptr);
 void QWindow_ContentOrientationChanged(void* ptr, int orientation);
 void QWindow_Create(void* ptr);
+void* QWindow_Cursor(void* ptr);
 void QWindow_Destroy(void* ptr);
 double QWindow_DevicePixelRatio(void* ptr);
 int QWindow_Event(void* ptr, void* ev);
@@ -3080,6 +3228,8 @@ void QWindow_DisconnectFocusObjectChanged(void* ptr);
 void QWindow_FocusObjectChanged(void* ptr, void* object);
 void QWindow_FocusOutEvent(void* ptr, void* ev);
 void QWindow_FocusOutEventDefault(void* ptr, void* ev);
+void* QWindow_Format(void* ptr);
+void* QWindow_FormatDefault(void* ptr);
 void* QWindow_FrameGeometry(void* ptr);
 void* QWindow_FramePosition(void* ptr);
 void* QWindow_QWindow_FromWinId(unsigned long long id);
@@ -3142,6 +3292,7 @@ void* QWindow_Position(void* ptr);
 void QWindow_Raise(void* ptr);
 void QWindow_RequestActivate(void* ptr);
 void QWindow_RequestUpdate(void* ptr);
+void* QWindow_RequestedFormat(void* ptr);
 void QWindow_Resize(void* ptr, void* newSize);
 void QWindow_Resize2(void* ptr, int w, int h);
 void QWindow_ResizeEvent(void* ptr, void* ev);

help/help.cpp

@@ -5,10 +5,8 @@
 
 #include <QAbstractItemDelegate>
 #include <QAbstractItemModel>
-#include <QAbstractItemView>
 #include <QAction>
 #include <QActionEvent>
-#include <QByteArray>
 #include <QChildEvent>
 #include <QCloseEvent>
 #include <QContextMenuEvent>
@@ -93,7 +91,6 @@ class MyQHelpContentModel: public QHelpContentModel {
 public:
 	void Signal_ContentsCreated() { callbackQHelpContentModelContentsCreated(this, this->objectName().toUtf8().data()); };
 	void Signal_ContentsCreationStarted() { callbackQHelpContentModelContentsCreationStarted(this, this->objectName().toUtf8().data()); };
-	void fetchMore(const QModelIndex & parent) { callbackQHelpContentModelFetchMore(this, this->objectName().toUtf8().data(), new QModelIndex(parent)); };
 	void revert() { if (!callbackQHelpContentModelRevert(this, this->objectName().toUtf8().data())) { QHelpContentModel::revert(); }; };
 	void sort(int column, Qt::SortOrder order) { callbackQHelpContentModelSort(this, this->objectName().toUtf8().data(), column, order); };
 	void timerEvent(QTimerEvent * event) { callbackQHelpContentModelTimerEvent(this, this->objectName().toUtf8().data(), event); };
@@ -141,18 +138,10 @@ void* QHelpContentModel_Data(void* ptr, void* index, int role){
 	return new QVariant(static_cast<QHelpContentModel*>(ptr)->data(*static_cast<QModelIndex*>(index), role));
 }
 
-void* QHelpContentModel_Index(void* ptr, int row, int column, void* parent){
-	return new QModelIndex(static_cast<QHelpContentModel*>(ptr)->index(row, column, *static_cast<QModelIndex*>(parent)));
-}
-
 int QHelpContentModel_IsCreatingContents(void* ptr){
 	return static_cast<QHelpContentModel*>(ptr)->isCreatingContents();
 }
 
-void* QHelpContentModel_Parent(void* ptr, void* index){
-	return new QModelIndex(static_cast<QHelpContentModel*>(ptr)->parent(*static_cast<QModelIndex*>(index)));
-}
-
 int QHelpContentModel_RowCount(void* ptr, void* parent){
 	return static_cast<QHelpContentModel*>(ptr)->rowCount(*static_cast<QModelIndex*>(parent));
 }
@@ -161,14 +150,6 @@ void QHelpContentModel_DestroyQHelpContentModel(void* ptr){
 	static_cast<QHelpContentModel*>(ptr)->~QHelpContentModel();
 }
 
-void QHelpContentModel_FetchMore(void* ptr, void* parent){
-	static_cast<MyQHelpContentModel*>(ptr)->fetchMore(*static_cast<QModelIndex*>(parent));
-}
-
-void QHelpContentModel_FetchMoreDefault(void* ptr, void* parent){
-	static_cast<QHelpContentModel*>(ptr)->QHelpContentModel::fetchMore(*static_cast<QModelIndex*>(parent));
-}
-
 void QHelpContentModel_Revert(void* ptr){
 	QMetaObject::invokeMethod(static_cast<MyQHelpContentModel*>(ptr), "revert");
 }
@@ -212,9 +193,7 @@ void QHelpContentModel_CustomEventDefault(void* ptr, void* event){
 class MyQHelpContentWidget: public QHelpContentWidget {
 public:
 	void Signal_LinkActivated(const QUrl & link) { callbackQHelpContentWidgetLinkActivated(this, this->objectName().toUtf8().data(), new QUrl(link)); };
-	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { if (!callbackQHelpContentWidgetCurrentChanged(this, this->objectName().toUtf8().data(), new QModelIndex(current), new QModelIndex(previous))) { QHelpContentWidget::currentChanged(current, previous); }; };
 	void dragMoveEvent(QDragMoveEvent * event) { callbackQHelpContentWidgetDragMoveEvent(this, this->objectName().toUtf8().data(), event); };
-	void drawBranches(QPainter * painter, const QRect & rect, const QModelIndex & index) const { callbackQHelpContentWidgetDrawBranches(const_cast<MyQHelpContentWidget*>(this), this->objectName().toUtf8().data(), painter, new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), new QModelIndex(index)); };
 	void keyPressEvent(QKeyEvent * event) { callbackQHelpContentWidgetKeyPressEvent(this, this->objectName().toUtf8().data(), event); };
 	void keyboardSearch(const QString & search) { callbackQHelpContentWidgetKeyboardSearch(this, this->objectName().toUtf8().data(), search.toUtf8().data()); };
 	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQHelpContentWidgetMouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
@@ -223,13 +202,9 @@ public:
 	void mouseReleaseEvent(QMouseEvent * event) { callbackQHelpContentWidgetMouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
 	void paintEvent(QPaintEvent * event) { callbackQHelpContentWidgetPaintEvent(this, this->objectName().toUtf8().data(), event); };
 	void reset() { if (!callbackQHelpContentWidgetReset(this, this->objectName().toUtf8().data())) { QHelpContentWidget::reset(); }; };
-	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { if (!callbackQHelpContentWidgetRowsAboutToBeRemoved(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end)) { QHelpContentWidget::rowsAboutToBeRemoved(parent, start, end); }; };
-	void rowsInserted(const QModelIndex & parent, int start, int end) { if (!callbackQHelpContentWidgetRowsInserted(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end)) { QHelpContentWidget::rowsInserted(parent, start, end); }; };
 	void scrollContentsBy(int dx, int dy) { callbackQHelpContentWidgetScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
-	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQHelpContentWidgetScrollTo(this, this->objectName().toUtf8().data(), new QModelIndex(index), hint); };
 	void selectAll() { if (!callbackQHelpContentWidgetSelectAll(this, this->objectName().toUtf8().data())) { QHelpContentWidget::selectAll(); }; };
 	void setModel(QAbstractItemModel * model) { callbackQHelpContentWidgetSetModel(this, this->objectName().toUtf8().data(), model); };
-	void setRootIndex(const QModelIndex & index) { if (!callbackQHelpContentWidgetSetRootIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index))) { QHelpContentWidget::setRootIndex(index); }; };
 	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { callbackQHelpContentWidgetSetSelection(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), command); };
 	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQHelpContentWidgetSetSelectionModel(this, this->objectName().toUtf8().data(), selectionModel); };
 	void timerEvent(QTimerEvent * event) { callbackQHelpContentWidgetTimerEvent(this, this->objectName().toUtf8().data(), event); };
@@ -264,10 +239,6 @@ public:
 	void customEvent(QEvent * event) { callbackQHelpContentWidgetCustomEvent(this, this->objectName().toUtf8().data(), event); };
 };
 
-void* QHelpContentWidget_IndexOf(void* ptr, void* link){
-	return new QModelIndex(static_cast<QHelpContentWidget*>(ptr)->indexOf(*static_cast<QUrl*>(link)));
-}
-
 void QHelpContentWidget_ConnectLinkActivated(void* ptr){
 	QObject::connect(static_cast<QHelpContentWidget*>(ptr), static_cast<void (QHelpContentWidget::*)(const QUrl &)>(&QHelpContentWidget::linkActivated), static_cast<MyQHelpContentWidget*>(ptr), static_cast<void (MyQHelpContentWidget::*)(const QUrl &)>(&MyQHelpContentWidget::Signal_LinkActivated));;
 }
@@ -280,14 +251,6 @@ void QHelpContentWidget_LinkActivated(void* ptr, void* link){
 	static_cast<QHelpContentWidget*>(ptr)->linkActivated(*static_cast<QUrl*>(link));
 }
 
-void QHelpContentWidget_CurrentChanged(void* ptr, void* current, void* previous){
-	QMetaObject::invokeMethod(static_cast<MyQHelpContentWidget*>(ptr), "currentChanged", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(current)), Q_ARG(QModelIndex, *static_cast<QModelIndex*>(previous)));
-}
-
-void QHelpContentWidget_CurrentChangedDefault(void* ptr, void* current, void* previous){
-	QMetaObject::invokeMethod(static_cast<QHelpContentWidget*>(ptr), "currentChanged", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(current)), Q_ARG(QModelIndex, *static_cast<QModelIndex*>(previous)));
-}
-
 void QHelpContentWidget_DragMoveEvent(void* ptr, void* event){
 	static_cast<MyQHelpContentWidget*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
 }
@@ -296,14 +259,6 @@ void QHelpContentWidget_DragMoveEventDefault(void* ptr, void* event){
 	static_cast<QHelpContentWidget*>(ptr)->QHelpContentWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
 }
 
-void QHelpContentWidget_DrawBranches(void* ptr, void* painter, void* rect, void* index){
-	static_cast<MyQHelpContentWidget*>(ptr)->drawBranches(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), *static_cast<QModelIndex*>(index));
-}
-
-void QHelpContentWidget_DrawBranchesDefault(void* ptr, void* painter, void* rect, void* index){
-	static_cast<QHelpContentWidget*>(ptr)->QHelpContentWidget::drawBranches(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), *static_cast<QModelIndex*>(index));
-}
-
 void QHelpContentWidget_KeyPressEvent(void* ptr, void* event){
 	static_cast<MyQHelpContentWidget*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
 }
@@ -368,22 +323,6 @@ void QHelpContentWidget_ResetDefault(void* ptr){
 	QMetaObject::invokeMethod(static_cast<QHelpContentWidget*>(ptr), "reset");
 }
 
-void QHelpContentWidget_RowsAboutToBeRemoved(void* ptr, void* parent, int start, int end){
-	QMetaObject::invokeMethod(static_cast<MyQHelpContentWidget*>(ptr), "rowsAboutToBeRemoved", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
-}
-
-void QHelpContentWidget_RowsAboutToBeRemovedDefault(void* ptr, void* parent, int start, int end){
-	QMetaObject::invokeMethod(static_cast<QHelpContentWidget*>(ptr), "rowsAboutToBeRemoved", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
-}
-
-void QHelpContentWidget_RowsInserted(void* ptr, void* parent, int start, int end){
-	QMetaObject::invokeMethod(static_cast<MyQHelpContentWidget*>(ptr), "rowsInserted", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
-}
-
-void QHelpContentWidget_RowsInsertedDefault(void* ptr, void* parent, int start, int end){
-	QMetaObject::invokeMethod(static_cast<QHelpContentWidget*>(ptr), "rowsInserted", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
-}
-
 void QHelpContentWidget_ScrollContentsBy(void* ptr, int dx, int dy){
 	static_cast<MyQHelpContentWidget*>(ptr)->scrollContentsBy(dx, dy);
 }
@@ -392,14 +331,6 @@ void QHelpContentWidget_ScrollContentsByDefault(void* ptr, int dx, int dy){
 	static_cast<QHelpContentWidget*>(ptr)->QHelpContentWidget::scrollContentsBy(dx, dy);
 }
 
-void QHelpContentWidget_ScrollTo(void* ptr, void* index, int hint){
-	static_cast<MyQHelpContentWidget*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
-}
-
-void QHelpContentWidget_ScrollToDefault(void* ptr, void* index, int hint){
-	static_cast<QHelpContentWidget*>(ptr)->QHelpContentWidget::scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
-}
-
 void QHelpContentWidget_SelectAll(void* ptr){
 	QMetaObject::invokeMethod(static_cast<MyQHelpContentWidget*>(ptr), "selectAll");
 }
@@ -416,14 +347,6 @@ void QHelpContentWidget_SetModelDefault(void* ptr, void* model){
 	static_cast<QHelpContentWidget*>(ptr)->QHelpContentWidget::setModel(static_cast<QAbstractItemModel*>(model));
 }
 
-void QHelpContentWidget_SetRootIndex(void* ptr, void* index){
-	QMetaObject::invokeMethod(static_cast<MyQHelpContentWidget*>(ptr), "setRootIndex", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
-}
-
-void QHelpContentWidget_SetRootIndexDefault(void* ptr, void* index){
-	QMetaObject::invokeMethod(static_cast<QHelpContentWidget*>(ptr), "setRootIndex", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
-}
-
 void QHelpContentWidget_SetSelection(void* ptr, void* rect, int command){
 	static_cast<MyQHelpContentWidget*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
 }
@@ -809,8 +732,8 @@ char* QHelpEngineCore_Error(void* ptr){
 	return static_cast<QHelpEngineCore*>(ptr)->error().toUtf8().data();
 }
 
-void* QHelpEngineCore_FileData(void* ptr, void* url){
-	return new QByteArray(static_cast<QHelpEngineCore*>(ptr)->fileData(*static_cast<QUrl*>(url)));
+char* QHelpEngineCore_FileData(void* ptr, void* url){
+	return QString(static_cast<QHelpEngineCore*>(ptr)->fileData(*static_cast<QUrl*>(url))).toUtf8().data();
 }
 
 char* QHelpEngineCore_FilterAttributes(void* ptr){
@@ -942,7 +865,6 @@ public:
 	void Signal_IndexCreated() { callbackQHelpIndexModelIndexCreated(this, this->objectName().toUtf8().data()); };
 	void Signal_IndexCreationStarted() { callbackQHelpIndexModelIndexCreationStarted(this, this->objectName().toUtf8().data()); };
 	void sort(int column, Qt::SortOrder order) { callbackQHelpIndexModelSort(this, this->objectName().toUtf8().data(), column, order); };
-	void fetchMore(const QModelIndex & parent) { callbackQHelpIndexModelFetchMore(this, this->objectName().toUtf8().data(), new QModelIndex(parent)); };
 	void revert() { if (!callbackQHelpIndexModelRevert(this, this->objectName().toUtf8().data())) { QHelpIndexModel::revert(); }; };
 	void timerEvent(QTimerEvent * event) { callbackQHelpIndexModelTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQHelpIndexModelChildEvent(this, this->objectName().toUtf8().data(), event); };
@@ -953,10 +875,6 @@ void QHelpIndexModel_CreateIndex(void* ptr, char* customFilterName){
 	static_cast<QHelpIndexModel*>(ptr)->createIndex(QString(customFilterName));
 }
 
-void* QHelpIndexModel_Filter(void* ptr, char* filter, char* wildcard){
-	return new QModelIndex(static_cast<QHelpIndexModel*>(ptr)->filter(QString(filter), QString(wildcard)));
-}
-
 void QHelpIndexModel_ConnectIndexCreated(void* ptr){
 	QObject::connect(static_cast<QHelpIndexModel*>(ptr), static_cast<void (QHelpIndexModel::*)()>(&QHelpIndexModel::indexCreated), static_cast<MyQHelpIndexModel*>(ptr), static_cast<void (MyQHelpIndexModel::*)()>(&MyQHelpIndexModel::Signal_IndexCreated));;
 }
@@ -993,14 +911,6 @@ void QHelpIndexModel_SortDefault(void* ptr, int column, int order){
 	static_cast<QHelpIndexModel*>(ptr)->QHelpIndexModel::sort(column, static_cast<Qt::SortOrder>(order));
 }
 
-void QHelpIndexModel_FetchMore(void* ptr, void* parent){
-	static_cast<MyQHelpIndexModel*>(ptr)->fetchMore(*static_cast<QModelIndex*>(parent));
-}
-
-void QHelpIndexModel_FetchMoreDefault(void* ptr, void* parent){
-	static_cast<QHelpIndexModel*>(ptr)->QHelpIndexModel::fetchMore(*static_cast<QModelIndex*>(parent));
-}
-
 void QHelpIndexModel_Revert(void* ptr){
 	QMetaObject::invokeMethod(static_cast<MyQHelpIndexModel*>(ptr), "revert");
 }
@@ -1036,7 +946,6 @@ void QHelpIndexModel_CustomEventDefault(void* ptr, void* event){
 class MyQHelpIndexWidget: public QHelpIndexWidget {
 public:
 	void Signal_LinkActivated(const QUrl & link, const QString & keyword) { callbackQHelpIndexWidgetLinkActivated(this, this->objectName().toUtf8().data(), new QUrl(link), keyword.toUtf8().data()); };
-	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { if (!callbackQHelpIndexWidgetCurrentChanged(this, this->objectName().toUtf8().data(), new QModelIndex(current), new QModelIndex(previous))) { QHelpIndexWidget::currentChanged(current, previous); }; };
 	void dragLeaveEvent(QDragLeaveEvent * e) { callbackQHelpIndexWidgetDragLeaveEvent(this, this->objectName().toUtf8().data(), e); };
 	void dragMoveEvent(QDragMoveEvent * e) { callbackQHelpIndexWidgetDragMoveEvent(this, this->objectName().toUtf8().data(), e); };
 	void dropEvent(QDropEvent * e) { callbackQHelpIndexWidgetDropEvent(this, this->objectName().toUtf8().data(), e); };
@@ -1044,9 +953,6 @@ public:
 	void mouseReleaseEvent(QMouseEvent * e) { callbackQHelpIndexWidgetMouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
 	void paintEvent(QPaintEvent * e) { callbackQHelpIndexWidgetPaintEvent(this, this->objectName().toUtf8().data(), e); };
 	void resizeEvent(QResizeEvent * e) { callbackQHelpIndexWidgetResizeEvent(this, this->objectName().toUtf8().data(), e); };
-	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { if (!callbackQHelpIndexWidgetRowsAboutToBeRemoved(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end)) { QHelpIndexWidget::rowsAboutToBeRemoved(parent, start, end); }; };
-	void rowsInserted(const QModelIndex & parent, int start, int end) { if (!callbackQHelpIndexWidgetRowsInserted(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end)) { QHelpIndexWidget::rowsInserted(parent, start, end); }; };
-	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQHelpIndexWidgetScrollTo(this, this->objectName().toUtf8().data(), new QModelIndex(index), hint); };
 	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { callbackQHelpIndexWidgetSetSelection(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), command); };
 	void startDrag(Qt::DropActions supportedActions) { callbackQHelpIndexWidgetStartDrag(this, this->objectName().toUtf8().data(), supportedActions); };
 	void timerEvent(QTimerEvent * e) { callbackQHelpIndexWidgetTimerEvent(this, this->objectName().toUtf8().data(), e); };
@@ -1065,7 +971,6 @@ public:
 	void reset() { if (!callbackQHelpIndexWidgetReset(this, this->objectName().toUtf8().data())) { QHelpIndexWidget::reset(); }; };
 	void selectAll() { if (!callbackQHelpIndexWidgetSelectAll(this, this->objectName().toUtf8().data())) { QHelpIndexWidget::selectAll(); }; };
 	void setModel(QAbstractItemModel * model) { callbackQHelpIndexWidgetSetModel(this, this->objectName().toUtf8().data(), model); };
-	void setRootIndex(const QModelIndex & index) { if (!callbackQHelpIndexWidgetSetRootIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index))) { QHelpIndexWidget::setRootIndex(index); }; };
 	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQHelpIndexWidgetSetSelectionModel(this, this->objectName().toUtf8().data(), selectionModel); };
 	void contextMenuEvent(QContextMenuEvent * e) { callbackQHelpIndexWidgetContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
 	void scrollContentsBy(int dx, int dy) { callbackQHelpIndexWidgetScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
@@ -1107,14 +1012,6 @@ void QHelpIndexWidget_LinkActivated(void* ptr, void* link, char* keyword){
 	static_cast<QHelpIndexWidget*>(ptr)->linkActivated(*static_cast<QUrl*>(link), QString(keyword));
 }
 
-void QHelpIndexWidget_CurrentChanged(void* ptr, void* current, void* previous){
-	QMetaObject::invokeMethod(static_cast<MyQHelpIndexWidget*>(ptr), "currentChanged", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(current)), Q_ARG(QModelIndex, *static_cast<QModelIndex*>(previous)));
-}
-
-void QHelpIndexWidget_CurrentChangedDefault(void* ptr, void* current, void* previous){
-	QMetaObject::invokeMethod(static_cast<QHelpIndexWidget*>(ptr), "currentChanged", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(current)), Q_ARG(QModelIndex, *static_cast<QModelIndex*>(previous)));
-}
-
 void QHelpIndexWidget_DragLeaveEvent(void* ptr, void* e){
 	static_cast<MyQHelpIndexWidget*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(e));
 }
@@ -1171,30 +1068,6 @@ void QHelpIndexWidget_ResizeEventDefault(void* ptr, void* e){
 	static_cast<QHelpIndexWidget*>(ptr)->QHelpIndexWidget::resizeEvent(static_cast<QResizeEvent*>(e));
 }
 
-void QHelpIndexWidget_RowsAboutToBeRemoved(void* ptr, void* parent, int start, int end){
-	QMetaObject::invokeMethod(static_cast<MyQHelpIndexWidget*>(ptr), "rowsAboutToBeRemoved", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
-}
-
-void QHelpIndexWidget_RowsAboutToBeRemovedDefault(void* ptr, void* parent, int start, int end){
-	QMetaObject::invokeMethod(static_cast<QHelpIndexWidget*>(ptr), "rowsAboutToBeRemoved", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
-}
-
-void QHelpIndexWidget_RowsInserted(void* ptr, void* parent, int start, int end){
-	QMetaObject::invokeMethod(static_cast<MyQHelpIndexWidget*>(ptr), "rowsInserted", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
-}
-
-void QHelpIndexWidget_RowsInsertedDefault(void* ptr, void* parent, int start, int end){
-	QMetaObject::invokeMethod(static_cast<QHelpIndexWidget*>(ptr), "rowsInserted", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
-}
-
-void QHelpIndexWidget_ScrollTo(void* ptr, void* index, int hint){
-	static_cast<MyQHelpIndexWidget*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
-}
-
-void QHelpIndexWidget_ScrollToDefault(void* ptr, void* index, int hint){
-	static_cast<QHelpIndexWidget*>(ptr)->QHelpIndexWidget::scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
-}
-
 void QHelpIndexWidget_SetSelection(void* ptr, void* rect, int command){
 	static_cast<MyQHelpIndexWidget*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
 }
@@ -1339,14 +1212,6 @@ void QHelpIndexWidget_SetModelDefault(void* ptr, void* model){
 	static_cast<QHelpIndexWidget*>(ptr)->QHelpIndexWidget::setModel(static_cast<QAbstractItemModel*>(model));
 }
 
-void QHelpIndexWidget_SetRootIndex(void* ptr, void* index){
-	QMetaObject::invokeMethod(static_cast<MyQHelpIndexWidget*>(ptr), "setRootIndex", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
-}
-
-void QHelpIndexWidget_SetRootIndexDefault(void* ptr, void* index){
-	QMetaObject::invokeMethod(static_cast<QHelpIndexWidget*>(ptr), "setRootIndex", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
-}
-
 void QHelpIndexWidget_SetSelectionModel(void* ptr, void* selectionModel){
 	static_cast<MyQHelpIndexWidget*>(ptr)->setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
 }

help/help.go

@@ -261,15 +261,6 @@ func (ptr *QHelpContentModel) Data(index core.QModelIndex_ITF, role int) *core.Q
 	return nil
 }
 
-func (ptr *QHelpContentModel) Index(row int, column int, parent core.QModelIndex_ITF) *core.QModelIndex {
-	defer qt.Recovering("QHelpContentModel::index")
-
-	if ptr.Pointer() != nil {
-		return core.NewQModelIndexFromPointer(C.QHelpContentModel_Index(ptr.Pointer(), C.int(row), C.int(column), core.PointerFromQModelIndex(parent)))
-	}
-	return nil
-}
-
 func (ptr *QHelpContentModel) IsCreatingContents() bool {
 	defer qt.Recovering("QHelpContentModel::isCreatingContents")
 
@@ -279,15 +270,6 @@ func (ptr *QHelpContentModel) IsCreatingContents() bool {
 	return false
 }
 
-func (ptr *QHelpContentModel) Parent(index core.QModelIndex_ITF) *core.QModelIndex {
-	defer qt.Recovering("QHelpContentModel::parent")
-
-	if ptr.Pointer() != nil {
-		return core.NewQModelIndexFromPointer(C.QHelpContentModel_Parent(ptr.Pointer(), core.PointerFromQModelIndex(index)))
-	}
-	return nil
-}
-
 func (ptr *QHelpContentModel) RowCount(parent core.QModelIndex_ITF) int {
 	defer qt.Recovering("QHelpContentModel::rowCount")
 
@@ -306,51 +288,6 @@ func (ptr *QHelpContentModel) DestroyQHelpContentModel() {
 	}
 }
 
-func (ptr *QHelpContentModel) ConnectFetchMore(f func(parent *core.QModelIndex)) {
-	defer qt.Recovering("connect QHelpContentModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-
-		qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
-	}
-}
-
-func (ptr *QHelpContentModel) DisconnectFetchMore() {
-	defer qt.Recovering("disconnect QHelpContentModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-
-		qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
-	}
-}
-
-//export callbackQHelpContentModelFetchMore
-func callbackQHelpContentModelFetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) {
-	defer qt.Recovering("callback QHelpContentModel::fetchMore")
-
-	if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
-		signal.(func(*core.QModelIndex))(core.NewQModelIndexFromPointer(parent))
-	} else {
-		NewQHelpContentModelFromPointer(ptr).FetchMoreDefault(core.NewQModelIndexFromPointer(parent))
-	}
-}
-
-func (ptr *QHelpContentModel) FetchMore(parent core.QModelIndex_ITF) {
-	defer qt.Recovering("QHelpContentModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-		C.QHelpContentModel_FetchMore(ptr.Pointer(), core.PointerFromQModelIndex(parent))
-	}
-}
-
-func (ptr *QHelpContentModel) FetchMoreDefault(parent core.QModelIndex_ITF) {
-	defer qt.Recovering("QHelpContentModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-		C.QHelpContentModel_FetchMoreDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))
-	}
-}
-
 func (ptr *QHelpContentModel) ConnectRevert(f func()) {
 	defer qt.Recovering("connect QHelpContentModel::revert")
 
@@ -611,15 +548,6 @@ func (ptr *QHelpContentWidget) QHelpContentWidget_PTR() *QHelpContentWidget {
 	return ptr
 }
 
-func (ptr *QHelpContentWidget) IndexOf(link core.QUrl_ITF) *core.QModelIndex {
-	defer qt.Recovering("QHelpContentWidget::indexOf")
-
-	if ptr.Pointer() != nil {
-		return core.NewQModelIndexFromPointer(C.QHelpContentWidget_IndexOf(ptr.Pointer(), core.PointerFromQUrl(link)))
-	}
-	return nil
-}
-
 func (ptr *QHelpContentWidget) ConnectLinkActivated(f func(link *core.QUrl)) {
 	defer qt.Recovering("connect QHelpContentWidget::linkActivated")
 
@@ -656,52 +584,6 @@ func (ptr *QHelpContentWidget) LinkActivated(link core.QUrl_ITF) {
 	}
 }
 
-func (ptr *QHelpContentWidget) ConnectCurrentChanged(f func(current *core.QModelIndex, previous *core.QModelIndex)) {
-	defer qt.Recovering("connect QHelpContentWidget::currentChanged")
-
-	if ptr.Pointer() != nil {
-
-		qt.ConnectSignal(ptr.ObjectName(), "currentChanged", f)
-	}
-}
-
-func (ptr *QHelpContentWidget) DisconnectCurrentChanged() {
-	defer qt.Recovering("disconnect QHelpContentWidget::currentChanged")
-
-	if ptr.Pointer() != nil {
-
-		qt.DisconnectSignal(ptr.ObjectName(), "currentChanged")
-	}
-}
-
-//export callbackQHelpContentWidgetCurrentChanged
-func callbackQHelpContentWidgetCurrentChanged(ptr unsafe.Pointer, ptrName *C.char, current unsafe.Pointer, previous unsafe.Pointer) bool {
-	defer qt.Recovering("callback QHelpContentWidget::currentChanged")
-
-	if signal := qt.GetSignal(C.GoString(ptrName), "currentChanged"); signal != nil {
-		signal.(func(*core.QModelIndex, *core.QModelIndex))(core.NewQModelIndexFromPointer(current), core.NewQModelIndexFromPointer(previous))
-		return true
-	}
-	return false
-
-}
-
-func (ptr *QHelpContentWidget) CurrentChanged(current core.QModelIndex_ITF, previous core.QModelIndex_ITF) {
-	defer qt.Recovering("QHelpContentWidget::currentChanged")
-
-	if ptr.Pointer() != nil {
-		C.QHelpContentWidget_CurrentChanged(ptr.Pointer(), core.PointerFromQModelIndex(current), core.PointerFromQModelIndex(previous))
-	}
-}
-
-func (ptr *QHelpContentWidget) CurrentChangedDefault(current core.QModelIndex_ITF, previous core.QModelIndex_ITF) {
-	defer qt.Recovering("QHelpContentWidget::currentChanged")
-
-	if ptr.Pointer() != nil {
-		C.QHelpContentWidget_CurrentChangedDefault(ptr.Pointer(), core.PointerFromQModelIndex(current), core.PointerFromQModelIndex(previous))
-	}
-}
-
 func (ptr *QHelpContentWidget) ConnectDragMoveEvent(f func(event *gui.QDragMoveEvent)) {
 	defer qt.Recovering("connect QHelpContentWidget::dragMoveEvent")
 
@@ -747,51 +629,6 @@ func (ptr *QHelpContentWidget) DragMoveEventDefault(event gui.QDragMoveEvent_ITF
 	}
 }
 
-func (ptr *QHelpContentWidget) ConnectDrawBranches(f func(painter *gui.QPainter, rect *core.QRect, index *core.QModelIndex)) {
-	defer qt.Recovering("connect QHelpContentWidget::drawBranches")
-
-	if ptr.Pointer() != nil {
-
-		qt.ConnectSignal(ptr.ObjectName(), "drawBranches", f)
-	}
-}
-
-func (ptr *QHelpContentWidget) DisconnectDrawBranches() {
-	defer qt.Recovering("disconnect QHelpContentWidget::drawBranches")
-
-	if ptr.Pointer() != nil {
-
-		qt.DisconnectSignal(ptr.ObjectName(), "drawBranches")
-	}
-}
-
-//export callbackQHelpContentWidgetDrawBranches
-func callbackQHelpContentWidgetDrawBranches(ptr unsafe.Pointer, ptrName *C.char, painter unsafe.Pointer, rect unsafe.Pointer, index unsafe.Pointer) {
-	defer qt.Recovering("callback QHelpContentWidget::drawBranches")
-
-	if signal := qt.GetSignal(C.GoString(ptrName), "drawBranches"); signal != nil {
-		signal.(func(*gui.QPainter, *core.QRect, *core.QModelIndex))(gui.NewQPainterFromPointer(painter), core.NewQRectFromPointer(rect), core.NewQModelIndexFromPointer(index))
-	} else {
-		NewQHelpContentWidgetFromPointer(ptr).DrawBranchesDefault(gui.NewQPainterFromPointer(painter), core.NewQRectFromPointer(rect), core.NewQModelIndexFromPointer(index))
-	}
-}
-
-func (ptr *QHelpContentWidget) DrawBranches(painter gui.QPainter_ITF, rect core.QRect_ITF, index core.QModelIndex_ITF) {
-	defer qt.Recovering("QHelpContentWidget::drawBranches")
-
-	if ptr.Pointer() != nil {
-		C.QHelpContentWidget_DrawBranches(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRect(rect), core.PointerFromQModelIndex(index))
-	}
-}
-
-func (ptr *QHelpContentWidget) DrawBranchesDefault(painter gui.QPainter_ITF, rect core.QRect_ITF, index core.QModelIndex_ITF) {
-	defer qt.Recovering("QHelpContentWidget::drawBranches")
-
-	if ptr.Pointer() != nil {
-		C.QHelpContentWidget_DrawBranchesDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRect(rect), core.PointerFromQModelIndex(index))
-	}
-}
-
 func (ptr *QHelpContentWidget) ConnectKeyPressEvent(f func(event *gui.QKeyEvent)) {
 	defer qt.Recovering("connect QHelpContentWidget::keyPressEvent")
 
@@ -1153,98 +990,6 @@ func (ptr *QHelpContentWidget) ResetDefault() {
 	}
 }
 
-func (ptr *QHelpContentWidget) ConnectRowsAboutToBeRemoved(f func(parent *core.QModelIndex, start int, end int)) {
-	defer qt.Recovering("connect QHelpContentWidget::rowsAboutToBeRemoved")
-
-	if ptr.Pointer() != nil {
-
-		qt.ConnectSignal(ptr.ObjectName(), "rowsAboutToBeRemoved", f)
-	}
-}
-
-func (ptr *QHelpContentWidget) DisconnectRowsAboutToBeRemoved() {
-	defer qt.Recovering("disconnect QHelpContentWidget::rowsAboutToBeRemoved")
-
-	if ptr.Pointer() != nil {
-
-		qt.DisconnectSignal(ptr.ObjectName(), "rowsAboutToBeRemoved")
-	}
-}
-
-//export callbackQHelpContentWidgetRowsAboutToBeRemoved
-func callbackQHelpContentWidgetRowsAboutToBeRemoved(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer, start C.int, end C.int) bool {
-	defer qt.Recovering("callback QHelpContentWidget::rowsAboutToBeRemoved")
-
-	if signal := qt.GetSignal(C.GoString(ptrName), "rowsAboutToBeRemoved"); signal != nil {
-		signal.(func(*core.QModelIndex, int, int))(core.NewQModelIndexFromPointer(parent), int(start), int(end))
-		return true
-	}
-	return false
-
-}
-
-func (ptr *QHelpContentWidget) RowsAboutToBeRemoved(parent core.QModelIndex_ITF, start int, end int) {
-	defer qt.Recovering("QHelpContentWidget::rowsAboutToBeRemoved")
-
-	if ptr.Pointer() != nil {
-		C.QHelpContentWidget_RowsAboutToBeRemoved(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(start), C.int(end))
-	}
-}
-
-func (ptr *QHelpContentWidget) RowsAboutToBeRemovedDefault(parent core.QModelIndex_ITF, start int, end int) {
-	defer qt.Recovering("QHelpContentWidget::rowsAboutToBeRemoved")
-
-	if ptr.Pointer() != nil {
-		C.QHelpContentWidget_RowsAboutToBeRemovedDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(start), C.int(end))
-	}
-}
-
-func (ptr *QHelpContentWidget) ConnectRowsInserted(f func(parent *core.QModelIndex, start int, end int)) {
-	defer qt.Recovering("connect QHelpContentWidget::rowsInserted")
-
-	if ptr.Pointer() != nil {
-
-		qt.ConnectSignal(ptr.ObjectName(), "rowsInserted", f)
-	}
-}
-
-func (ptr *QHelpContentWidget) DisconnectRowsInserted() {
-	defer qt.Recovering("disconnect QHelpContentWidget::rowsInserted")
-
-	if ptr.Pointer() != nil {
-
-		qt.DisconnectSignal(ptr.ObjectName(), "rowsInserted")
-	}
-}
-
-//export callbackQHelpContentWidgetRowsInserted
-func callbackQHelpContentWidgetRowsInserted(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer, start C.int, end C.int) bool {
-	defer qt.Recovering("callback QHelpContentWidget::rowsInserted")
-
-	if signal := qt.GetSignal(C.GoString(ptrName), "rowsInserted"); signal != nil {
-		signal.(func(*core.QModelIndex, int, int))(core.NewQModelIndexFromPointer(parent), int(start), int(end))
-		return true
-	}
-	return false
-
-}
-
-func (ptr *QHelpContentWidget) RowsInserted(parent core.QModelIndex_ITF, start int, end int) {
-	defer qt.Recovering("QHelpContentWidget::rowsInserted")
-
-	if ptr.Pointer() != nil {
-		C.QHelpContentWidget_RowsInserted(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(start), C.int(end))
-	}
-}
-
-func (ptr *QHelpContentWidget) RowsInsertedDefault(parent core.QModelIndex_ITF, start int, end int) {
-	defer qt.Recovering("QHelpContentWidget::rowsInserted")
-
-	if ptr.Pointer() != nil {
-		C.QHelpContentWidget_RowsInsertedDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(start), C.int(end))
-	}
-}
-
 func (ptr *QHelpContentWidget) ConnectScrollContentsBy(f func(dx int, dy int)) {
 	defer qt.Recovering("connect QHelpContentWidget::scrollContentsBy")
 
@@ -1290,51 +1035,6 @@ func (ptr *QHelpContentWidget) ScrollContentsByDefault(dx int, dy int) {
 	}
 }
 
-func (ptr *QHelpContentWidget) ConnectScrollTo(f func(index *core.QModelIndex, hint widgets.QAbstractItemView__ScrollHint)) {
-	defer qt.Recovering("connect QHelpContentWidget::scrollTo")
-
-	if ptr.Pointer() != nil {
-
-		qt.ConnectSignal(ptr.ObjectName(), "scrollTo", f)
-	}
-}
-
-func (ptr *QHelpContentWidget) DisconnectScrollTo() {
-	defer qt.Recovering("disconnect QHelpContentWidget::scrollTo")
-
-	if ptr.Pointer() != nil {
-
-		qt.DisconnectSignal(ptr.ObjectName(), "scrollTo")
-	}
-}
-
-//export callbackQHelpContentWidgetScrollTo
-func callbackQHelpContentWidgetScrollTo(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer, hint C.int) {
-	defer qt.Recovering("callback QHelpContentWidget::scrollTo")
-
-	if signal := qt.GetSignal(C.GoString(ptrName), "scrollTo"); signal != nil {
-		signal.(func(*core.QModelIndex, widgets.QAbstractItemView__ScrollHint))(core.NewQModelIndexFromPointer(index), widgets.QAbstractItemView__ScrollHint(hint))
-	} else {
-		NewQHelpContentWidgetFromPointer(ptr).ScrollToDefault(core.NewQModelIndexFromPointer(index), widgets.QAbstractItemView__ScrollHint(hint))
-	}
-}
-
-func (ptr *QHelpContentWidget) ScrollTo(index core.QModelIndex_ITF, hint widgets.QAbstractItemView__ScrollHint) {
-	defer qt.Recovering("QHelpContentWidget::scrollTo")
-
-	if ptr.Pointer() != nil {
-		C.QHelpContentWidget_ScrollTo(ptr.Pointer(), core.PointerFromQModelIndex(index), C.int(hint))
-	}
-}
-
-func (ptr *QHelpContentWidget) ScrollToDefault(index core.QModelIndex_ITF, hint widgets.QAbstractItemView__ScrollHint) {
-	defer qt.Recovering("QHelpContentWidget::scrollTo")
-
-	if ptr.Pointer() != nil {
-		C.QHelpContentWidget_ScrollToDefault(ptr.Pointer(), core.PointerFromQModelIndex(index), C.int(hint))
-	}
-}
-
 func (ptr *QHelpContentWidget) ConnectSelectAll(f func()) {
 	defer qt.Recovering("connect QHelpContentWidget::selectAll")
 
@@ -1426,52 +1126,6 @@ func (ptr *QHelpContentWidget) SetModelDefault(model core.QAbstractItemModel_ITF
 	}
 }
 
-func (ptr *QHelpContentWidget) ConnectSetRootIndex(f func(index *core.QModelIndex)) {
-	defer qt.Recovering("connect QHelpContentWidget::setRootIndex")
-
-	if ptr.Pointer() != nil {
-
-		qt.ConnectSignal(ptr.ObjectName(), "setRootIndex", f)
-	}
-}
-
-func (ptr *QHelpContentWidget) DisconnectSetRootIndex() {
-	defer qt.Recovering("disconnect QHelpContentWidget::setRootIndex")
-
-	if ptr.Pointer() != nil {
-
-		qt.DisconnectSignal(ptr.ObjectName(), "setRootIndex")
-	}
-}
-
-//export callbackQHelpContentWidgetSetRootIndex
-func callbackQHelpContentWidgetSetRootIndex(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) bool {
-	defer qt.Recovering("callback QHelpContentWidget::setRootIndex")
-
-	if signal := qt.GetSignal(C.GoString(ptrName), "setRootIndex"); signal != nil {
-		signal.(func(*core.QModelIndex))(core.NewQModelIndexFromPointer(index))
-		return true
-	}
-	return false
-
-}
-
-func (ptr *QHelpContentWidget) SetRootIndex(index core.QModelIndex_ITF) {
-	defer qt.Recovering("QHelpContentWidget::setRootIndex")
-
-	if ptr.Pointer() != nil {
-		C.QHelpContentWidget_SetRootIndex(ptr.Pointer(), core.PointerFromQModelIndex(index))
-	}
-}
-
-func (ptr *QHelpContentWidget) SetRootIndexDefault(index core.QModelIndex_ITF) {
-	defer qt.Recovering("QHelpContentWidget::setRootIndex")
-
-	if ptr.Pointer() != nil {
-		C.QHelpContentWidget_SetRootIndexDefault(ptr.Pointer(), core.PointerFromQModelIndex(index))
-	}
-}
-
 func (ptr *QHelpContentWidget) ConnectSetSelection(f func(rect *core.QRect, command core.QItemSelectionModel__SelectionFlag)) {
 	defer qt.Recovering("connect QHelpContentWidget::setSelection")
 
@@ -3327,13 +2981,13 @@ func (ptr *QHelpEngineCore) Error() string {
 	return ""
 }
 
-func (ptr *QHelpEngineCore) FileData(url core.QUrl_ITF) *core.QByteArray {
+func (ptr *QHelpEngineCore) FileData(url core.QUrl_ITF) string {
 	defer qt.Recovering("QHelpEngineCore::fileData")
 
 	if ptr.Pointer() != nil {
-		return core.NewQByteArrayFromPointer(C.QHelpEngineCore_FileData(ptr.Pointer(), core.PointerFromQUrl(url)))
+		return C.GoString(C.QHelpEngineCore_FileData(ptr.Pointer(), core.PointerFromQUrl(url)))
 	}
-	return nil
+	return ""
 }
 
 func (ptr *QHelpEngineCore) FilterAttributes() []string {
@@ -3768,15 +3422,6 @@ func (ptr *QHelpIndexModel) CreateIndex(customFilterName string) {
 	}
 }
 
-func (ptr *QHelpIndexModel) Filter(filter string, wildcard string) *core.QModelIndex {
-	defer qt.Recovering("QHelpIndexModel::filter")
-
-	if ptr.Pointer() != nil {
-		return core.NewQModelIndexFromPointer(C.QHelpIndexModel_Filter(ptr.Pointer(), C.CString(filter), C.CString(wildcard)))
-	}
-	return nil
-}
-
 func (ptr *QHelpIndexModel) ConnectIndexCreated(f func()) {
 	defer qt.Recovering("connect QHelpIndexModel::indexCreated")
 
@@ -3903,51 +3548,6 @@ func (ptr *QHelpIndexModel) SortDefault(column int, order core.Qt__SortOrder) {
 	}
 }
 
-func (ptr *QHelpIndexModel) ConnectFetchMore(f func(parent *core.QModelIndex)) {
-	defer qt.Recovering("connect QHelpIndexModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-
-		qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
-	}
-}
-
-func (ptr *QHelpIndexModel) DisconnectFetchMore() {
-	defer qt.Recovering("disconnect QHelpIndexModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-
-		qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
-	}
-}
-
-//export callbackQHelpIndexModelFetchMore
-func callbackQHelpIndexModelFetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) {
-	defer qt.Recovering("callback QHelpIndexModel::fetchMore")
-
-	if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
-		signal.(func(*core.QModelIndex))(core.NewQModelIndexFromPointer(parent))
-	} else {
-		NewQHelpIndexModelFromPointer(ptr).FetchMoreDefault(core.NewQModelIndexFromPointer(parent))
-	}
-}
-
-func (ptr *QHelpIndexModel) FetchMore(parent core.QModelIndex_ITF) {
-	defer qt.Recovering("QHelpIndexModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-		C.QHelpIndexModel_FetchMore(ptr.Pointer(), core.PointerFromQModelIndex(parent))
-	}
-}
-
-func (ptr *QHelpIndexModel) FetchMoreDefault(parent core.QModelIndex_ITF) {
-	defer qt.Recovering("QHelpIndexModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-		C.QHelpIndexModel_FetchMoreDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))
-	}
-}
-
 func (ptr *QHelpIndexModel) ConnectRevert(f func()) {
 	defer qt.Recovering("connect QHelpIndexModel::revert")
 
@@ -4215,52 +3815,6 @@ func (ptr *QHelpIndexWidget) LinkActivated(link core.QUrl_ITF, keyword string) {
 	}
 }
 
-func (ptr *QHelpIndexWidget) ConnectCurrentChanged(f func(current *core.QModelIndex, previous *core.QModelIndex)) {
-	defer qt.Recovering("connect QHelpIndexWidget::currentChanged")
-
-	if ptr.Pointer() != nil {
-
-		qt.ConnectSignal(ptr.ObjectName(), "currentChanged", f)
-	}
-}
-
-func (ptr *QHelpIndexWidget) DisconnectCurrentChanged() {
-	defer qt.Recovering("disconnect QHelpIndexWidget::currentChanged")
-
-	if ptr.Pointer() != nil {
-
-		qt.DisconnectSignal(ptr.ObjectName(), "currentChanged")
-	}
-}
-
-//export callbackQHelpIndexWidgetCurrentChanged
-func callbackQHelpIndexWidgetCurrentChanged(ptr unsafe.Pointer, ptrName *C.char, current unsafe.Pointer, previous unsafe.Pointer) bool {
-	defer qt.Recovering("callback QHelpIndexWidget::currentChanged")
-
-	if signal := qt.GetSignal(C.GoString(ptrName), "currentChanged"); signal != nil {
-		signal.(func(*core.QModelIndex, *core.QModelIndex))(core.NewQModelIndexFromPointer(current), core.NewQModelIndexFromPointer(previous))
-		return true
-	}
-	return false
-
-}
-
-func (ptr *QHelpIndexWidget) CurrentChanged(current core.QModelIndex_ITF, previous core.QModelIndex_ITF) {
-	defer qt.Recovering("QHelpIndexWidget::currentChanged")
-
-	if ptr.Pointer() != nil {
-		C.QHelpIndexWidget_CurrentChanged(ptr.Pointer(), core.PointerFromQModelIndex(current), core.PointerFromQModelIndex(previous))
-	}
-}
-
-func (ptr *QHelpIndexWidget) CurrentChangedDefault(current core.QModelIndex_ITF, previous core.QModelIndex_ITF) {
-	defer qt.Recovering("QHelpIndexWidget::currentChanged")
-
-	if ptr.Pointer() != nil {
-		C.QHelpIndexWidget_CurrentChangedDefault(ptr.Pointer(), core.PointerFromQModelIndex(current), core.PointerFromQModelIndex(previous))
-	}
-}
-
 func (ptr *QHelpIndexWidget) ConnectDragLeaveEvent(f func(e *gui.QDragLeaveEvent)) {
 	defer qt.Recovering("connect QHelpIndexWidget::dragLeaveEvent")
 
@@ -4576,143 +4130,6 @@ func (ptr *QHelpIndexWidget) ResizeEventDefault(e gui.QResizeEvent_ITF) {
 	}
 }
 
-func (ptr *QHelpIndexWidget) ConnectRowsAboutToBeRemoved(f func(parent *core.QModelIndex, start int, end int)) {
-	defer qt.Recovering("connect QHelpIndexWidget::rowsAboutToBeRemoved")
-
-	if ptr.Pointer() != nil {
-
-		qt.ConnectSignal(ptr.ObjectName(), "rowsAboutToBeRemoved", f)
-	}
-}
-
-func (ptr *QHelpIndexWidget) DisconnectRowsAboutToBeRemoved() {
-	defer qt.Recovering("disconnect QHelpIndexWidget::rowsAboutToBeRemoved")
-
-	if ptr.Pointer() != nil {
-
-		qt.DisconnectSignal(ptr.ObjectName(), "rowsAboutToBeRemoved")
-	}
-}
-
-//export callbackQHelpIndexWidgetRowsAboutToBeRemoved
-func callbackQHelpIndexWidgetRowsAboutToBeRemoved(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer, start C.int, end C.int) bool {
-	defer qt.Recovering("callback QHelpIndexWidget::rowsAboutToBeRemoved")
-
-	if signal := qt.GetSignal(C.GoString(ptrName), "rowsAboutToBeRemoved"); signal != nil {
-		signal.(func(*core.QModelIndex, int, int))(core.NewQModelIndexFromPointer(parent), int(start), int(end))
-		return true
-	}
-	return false
-
-}
-
-func (ptr *QHelpIndexWidget) RowsAboutToBeRemoved(parent core.QModelIndex_ITF, start int, end int) {
-	defer qt.Recovering("QHelpIndexWidget::rowsAboutToBeRemoved")
-
-	if ptr.Pointer() != nil {
-		C.QHelpIndexWidget_RowsAboutToBeRemoved(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(start), C.int(end))
-	}
-}
-
-func (ptr *QHelpIndexWidget) RowsAboutToBeRemovedDefault(parent core.QModelIndex_ITF, start int, end int) {
-	defer qt.Recovering("QHelpIndexWidget::rowsAboutToBeRemoved")
-
-	if ptr.Pointer() != nil {
-		C.QHelpIndexWidget_RowsAboutToBeRemovedDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(start), C.int(end))
-	}
-}
-
-func (ptr *QHelpIndexWidget) ConnectRowsInserted(f func(parent *core.QModelIndex, start int, end int)) {
-	defer qt.Recovering("connect QHelpIndexWidget::rowsInserted")
-
-	if ptr.Pointer() != nil {
-
-		qt.ConnectSignal(ptr.ObjectName(), "rowsInserted", f)
-	}
-}
-
-func (ptr *QHelpIndexWidget) DisconnectRowsInserted() {
-	defer qt.Recovering("disconnect QHelpIndexWidget::rowsInserted")
-
-	if ptr.Pointer() != nil {
-
-		qt.DisconnectSignal(ptr.ObjectName(), "rowsInserted")
-	}
-}
-
-//export callbackQHelpIndexWidgetRowsInserted
-func callbackQHelpIndexWidgetRowsInserted(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer, start C.int, end C.int) bool {
-	defer qt.Recovering("callback QHelpIndexWidget::rowsInserted")
-
-	if signal := qt.GetSignal(C.GoString(ptrName), "rowsInserted"); signal != nil {
-		signal.(func(*core.QModelIndex, int, int))(core.NewQModelIndexFromPointer(parent), int(start), int(end))
-		return true
-	}
-	return false
-
-}
-
-func (ptr *QHelpIndexWidget) RowsInserted(parent core.QModelIndex_ITF, start int, end int) {
-	defer qt.Recovering("QHelpIndexWidget::rowsInserted")
-
-	if ptr.Pointer() != nil {
-		C.QHelpIndexWidget_RowsInserted(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(start), C.int(end))
-	}
-}
-
-func (ptr *QHelpIndexWidget) RowsInsertedDefault(parent core.QModelIndex_ITF, start int, end int) {
-	defer qt.Recovering("QHelpIndexWidget::rowsInserted")
-
-	if ptr.Pointer() != nil {
-		C.QHelpIndexWidget_RowsInsertedDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(start), C.int(end))
-	}
-}
-
-func (ptr *QHelpIndexWidget) ConnectScrollTo(f func(index *core.QModelIndex, hint widgets.QAbstractItemView__ScrollHint)) {
-	defer qt.Recovering("connect QHelpIndexWidget::scrollTo")
-
-	if ptr.Pointer() != nil {
-
-		qt.ConnectSignal(ptr.ObjectName(), "scrollTo", f)
-	}
-}
-
-func (ptr *QHelpIndexWidget) DisconnectScrollTo() {
-	defer qt.Recovering("disconnect QHelpIndexWidget::scrollTo")
-
-	if ptr.Pointer() != nil {
-
-		qt.DisconnectSignal(ptr.ObjectName(), "scrollTo")
-	}
-}
-
-//export callbackQHelpIndexWidgetScrollTo
-func callbackQHelpIndexWidgetScrollTo(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer, hint C.int) {
-	defer qt.Recovering("callback QHelpIndexWidget::scrollTo")
-
-	if signal := qt.GetSignal(C.GoString(ptrName), "scrollTo"); signal != nil {
-		signal.(func(*core.QModelIndex, widgets.QAbstractItemView__ScrollHint))(core.NewQModelIndexFromPointer(index), widgets.QAbstractItemView__ScrollHint(hint))
-	} else {
-		NewQHelpIndexWidgetFromPointer(ptr).ScrollToDefault(core.NewQModelIndexFromPointer(index), widgets.QAbstractItemView__ScrollHint(hint))
-	}
-}
-
-func (ptr *QHelpIndexWidget) ScrollTo(index core.QModelIndex_ITF, hint widgets.QAbstractItemView__ScrollHint) {
-	defer qt.Recovering("QHelpIndexWidget::scrollTo")
-
-	if ptr.Pointer() != nil {
-		C.QHelpIndexWidget_ScrollTo(ptr.Pointer(), core.PointerFromQModelIndex(index), C.int(hint))
-	}
-}
-
-func (ptr *QHelpIndexWidget) ScrollToDefault(index core.QModelIndex_ITF, hint widgets.QAbstractItemView__ScrollHint) {
-	defer qt.Recovering("QHelpIndexWidget::scrollTo")
-
-	if ptr.Pointer() != nil {
-		C.QHelpIndexWidget_ScrollToDefault(ptr.Pointer(), core.PointerFromQModelIndex(index), C.int(hint))
-	}
-}
-
 func (ptr *QHelpIndexWidget) ConnectSetSelection(f func(rect *core.QRect, command core.QItemSelectionModel__SelectionFlag)) {
 	defer qt.Recovering("connect QHelpIndexWidget::setSelection")
 
@@ -5529,52 +4946,6 @@ func (ptr *QHelpIndexWidget) SetModelDefault(model core.QAbstractItemModel_ITF)
 	}
 }
 
-func (ptr *QHelpIndexWidget) ConnectSetRootIndex(f func(index *core.QModelIndex)) {
-	defer qt.Recovering("connect QHelpIndexWidget::setRootIndex")
-
-	if ptr.Pointer() != nil {
-
-		qt.ConnectSignal(ptr.ObjectName(), "setRootIndex", f)
-	}
-}
-
-func (ptr *QHelpIndexWidget) DisconnectSetRootIndex() {
-	defer qt.Recovering("disconnect QHelpIndexWidget::setRootIndex")
-
-	if ptr.Pointer() != nil {
-
-		qt.DisconnectSignal(ptr.ObjectName(), "setRootIndex")
-	}
-}
-
-//export callbackQHelpIndexWidgetSetRootIndex
-func callbackQHelpIndexWidgetSetRootIndex(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) bool {
-	defer qt.Recovering("callback QHelpIndexWidget::setRootIndex")
-
-	if signal := qt.GetSignal(C.GoString(ptrName), "setRootIndex"); signal != nil {
-		signal.(func(*core.QModelIndex))(core.NewQModelIndexFromPointer(index))
-		return true
-	}
-	return false
-
-}
-
-func (ptr *QHelpIndexWidget) SetRootIndex(index core.QModelIndex_ITF) {
-	defer qt.Recovering("QHelpIndexWidget::setRootIndex")
-
-	if ptr.Pointer() != nil {
-		C.QHelpIndexWidget_SetRootIndex(ptr.Pointer(), core.PointerFromQModelIndex(index))
-	}
-}
-
-func (ptr *QHelpIndexWidget) SetRootIndexDefault(index core.QModelIndex_ITF) {
-	defer qt.Recovering("QHelpIndexWidget::setRootIndex")
-
-	if ptr.Pointer() != nil {
-		C.QHelpIndexWidget_SetRootIndexDefault(ptr.Pointer(), core.PointerFromQModelIndex(index))
-	}
-}
-
 func (ptr *QHelpIndexWidget) ConnectSetSelectionModel(f func(selectionModel *core.QItemSelectionModel)) {
 	defer qt.Recovering("connect QHelpIndexWidget::setSelectionModel")
 

help/help.h

@@ -27,16 +27,10 @@ void QHelpContentModel_ContentsCreationStarted(void* ptr);
 void QHelpContentModel_CreateContents(void* ptr, char* customFilterName);
 void* QHelpContentModel_Data(void* ptr, void* index, int role);
 void* QHelpContentModel_DataDefault(void* ptr, void* index, int role);
-void* QHelpContentModel_Index(void* ptr, int row, int column, void* parent);
-void* QHelpContentModel_IndexDefault(void* ptr, int row, int column, void* parent);
 int QHelpContentModel_IsCreatingContents(void* ptr);
-void* QHelpContentModel_Parent(void* ptr, void* index);
-void* QHelpContentModel_ParentDefault(void* ptr, void* index);
 int QHelpContentModel_RowCount(void* ptr, void* parent);
 int QHelpContentModel_RowCountDefault(void* ptr, void* parent);
 void QHelpContentModel_DestroyQHelpContentModel(void* ptr);
-void QHelpContentModel_FetchMore(void* ptr, void* parent);
-void QHelpContentModel_FetchMoreDefault(void* ptr, void* parent);
 void QHelpContentModel_Revert(void* ptr);
 void QHelpContentModel_RevertDefault(void* ptr);
 void QHelpContentModel_Sort(void* ptr, int column, int order);
@@ -47,16 +41,11 @@ void QHelpContentModel_ChildEvent(void* ptr, void* event);
 void QHelpContentModel_ChildEventDefault(void* ptr, void* event);
 void QHelpContentModel_CustomEvent(void* ptr, void* event);
 void QHelpContentModel_CustomEventDefault(void* ptr, void* event);
-void* QHelpContentWidget_IndexOf(void* ptr, void* link);
 void QHelpContentWidget_ConnectLinkActivated(void* ptr);
 void QHelpContentWidget_DisconnectLinkActivated(void* ptr);
 void QHelpContentWidget_LinkActivated(void* ptr, void* link);
-void QHelpContentWidget_CurrentChanged(void* ptr, void* current, void* previous);
-void QHelpContentWidget_CurrentChangedDefault(void* ptr, void* current, void* previous);
 void QHelpContentWidget_DragMoveEvent(void* ptr, void* event);
 void QHelpContentWidget_DragMoveEventDefault(void* ptr, void* event);
-void QHelpContentWidget_DrawBranches(void* ptr, void* painter, void* rect, void* index);
-void QHelpContentWidget_DrawBranchesDefault(void* ptr, void* painter, void* rect, void* index);
 void QHelpContentWidget_KeyPressEvent(void* ptr, void* event);
 void QHelpContentWidget_KeyPressEventDefault(void* ptr, void* event);
 void QHelpContentWidget_KeyboardSearch(void* ptr, char* search);
@@ -73,20 +62,12 @@ void QHelpContentWidget_PaintEvent(void* ptr, void* event);
 void QHelpContentWidget_PaintEventDefault(void* ptr, void* event);
 void QHelpContentWidget_Reset(void* ptr);
 void QHelpContentWidget_ResetDefault(void* ptr);
-void QHelpContentWidget_RowsAboutToBeRemoved(void* ptr, void* parent, int start, int end);
-void QHelpContentWidget_RowsAboutToBeRemovedDefault(void* ptr, void* parent, int start, int end);
-void QHelpContentWidget_RowsInserted(void* ptr, void* parent, int start, int end);
-void QHelpContentWidget_RowsInsertedDefault(void* ptr, void* parent, int start, int end);
 void QHelpContentWidget_ScrollContentsBy(void* ptr, int dx, int dy);
 void QHelpContentWidget_ScrollContentsByDefault(void* ptr, int dx, int dy);
-void QHelpContentWidget_ScrollTo(void* ptr, void* index, int hint);
-void QHelpContentWidget_ScrollToDefault(void* ptr, void* index, int hint);
 void QHelpContentWidget_SelectAll(void* ptr);
 void QHelpContentWidget_SelectAllDefault(void* ptr);
 void QHelpContentWidget_SetModel(void* ptr, void* model);
 void QHelpContentWidget_SetModelDefault(void* ptr, void* model);
-void QHelpContentWidget_SetRootIndex(void* ptr, void* index);
-void QHelpContentWidget_SetRootIndexDefault(void* ptr, void* index);
 void QHelpContentWidget_SetSelection(void* ptr, void* rect, int command);
 void QHelpContentWidget_SetSelectionDefault(void* ptr, void* rect, int command);
 void QHelpContentWidget_SetSelectionModel(void* ptr, void* selectionModel);
@@ -180,7 +161,7 @@ char* QHelpEngineCore_CustomFilters(void* ptr);
 void* QHelpEngineCore_CustomValue(void* ptr, char* key, void* defaultValue);
 char* QHelpEngineCore_DocumentationFileName(void* ptr, char* namespaceName);
 char* QHelpEngineCore_Error(void* ptr);
-void* QHelpEngineCore_FileData(void* ptr, void* url);
+char* QHelpEngineCore_FileData(void* ptr, void* url);
 char* QHelpEngineCore_FilterAttributes(void* ptr);
 char* QHelpEngineCore_FilterAttributes2(void* ptr, char* filterName);
 void* QHelpEngineCore_FindFile(void* ptr, void* url);
@@ -213,7 +194,6 @@ void QHelpEngineCore_ChildEventDefault(void* ptr, void* event);
 void QHelpEngineCore_CustomEvent(void* ptr, void* event);
 void QHelpEngineCore_CustomEventDefault(void* ptr, void* event);
 void QHelpIndexModel_CreateIndex(void* ptr, char* customFilterName);
-void* QHelpIndexModel_Filter(void* ptr, char* filter, char* wildcard);
 void QHelpIndexModel_ConnectIndexCreated(void* ptr);
 void QHelpIndexModel_DisconnectIndexCreated(void* ptr);
 void QHelpIndexModel_IndexCreated(void* ptr);
@@ -223,8 +203,6 @@ void QHelpIndexModel_IndexCreationStarted(void* ptr);
 int QHelpIndexModel_IsCreatingIndex(void* ptr);
 void QHelpIndexModel_Sort(void* ptr, int column, int order);
 void QHelpIndexModel_SortDefault(void* ptr, int column, int order);
-void QHelpIndexModel_FetchMore(void* ptr, void* parent);
-void QHelpIndexModel_FetchMoreDefault(void* ptr, void* parent);
 void QHelpIndexModel_Revert(void* ptr);
 void QHelpIndexModel_RevertDefault(void* ptr);
 void QHelpIndexModel_TimerEvent(void* ptr, void* event);
@@ -238,8 +216,6 @@ void QHelpIndexWidget_FilterIndices(void* ptr, char* filter, char* wildcard);
 void QHelpIndexWidget_ConnectLinkActivated(void* ptr);
 void QHelpIndexWidget_DisconnectLinkActivated(void* ptr);
 void QHelpIndexWidget_LinkActivated(void* ptr, void* link, char* keyword);
-void QHelpIndexWidget_CurrentChanged(void* ptr, void* current, void* previous);
-void QHelpIndexWidget_CurrentChangedDefault(void* ptr, void* current, void* previous);
 void QHelpIndexWidget_DragLeaveEvent(void* ptr, void* e);
 void QHelpIndexWidget_DragLeaveEventDefault(void* ptr, void* e);
 void QHelpIndexWidget_DragMoveEvent(void* ptr, void* e);
@@ -254,12 +230,6 @@ void QHelpIndexWidget_PaintEvent(void* ptr, void* e);
 void QHelpIndexWidget_PaintEventDefault(void* ptr, void* e);
 void QHelpIndexWidget_ResizeEvent(void* ptr, void* e);
 void QHelpIndexWidget_ResizeEventDefault(void* ptr, void* e);
-void QHelpIndexWidget_RowsAboutToBeRemoved(void* ptr, void* parent, int start, int end);
-void QHelpIndexWidget_RowsAboutToBeRemovedDefault(void* ptr, void* parent, int start, int end);
-void QHelpIndexWidget_RowsInserted(void* ptr, void* parent, int start, int end);
-void QHelpIndexWidget_RowsInsertedDefault(void* ptr, void* parent, int start, int end);
-void QHelpIndexWidget_ScrollTo(void* ptr, void* index, int hint);
-void QHelpIndexWidget_ScrollToDefault(void* ptr, void* index, int hint);
 void QHelpIndexWidget_SetSelection(void* ptr, void* rect, int command);
 void QHelpIndexWidget_SetSelectionDefault(void* ptr, void* rect, int command);
 void QHelpIndexWidget_StartDrag(void* ptr, int supportedActions);
@@ -296,8 +266,6 @@ void QHelpIndexWidget_SelectAll(void* ptr);
 void QHelpIndexWidget_SelectAllDefault(void* ptr);
 void QHelpIndexWidget_SetModel(void* ptr, void* model);
 void QHelpIndexWidget_SetModelDefault(void* ptr, void* model);
-void QHelpIndexWidget_SetRootIndex(void* ptr, void* index);
-void QHelpIndexWidget_SetRootIndexDefault(void* ptr, void* index);
 void QHelpIndexWidget_SetSelectionModel(void* ptr, void* selectionModel);
 void QHelpIndexWidget_SetSelectionModelDefault(void* ptr, void* selectionModel);
 void QHelpIndexWidget_ContextMenuEvent(void* ptr, void* e);

internal/binding/converter/input.go

@@ -19,7 +19,7 @@ func goInput(name string, value string, f *parser.Function) string {
 			return fmt.Sprintf("C.CString(strings.Join(%v, \"|\"))", name)
 		}
 
-	case "uchar", "char", "QString":
+	case "uchar", "char", "QString", "QByteArray":
 		{
 			if strings.Contains(vOld, "**") {
 				return fmt.Sprintf("C.CString(strings.Join(%v, \"|\"))", name)
@@ -127,7 +127,7 @@ func cppInput(name string, value string, f *parser.Function) string {
 			return fmt.Sprintf("%v.split(\"|\", QString::SkipEmptyParts)", cppInput(name, "QString", f))
 		}
 
-	case "QString":
+	case "QString", "QByteArray":
 		{
 			if strings.Contains(vOld, "&") {
 				if strings.Contains(vOld, "const") {

internal/binding/converter/output.go

@@ -19,7 +19,7 @@ func goOutput(name string, value string, f *parser.Function) string {
 			return fmt.Sprintf("strings.Split(%v, \"|\")", goOutput(name, "QString", f))
 		}
 
-	case "uchar", "char", "QString":
+	case "uchar", "char", "QString", "QByteArray":
 		{
 			return fmt.Sprintf("C.GoString(%v)", name)
 		}
@@ -127,7 +127,7 @@ func goOutputFailed(value string, f *parser.Function) string {
 			return "0"
 		}
 
-	case "uchar", "char", "QString":
+	case "uchar", "char", "QString", "QByteArray":
 		{
 			return "\"\""
 		}
@@ -200,7 +200,7 @@ func cgoOutput(name string, value string, f *parser.Function) string {
 			return fmt.Sprintf("strings.Split(%v, \"|\")", cgoOutput(name, "QString", f))
 		}
 
-	case "uchar", "char", "QString":
+	case "uchar", "char", "QString", "QByteArray":
 		{
 			return fmt.Sprintf("C.GoString(%v)", name)
 		}
@@ -283,6 +283,11 @@ func cppOutput(name string, value string, f *parser.Function) string {
 			return fmt.Sprintf("%v.toUtf8().data()", name)
 		}
 
+	case "QByteArray":
+		{
+			return cppOutput(fmt.Sprintf("QString(%v)", name), "QString", f)
+		}
+
 	case "bool", "int", "void", "", "T", "JavaVM", "jclass", "jobject":
 		{
 			if value == "void" {
@@ -329,11 +334,6 @@ func cppOutput(name string, value string, f *parser.Function) string {
 			}
 
 			switch value {
-			case "QModelIndex", "QMediaContent", "QIcon", "QUrl", "QJSValue", "QScriptValue", "QVariant", "QStringRef", "QDateTime", "QTimeZone", "QRegularExpressionMatchIterator", "QRegularExpressionMatch", "QRegularExpression", "QDir", "QByteArray", "QEasingCurve", "QCommandLineOption", "QRegExp", "QJsonObject", "QJsonArray", "QJsonDocument", "QRegion", "QBrush", "QColor":
-				{
-					return fmt.Sprintf("new %v(%v)", value, name)
-				}
-
 			case "QAndroidJniObject":
 				{
 					return fmt.Sprintf("new %v(%v.object())", value, name)
@@ -354,6 +354,16 @@ func cppOutput(name string, value string, f *parser.Function) string {
 					return fmt.Sprintf("new %v(static_cast<%v>(%v).x(), static_cast<%v>(%v).y(), static_cast<%v>(%v).width(), static_cast<%v>(%v).height())", value, value, name, value, name, value, name, value, name)
 				}
 			}
+
+			for _, f := range parser.ClassMap[value].Functions {
+				if f.Meta == "constructor" {
+					if len(f.Parameters) == 1 {
+						if cleanValue(f.Parameters[0].Value) == value {
+							return fmt.Sprintf("new %v(%v)", value, name)
+						}
+					}
+				}
+			}
 		}
 	}
 

internal/binding/converter/type.go

@@ -13,7 +13,7 @@ func goType(f *parser.Function, value string) string {
 	value = cleanValue(value)
 
 	switch value {
-	case "uchar", "char", "QString":
+	case "uchar", "char", "QString", "QByteArray":
 		{
 			if strings.Contains(vOld, "**") {
 				return "[]string"
@@ -129,7 +129,7 @@ func cgoType(f *parser.Function, value string) string {
 	value = cleanValue(value)
 
 	switch value {
-	case "uchar", "char", "QString", "QStringList":
+	case "uchar", "char", "QString", "QByteArray", "QStringList":
 		{
 			return "*C.char"
 		}
@@ -180,7 +180,7 @@ func cppType(f *parser.Function, value string) string {
 	value = cleanValue(value)
 
 	switch value {
-	case "uchar", "char", "QString", "QStringList":
+	case "uchar", "char", "QString", "QByteArray", "QStringList":
 		{
 			return "char*"
 		}

internal/binding/parser/function.go

@@ -43,6 +43,10 @@ func (f *Function) fix() {
 	if f.Fullname == "QThread::start" {
 		f.Parameters = make([]*Parameter, 0)
 	}
+
+	if f.Fullname == "QQuickImageProvider::requestImage" || f.Fullname == "QQuickImageProvider::requestPixmap" {
+		f.Parameters = f.Parameters[:len(f.Parameters)-1]
+	}
 }
 
 func (f *Function) fixOverload() {

internal/binding/templater/templater.go

@@ -11,7 +11,7 @@ import (
 )
 
 func isSupportedFunction(c *parser.Class, f *parser.Function) bool {
-	return (f.Access == "public" || (f.Access == "protected" && strings.Contains(f.Virtual, "impure"))) && f.Status != "obsolete" && isNotAbstractConstructor(c, f) && isNotAtomic(f) && !isBlocked(f) && !(strings.Contains(f.Virtual, "impure") && f.Overload)
+	return (f.Access == "public" || (f.Access == "protected" && strings.Contains(f.Virtual, "impure"))) && f.Status != "obsolete" && f.Status != "compat" && isNotAbstractConstructor(c, f) && isNotAtomic(f) && !isBlocked(f) && !(strings.Contains(f.Virtual, "impure") && f.Overload)
 }
 
 func isNotAbstractConstructor(c *parser.Class, f *parser.Function) bool {
@@ -73,20 +73,27 @@ func classHasRealFunctionFromFile(c string, n string) bool {
 
 	switch runtime.GOOS {
 	case "darwin":
-		fData = utils.Load(fmt.Sprintf("/usr/local/Qt5.5.1/5.5/clang_64/lib/%v.framework/Versions/5/Headers/%v", strings.Title(parser.ClassMap[f.Class()].DocModule), strings.Replace(filepath.Base(f.Filepath), ".cpp", ".h", -1)))
+		{
+			fData = utils.Load(fmt.Sprintf("/usr/local/Qt5.5.1/5.5/clang_64/lib/%v.framework/Versions/5/Headers/%v", strings.Title(parser.ClassMap[f.Class()].DocModule), strings.Replace(filepath.Base(f.Filepath), ".cpp", ".h", -1)))
+		}
 
 	case "windows":
-		fData = utils.Load(fmt.Sprintf("C:\\Qt\\Qt5.5.1\\5.5\\mingw492_32\\include\\%v\\%v", strings.Title(parser.ClassMap[f.Class()].DocModule), strings.Replace(filepath.Base(f.Filepath), ".cpp", ".h", -1)))
+		{
+			fData = utils.Load(fmt.Sprintf("C:\\Qt\\Qt5.5.1\\5.5\\mingw492_32\\include\\%v\\%v", strings.Title(parser.ClassMap[f.Class()].DocModule), strings.Replace(filepath.Base(f.Filepath), ".cpp", ".h", -1)))
+		}
 
 	case "linux":
-		switch runtime.GOARCH {
-		case "amd64":
-			{
-				fData = utils.Load(fmt.Sprintf("/usr/local/Qt5.5.1/5.5/gcc_64/include/%v/%v", strings.Title(parser.ClassMap[f.Class()].DocModule), strings.Replace(filepath.Base(f.Filepath), ".cpp", ".h", -1)))
-			}
-		case "386":
-			{
-				fData = utils.Load(fmt.Sprintf("/usr/local/Qt5.5.1/5.5/gcc/include/%v/%v", strings.Title(parser.ClassMap[f.Class()].DocModule), strings.Replace(filepath.Base(f.Filepath), ".cpp", ".h", -1)))
+		{
+			switch runtime.GOARCH {
+			case "amd64":
+				{
+					fData = utils.Load(fmt.Sprintf("/usr/local/Qt5.5.1/5.5/gcc_64/include/%v/%v", strings.Title(parser.ClassMap[f.Class()].DocModule), strings.Replace(filepath.Base(f.Filepath), ".cpp", ".h", -1)))
+				}
+
+			case "386":
+				{
+					fData = utils.Load(fmt.Sprintf("/usr/local/Qt5.5.1/5.5/gcc/include/%v/%v", strings.Title(parser.ClassMap[f.Class()].DocModule), strings.Replace(filepath.Base(f.Filepath), ".cpp", ".h", -1)))
+				}
 			}
 		}
 	}
@@ -202,7 +209,7 @@ func isSupportedClass(c *parser.Class) bool {
 }
 
 func isBlockedClass(c *parser.Class) bool {
-	for _, n := range []string{"QException", "QPlaceContentRequest", "QPlaceContentReply", "QPlaceContent", "QPlaceContactDetail", "QPlaceCategory", "QPlaceAttribute", "QPlace", "QGeoCodingManagerEngine", "QGeoCodingManager", "QHash", "QGenericMatrix", "QContiguousCache", "QStringList", "QCache", "QString", "QItemEditorCreator", "QImageIOPlugin", "QImageIOHandler", "QIconEnginePlugin", "QGraphicsTransform", "QGraphicsLayoutItem", "QGraphicsLayout", "QGraphicsItem", "QGraphicsEffect", "QGestureRecognizer", "QGenericPlugin", "QDebug", "QAnimationGroup", "QAccessiblePlugin", "QOpenGLFunctions_ES2", "Qt", "QSharedDataPointer", "QScopedValueRollback", "QScopedArrayPointer", "QQueue", "QMultiMap", "QWinEventNotifier", "QWeakPointer", "QVarLengthArray", "QThreadStorage", "QSharedPointer", "QScopedPointer", "QMutableHashIterator", "QMultiHash", "QMapIterator", "QListIterator", "QLinkedListIterator", "QHashIterator", "QGlobalStatic", "QFutureWatcher", "QFutureSynchronizer", "QFutureIterator", "QFuture", "QEnableSharedFromThis", "QExplicitlySharedDataPointer", "QFlags"} {
+	for _, n := range []string{"QException", "QPlaceContentRequest", "QPlaceContentReply", "QPlaceContent", "QPlaceContactDetail", "QPlaceCategory", "QPlaceAttribute", "QPlace", "QGeoCodingManagerEngine", "QGeoCodingManager", "QHash", "QGenericMatrix", "QContiguousCache", "QStringList", "QCache", "QString", "QByteArray", "QItemEditorCreator", "QImageIOPlugin", "QImageIOHandler", "QIconEnginePlugin", "QGraphicsTransform", "QGraphicsLayoutItem", "QGraphicsLayout", "QGraphicsItem", "QGraphicsEffect", "QGestureRecognizer", "QGenericPlugin", "QDebug", "QAnimationGroup", "QAccessiblePlugin", "QOpenGLFunctions_ES2", "Qt", "QSharedDataPointer", "QScopedValueRollback", "QScopedArrayPointer", "QQueue", "QMultiMap", "QWinEventNotifier", "QWeakPointer", "QVarLengthArray", "QThreadStorage", "QSharedPointer", "QScopedPointer", "QMutableHashIterator", "QMultiHash", "QMapIterator", "QListIterator", "QLinkedListIterator", "QHashIterator", "QGlobalStatic", "QFutureWatcher", "QFutureSynchronizer", "QFutureIterator", "QFuture", "QEnableSharedFromThis", "QExplicitlySharedDataPointer", "QFlags"} {
 		if c.Name == n || strings.Contains(c.Name, "Iterator") {
 			return true
 		}

internal/deploy/deploy.go

@@ -236,19 +236,19 @@ func qmlHeader() string {
 
 	return fmt.Sprintf(`package main
 
-  	/*
-  	#cgo +build android,arm LDFLAGS: -L%v/Qt5.5.1/5.5/android_armv7/lib -lQt5Core
-		#cgo +build darwin,amd64 LDFLAGS: -F/usr/local/Qt5.5.1/5.5/clang_64/lib -framework QtCore
+/*
+#cgo +build android,arm LDFLAGS: -L%v/Qt5.5.1/5.5/android_armv7/lib -lQt5Core
+#cgo +build darwin,amd64 LDFLAGS: -F/usr/local/Qt5.5.1/5.5/clang_64/lib -framework QtCore
 
-	  #cgo +build linux,amd64 LDFLAGS: -Wl,-rpath,/usr/local/Qt5.5.1/5.5/gcc_64/lib
-	  #cgo +build linux,amd64 LDFLAGS: -L/usr/local/Qt5.5.1/5.5/gcc_64/lib -lQt5Core
+#cgo +build linux,amd64 LDFLAGS: -Wl,-rpath,/usr/local/Qt5.5.1/5.5/gcc_64/lib
+#cgo +build linux,amd64 LDFLAGS: -L/usr/local/Qt5.5.1/5.5/gcc_64/lib -lQt5Core
 
-	  #cgo +build linux,386 LDFLAGS: -Wl,-rpath,/usr/local/Qt5.5.1/5.5/gcc/lib
-	  #cgo +build linux,386 LDFLAGS: -L/usr/local/Qt5.5.1/5.5/gcc/lib -lQt5Core
+#cgo +build linux,386 LDFLAGS: -Wl,-rpath,/usr/local/Qt5.5.1/5.5/gcc/lib
+#cgo +build linux,386 LDFLAGS: -L/usr/local/Qt5.5.1/5.5/gcc/lib -lQt5Core
 
-	  #cgo +build windows,386 LDFLAGS: -LC:/Qt/Qt5.5.1/5.5/mingw492_32/lib -lQt5Core
-	  */
-	  import "C"`, hloc)
+#cgo +build windows,386 LDFLAGS: -LC:/Qt/Qt5.5.1/5.5/mingw492_32/lib -lQt5Core
+*/
+import "C"`, hloc)
 }
 
 func build() {
@@ -297,6 +297,7 @@ func build() {
 				}
 			}
 		}
+
 	case "desktop":
 		{
 			switch runtime.GOOS {
@@ -354,9 +355,14 @@ func predeploy() {
 
 	switch runtime.GOOS {
 	case "windows":
-		copyCmd = "xcopy"
+		{
+			copyCmd = "xcopy"
+		}
+
 	default:
-		copyCmd = "cp"
+		{
+			copyCmd = "cp"
+		}
 	}
 
 	switch buildTarget {
@@ -515,6 +521,7 @@ func deploy() {
 					qtPrefix = "/usr/local"
 					androidPrefix = "/opt"
 				}
+
 			case "windows":
 				{
 					var version = strings.Split(runCmd(exec.Command("java", "-version"), "deploy.jdk"), "\"")[1]
@@ -555,6 +562,7 @@ func deploy() {
 				runCmd(deploy, "deploy")
 			}
 		}
+
 	case "desktop":
 		{
 			switch runtime.GOOS {
@@ -627,6 +635,7 @@ func pastdeploy() {
 					copyCmd = "cp"
 					apkEnding = "apk"
 				}
+
 			case "windows":
 				{
 					copyCmd = "xcopy"
@@ -643,6 +652,7 @@ func pastdeploy() {
 			//TODO: copy manifest to android folder and change mindSdkVersion >= 16
 
 		}
+
 	case "desktop":
 		{
 			switch runtime.GOOS {
@@ -675,9 +685,11 @@ func run() {
 		{
 			switch runtime.GOOS {
 			case "darwin", "linux":
-				runCmdOptional(exec.Command("killall", "adb"), "run.killadb")
-				//runCmdOptional(exec.Command("/opt/android-sdk/platform-tools/adb", "logcat", "-c"), "run.adblogcat")
-				exec.Command("/opt/android-sdk/platform-tools/adb", "install", "-r", filepath.Join(depPath, fmt.Sprintf("%v.apk", appName))).Start()
+				{
+					runCmdOptional(exec.Command("killall", "adb"), "run.killadb")
+					//runCmdOptional(exec.Command("/opt/android-sdk/platform-tools/adb", "logcat", "-c"), "run.adblogcat")
+					exec.Command("/opt/android-sdk/platform-tools/adb", "install", "-r", filepath.Join(depPath, fmt.Sprintf("%v.apk", appName))).Start()
+				}
 
 			case "windows":
 				{

internal/examples/quick/bridge/qml/bridge.qml

@@ -2,7 +2,7 @@ import QtQuick 2.5
 
 Rectangle
 {
-	width: 320
+	width: 160
 	height: 240
 
 	Rectangle

location/location.cpp

@@ -47,6 +47,10 @@ int QGeoManeuver_IsValid(void* ptr){
 	return static_cast<QGeoManeuver*>(ptr)->isValid();
 }
 
+void* QGeoManeuver_Position(void* ptr){
+	return new QGeoCoordinate(static_cast<QGeoManeuver*>(ptr)->position());
+}
+
 void QGeoManeuver_SetDirection(void* ptr, int direction){
 	static_cast<QGeoManeuver*>(ptr)->setDirection(static_cast<QGeoManeuver::InstructionDirection>(direction));
 }
@@ -75,6 +79,10 @@ int QGeoManeuver_TimeToNextInstruction(void* ptr){
 	return static_cast<QGeoManeuver*>(ptr)->timeToNextInstruction();
 }
 
+void* QGeoManeuver_Waypoint(void* ptr){
+	return new QGeoCoordinate(static_cast<QGeoManeuver*>(ptr)->waypoint());
+}
+
 void QGeoManeuver_DestroyQGeoManeuver(void* ptr){
 	static_cast<QGeoManeuver*>(ptr)->~QGeoManeuver();
 }
@@ -87,10 +95,22 @@ void* QGeoRoute_NewQGeoRoute2(void* other){
 	return new QGeoRoute(*static_cast<QGeoRoute*>(other));
 }
 
+void* QGeoRoute_Bounds(void* ptr){
+	return new QGeoRectangle(static_cast<QGeoRoute*>(ptr)->bounds());
+}
+
 double QGeoRoute_Distance(void* ptr){
 	return static_cast<double>(static_cast<QGeoRoute*>(ptr)->distance());
 }
 
+void* QGeoRoute_FirstRouteSegment(void* ptr){
+	return new QGeoRouteSegment(static_cast<QGeoRoute*>(ptr)->firstRouteSegment());
+}
+
+void* QGeoRoute_Request(void* ptr){
+	return new QGeoRouteRequest(static_cast<QGeoRoute*>(ptr)->request());
+}
+
 char* QGeoRoute_RouteId(void* ptr){
 	return static_cast<QGeoRoute*>(ptr)->routeId().toUtf8().data();
 }
@@ -194,6 +214,10 @@ int QGeoRouteReply_IsFinished(void* ptr){
 	return static_cast<QGeoRouteReply*>(ptr)->isFinished();
 }
 
+void* QGeoRouteReply_Request(void* ptr){
+	return new QGeoRouteRequest(static_cast<QGeoRouteReply*>(ptr)->request());
+}
+
 void QGeoRouteReply_DestroyQGeoRouteReply(void* ptr){
 	static_cast<QGeoRouteReply*>(ptr)->~QGeoRouteReply();
 }
@@ -298,6 +322,14 @@ int QGeoRouteSegment_IsValid(void* ptr){
 	return static_cast<QGeoRouteSegment*>(ptr)->isValid();
 }
 
+void* QGeoRouteSegment_Maneuver(void* ptr){
+	return new QGeoManeuver(static_cast<QGeoRouteSegment*>(ptr)->maneuver());
+}
+
+void* QGeoRouteSegment_NextRouteSegment(void* ptr){
+	return new QGeoRouteSegment(static_cast<QGeoRouteSegment*>(ptr)->nextRouteSegment());
+}
+
 void QGeoRouteSegment_SetDistance(void* ptr, double distance){
 	static_cast<QGeoRouteSegment*>(ptr)->setDistance(static_cast<double>(distance));
 }
@@ -359,6 +391,10 @@ void QGeoRoutingManager_Finished(void* ptr, void* reply){
 	static_cast<QGeoRoutingManager*>(ptr)->finished(static_cast<QGeoRouteReply*>(reply));
 }
 
+void* QGeoRoutingManager_Locale(void* ptr){
+	return new QLocale(static_cast<QGeoRoutingManager*>(ptr)->locale());
+}
+
 char* QGeoRoutingManager_ManagerName(void* ptr){
 	return static_cast<QGeoRoutingManager*>(ptr)->managerName().toUtf8().data();
 }
@@ -472,6 +508,10 @@ void QGeoRoutingManagerEngine_Finished(void* ptr, void* reply){
 	static_cast<QGeoRoutingManagerEngine*>(ptr)->finished(static_cast<QGeoRouteReply*>(reply));
 }
 
+void* QGeoRoutingManagerEngine_Locale(void* ptr){
+	return new QLocale(static_cast<QGeoRoutingManagerEngine*>(ptr)->locale());
+}
+
 char* QGeoRoutingManagerEngine_ManagerName(void* ptr){
 	return static_cast<QGeoRoutingManagerEngine*>(ptr)->managerName().toUtf8().data();
 }

location/location.go

@@ -229,6 +229,15 @@ func (ptr *QGeoManeuver) IsValid() bool {
 	return false
 }
 
+func (ptr *QGeoManeuver) Position() *positioning.QGeoCoordinate {
+	defer qt.Recovering("QGeoManeuver::position")
+
+	if ptr.Pointer() != nil {
+		return positioning.NewQGeoCoordinateFromPointer(C.QGeoManeuver_Position(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QGeoManeuver) SetDirection(direction QGeoManeuver__InstructionDirection) {
 	defer qt.Recovering("QGeoManeuver::setDirection")
 
@@ -286,6 +295,15 @@ func (ptr *QGeoManeuver) TimeToNextInstruction() int {
 	return 0
 }
 
+func (ptr *QGeoManeuver) Waypoint() *positioning.QGeoCoordinate {
+	defer qt.Recovering("QGeoManeuver::waypoint")
+
+	if ptr.Pointer() != nil {
+		return positioning.NewQGeoCoordinateFromPointer(C.QGeoManeuver_Waypoint(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QGeoManeuver) DestroyQGeoManeuver() {
 	defer qt.Recovering("QGeoManeuver::~QGeoManeuver")
 
@@ -344,6 +362,15 @@ func NewQGeoRoute2(other QGeoRoute_ITF) *QGeoRoute {
 	return newQGeoRouteFromPointer(C.QGeoRoute_NewQGeoRoute2(PointerFromQGeoRoute(other)))
 }
 
+func (ptr *QGeoRoute) Bounds() *positioning.QGeoRectangle {
+	defer qt.Recovering("QGeoRoute::bounds")
+
+	if ptr.Pointer() != nil {
+		return positioning.NewQGeoRectangleFromPointer(C.QGeoRoute_Bounds(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QGeoRoute) Distance() float64 {
 	defer qt.Recovering("QGeoRoute::distance")
 
@@ -353,6 +380,24 @@ func (ptr *QGeoRoute) Distance() float64 {
 	return 0
 }
 
+func (ptr *QGeoRoute) FirstRouteSegment() *QGeoRouteSegment {
+	defer qt.Recovering("QGeoRoute::firstRouteSegment")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoRouteSegmentFromPointer(C.QGeoRoute_FirstRouteSegment(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QGeoRoute) Request() *QGeoRouteRequest {
+	defer qt.Recovering("QGeoRoute::request")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoRouteRequestFromPointer(C.QGeoRoute_Request(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QGeoRoute) RouteId() string {
 	defer qt.Recovering("QGeoRoute::routeId")
 
@@ -640,6 +685,15 @@ func (ptr *QGeoRouteReply) IsFinished() bool {
 	return false
 }
 
+func (ptr *QGeoRouteReply) Request() *QGeoRouteRequest {
+	defer qt.Recovering("QGeoRouteReply::request")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoRouteRequestFromPointer(C.QGeoRouteReply_Request(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QGeoRouteReply) DestroyQGeoRouteReply() {
 	defer qt.Recovering("QGeoRouteReply::~QGeoRouteReply")
 
@@ -1075,6 +1129,24 @@ func (ptr *QGeoRouteSegment) IsValid() bool {
 	return false
 }
 
+func (ptr *QGeoRouteSegment) Maneuver() *QGeoManeuver {
+	defer qt.Recovering("QGeoRouteSegment::maneuver")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoManeuverFromPointer(C.QGeoRouteSegment_Maneuver(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QGeoRouteSegment) NextRouteSegment() *QGeoRouteSegment {
+	defer qt.Recovering("QGeoRouteSegment::nextRouteSegment")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoRouteSegmentFromPointer(C.QGeoRouteSegment_NextRouteSegment(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QGeoRouteSegment) SetDistance(distance float64) {
 	defer qt.Recovering("QGeoRouteSegment::setDistance")
 
@@ -1239,6 +1311,15 @@ func (ptr *QGeoRoutingManager) Finished(reply QGeoRouteReply_ITF) {
 	}
 }
 
+func (ptr *QGeoRoutingManager) Locale() *core.QLocale {
+	defer qt.Recovering("QGeoRoutingManager::locale")
+
+	if ptr.Pointer() != nil {
+		return core.NewQLocaleFromPointer(C.QGeoRoutingManager_Locale(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QGeoRoutingManager) ManagerName() string {
 	defer qt.Recovering("QGeoRoutingManager::managerName")
 
@@ -1604,6 +1685,15 @@ func (ptr *QGeoRoutingManagerEngine) Finished(reply QGeoRouteReply_ITF) {
 	}
 }
 
+func (ptr *QGeoRoutingManagerEngine) Locale() *core.QLocale {
+	defer qt.Recovering("QGeoRoutingManagerEngine::locale")
+
+	if ptr.Pointer() != nil {
+		return core.NewQLocaleFromPointer(C.QGeoRoutingManagerEngine_Locale(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QGeoRoutingManagerEngine) ManagerName() string {
 	defer qt.Recovering("QGeoRoutingManagerEngine::managerName")
 

location/location.h

@@ -31,6 +31,7 @@ int QGeoManeuver_Direction(void* ptr);
 double QGeoManeuver_DistanceToNextInstruction(void* ptr);
 char* QGeoManeuver_InstructionText(void* ptr);
 int QGeoManeuver_IsValid(void* ptr);
+void* QGeoManeuver_Position(void* ptr);
 void QGeoManeuver_SetDirection(void* ptr, int direction);
 void QGeoManeuver_SetDistanceToNextInstruction(void* ptr, double distance);
 void QGeoManeuver_SetInstructionText(void* ptr, char* instructionText);
@@ -38,10 +39,14 @@ void QGeoManeuver_SetPosition(void* ptr, void* position);
 void QGeoManeuver_SetTimeToNextInstruction(void* ptr, int secs);
 void QGeoManeuver_SetWaypoint(void* ptr, void* coordinate);
 int QGeoManeuver_TimeToNextInstruction(void* ptr);
+void* QGeoManeuver_Waypoint(void* ptr);
 void QGeoManeuver_DestroyQGeoManeuver(void* ptr);
 void* QGeoRoute_NewQGeoRoute();
 void* QGeoRoute_NewQGeoRoute2(void* other);
+void* QGeoRoute_Bounds(void* ptr);
 double QGeoRoute_Distance(void* ptr);
+void* QGeoRoute_FirstRouteSegment(void* ptr);
+void* QGeoRoute_Request(void* ptr);
 char* QGeoRoute_RouteId(void* ptr);
 void QGeoRoute_SetBounds(void* ptr, void* bounds);
 void QGeoRoute_SetDistance(void* ptr, double distance);
@@ -65,6 +70,7 @@ void QGeoRouteReply_ConnectFinished(void* ptr);
 void QGeoRouteReply_DisconnectFinished(void* ptr);
 void QGeoRouteReply_Finished(void* ptr);
 int QGeoRouteReply_IsFinished(void* ptr);
+void* QGeoRouteReply_Request(void* ptr);
 void QGeoRouteReply_DestroyQGeoRouteReply(void* ptr);
 void QGeoRouteReply_TimerEvent(void* ptr, void* event);
 void QGeoRouteReply_TimerEventDefault(void* ptr, void* event);
@@ -91,6 +97,8 @@ void* QGeoRouteSegment_NewQGeoRouteSegment();
 void* QGeoRouteSegment_NewQGeoRouteSegment2(void* other);
 double QGeoRouteSegment_Distance(void* ptr);
 int QGeoRouteSegment_IsValid(void* ptr);
+void* QGeoRouteSegment_Maneuver(void* ptr);
+void* QGeoRouteSegment_NextRouteSegment(void* ptr);
 void QGeoRouteSegment_SetDistance(void* ptr, double distance);
 void QGeoRouteSegment_SetManeuver(void* ptr, void* maneuver);
 void QGeoRouteSegment_SetNextRouteSegment(void* ptr, void* routeSegment);
@@ -104,6 +112,7 @@ void QGeoRoutingManager_Error(void* ptr, void* reply, int error, char* errorStri
 void QGeoRoutingManager_ConnectFinished(void* ptr);
 void QGeoRoutingManager_DisconnectFinished(void* ptr);
 void QGeoRoutingManager_Finished(void* ptr, void* reply);
+void* QGeoRoutingManager_Locale(void* ptr);
 char* QGeoRoutingManager_ManagerName(void* ptr);
 int QGeoRoutingManager_ManagerVersion(void* ptr);
 int QGeoRoutingManager_MeasurementSystem(void* ptr);
@@ -130,6 +139,7 @@ void QGeoRoutingManagerEngine_Error(void* ptr, void* reply, int error, char* err
 void QGeoRoutingManagerEngine_ConnectFinished(void* ptr);
 void QGeoRoutingManagerEngine_DisconnectFinished(void* ptr);
 void QGeoRoutingManagerEngine_Finished(void* ptr, void* reply);
+void* QGeoRoutingManagerEngine_Locale(void* ptr);
 char* QGeoRoutingManagerEngine_ManagerName(void* ptr);
 int QGeoRoutingManagerEngine_ManagerVersion(void* ptr);
 int QGeoRoutingManagerEngine_MeasurementSystem(void* ptr);

multimedia/multimedia.cpp

@@ -82,6 +82,7 @@
 #include <QMetaDataWriterControl>
 #include <QMetaObject>
 #include <QMultimedia>
+#include <QNetworkConfiguration>
 #include <QNetworkRequest>
 #include <QObject>
 #include <QPoint>
@@ -103,6 +104,7 @@
 #include <QVideoDeviceSelectorControl>
 #include <QVideoEncoderSettings>
 #include <QVideoEncoderSettingsControl>
+#include <QVideoFilterRunnable>
 #include <QVideoFrame>
 #include <QVideoProbe>
 #include <QVideoRendererControl>
@@ -254,6 +256,7 @@ public:
 	void Signal_NativeResolutionChanged(const QSize & resolution) { callbackQAbstractVideoSurfaceNativeResolutionChanged(this, this->objectName().toUtf8().data(), new QSize(static_cast<QSize>(resolution).width(), static_cast<QSize>(resolution).height())); };
 	void stop() { callbackQAbstractVideoSurfaceStop(this, this->objectName().toUtf8().data()); };
 	void Signal_SupportedFormatsChanged() { callbackQAbstractVideoSurfaceSupportedFormatsChanged(this, this->objectName().toUtf8().data()); };
+	void Signal_SurfaceFormatChanged(const QVideoSurfaceFormat & format) { callbackQAbstractVideoSurfaceSurfaceFormatChanged(this, this->objectName().toUtf8().data(), new QVideoSurfaceFormat(format)); };
 	void timerEvent(QTimerEvent * event) { callbackQAbstractVideoSurfaceTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQAbstractVideoSurfaceChildEvent(this, this->objectName().toUtf8().data(), event); };
 	void customEvent(QEvent * event) { callbackQAbstractVideoSurfaceCustomEvent(this, this->objectName().toUtf8().data(), event); };
@@ -299,6 +302,10 @@ void QAbstractVideoSurface_NativeResolutionChanged(void* ptr, void* resolution){
 	static_cast<QAbstractVideoSurface*>(ptr)->nativeResolutionChanged(*static_cast<QSize*>(resolution));
 }
 
+void* QAbstractVideoSurface_NearestFormat(void* ptr, void* format){
+	return new QVideoSurfaceFormat(static_cast<QAbstractVideoSurface*>(ptr)->nearestFormat(*static_cast<QVideoSurfaceFormat*>(format)));
+}
+
 int QAbstractVideoSurface_Present(void* ptr, void* frame){
 	return static_cast<QAbstractVideoSurface*>(ptr)->present(*static_cast<QVideoFrame*>(frame));
 }
@@ -327,6 +334,22 @@ void QAbstractVideoSurface_SupportedFormatsChanged(void* ptr){
 	static_cast<QAbstractVideoSurface*>(ptr)->supportedFormatsChanged();
 }
 
+void* QAbstractVideoSurface_SurfaceFormat(void* ptr){
+	return new QVideoSurfaceFormat(static_cast<QAbstractVideoSurface*>(ptr)->surfaceFormat());
+}
+
+void QAbstractVideoSurface_ConnectSurfaceFormatChanged(void* ptr){
+	QObject::connect(static_cast<QAbstractVideoSurface*>(ptr), static_cast<void (QAbstractVideoSurface::*)(const QVideoSurfaceFormat &)>(&QAbstractVideoSurface::surfaceFormatChanged), static_cast<MyQAbstractVideoSurface*>(ptr), static_cast<void (MyQAbstractVideoSurface::*)(const QVideoSurfaceFormat &)>(&MyQAbstractVideoSurface::Signal_SurfaceFormatChanged));;
+}
+
+void QAbstractVideoSurface_DisconnectSurfaceFormatChanged(void* ptr){
+	QObject::disconnect(static_cast<QAbstractVideoSurface*>(ptr), static_cast<void (QAbstractVideoSurface::*)(const QVideoSurfaceFormat &)>(&QAbstractVideoSurface::surfaceFormatChanged), static_cast<MyQAbstractVideoSurface*>(ptr), static_cast<void (MyQAbstractVideoSurface::*)(const QVideoSurfaceFormat &)>(&MyQAbstractVideoSurface::Signal_SurfaceFormatChanged));;
+}
+
+void QAbstractVideoSurface_SurfaceFormatChanged(void* ptr, void* format){
+	static_cast<QAbstractVideoSurface*>(ptr)->surfaceFormatChanged(*static_cast<QVideoSurfaceFormat*>(format));
+}
+
 void QAbstractVideoSurface_DestroyQAbstractVideoSurface(void* ptr){
 	static_cast<QAbstractVideoSurface*>(ptr)->~QAbstractVideoSurface();
 }
@@ -363,8 +386,8 @@ void* QAudioBuffer_NewQAudioBuffer3(void* other){
 	return new QAudioBuffer(*static_cast<QAudioBuffer*>(other));
 }
 
-void* QAudioBuffer_NewQAudioBuffer4(void* data, void* format, long long startTime){
-	return new QAudioBuffer(*static_cast<QByteArray*>(data), *static_cast<QAudioFormat*>(format), static_cast<long long>(startTime));
+void* QAudioBuffer_NewQAudioBuffer4(char* data, void* format, long long startTime){
+	return new QAudioBuffer(QByteArray(data), *static_cast<QAudioFormat*>(format), static_cast<long long>(startTime));
 }
 
 void* QAudioBuffer_NewQAudioBuffer5(int numFrames, void* format, long long startTime){
@@ -391,6 +414,10 @@ long long QAudioBuffer_Duration(void* ptr){
 	return static_cast<long long>(static_cast<QAudioBuffer*>(ptr)->duration());
 }
 
+void* QAudioBuffer_Format(void* ptr){
+	return new QAudioFormat(static_cast<QAudioBuffer*>(ptr)->format());
+}
+
 int QAudioBuffer_FrameCount(void* ptr){
 	return static_cast<QAudioBuffer*>(ptr)->frameCount();
 }
@@ -418,6 +445,7 @@ public:
 	void Signal_DurationChanged(qint64 duration) { callbackQAudioDecoderDurationChanged(this, this->objectName().toUtf8().data(), static_cast<long long>(duration)); };
 	void Signal_Error2(QAudioDecoder::Error error) { callbackQAudioDecoderError2(this, this->objectName().toUtf8().data(), error); };
 	void Signal_Finished() { callbackQAudioDecoderFinished(this, this->objectName().toUtf8().data()); };
+	void Signal_FormatChanged(const QAudioFormat & format) { callbackQAudioDecoderFormatChanged(this, this->objectName().toUtf8().data(), new QAudioFormat(format)); };
 	void Signal_PositionChanged(qint64 position) { callbackQAudioDecoderPositionChanged(this, this->objectName().toUtf8().data(), static_cast<long long>(position)); };
 	void Signal_SourceChanged() { callbackQAudioDecoderSourceChanged(this, this->objectName().toUtf8().data()); };
 	void Signal_StateChanged(QAudioDecoder::State state) { callbackQAudioDecoderStateChanged(this, this->objectName().toUtf8().data(), state); };
@@ -439,6 +467,10 @@ void* QAudioDecoder_NewQAudioDecoder(void* parent){
 	return new QAudioDecoder(static_cast<QObject*>(parent));
 }
 
+void* QAudioDecoder_AudioFormat(void* ptr){
+	return new QAudioFormat(static_cast<QAudioDecoder*>(ptr)->audioFormat());
+}
+
 int QAudioDecoder_BufferAvailable(void* ptr){
 	return static_cast<QAudioDecoder*>(ptr)->bufferAvailable();
 }
@@ -511,6 +543,18 @@ void QAudioDecoder_Finished(void* ptr){
 	static_cast<QAudioDecoder*>(ptr)->finished();
 }
 
+void QAudioDecoder_ConnectFormatChanged(void* ptr){
+	QObject::connect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)(const QAudioFormat &)>(&QAudioDecoder::formatChanged), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)(const QAudioFormat &)>(&MyQAudioDecoder::Signal_FormatChanged));;
+}
+
+void QAudioDecoder_DisconnectFormatChanged(void* ptr){
+	QObject::disconnect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)(const QAudioFormat &)>(&QAudioDecoder::formatChanged), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)(const QAudioFormat &)>(&MyQAudioDecoder::Signal_FormatChanged));;
+}
+
+void QAudioDecoder_FormatChanged(void* ptr, void* format){
+	static_cast<QAudioDecoder*>(ptr)->formatChanged(*static_cast<QAudioFormat*>(format));
+}
+
 int QAudioDecoder_QAudioDecoder_HasSupport(char* mimeType, char* codecs){
 	return QAudioDecoder::hasSupport(QString(mimeType), QString(codecs).split("|", QString::SkipEmptyParts));
 }
@@ -531,6 +575,10 @@ void QAudioDecoder_PositionChanged(void* ptr, long long position){
 	static_cast<QAudioDecoder*>(ptr)->positionChanged(static_cast<long long>(position));
 }
 
+void* QAudioDecoder_Read(void* ptr){
+	return new QAudioBuffer(static_cast<QAudioDecoder*>(ptr)->read());
+}
+
 void QAudioDecoder_SetAudioFormat(void* ptr, void* format){
 	static_cast<QAudioDecoder*>(ptr)->setAudioFormat(*static_cast<QAudioFormat*>(format));
 }
@@ -626,6 +674,7 @@ public:
 	void Signal_DurationChanged(qint64 duration) { callbackQAudioDecoderControlDurationChanged(this, this->objectName().toUtf8().data(), static_cast<long long>(duration)); };
 	void Signal_Error(int error, const QString & errorString) { callbackQAudioDecoderControlError(this, this->objectName().toUtf8().data(), error, errorString.toUtf8().data()); };
 	void Signal_Finished() { callbackQAudioDecoderControlFinished(this, this->objectName().toUtf8().data()); };
+	void Signal_FormatChanged(const QAudioFormat & format) { callbackQAudioDecoderControlFormatChanged(this, this->objectName().toUtf8().data(), new QAudioFormat(format)); };
 	void Signal_PositionChanged(qint64 position) { callbackQAudioDecoderControlPositionChanged(this, this->objectName().toUtf8().data(), static_cast<long long>(position)); };
 	void Signal_SourceChanged() { callbackQAudioDecoderControlSourceChanged(this, this->objectName().toUtf8().data()); };
 	void Signal_StateChanged(QAudioDecoder::State state) { callbackQAudioDecoderControlStateChanged(this, this->objectName().toUtf8().data(), state); };
@@ -634,6 +683,10 @@ public:
 	void customEvent(QEvent * event) { callbackQAudioDecoderControlCustomEvent(this, this->objectName().toUtf8().data(), event); };
 };
 
+void* QAudioDecoderControl_AudioFormat(void* ptr){
+	return new QAudioFormat(static_cast<QAudioDecoderControl*>(ptr)->audioFormat());
+}
+
 int QAudioDecoderControl_BufferAvailable(void* ptr){
 	return static_cast<QAudioDecoderControl*>(ptr)->bufferAvailable();
 }
@@ -702,6 +755,18 @@ void QAudioDecoderControl_Finished(void* ptr){
 	static_cast<QAudioDecoderControl*>(ptr)->finished();
 }
 
+void QAudioDecoderControl_ConnectFormatChanged(void* ptr){
+	QObject::connect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)(const QAudioFormat &)>(&QAudioDecoderControl::formatChanged), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)(const QAudioFormat &)>(&MyQAudioDecoderControl::Signal_FormatChanged));;
+}
+
+void QAudioDecoderControl_DisconnectFormatChanged(void* ptr){
+	QObject::disconnect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)(const QAudioFormat &)>(&QAudioDecoderControl::formatChanged), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)(const QAudioFormat &)>(&MyQAudioDecoderControl::Signal_FormatChanged));;
+}
+
+void QAudioDecoderControl_FormatChanged(void* ptr, void* format){
+	static_cast<QAudioDecoderControl*>(ptr)->formatChanged(*static_cast<QAudioFormat*>(format));
+}
+
 long long QAudioDecoderControl_Position(void* ptr){
 	return static_cast<long long>(static_cast<QAudioDecoderControl*>(ptr)->position());
 }
@@ -718,6 +783,10 @@ void QAudioDecoderControl_PositionChanged(void* ptr, long long position){
 	static_cast<QAudioDecoderControl*>(ptr)->positionChanged(static_cast<long long>(position));
 }
 
+void* QAudioDecoderControl_Read(void* ptr){
+	return new QAudioBuffer(static_cast<QAudioDecoderControl*>(ptr)->read());
+}
+
 void QAudioDecoderControl_SetAudioFormat(void* ptr, void* format){
 	static_cast<QAudioDecoderControl*>(ptr)->setAudioFormat(*static_cast<QAudioFormat*>(format));
 }
@@ -810,6 +879,14 @@ void* QAudioDeviceInfo_NewQAudioDeviceInfo2(void* other){
 	return new QAudioDeviceInfo(*static_cast<QAudioDeviceInfo*>(other));
 }
 
+void* QAudioDeviceInfo_QAudioDeviceInfo_DefaultInputDevice(){
+	return new QAudioDeviceInfo(QAudioDeviceInfo::defaultInputDevice());
+}
+
+void* QAudioDeviceInfo_QAudioDeviceInfo_DefaultOutputDevice(){
+	return new QAudioDeviceInfo(QAudioDeviceInfo::defaultOutputDevice());
+}
+
 char* QAudioDeviceInfo_DeviceName(void* ptr){
 	return static_cast<QAudioDeviceInfo*>(ptr)->deviceName().toUtf8().data();
 }
@@ -822,6 +899,14 @@ int QAudioDeviceInfo_IsNull(void* ptr){
 	return static_cast<QAudioDeviceInfo*>(ptr)->isNull();
 }
 
+void* QAudioDeviceInfo_NearestFormat(void* ptr, void* settings){
+	return new QAudioFormat(static_cast<QAudioDeviceInfo*>(ptr)->nearestFormat(*static_cast<QAudioFormat*>(settings)));
+}
+
+void* QAudioDeviceInfo_PreferredFormat(void* ptr){
+	return new QAudioFormat(static_cast<QAudioDeviceInfo*>(ptr)->preferredFormat());
+}
+
 char* QAudioDeviceInfo_SupportedCodecs(void* ptr){
 	return static_cast<QAudioDeviceInfo*>(ptr)->supportedCodecs().join("|").toUtf8().data();
 }
@@ -909,6 +994,10 @@ public:
 	void customEvent(QEvent * event) { callbackQAudioEncoderSettingsControlCustomEvent(this, this->objectName().toUtf8().data(), event); };
 };
 
+void* QAudioEncoderSettingsControl_AudioSettings(void* ptr){
+	return new QAudioEncoderSettings(static_cast<QAudioEncoderSettingsControl*>(ptr)->audioSettings());
+}
+
 char* QAudioEncoderSettingsControl_CodecDescription(void* ptr, char* codec){
 	return static_cast<QAudioEncoderSettingsControl*>(ptr)->codecDescription(QString(codec)).toUtf8().data();
 }
@@ -1050,6 +1139,10 @@ int QAudioInput_Error(void* ptr){
 	return static_cast<QAudioInput*>(ptr)->error();
 }
 
+void* QAudioInput_Format(void* ptr){
+	return new QAudioFormat(static_cast<QAudioInput*>(ptr)->format());
+}
+
 void QAudioInput_ConnectNotify(void* ptr){
 	QObject::connect(static_cast<QAudioInput*>(ptr), static_cast<void (QAudioInput::*)()>(&QAudioInput::notify), static_cast<MyQAudioInput*>(ptr), static_cast<void (MyQAudioInput::*)()>(&MyQAudioInput::Signal_Notify));;
 }
@@ -1272,6 +1365,10 @@ int QAudioOutput_Error(void* ptr){
 	return static_cast<QAudioOutput*>(ptr)->error();
 }
 
+void* QAudioOutput_Format(void* ptr){
+	return new QAudioFormat(static_cast<QAudioOutput*>(ptr)->format());
+}
+
 void QAudioOutput_ConnectNotify(void* ptr){
 	QObject::connect(static_cast<QAudioOutput*>(ptr), static_cast<void (QAudioOutput::*)()>(&QAudioOutput::notify), static_cast<MyQAudioOutput*>(ptr), static_cast<void (MyQAudioOutput::*)()>(&MyQAudioOutput::Signal_Notify));;
 }
@@ -1463,6 +1560,7 @@ void QAudioOutputSelectorControl_CustomEventDefault(void* ptr, void* event){
 
 class MyQAudioProbe: public QAudioProbe {
 public:
+	void Signal_AudioBufferProbed(const QAudioBuffer & buffer) { callbackQAudioProbeAudioBufferProbed(this, this->objectName().toUtf8().data(), new QAudioBuffer(buffer)); };
 	void Signal_Flush() { callbackQAudioProbeFlush(this, this->objectName().toUtf8().data()); };
 	void timerEvent(QTimerEvent * event) { callbackQAudioProbeTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQAudioProbeChildEvent(this, this->objectName().toUtf8().data(), event); };
@@ -1473,6 +1571,18 @@ void* QAudioProbe_NewQAudioProbe(void* parent){
 	return new QAudioProbe(static_cast<QObject*>(parent));
 }
 
+void QAudioProbe_ConnectAudioBufferProbed(void* ptr){
+	QObject::connect(static_cast<QAudioProbe*>(ptr), static_cast<void (QAudioProbe::*)(const QAudioBuffer &)>(&QAudioProbe::audioBufferProbed), static_cast<MyQAudioProbe*>(ptr), static_cast<void (MyQAudioProbe::*)(const QAudioBuffer &)>(&MyQAudioProbe::Signal_AudioBufferProbed));;
+}
+
+void QAudioProbe_DisconnectAudioBufferProbed(void* ptr){
+	QObject::disconnect(static_cast<QAudioProbe*>(ptr), static_cast<void (QAudioProbe::*)(const QAudioBuffer &)>(&QAudioProbe::audioBufferProbed), static_cast<MyQAudioProbe*>(ptr), static_cast<void (MyQAudioProbe::*)(const QAudioBuffer &)>(&MyQAudioProbe::Signal_AudioBufferProbed));;
+}
+
+void QAudioProbe_AudioBufferProbed(void* ptr, void* buffer){
+	static_cast<QAudioProbe*>(ptr)->audioBufferProbed(*static_cast<QAudioBuffer*>(buffer));
+}
+
 void QAudioProbe_ConnectFlush(void* ptr){
 	QObject::connect(static_cast<QAudioProbe*>(ptr), static_cast<void (QAudioProbe::*)()>(&QAudioProbe::flush), static_cast<MyQAudioProbe*>(ptr), static_cast<void (MyQAudioProbe::*)()>(&MyQAudioProbe::Signal_Flush));;
 }
@@ -1658,8 +1768,8 @@ void* QCamera_NewQCamera(void* parent){
 	return new MyQCamera(static_cast<QObject*>(parent));
 }
 
-void* QCamera_NewQCamera2(void* deviceName, void* parent){
-	return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QObject*>(parent));
+void* QCamera_NewQCamera2(char* deviceName, void* parent){
+	return new MyQCamera(QByteArray(deviceName), static_cast<QObject*>(parent));
 }
 
 void* QCamera_NewQCamera3(void* cameraInfo, void* parent){
@@ -1850,6 +1960,10 @@ void QCamera_Unlock2(void* ptr, int locks){
 	QMetaObject::invokeMethod(static_cast<QCamera*>(ptr), "unlock", Q_ARG(QCamera::LockType, static_cast<QCamera::LockType>(locks)));
 }
 
+void* QCamera_ViewfinderSettings(void* ptr){
+	return new QCameraViewfinderSettings(static_cast<QCamera*>(ptr)->viewfinderSettings());
+}
+
 void QCamera_DestroyQCamera(void* ptr){
 	static_cast<QCamera*>(ptr)->~QCamera();
 }
@@ -2817,6 +2931,8 @@ public:
 	void Signal_BufferFormatChanged(QVideoFrame::PixelFormat format) { callbackQCameraImageCaptureBufferFormatChanged(this, this->objectName().toUtf8().data(), format); };
 	void Signal_CaptureDestinationChanged(QCameraImageCapture::CaptureDestinations destination) { callbackQCameraImageCaptureCaptureDestinationChanged(this, this->objectName().toUtf8().data(), destination); };
 	void Signal_Error2(int id, QCameraImageCapture::Error error, const QString & errorString) { callbackQCameraImageCaptureError2(this, this->objectName().toUtf8().data(), id, error, errorString.toUtf8().data()); };
+	void Signal_ImageAvailable(int id, const QVideoFrame & buffer) { callbackQCameraImageCaptureImageAvailable(this, this->objectName().toUtf8().data(), id, new QVideoFrame(buffer)); };
+	void Signal_ImageCaptured(int id, const QImage & preview) { callbackQCameraImageCaptureImageCaptured(this, this->objectName().toUtf8().data(), id, new QImage(preview)); };
 	void Signal_ImageExposed(int id) { callbackQCameraImageCaptureImageExposed(this, this->objectName().toUtf8().data(), id); };
 	void Signal_ImageMetadataAvailable(int id, const QString & key, const QVariant & value) { callbackQCameraImageCaptureImageMetadataAvailable(this, this->objectName().toUtf8().data(), id, key.toUtf8().data(), new QVariant(value)); };
 	void Signal_ImageSaved(int id, const QString & fileName) { callbackQCameraImageCaptureImageSaved(this, this->objectName().toUtf8().data(), id, fileName.toUtf8().data()); };
@@ -2878,6 +2994,10 @@ void QCameraImageCapture_CaptureDestinationChanged(void* ptr, int destination){
 	static_cast<QCameraImageCapture*>(ptr)->captureDestinationChanged(static_cast<QCameraImageCapture::CaptureDestination>(destination));
 }
 
+void* QCameraImageCapture_EncodingSettings(void* ptr){
+	return new QImageEncoderSettings(static_cast<QCameraImageCapture*>(ptr)->encodingSettings());
+}
+
 void QCameraImageCapture_ConnectError2(void* ptr){
 	QObject::connect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(int, QCameraImageCapture::Error, const QString &)>(&QCameraImageCapture::error), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(int, QCameraImageCapture::Error, const QString &)>(&MyQCameraImageCapture::Signal_Error2));;
 }
@@ -2898,6 +3018,30 @@ char* QCameraImageCapture_ErrorString(void* ptr){
 	return static_cast<QCameraImageCapture*>(ptr)->errorString().toUtf8().data();
 }
 
+void QCameraImageCapture_ConnectImageAvailable(void* ptr){
+	QObject::connect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(int, const QVideoFrame &)>(&QCameraImageCapture::imageAvailable), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(int, const QVideoFrame &)>(&MyQCameraImageCapture::Signal_ImageAvailable));;
+}
+
+void QCameraImageCapture_DisconnectImageAvailable(void* ptr){
+	QObject::disconnect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(int, const QVideoFrame &)>(&QCameraImageCapture::imageAvailable), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(int, const QVideoFrame &)>(&MyQCameraImageCapture::Signal_ImageAvailable));;
+}
+
+void QCameraImageCapture_ImageAvailable(void* ptr, int id, void* buffer){
+	static_cast<QCameraImageCapture*>(ptr)->imageAvailable(id, *static_cast<QVideoFrame*>(buffer));
+}
+
+void QCameraImageCapture_ConnectImageCaptured(void* ptr){
+	QObject::connect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(int, const QImage &)>(&QCameraImageCapture::imageCaptured), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(int, const QImage &)>(&MyQCameraImageCapture::Signal_ImageCaptured));;
+}
+
+void QCameraImageCapture_DisconnectImageCaptured(void* ptr){
+	QObject::disconnect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(int, const QImage &)>(&QCameraImageCapture::imageCaptured), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(int, const QImage &)>(&MyQCameraImageCapture::Signal_ImageCaptured));;
+}
+
+void QCameraImageCapture_ImageCaptured(void* ptr, int id, void* preview){
+	static_cast<QCameraImageCapture*>(ptr)->imageCaptured(id, *static_cast<QImage*>(preview));
+}
+
 char* QCameraImageCapture_ImageCodecDescription(void* ptr, char* codec){
 	return static_cast<QCameraImageCapture*>(ptr)->imageCodecDescription(QString(codec)).toUtf8().data();
 }
@@ -3013,6 +3157,8 @@ void QCameraImageCapture_CustomEventDefault(void* ptr, void* event){
 class MyQCameraImageCaptureControl: public QCameraImageCaptureControl {
 public:
 	void Signal_Error(int id, int error, const QString & errorString) { callbackQCameraImageCaptureControlError(this, this->objectName().toUtf8().data(), id, error, errorString.toUtf8().data()); };
+	void Signal_ImageAvailable(int requestId, const QVideoFrame & buffer) { callbackQCameraImageCaptureControlImageAvailable(this, this->objectName().toUtf8().data(), requestId, new QVideoFrame(buffer)); };
+	void Signal_ImageCaptured(int requestId, const QImage & preview) { callbackQCameraImageCaptureControlImageCaptured(this, this->objectName().toUtf8().data(), requestId, new QImage(preview)); };
 	void Signal_ImageExposed(int requestId) { callbackQCameraImageCaptureControlImageExposed(this, this->objectName().toUtf8().data(), requestId); };
 	void Signal_ImageMetadataAvailable(int id, const QString & key, const QVariant & value) { callbackQCameraImageCaptureControlImageMetadataAvailable(this, this->objectName().toUtf8().data(), id, key.toUtf8().data(), new QVariant(value)); };
 	void Signal_ImageSaved(int requestId, const QString & fileName) { callbackQCameraImageCaptureControlImageSaved(this, this->objectName().toUtf8().data(), requestId, fileName.toUtf8().data()); };
@@ -3046,6 +3192,30 @@ void QCameraImageCaptureControl_Error(void* ptr, int id, int error, char* errorS
 	static_cast<QCameraImageCaptureControl*>(ptr)->error(id, error, QString(errorString));
 }
 
+void QCameraImageCaptureControl_ConnectImageAvailable(void* ptr){
+	QObject::connect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(int, const QVideoFrame &)>(&QCameraImageCaptureControl::imageAvailable), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(int, const QVideoFrame &)>(&MyQCameraImageCaptureControl::Signal_ImageAvailable));;
+}
+
+void QCameraImageCaptureControl_DisconnectImageAvailable(void* ptr){
+	QObject::disconnect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(int, const QVideoFrame &)>(&QCameraImageCaptureControl::imageAvailable), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(int, const QVideoFrame &)>(&MyQCameraImageCaptureControl::Signal_ImageAvailable));;
+}
+
+void QCameraImageCaptureControl_ImageAvailable(void* ptr, int requestId, void* buffer){
+	static_cast<QCameraImageCaptureControl*>(ptr)->imageAvailable(requestId, *static_cast<QVideoFrame*>(buffer));
+}
+
+void QCameraImageCaptureControl_ConnectImageCaptured(void* ptr){
+	QObject::connect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(int, const QImage &)>(&QCameraImageCaptureControl::imageCaptured), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(int, const QImage &)>(&MyQCameraImageCaptureControl::Signal_ImageCaptured));;
+}
+
+void QCameraImageCaptureControl_DisconnectImageCaptured(void* ptr){
+	QObject::disconnect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(int, const QImage &)>(&QCameraImageCaptureControl::imageCaptured), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(int, const QImage &)>(&MyQCameraImageCaptureControl::Signal_ImageCaptured));;
+}
+
+void QCameraImageCaptureControl_ImageCaptured(void* ptr, int requestId, void* preview){
+	static_cast<QCameraImageCaptureControl*>(ptr)->imageCaptured(requestId, *static_cast<QImage*>(preview));
+}
+
 void QCameraImageCaptureControl_ConnectImageExposed(void* ptr){
 	QObject::connect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(int)>(&QCameraImageCaptureControl::imageExposed), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(int)>(&MyQCameraImageCaptureControl::Signal_ImageExposed));;
 }
@@ -3266,8 +3436,8 @@ void QCameraImageProcessingControl_CustomEventDefault(void* ptr, void* event){
 	static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::customEvent(static_cast<QEvent*>(event));
 }
 
-void* QCameraInfo_NewQCameraInfo(void* name){
-	return new QCameraInfo(*static_cast<QByteArray*>(name));
+void* QCameraInfo_NewQCameraInfo(char* name){
+	return new QCameraInfo(QByteArray(name));
 }
 
 void* QCameraInfo_NewQCameraInfo2(void* camera){
@@ -3278,6 +3448,10 @@ void* QCameraInfo_NewQCameraInfo3(void* other){
 	return new QCameraInfo(*static_cast<QCameraInfo*>(other));
 }
 
+void* QCameraInfo_QCameraInfo_DefaultCamera(){
+	return new QCameraInfo(QCameraInfo::defaultCamera());
+}
+
 char* QCameraInfo_Description(void* ptr){
 	return static_cast<QCameraInfo*>(ptr)->description().toUtf8().data();
 }
@@ -3528,6 +3702,10 @@ void QCameraViewfinderSettingsControl2_SetViewfinderSettings(void* ptr, void* se
 	static_cast<QCameraViewfinderSettingsControl2*>(ptr)->setViewfinderSettings(*static_cast<QCameraViewfinderSettings*>(settings));
 }
 
+void* QCameraViewfinderSettingsControl2_ViewfinderSettings(void* ptr){
+	return new QCameraViewfinderSettings(static_cast<QCameraViewfinderSettingsControl2*>(ptr)->viewfinderSettings());
+}
+
 void QCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2(void* ptr){
 	static_cast<QCameraViewfinderSettingsControl2*>(ptr)->~QCameraViewfinderSettingsControl2();
 }
@@ -3708,6 +3886,10 @@ char* QImageEncoderControl_ImageCodecDescription(void* ptr, char* codec){
 	return static_cast<QImageEncoderControl*>(ptr)->imageCodecDescription(QString(codec)).toUtf8().data();
 }
 
+void* QImageEncoderControl_ImageSettings(void* ptr){
+	return new QImageEncoderSettings(static_cast<QImageEncoderControl*>(ptr)->imageSettings());
+}
+
 void QImageEncoderControl_SetImageSettings(void* ptr, void* settings){
 	static_cast<QImageEncoderControl*>(ptr)->setImageSettings(*static_cast<QImageEncoderSettings*>(settings));
 }
@@ -3798,12 +3980,25 @@ void QImageEncoderSettings_DestroyQImageEncoderSettings(void* ptr){
 
 class MyQMediaAudioProbeControl: public QMediaAudioProbeControl {
 public:
+	void Signal_AudioBufferProbed(const QAudioBuffer & buffer) { callbackQMediaAudioProbeControlAudioBufferProbed(this, this->objectName().toUtf8().data(), new QAudioBuffer(buffer)); };
 	void Signal_Flush() { callbackQMediaAudioProbeControlFlush(this, this->objectName().toUtf8().data()); };
 	void timerEvent(QTimerEvent * event) { callbackQMediaAudioProbeControlTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQMediaAudioProbeControlChildEvent(this, this->objectName().toUtf8().data(), event); };
 	void customEvent(QEvent * event) { callbackQMediaAudioProbeControlCustomEvent(this, this->objectName().toUtf8().data(), event); };
 };
 
+void QMediaAudioProbeControl_ConnectAudioBufferProbed(void* ptr){
+	QObject::connect(static_cast<QMediaAudioProbeControl*>(ptr), static_cast<void (QMediaAudioProbeControl::*)(const QAudioBuffer &)>(&QMediaAudioProbeControl::audioBufferProbed), static_cast<MyQMediaAudioProbeControl*>(ptr), static_cast<void (MyQMediaAudioProbeControl::*)(const QAudioBuffer &)>(&MyQMediaAudioProbeControl::Signal_AudioBufferProbed));;
+}
+
+void QMediaAudioProbeControl_DisconnectAudioBufferProbed(void* ptr){
+	QObject::disconnect(static_cast<QMediaAudioProbeControl*>(ptr), static_cast<void (QMediaAudioProbeControl::*)(const QAudioBuffer &)>(&QMediaAudioProbeControl::audioBufferProbed), static_cast<MyQMediaAudioProbeControl*>(ptr), static_cast<void (MyQMediaAudioProbeControl::*)(const QAudioBuffer &)>(&MyQMediaAudioProbeControl::Signal_AudioBufferProbed));;
+}
+
+void QMediaAudioProbeControl_AudioBufferProbed(void* ptr, void* buffer){
+	static_cast<QMediaAudioProbeControl*>(ptr)->audioBufferProbed(*static_cast<QAudioBuffer*>(buffer));
+}
+
 void QMediaAudioProbeControl_ConnectFlush(void* ptr){
 	QObject::connect(static_cast<QMediaAudioProbeControl*>(ptr), static_cast<void (QMediaAudioProbeControl::*)()>(&QMediaAudioProbeControl::flush), static_cast<MyQMediaAudioProbeControl*>(ptr), static_cast<void (MyQMediaAudioProbeControl::*)()>(&MyQMediaAudioProbeControl::Signal_Flush));;
 }
@@ -3999,6 +4194,14 @@ void* QMediaContent_NewQMediaContent2(void* url){
 	return new QMediaContent(*static_cast<QUrl*>(url));
 }
 
+void* QMediaContent_CanonicalRequest(void* ptr){
+	return new QNetworkRequest(static_cast<QMediaContent*>(ptr)->canonicalRequest());
+}
+
+void* QMediaContent_CanonicalResource(void* ptr){
+	return new QMediaResource(static_cast<QMediaContent*>(ptr)->canonicalResource());
+}
+
 void* QMediaContent_CanonicalUrl(void* ptr){
 	return new QUrl(static_cast<QMediaContent*>(ptr)->canonicalUrl());
 }
@@ -4139,11 +4342,28 @@ void QMediaGaplessPlaybackControl_CustomEventDefault(void* ptr, void* event){
 
 class MyQMediaNetworkAccessControl: public QMediaNetworkAccessControl {
 public:
+	void Signal_ConfigurationChanged(const QNetworkConfiguration & configuration) { callbackQMediaNetworkAccessControlConfigurationChanged(this, this->objectName().toUtf8().data(), new QNetworkConfiguration(configuration)); };
 	void timerEvent(QTimerEvent * event) { callbackQMediaNetworkAccessControlTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQMediaNetworkAccessControlChildEvent(this, this->objectName().toUtf8().data(), event); };
 	void customEvent(QEvent * event) { callbackQMediaNetworkAccessControlCustomEvent(this, this->objectName().toUtf8().data(), event); };
 };
 
+void QMediaNetworkAccessControl_ConnectConfigurationChanged(void* ptr){
+	QObject::connect(static_cast<QMediaNetworkAccessControl*>(ptr), static_cast<void (QMediaNetworkAccessControl::*)(const QNetworkConfiguration &)>(&QMediaNetworkAccessControl::configurationChanged), static_cast<MyQMediaNetworkAccessControl*>(ptr), static_cast<void (MyQMediaNetworkAccessControl::*)(const QNetworkConfiguration &)>(&MyQMediaNetworkAccessControl::Signal_ConfigurationChanged));;
+}
+
+void QMediaNetworkAccessControl_DisconnectConfigurationChanged(void* ptr){
+	QObject::disconnect(static_cast<QMediaNetworkAccessControl*>(ptr), static_cast<void (QMediaNetworkAccessControl::*)(const QNetworkConfiguration &)>(&QMediaNetworkAccessControl::configurationChanged), static_cast<MyQMediaNetworkAccessControl*>(ptr), static_cast<void (MyQMediaNetworkAccessControl::*)(const QNetworkConfiguration &)>(&MyQMediaNetworkAccessControl::Signal_ConfigurationChanged));;
+}
+
+void QMediaNetworkAccessControl_ConfigurationChanged(void* ptr, void* configuration){
+	static_cast<QMediaNetworkAccessControl*>(ptr)->configurationChanged(*static_cast<QNetworkConfiguration*>(configuration));
+}
+
+void* QMediaNetworkAccessControl_CurrentConfiguration(void* ptr){
+	return new QNetworkConfiguration(static_cast<QMediaNetworkAccessControl*>(ptr)->currentConfiguration());
+}
+
 void QMediaNetworkAccessControl_DestroyQMediaNetworkAccessControl(void* ptr){
 	static_cast<QMediaNetworkAccessControl*>(ptr)->~QMediaNetworkAccessControl();
 }
@@ -4341,6 +4561,7 @@ public:
 	void Signal_MediaChanged(const QMediaContent & media) { callbackQMediaPlayerMediaChanged(this, this->objectName().toUtf8().data(), new QMediaContent(media)); };
 	void Signal_MediaStatusChanged(QMediaPlayer::MediaStatus status) { callbackQMediaPlayerMediaStatusChanged(this, this->objectName().toUtf8().data(), status); };
 	void Signal_MutedChanged(bool muted) { callbackQMediaPlayerMutedChanged(this, this->objectName().toUtf8().data(), muted); };
+	void Signal_NetworkConfigurationChanged(const QNetworkConfiguration & configuration) { callbackQMediaPlayerNetworkConfigurationChanged(this, this->objectName().toUtf8().data(), new QNetworkConfiguration(configuration)); };
 	void Signal_PlaybackRateChanged(qreal rate) { callbackQMediaPlayerPlaybackRateChanged(this, this->objectName().toUtf8().data(), static_cast<double>(rate)); };
 	void Signal_PositionChanged(qint64 position) { callbackQMediaPlayerPositionChanged(this, this->objectName().toUtf8().data(), static_cast<long long>(position)); };
 	void Signal_SeekableChanged(bool seekable) { callbackQMediaPlayerSeekableChanged(this, this->objectName().toUtf8().data(), seekable); };
@@ -4485,6 +4706,10 @@ void QMediaPlayer_CurrentMediaChanged(void* ptr, void* media){
 	static_cast<QMediaPlayer*>(ptr)->currentMediaChanged(*static_cast<QMediaContent*>(media));
 }
 
+void* QMediaPlayer_CurrentNetworkConfiguration(void* ptr){
+	return new QNetworkConfiguration(static_cast<QMediaPlayer*>(ptr)->currentNetworkConfiguration());
+}
+
 void QMediaPlayer_ConnectDurationChanged(void* ptr){
 	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(qint64)>(&QMediaPlayer::durationChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(qint64)>(&MyQMediaPlayer::Signal_DurationChanged));;
 }
@@ -4557,6 +4782,18 @@ void QMediaPlayer_MutedChanged(void* ptr, int muted){
 	static_cast<QMediaPlayer*>(ptr)->mutedChanged(muted != 0);
 }
 
+void QMediaPlayer_ConnectNetworkConfigurationChanged(void* ptr){
+	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(const QNetworkConfiguration &)>(&QMediaPlayer::networkConfigurationChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(const QNetworkConfiguration &)>(&MyQMediaPlayer::Signal_NetworkConfigurationChanged));;
+}
+
+void QMediaPlayer_DisconnectNetworkConfigurationChanged(void* ptr){
+	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(const QNetworkConfiguration &)>(&QMediaPlayer::networkConfigurationChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(const QNetworkConfiguration &)>(&MyQMediaPlayer::Signal_NetworkConfigurationChanged));;
+}
+
+void QMediaPlayer_NetworkConfigurationChanged(void* ptr, void* configuration){
+	static_cast<QMediaPlayer*>(ptr)->networkConfigurationChanged(*static_cast<QNetworkConfiguration*>(configuration));
+}
+
 void QMediaPlayer_Pause(void* ptr){
 	QMetaObject::invokeMethod(static_cast<QMediaPlayer*>(ptr), "pause");
 }
@@ -4688,6 +4925,7 @@ void QMediaPlayer_CustomEventDefault(void* ptr, void* event){
 class MyQMediaPlayerControl: public QMediaPlayerControl {
 public:
 	void Signal_AudioAvailableChanged(bool audio) { callbackQMediaPlayerControlAudioAvailableChanged(this, this->objectName().toUtf8().data(), audio); };
+	void Signal_AvailablePlaybackRangesChanged(const QMediaTimeRange & ranges) { callbackQMediaPlayerControlAvailablePlaybackRangesChanged(this, this->objectName().toUtf8().data(), new QMediaTimeRange(ranges)); };
 	void Signal_BufferStatusChanged(int progress) { callbackQMediaPlayerControlBufferStatusChanged(this, this->objectName().toUtf8().data(), progress); };
 	void Signal_DurationChanged(qint64 duration) { callbackQMediaPlayerControlDurationChanged(this, this->objectName().toUtf8().data(), static_cast<long long>(duration)); };
 	void Signal_Error(int error, const QString & errorString) { callbackQMediaPlayerControlError(this, this->objectName().toUtf8().data(), error, errorString.toUtf8().data()); };
@@ -4717,6 +4955,22 @@ void QMediaPlayerControl_AudioAvailableChanged(void* ptr, int audio){
 	static_cast<QMediaPlayerControl*>(ptr)->audioAvailableChanged(audio != 0);
 }
 
+void* QMediaPlayerControl_AvailablePlaybackRanges(void* ptr){
+	return new QMediaTimeRange(static_cast<QMediaPlayerControl*>(ptr)->availablePlaybackRanges());
+}
+
+void QMediaPlayerControl_ConnectAvailablePlaybackRangesChanged(void* ptr){
+	QObject::connect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(const QMediaTimeRange &)>(&QMediaPlayerControl::availablePlaybackRangesChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(const QMediaTimeRange &)>(&MyQMediaPlayerControl::Signal_AvailablePlaybackRangesChanged));;
+}
+
+void QMediaPlayerControl_DisconnectAvailablePlaybackRangesChanged(void* ptr){
+	QObject::disconnect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(const QMediaTimeRange &)>(&QMediaPlayerControl::availablePlaybackRangesChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(const QMediaTimeRange &)>(&MyQMediaPlayerControl::Signal_AvailablePlaybackRangesChanged));;
+}
+
+void QMediaPlayerControl_AvailablePlaybackRangesChanged(void* ptr, void* ranges){
+	static_cast<QMediaPlayerControl*>(ptr)->availablePlaybackRangesChanged(*static_cast<QMediaTimeRange*>(ranges));
+}
+
 int QMediaPlayerControl_BufferStatus(void* ptr){
 	return static_cast<QMediaPlayerControl*>(ptr)->bufferStatus();
 }
@@ -5332,6 +5586,10 @@ char* QMediaRecorder_AudioCodecDescription(void* ptr, char* codec){
 	return static_cast<QMediaRecorder*>(ptr)->audioCodecDescription(QString(codec)).toUtf8().data();
 }
 
+void* QMediaRecorder_AudioSettings(void* ptr){
+	return new QAudioEncoderSettings(static_cast<QMediaRecorder*>(ptr)->audioSettings());
+}
+
 int QMediaRecorder_Availability(void* ptr){
 	return static_cast<QMediaRecorder*>(ptr)->availability();
 }
@@ -5556,6 +5814,10 @@ char* QMediaRecorder_VideoCodecDescription(void* ptr, char* codec){
 	return static_cast<QMediaRecorder*>(ptr)->videoCodecDescription(QString(codec)).toUtf8().data();
 }
 
+void* QMediaRecorder_VideoSettings(void* ptr){
+	return new QVideoEncoderSettings(static_cast<QMediaRecorder*>(ptr)->videoSettings());
+}
+
 void QMediaRecorder_ConnectVolumeChanged(void* ptr){
 	QObject::connect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(qreal)>(&QMediaRecorder::volumeChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(qreal)>(&MyQMediaRecorder::Signal_VolumeChanged));;
 }
@@ -5810,6 +6072,10 @@ char* QMediaResource_MimeType(void* ptr){
 	return static_cast<QMediaResource*>(ptr)->mimeType().toUtf8().data();
 }
 
+void* QMediaResource_Request(void* ptr){
+	return new QNetworkRequest(static_cast<QMediaResource*>(ptr)->request());
+}
+
 void* QMediaResource_Resolution(void* ptr){
 	return new QSize(static_cast<QSize>(static_cast<QMediaResource*>(ptr)->resolution()).width(), static_cast<QSize>(static_cast<QMediaResource*>(ptr)->resolution()).height());
 }
@@ -5921,12 +6187,12 @@ public:
 	void setObjectNameAbs(const QString &name) { this->_objectName = name; };
 };
 
-int QMediaServiceCameraInfoInterface_CameraOrientation(void* ptr, void* device){
-	return static_cast<QMediaServiceCameraInfoInterface*>(ptr)->cameraOrientation(*static_cast<QByteArray*>(device));
+int QMediaServiceCameraInfoInterface_CameraOrientation(void* ptr, char* device){
+	return static_cast<QMediaServiceCameraInfoInterface*>(ptr)->cameraOrientation(QByteArray(device));
 }
 
-int QMediaServiceCameraInfoInterface_CameraPosition(void* ptr, void* device){
-	return static_cast<QMediaServiceCameraInfoInterface*>(ptr)->cameraPosition(*static_cast<QByteArray*>(device));
+int QMediaServiceCameraInfoInterface_CameraPosition(void* ptr, char* device){
+	return static_cast<QMediaServiceCameraInfoInterface*>(ptr)->cameraPosition(QByteArray(device));
 }
 
 void QMediaServiceCameraInfoInterface_DestroyQMediaServiceCameraInfoInterface(void* ptr){
@@ -5953,8 +6219,8 @@ public:
 	void setObjectNameAbs(const QString &name) { this->_objectName = name; };
 };
 
-void* QMediaServiceDefaultDeviceInterface_DefaultDevice(void* ptr, void* service){
-	return new QByteArray(static_cast<QMediaServiceDefaultDeviceInterface*>(ptr)->defaultDevice(*static_cast<QByteArray*>(service)));
+char* QMediaServiceDefaultDeviceInterface_DefaultDevice(void* ptr, char* service){
+	return QString(static_cast<QMediaServiceDefaultDeviceInterface*>(ptr)->defaultDevice(QByteArray(service))).toUtf8().data();
 }
 
 void QMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterface(void* ptr){
@@ -6037,8 +6303,8 @@ public:
 	void setObjectNameAbs(const QString &name) { this->_objectName = name; };
 };
 
-char* QMediaServiceSupportedDevicesInterface_DeviceDescription(void* ptr, void* service, void* device){
-	return static_cast<QMediaServiceSupportedDevicesInterface*>(ptr)->deviceDescription(*static_cast<QByteArray*>(service), *static_cast<QByteArray*>(device)).toUtf8().data();
+char* QMediaServiceSupportedDevicesInterface_DeviceDescription(void* ptr, char* service, char* device){
+	return static_cast<QMediaServiceSupportedDevicesInterface*>(ptr)->deviceDescription(QByteArray(service), QByteArray(device)).toUtf8().data();
 }
 
 void QMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterface(void* ptr){
@@ -6195,10 +6461,18 @@ int QMediaTimeInterval_IsNormal(void* ptr){
 	return static_cast<QMediaTimeInterval*>(ptr)->isNormal();
 }
 
+void* QMediaTimeInterval_Normalized(void* ptr){
+	return new QMediaTimeInterval(static_cast<QMediaTimeInterval*>(ptr)->normalized());
+}
+
 long long QMediaTimeInterval_Start(void* ptr){
 	return static_cast<long long>(static_cast<QMediaTimeInterval*>(ptr)->start());
 }
 
+void* QMediaTimeInterval_Translated(void* ptr, long long offset){
+	return new QMediaTimeInterval(static_cast<QMediaTimeInterval*>(ptr)->translated(static_cast<long long>(offset)));
+}
+
 void* QMediaTimeRange_NewQMediaTimeRange(){
 	return new QMediaTimeRange();
 }
@@ -6270,6 +6544,7 @@ void QMediaTimeRange_DestroyQMediaTimeRange(void* ptr){
 class MyQMediaVideoProbeControl: public QMediaVideoProbeControl {
 public:
 	void Signal_Flush() { callbackQMediaVideoProbeControlFlush(this, this->objectName().toUtf8().data()); };
+	void Signal_VideoFrameProbed(const QVideoFrame & frame) { callbackQMediaVideoProbeControlVideoFrameProbed(this, this->objectName().toUtf8().data(), new QVideoFrame(frame)); };
 	void timerEvent(QTimerEvent * event) { callbackQMediaVideoProbeControlTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQMediaVideoProbeControlChildEvent(this, this->objectName().toUtf8().data(), event); };
 	void customEvent(QEvent * event) { callbackQMediaVideoProbeControlCustomEvent(this, this->objectName().toUtf8().data(), event); };
@@ -6287,6 +6562,18 @@ void QMediaVideoProbeControl_Flush(void* ptr){
 	static_cast<QMediaVideoProbeControl*>(ptr)->flush();
 }
 
+void QMediaVideoProbeControl_ConnectVideoFrameProbed(void* ptr){
+	QObject::connect(static_cast<QMediaVideoProbeControl*>(ptr), static_cast<void (QMediaVideoProbeControl::*)(const QVideoFrame &)>(&QMediaVideoProbeControl::videoFrameProbed), static_cast<MyQMediaVideoProbeControl*>(ptr), static_cast<void (MyQMediaVideoProbeControl::*)(const QVideoFrame &)>(&MyQMediaVideoProbeControl::Signal_VideoFrameProbed));;
+}
+
+void QMediaVideoProbeControl_DisconnectVideoFrameProbed(void* ptr){
+	QObject::disconnect(static_cast<QMediaVideoProbeControl*>(ptr), static_cast<void (QMediaVideoProbeControl::*)(const QVideoFrame &)>(&QMediaVideoProbeControl::videoFrameProbed), static_cast<MyQMediaVideoProbeControl*>(ptr), static_cast<void (MyQMediaVideoProbeControl::*)(const QVideoFrame &)>(&MyQMediaVideoProbeControl::Signal_VideoFrameProbed));;
+}
+
+void QMediaVideoProbeControl_VideoFrameProbed(void* ptr, void* frame){
+	static_cast<QMediaVideoProbeControl*>(ptr)->videoFrameProbed(*static_cast<QVideoFrame*>(frame));
+}
+
 void QMediaVideoProbeControl_DestroyQMediaVideoProbeControl(void* ptr){
 	static_cast<QMediaVideoProbeControl*>(ptr)->~QMediaVideoProbeControl();
 }
@@ -7908,6 +8195,10 @@ char* QVideoEncoderSettingsControl_VideoCodecDescription(void* ptr, char* codec)
 	return static_cast<QVideoEncoderSettingsControl*>(ptr)->videoCodecDescription(QString(codec)).toUtf8().data();
 }
 
+void* QVideoEncoderSettingsControl_VideoSettings(void* ptr){
+	return new QVideoEncoderSettings(static_cast<QVideoEncoderSettingsControl*>(ptr)->videoSettings());
+}
+
 void QVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControl(void* ptr){
 	static_cast<QVideoEncoderSettingsControl*>(ptr)->~QVideoEncoderSettingsControl();
 }
@@ -7936,6 +8227,10 @@ void QVideoEncoderSettingsControl_CustomEventDefault(void* ptr, void* event){
 	static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::customEvent(static_cast<QEvent*>(event));
 }
 
+void* QVideoFilterRunnable_Run(void* ptr, void* input, void* surfaceFormat, int flags){
+	return new QVideoFrame(static_cast<QVideoFilterRunnable*>(ptr)->run(static_cast<QVideoFrame*>(input), *static_cast<QVideoSurfaceFormat*>(surfaceFormat), static_cast<QVideoFilterRunnable::RunFlag>(flags)));
+}
+
 void* QVideoFrame_NewQVideoFrame(){
 	return new QVideoFrame();
 }
@@ -8071,6 +8366,7 @@ void QVideoFrame_DestroyQVideoFrame(void* ptr){
 class MyQVideoProbe: public QVideoProbe {
 public:
 	void Signal_Flush() { callbackQVideoProbeFlush(this, this->objectName().toUtf8().data()); };
+	void Signal_VideoFrameProbed(const QVideoFrame & frame) { callbackQVideoProbeVideoFrameProbed(this, this->objectName().toUtf8().data(), new QVideoFrame(frame)); };
 	void timerEvent(QTimerEvent * event) { callbackQVideoProbeTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQVideoProbeChildEvent(this, this->objectName().toUtf8().data(), event); };
 	void customEvent(QEvent * event) { callbackQVideoProbeCustomEvent(this, this->objectName().toUtf8().data(), event); };
@@ -8104,6 +8400,18 @@ int QVideoProbe_SetSource2(void* ptr, void* mediaRecorder){
 	return static_cast<QVideoProbe*>(ptr)->setSource(static_cast<QMediaRecorder*>(mediaRecorder));
 }
 
+void QVideoProbe_ConnectVideoFrameProbed(void* ptr){
+	QObject::connect(static_cast<QVideoProbe*>(ptr), static_cast<void (QVideoProbe::*)(const QVideoFrame &)>(&QVideoProbe::videoFrameProbed), static_cast<MyQVideoProbe*>(ptr), static_cast<void (MyQVideoProbe::*)(const QVideoFrame &)>(&MyQVideoProbe::Signal_VideoFrameProbed));;
+}
+
+void QVideoProbe_DisconnectVideoFrameProbed(void* ptr){
+	QObject::disconnect(static_cast<QVideoProbe*>(ptr), static_cast<void (QVideoProbe::*)(const QVideoFrame &)>(&QVideoProbe::videoFrameProbed), static_cast<MyQVideoProbe*>(ptr), static_cast<void (MyQVideoProbe::*)(const QVideoFrame &)>(&MyQVideoProbe::Signal_VideoFrameProbed));;
+}
+
+void QVideoProbe_VideoFrameProbed(void* ptr, void* frame){
+	static_cast<QVideoProbe*>(ptr)->videoFrameProbed(*static_cast<QVideoFrame*>(frame));
+}
+
 void QVideoProbe_DestroyQVideoProbe(void* ptr){
 	static_cast<QVideoProbe*>(ptr)->~QVideoProbe();
 }

multimedia/multimedia.h

@@ -45,6 +45,8 @@ int QAbstractVideoSurface_IsFormatSupportedDefault(void* ptr, void* format);
 void QAbstractVideoSurface_ConnectNativeResolutionChanged(void* ptr);
 void QAbstractVideoSurface_DisconnectNativeResolutionChanged(void* ptr);
 void QAbstractVideoSurface_NativeResolutionChanged(void* ptr, void* resolution);
+void* QAbstractVideoSurface_NearestFormat(void* ptr, void* format);
+void* QAbstractVideoSurface_NearestFormatDefault(void* ptr, void* format);
 int QAbstractVideoSurface_Present(void* ptr, void* frame);
 int QAbstractVideoSurface_Start(void* ptr, void* format);
 int QAbstractVideoSurface_StartDefault(void* ptr, void* format);
@@ -53,6 +55,10 @@ void QAbstractVideoSurface_StopDefault(void* ptr);
 void QAbstractVideoSurface_ConnectSupportedFormatsChanged(void* ptr);
 void QAbstractVideoSurface_DisconnectSupportedFormatsChanged(void* ptr);
 void QAbstractVideoSurface_SupportedFormatsChanged(void* ptr);
+void* QAbstractVideoSurface_SurfaceFormat(void* ptr);
+void QAbstractVideoSurface_ConnectSurfaceFormatChanged(void* ptr);
+void QAbstractVideoSurface_DisconnectSurfaceFormatChanged(void* ptr);
+void QAbstractVideoSurface_SurfaceFormatChanged(void* ptr, void* format);
 void QAbstractVideoSurface_DestroyQAbstractVideoSurface(void* ptr);
 void QAbstractVideoSurface_TimerEvent(void* ptr, void* event);
 void QAbstractVideoSurface_TimerEventDefault(void* ptr, void* event);
@@ -62,13 +68,14 @@ void QAbstractVideoSurface_CustomEvent(void* ptr, void* event);
 void QAbstractVideoSurface_CustomEventDefault(void* ptr, void* event);
 void* QAudioBuffer_NewQAudioBuffer();
 void* QAudioBuffer_NewQAudioBuffer3(void* other);
-void* QAudioBuffer_NewQAudioBuffer4(void* data, void* format, long long startTime);
+void* QAudioBuffer_NewQAudioBuffer4(char* data, void* format, long long startTime);
 void* QAudioBuffer_NewQAudioBuffer5(int numFrames, void* format, long long startTime);
 int QAudioBuffer_ByteCount(void* ptr);
 void* QAudioBuffer_ConstData(void* ptr);
 void* QAudioBuffer_Data2(void* ptr);
 void* QAudioBuffer_Data(void* ptr);
 long long QAudioBuffer_Duration(void* ptr);
+void* QAudioBuffer_Format(void* ptr);
 int QAudioBuffer_FrameCount(void* ptr);
 int QAudioBuffer_IsValid(void* ptr);
 int QAudioBuffer_SampleCount(void* ptr);
@@ -77,6 +84,7 @@ void QAudioBuffer_DestroyQAudioBuffer(void* ptr);
 char* QAudioDecoder_ErrorString(void* ptr);
 int QAudioDecoder_State(void* ptr);
 void* QAudioDecoder_NewQAudioDecoder(void* parent);
+void* QAudioDecoder_AudioFormat(void* ptr);
 int QAudioDecoder_BufferAvailable(void* ptr);
 void QAudioDecoder_ConnectBufferAvailableChanged(void* ptr);
 void QAudioDecoder_DisconnectBufferAvailableChanged(void* ptr);
@@ -95,11 +103,15 @@ int QAudioDecoder_Error(void* ptr);
 void QAudioDecoder_ConnectFinished(void* ptr);
 void QAudioDecoder_DisconnectFinished(void* ptr);
 void QAudioDecoder_Finished(void* ptr);
+void QAudioDecoder_ConnectFormatChanged(void* ptr);
+void QAudioDecoder_DisconnectFormatChanged(void* ptr);
+void QAudioDecoder_FormatChanged(void* ptr, void* format);
 int QAudioDecoder_QAudioDecoder_HasSupport(char* mimeType, char* codecs);
 long long QAudioDecoder_Position(void* ptr);
 void QAudioDecoder_ConnectPositionChanged(void* ptr);
 void QAudioDecoder_DisconnectPositionChanged(void* ptr);
 void QAudioDecoder_PositionChanged(void* ptr, long long position);
+void* QAudioDecoder_Read(void* ptr);
 void QAudioDecoder_SetAudioFormat(void* ptr, void* format);
 void QAudioDecoder_SetSourceDevice(void* ptr, void* device);
 void QAudioDecoder_SetSourceFilename(void* ptr, char* fileName);
@@ -122,6 +134,7 @@ void QAudioDecoder_ChildEvent(void* ptr, void* event);
 void QAudioDecoder_ChildEventDefault(void* ptr, void* event);
 void QAudioDecoder_CustomEvent(void* ptr, void* event);
 void QAudioDecoder_CustomEventDefault(void* ptr, void* event);
+void* QAudioDecoderControl_AudioFormat(void* ptr);
 int QAudioDecoderControl_BufferAvailable(void* ptr);
 void QAudioDecoderControl_ConnectBufferAvailableChanged(void* ptr);
 void QAudioDecoderControl_DisconnectBufferAvailableChanged(void* ptr);
@@ -139,10 +152,14 @@ void QAudioDecoderControl_Error(void* ptr, int error, char* errorString);
 void QAudioDecoderControl_ConnectFinished(void* ptr);
 void QAudioDecoderControl_DisconnectFinished(void* ptr);
 void QAudioDecoderControl_Finished(void* ptr);
+void QAudioDecoderControl_ConnectFormatChanged(void* ptr);
+void QAudioDecoderControl_DisconnectFormatChanged(void* ptr);
+void QAudioDecoderControl_FormatChanged(void* ptr, void* format);
 long long QAudioDecoderControl_Position(void* ptr);
 void QAudioDecoderControl_ConnectPositionChanged(void* ptr);
 void QAudioDecoderControl_DisconnectPositionChanged(void* ptr);
 void QAudioDecoderControl_PositionChanged(void* ptr, long long position);
+void* QAudioDecoderControl_Read(void* ptr);
 void QAudioDecoderControl_SetAudioFormat(void* ptr, void* format);
 void QAudioDecoderControl_SetSourceDevice(void* ptr, void* device);
 void QAudioDecoderControl_SetSourceFilename(void* ptr, char* fileName);
@@ -166,9 +183,13 @@ void QAudioDecoderControl_CustomEvent(void* ptr, void* event);
 void QAudioDecoderControl_CustomEventDefault(void* ptr, void* event);
 void* QAudioDeviceInfo_NewQAudioDeviceInfo();
 void* QAudioDeviceInfo_NewQAudioDeviceInfo2(void* other);
+void* QAudioDeviceInfo_QAudioDeviceInfo_DefaultInputDevice();
+void* QAudioDeviceInfo_QAudioDeviceInfo_DefaultOutputDevice();
 char* QAudioDeviceInfo_DeviceName(void* ptr);
 int QAudioDeviceInfo_IsFormatSupported(void* ptr, void* settings);
 int QAudioDeviceInfo_IsNull(void* ptr);
+void* QAudioDeviceInfo_NearestFormat(void* ptr, void* settings);
+void* QAudioDeviceInfo_PreferredFormat(void* ptr);
 char* QAudioDeviceInfo_SupportedCodecs(void* ptr);
 void QAudioDeviceInfo_DestroyQAudioDeviceInfo(void* ptr);
 void* QAudioEncoderSettings_NewQAudioEncoderSettings();
@@ -189,6 +210,7 @@ void QAudioEncoderSettings_SetEncodingOption(void* ptr, char* option, void* valu
 void QAudioEncoderSettings_SetQuality(void* ptr, int quality);
 void QAudioEncoderSettings_SetSampleRate(void* ptr, int rate);
 void QAudioEncoderSettings_DestroyQAudioEncoderSettings(void* ptr);
+void* QAudioEncoderSettingsControl_AudioSettings(void* ptr);
 char* QAudioEncoderSettingsControl_CodecDescription(void* ptr, char* codec);
 void QAudioEncoderSettingsControl_SetAudioSettings(void* ptr, void* settings);
 char* QAudioEncoderSettingsControl_SupportedAudioCodecs(void* ptr);
@@ -222,6 +244,7 @@ int QAudioInput_BufferSize(void* ptr);
 int QAudioInput_BytesReady(void* ptr);
 long long QAudioInput_ElapsedUSecs(void* ptr);
 int QAudioInput_Error(void* ptr);
+void* QAudioInput_Format(void* ptr);
 void QAudioInput_ConnectNotify(void* ptr);
 void QAudioInput_DisconnectNotify(void* ptr);
 void QAudioInput_Notify(void* ptr);
@@ -273,6 +296,7 @@ int QAudioOutput_BytesFree(void* ptr);
 char* QAudioOutput_Category(void* ptr);
 long long QAudioOutput_ElapsedUSecs(void* ptr);
 int QAudioOutput_Error(void* ptr);
+void* QAudioOutput_Format(void* ptr);
 void QAudioOutput_ConnectNotify(void* ptr);
 void QAudioOutput_DisconnectNotify(void* ptr);
 void QAudioOutput_Notify(void* ptr);
@@ -319,6 +343,9 @@ void QAudioOutputSelectorControl_ChildEventDefault(void* ptr, void* event);
 void QAudioOutputSelectorControl_CustomEvent(void* ptr, void* event);
 void QAudioOutputSelectorControl_CustomEventDefault(void* ptr, void* event);
 void* QAudioProbe_NewQAudioProbe(void* parent);
+void QAudioProbe_ConnectAudioBufferProbed(void* ptr);
+void QAudioProbe_DisconnectAudioBufferProbed(void* ptr);
+void QAudioProbe_AudioBufferProbed(void* ptr, void* buffer);
 void QAudioProbe_ConnectFlush(void* ptr);
 void QAudioProbe_DisconnectFlush(void* ptr);
 void QAudioProbe_Flush(void* ptr);
@@ -358,7 +385,7 @@ int QCamera_State(void* ptr);
 int QCamera_Status(void* ptr);
 void* QCamera_NewQCamera4(int position, void* parent);
 void* QCamera_NewQCamera(void* parent);
-void* QCamera_NewQCamera2(void* deviceName, void* parent);
+void* QCamera_NewQCamera2(char* deviceName, void* parent);
 void* QCamera_NewQCamera3(void* cameraInfo, void* parent);
 int QCamera_Availability(void* ptr);
 int QCamera_AvailabilityDefault(void* ptr);
@@ -407,6 +434,7 @@ int QCamera_SupportedLocks(void* ptr);
 void QCamera_Unload(void* ptr);
 void QCamera_Unlock(void* ptr);
 void QCamera_Unlock2(void* ptr, int locks);
+void* QCamera_ViewfinderSettings(void* ptr);
 void QCamera_DestroyQCamera(void* ptr);
 void QCamera_Unbind(void* ptr, void* object);
 void QCamera_UnbindDefault(void* ptr, void* object);
@@ -640,11 +668,18 @@ int QCameraImageCapture_CaptureDestination(void* ptr);
 void QCameraImageCapture_ConnectCaptureDestinationChanged(void* ptr);
 void QCameraImageCapture_DisconnectCaptureDestinationChanged(void* ptr);
 void QCameraImageCapture_CaptureDestinationChanged(void* ptr, int destination);
+void* QCameraImageCapture_EncodingSettings(void* ptr);
 void QCameraImageCapture_ConnectError2(void* ptr);
 void QCameraImageCapture_DisconnectError2(void* ptr);
 void QCameraImageCapture_Error2(void* ptr, int id, int error, char* errorString);
 int QCameraImageCapture_Error(void* ptr);
 char* QCameraImageCapture_ErrorString(void* ptr);
+void QCameraImageCapture_ConnectImageAvailable(void* ptr);
+void QCameraImageCapture_DisconnectImageAvailable(void* ptr);
+void QCameraImageCapture_ImageAvailable(void* ptr, int id, void* buffer);
+void QCameraImageCapture_ConnectImageCaptured(void* ptr);
+void QCameraImageCapture_DisconnectImageCaptured(void* ptr);
+void QCameraImageCapture_ImageCaptured(void* ptr, int id, void* preview);
 char* QCameraImageCapture_ImageCodecDescription(void* ptr, char* codec);
 void QCameraImageCapture_ConnectImageExposed(void* ptr);
 void QCameraImageCapture_DisconnectImageExposed(void* ptr);
@@ -681,6 +716,12 @@ int QCameraImageCaptureControl_DriveMode(void* ptr);
 void QCameraImageCaptureControl_ConnectError(void* ptr);
 void QCameraImageCaptureControl_DisconnectError(void* ptr);
 void QCameraImageCaptureControl_Error(void* ptr, int id, int error, char* errorString);
+void QCameraImageCaptureControl_ConnectImageAvailable(void* ptr);
+void QCameraImageCaptureControl_DisconnectImageAvailable(void* ptr);
+void QCameraImageCaptureControl_ImageAvailable(void* ptr, int requestId, void* buffer);
+void QCameraImageCaptureControl_ConnectImageCaptured(void* ptr);
+void QCameraImageCaptureControl_DisconnectImageCaptured(void* ptr);
+void QCameraImageCaptureControl_ImageCaptured(void* ptr, int requestId, void* preview);
 void QCameraImageCaptureControl_ConnectImageExposed(void* ptr);
 void QCameraImageCaptureControl_DisconnectImageExposed(void* ptr);
 void QCameraImageCaptureControl_ImageExposed(void* ptr, int requestId);
@@ -736,9 +777,10 @@ void QCameraImageProcessingControl_ChildEvent(void* ptr, void* event);
 void QCameraImageProcessingControl_ChildEventDefault(void* ptr, void* event);
 void QCameraImageProcessingControl_CustomEvent(void* ptr, void* event);
 void QCameraImageProcessingControl_CustomEventDefault(void* ptr, void* event);
-void* QCameraInfo_NewQCameraInfo(void* name);
+void* QCameraInfo_NewQCameraInfo(char* name);
 void* QCameraInfo_NewQCameraInfo2(void* camera);
 void* QCameraInfo_NewQCameraInfo3(void* other);
+void* QCameraInfo_QCameraInfo_DefaultCamera();
 char* QCameraInfo_Description(void* ptr);
 char* QCameraInfo_DeviceName(void* ptr);
 int QCameraInfo_IsNull(void* ptr);
@@ -796,6 +838,7 @@ void QCameraViewfinderSettingsControl_ChildEventDefault(void* ptr, void* event);
 void QCameraViewfinderSettingsControl_CustomEvent(void* ptr, void* event);
 void QCameraViewfinderSettingsControl_CustomEventDefault(void* ptr, void* event);
 void QCameraViewfinderSettingsControl2_SetViewfinderSettings(void* ptr, void* settings);
+void* QCameraViewfinderSettingsControl2_ViewfinderSettings(void* ptr);
 void QCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2(void* ptr);
 void QCameraViewfinderSettingsControl2_TimerEvent(void* ptr, void* event);
 void QCameraViewfinderSettingsControl2_TimerEventDefault(void* ptr, void* event);
@@ -836,6 +879,7 @@ void QCameraZoomControl_ChildEventDefault(void* ptr, void* event);
 void QCameraZoomControl_CustomEvent(void* ptr, void* event);
 void QCameraZoomControl_CustomEventDefault(void* ptr, void* event);
 char* QImageEncoderControl_ImageCodecDescription(void* ptr, char* codec);
+void* QImageEncoderControl_ImageSettings(void* ptr);
 void QImageEncoderControl_SetImageSettings(void* ptr, void* settings);
 char* QImageEncoderControl_SupportedImageCodecs(void* ptr);
 void QImageEncoderControl_DestroyQImageEncoderControl(void* ptr);
@@ -858,6 +902,9 @@ void QImageEncoderSettings_SetQuality(void* ptr, int quality);
 void QImageEncoderSettings_SetResolution(void* ptr, void* resolution);
 void QImageEncoderSettings_SetResolution2(void* ptr, int width, int height);
 void QImageEncoderSettings_DestroyQImageEncoderSettings(void* ptr);
+void QMediaAudioProbeControl_ConnectAudioBufferProbed(void* ptr);
+void QMediaAudioProbeControl_DisconnectAudioBufferProbed(void* ptr);
+void QMediaAudioProbeControl_AudioBufferProbed(void* ptr, void* buffer);
 void QMediaAudioProbeControl_ConnectFlush(void* ptr);
 void QMediaAudioProbeControl_DisconnectFlush(void* ptr);
 void QMediaAudioProbeControl_Flush(void* ptr);
@@ -900,6 +947,8 @@ void* QMediaContent_NewQMediaContent6(void* other);
 void* QMediaContent_NewQMediaContent4(void* resource);
 void* QMediaContent_NewQMediaContent3(void* request);
 void* QMediaContent_NewQMediaContent2(void* url);
+void* QMediaContent_CanonicalRequest(void* ptr);
+void* QMediaContent_CanonicalResource(void* ptr);
 void* QMediaContent_CanonicalUrl(void* ptr);
 int QMediaContent_IsNull(void* ptr);
 void* QMediaContent_Playlist(void* ptr);
@@ -932,6 +981,10 @@ void QMediaGaplessPlaybackControl_ChildEvent(void* ptr, void* event);
 void QMediaGaplessPlaybackControl_ChildEventDefault(void* ptr, void* event);
 void QMediaGaplessPlaybackControl_CustomEvent(void* ptr, void* event);
 void QMediaGaplessPlaybackControl_CustomEventDefault(void* ptr, void* event);
+void QMediaNetworkAccessControl_ConnectConfigurationChanged(void* ptr);
+void QMediaNetworkAccessControl_DisconnectConfigurationChanged(void* ptr);
+void QMediaNetworkAccessControl_ConfigurationChanged(void* ptr, void* configuration);
+void* QMediaNetworkAccessControl_CurrentConfiguration(void* ptr);
 void QMediaNetworkAccessControl_DestroyQMediaNetworkAccessControl(void* ptr);
 void QMediaNetworkAccessControl_TimerEvent(void* ptr, void* event);
 void QMediaNetworkAccessControl_TimerEventDefault(void* ptr, void* event);
@@ -1013,6 +1066,7 @@ void QMediaPlayer_BufferStatusChanged(void* ptr, int percentFilled);
 void QMediaPlayer_ConnectCurrentMediaChanged(void* ptr);
 void QMediaPlayer_DisconnectCurrentMediaChanged(void* ptr);
 void QMediaPlayer_CurrentMediaChanged(void* ptr, void* media);
+void* QMediaPlayer_CurrentNetworkConfiguration(void* ptr);
 void QMediaPlayer_ConnectDurationChanged(void* ptr);
 void QMediaPlayer_DisconnectDurationChanged(void* ptr);
 void QMediaPlayer_DurationChanged(void* ptr, long long duration);
@@ -1031,6 +1085,9 @@ void* QMediaPlayer_MediaStream(void* ptr);
 void QMediaPlayer_ConnectMutedChanged(void* ptr);
 void QMediaPlayer_DisconnectMutedChanged(void* ptr);
 void QMediaPlayer_MutedChanged(void* ptr, int muted);
+void QMediaPlayer_ConnectNetworkConfigurationChanged(void* ptr);
+void QMediaPlayer_DisconnectNetworkConfigurationChanged(void* ptr);
+void QMediaPlayer_NetworkConfigurationChanged(void* ptr, void* configuration);
 void QMediaPlayer_Pause(void* ptr);
 void QMediaPlayer_Play(void* ptr);
 void QMediaPlayer_ConnectPlaybackRateChanged(void* ptr);
@@ -1066,6 +1123,10 @@ void QMediaPlayer_CustomEventDefault(void* ptr, void* event);
 void QMediaPlayerControl_ConnectAudioAvailableChanged(void* ptr);
 void QMediaPlayerControl_DisconnectAudioAvailableChanged(void* ptr);
 void QMediaPlayerControl_AudioAvailableChanged(void* ptr, int audio);
+void* QMediaPlayerControl_AvailablePlaybackRanges(void* ptr);
+void QMediaPlayerControl_ConnectAvailablePlaybackRangesChanged(void* ptr);
+void QMediaPlayerControl_DisconnectAvailablePlaybackRangesChanged(void* ptr);
+void QMediaPlayerControl_AvailablePlaybackRangesChanged(void* ptr, void* ranges);
 int QMediaPlayerControl_BufferStatus(void* ptr);
 void QMediaPlayerControl_ConnectBufferStatusChanged(void* ptr);
 void QMediaPlayerControl_DisconnectBufferStatusChanged(void* ptr);
@@ -1211,6 +1272,7 @@ void QMediaRecorder_ConnectActualLocationChanged(void* ptr);
 void QMediaRecorder_DisconnectActualLocationChanged(void* ptr);
 void QMediaRecorder_ActualLocationChanged(void* ptr, void* location);
 char* QMediaRecorder_AudioCodecDescription(void* ptr, char* codec);
+void* QMediaRecorder_AudioSettings(void* ptr);
 int QMediaRecorder_Availability(void* ptr);
 void QMediaRecorder_ConnectAvailabilityChanged2(void* ptr);
 void QMediaRecorder_DisconnectAvailabilityChanged2(void* ptr);
@@ -1268,6 +1330,7 @@ char* QMediaRecorder_SupportedAudioCodecs(void* ptr);
 char* QMediaRecorder_SupportedContainers(void* ptr);
 char* QMediaRecorder_SupportedVideoCodecs(void* ptr);
 char* QMediaRecorder_VideoCodecDescription(void* ptr, char* codec);
+void* QMediaRecorder_VideoSettings(void* ptr);
 void QMediaRecorder_ConnectVolumeChanged(void* ptr);
 void QMediaRecorder_DisconnectVolumeChanged(void* ptr);
 void QMediaRecorder_VolumeChanged(void* ptr, double volume);
@@ -1328,6 +1391,7 @@ long long QMediaResource_DataSize(void* ptr);
 int QMediaResource_IsNull(void* ptr);
 char* QMediaResource_Language(void* ptr);
 char* QMediaResource_MimeType(void* ptr);
+void* QMediaResource_Request(void* ptr);
 void* QMediaResource_Resolution(void* ptr);
 int QMediaResource_SampleRate(void* ptr);
 void QMediaResource_SetAudioBitRate(void* ptr, int rate);
@@ -1354,12 +1418,12 @@ void QMediaService_ChildEvent(void* ptr, void* event);
 void QMediaService_ChildEventDefault(void* ptr, void* event);
 void QMediaService_CustomEvent(void* ptr, void* event);
 void QMediaService_CustomEventDefault(void* ptr, void* event);
-int QMediaServiceCameraInfoInterface_CameraOrientation(void* ptr, void* device);
-int QMediaServiceCameraInfoInterface_CameraPosition(void* ptr, void* device);
+int QMediaServiceCameraInfoInterface_CameraOrientation(void* ptr, char* device);
+int QMediaServiceCameraInfoInterface_CameraPosition(void* ptr, char* device);
 void QMediaServiceCameraInfoInterface_DestroyQMediaServiceCameraInfoInterface(void* ptr);
 char* QMediaServiceCameraInfoInterface_ObjectNameAbs(void* ptr);
 void QMediaServiceCameraInfoInterface_SetObjectNameAbs(void* ptr, char* name);
-void* QMediaServiceDefaultDeviceInterface_DefaultDevice(void* ptr, void* service);
+char* QMediaServiceDefaultDeviceInterface_DefaultDevice(void* ptr, char* service);
 void QMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterface(void* ptr);
 char* QMediaServiceDefaultDeviceInterface_ObjectNameAbs(void* ptr);
 void QMediaServiceDefaultDeviceInterface_SetObjectNameAbs(void* ptr, char* name);
@@ -1374,7 +1438,7 @@ void QMediaServiceProviderPlugin_ChildEvent(void* ptr, void* event);
 void QMediaServiceProviderPlugin_ChildEventDefault(void* ptr, void* event);
 void QMediaServiceProviderPlugin_CustomEvent(void* ptr, void* event);
 void QMediaServiceProviderPlugin_CustomEventDefault(void* ptr, void* event);
-char* QMediaServiceSupportedDevicesInterface_DeviceDescription(void* ptr, void* service, void* device);
+char* QMediaServiceSupportedDevicesInterface_DeviceDescription(void* ptr, char* service, char* device);
 void QMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterface(void* ptr);
 char* QMediaServiceSupportedDevicesInterface_ObjectNameAbs(void* ptr);
 void QMediaServiceSupportedDevicesInterface_SetObjectNameAbs(void* ptr, char* name);
@@ -1407,7 +1471,9 @@ void* QMediaTimeInterval_NewQMediaTimeInterval2(long long start, long long end);
 int QMediaTimeInterval_Contains(void* ptr, long long time);
 long long QMediaTimeInterval_End(void* ptr);
 int QMediaTimeInterval_IsNormal(void* ptr);
+void* QMediaTimeInterval_Normalized(void* ptr);
 long long QMediaTimeInterval_Start(void* ptr);
+void* QMediaTimeInterval_Translated(void* ptr, long long offset);
 void* QMediaTimeRange_NewQMediaTimeRange();
 void* QMediaTimeRange_NewQMediaTimeRange3(void* interval);
 void* QMediaTimeRange_NewQMediaTimeRange4(void* ran);
@@ -1428,6 +1494,9 @@ void QMediaTimeRange_DestroyQMediaTimeRange(void* ptr);
 void QMediaVideoProbeControl_ConnectFlush(void* ptr);
 void QMediaVideoProbeControl_DisconnectFlush(void* ptr);
 void QMediaVideoProbeControl_Flush(void* ptr);
+void QMediaVideoProbeControl_ConnectVideoFrameProbed(void* ptr);
+void QMediaVideoProbeControl_DisconnectVideoFrameProbed(void* ptr);
+void QMediaVideoProbeControl_VideoFrameProbed(void* ptr, void* frame);
 void QMediaVideoProbeControl_DestroyQMediaVideoProbeControl(void* ptr);
 void QMediaVideoProbeControl_TimerEvent(void* ptr, void* event);
 void QMediaVideoProbeControl_TimerEventDefault(void* ptr, void* event);
@@ -1807,6 +1876,7 @@ void QVideoEncoderSettings_DestroyQVideoEncoderSettings(void* ptr);
 void QVideoEncoderSettingsControl_SetVideoSettings(void* ptr, void* settings);
 char* QVideoEncoderSettingsControl_SupportedVideoCodecs(void* ptr);
 char* QVideoEncoderSettingsControl_VideoCodecDescription(void* ptr, char* codec);
+void* QVideoEncoderSettingsControl_VideoSettings(void* ptr);
 void QVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControl(void* ptr);
 void QVideoEncoderSettingsControl_TimerEvent(void* ptr, void* event);
 void QVideoEncoderSettingsControl_TimerEventDefault(void* ptr, void* event);
@@ -1814,6 +1884,7 @@ void QVideoEncoderSettingsControl_ChildEvent(void* ptr, void* event);
 void QVideoEncoderSettingsControl_ChildEventDefault(void* ptr, void* event);
 void QVideoEncoderSettingsControl_CustomEvent(void* ptr, void* event);
 void QVideoEncoderSettingsControl_CustomEventDefault(void* ptr, void* event);
+void* QVideoFilterRunnable_Run(void* ptr, void* input, void* surfaceFormat, int flags);
 void* QVideoFrame_NewQVideoFrame();
 void* QVideoFrame_NewQVideoFrame2(void* buffer, void* size, int format);
 void* QVideoFrame_NewQVideoFrame4(void* image);
@@ -1854,6 +1925,9 @@ void QVideoProbe_Flush(void* ptr);
 int QVideoProbe_IsActive(void* ptr);
 int QVideoProbe_SetSource(void* ptr, void* source);
 int QVideoProbe_SetSource2(void* ptr, void* mediaRecorder);
+void QVideoProbe_ConnectVideoFrameProbed(void* ptr);
+void QVideoProbe_DisconnectVideoFrameProbed(void* ptr);
+void QVideoProbe_VideoFrameProbed(void* ptr, void* frame);
 void QVideoProbe_DestroyQVideoProbe(void* ptr);
 void QVideoProbe_TimerEvent(void* ptr, void* event);
 void QVideoProbe_TimerEventDefault(void* ptr, void* event);

network/network.cpp

@@ -80,6 +80,10 @@ void* QAbstractNetworkCache_Data(void* ptr, void* url){
 	return static_cast<QAbstractNetworkCache*>(ptr)->data(*static_cast<QUrl*>(url));
 }
 
+void* QAbstractNetworkCache_MetaData(void* ptr, void* url){
+	return new QNetworkCacheMetaData(static_cast<QAbstractNetworkCache*>(ptr)->metaData(*static_cast<QUrl*>(url)));
+}
+
 void* QAbstractNetworkCache_Prepare(void* ptr, void* metaData){
 	return static_cast<QAbstractNetworkCache*>(ptr)->prepare(*static_cast<QNetworkCacheMetaData*>(metaData));
 }
@@ -125,6 +129,7 @@ public:
 	void Signal_Disconnected() { callbackQAbstractSocketDisconnected(this, this->objectName().toUtf8().data()); };
 	void Signal_Error2(QAbstractSocket::SocketError socketError) { callbackQAbstractSocketError2(this, this->objectName().toUtf8().data(), socketError); };
 	void Signal_HostFound() { callbackQAbstractSocketHostFound(this, this->objectName().toUtf8().data()); };
+	void Signal_ProxyAuthenticationRequired(const QNetworkProxy & proxy, QAuthenticator * authenticator) { callbackQAbstractSocketProxyAuthenticationRequired(this, this->objectName().toUtf8().data(), new QNetworkProxy(proxy), authenticator); };
 	void resume() { callbackQAbstractSocketResume(this, this->objectName().toUtf8().data()); };
 	void setReadBufferSize(qint64 size) { callbackQAbstractSocketSetReadBufferSize(this, this->objectName().toUtf8().data(), static_cast<long long>(size)); };
 	void setSocketOption(QAbstractSocket::SocketOption option, const QVariant & value) { callbackQAbstractSocketSetSocketOption(this, this->objectName().toUtf8().data(), option, new QVariant(value)); };
@@ -238,14 +243,38 @@ int QAbstractSocket_IsValid(void* ptr){
 	return static_cast<QAbstractSocket*>(ptr)->isValid();
 }
 
+void* QAbstractSocket_LocalAddress(void* ptr){
+	return new QHostAddress(static_cast<QAbstractSocket*>(ptr)->localAddress());
+}
+
 int QAbstractSocket_PauseMode(void* ptr){
 	return static_cast<QAbstractSocket*>(ptr)->pauseMode();
 }
 
+void* QAbstractSocket_PeerAddress(void* ptr){
+	return new QHostAddress(static_cast<QAbstractSocket*>(ptr)->peerAddress());
+}
+
 char* QAbstractSocket_PeerName(void* ptr){
 	return static_cast<QAbstractSocket*>(ptr)->peerName().toUtf8().data();
 }
 
+void* QAbstractSocket_Proxy(void* ptr){
+	return new QNetworkProxy(static_cast<QAbstractSocket*>(ptr)->proxy());
+}
+
+void QAbstractSocket_ConnectProxyAuthenticationRequired(void* ptr){
+	QObject::connect(static_cast<QAbstractSocket*>(ptr), static_cast<void (QAbstractSocket::*)(const QNetworkProxy &, QAuthenticator *)>(&QAbstractSocket::proxyAuthenticationRequired), static_cast<MyQAbstractSocket*>(ptr), static_cast<void (MyQAbstractSocket::*)(const QNetworkProxy &, QAuthenticator *)>(&MyQAbstractSocket::Signal_ProxyAuthenticationRequired));;
+}
+
+void QAbstractSocket_DisconnectProxyAuthenticationRequired(void* ptr){
+	QObject::disconnect(static_cast<QAbstractSocket*>(ptr), static_cast<void (QAbstractSocket::*)(const QNetworkProxy &, QAuthenticator *)>(&QAbstractSocket::proxyAuthenticationRequired), static_cast<MyQAbstractSocket*>(ptr), static_cast<void (MyQAbstractSocket::*)(const QNetworkProxy &, QAuthenticator *)>(&MyQAbstractSocket::Signal_ProxyAuthenticationRequired));;
+}
+
+void QAbstractSocket_ProxyAuthenticationRequired(void* ptr, void* proxy, void* authenticator){
+	static_cast<QAbstractSocket*>(ptr)->proxyAuthenticationRequired(*static_cast<QNetworkProxy*>(proxy), static_cast<QAuthenticator*>(authenticator));
+}
+
 long long QAbstractSocket_ReadBufferSize(void* ptr){
 	return static_cast<long long>(static_cast<QAbstractSocket*>(ptr)->readBufferSize());
 }
@@ -446,6 +475,10 @@ void QDnsHostAddressRecord_Swap(void* ptr, void* other){
 	static_cast<QDnsHostAddressRecord*>(ptr)->swap(*static_cast<QDnsHostAddressRecord*>(other));
 }
 
+void* QDnsHostAddressRecord_Value(void* ptr){
+	return new QHostAddress(static_cast<QDnsHostAddressRecord*>(ptr)->value());
+}
+
 void QDnsHostAddressRecord_DestroyQDnsHostAddressRecord(void* ptr){
 	static_cast<QDnsHostAddressRecord*>(ptr)->~QDnsHostAddressRecord();
 }
@@ -454,6 +487,7 @@ class MyQDnsLookup: public QDnsLookup {
 public:
 	void Signal_Finished() { callbackQDnsLookupFinished(this, this->objectName().toUtf8().data()); };
 	void Signal_NameChanged(const QString & name) { callbackQDnsLookupNameChanged(this, this->objectName().toUtf8().data(), name.toUtf8().data()); };
+	void Signal_NameserverChanged(const QHostAddress & nameserver) { callbackQDnsLookupNameserverChanged(this, this->objectName().toUtf8().data(), new QHostAddress(nameserver)); };
 	void Signal_TypeChanged(QDnsLookup::Type ty) { callbackQDnsLookupTypeChanged(this, this->objectName().toUtf8().data(), ty); };
 	void timerEvent(QTimerEvent * event) { callbackQDnsLookupTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQDnsLookupChildEvent(this, this->objectName().toUtf8().data(), event); };
@@ -476,6 +510,10 @@ char* QDnsLookup_Name(void* ptr){
 	return static_cast<QDnsLookup*>(ptr)->name().toUtf8().data();
 }
 
+void* QDnsLookup_Nameserver(void* ptr){
+	return new QHostAddress(static_cast<QDnsLookup*>(ptr)->nameserver());
+}
+
 void QDnsLookup_SetName(void* ptr, char* name){
 	static_cast<QDnsLookup*>(ptr)->setName(QString(name));
 }
@@ -536,6 +574,18 @@ void QDnsLookup_NameChanged(void* ptr, char* name){
 	static_cast<QDnsLookup*>(ptr)->nameChanged(QString(name));
 }
 
+void QDnsLookup_ConnectNameserverChanged(void* ptr){
+	QObject::connect(static_cast<QDnsLookup*>(ptr), static_cast<void (QDnsLookup::*)(const QHostAddress &)>(&QDnsLookup::nameserverChanged), static_cast<MyQDnsLookup*>(ptr), static_cast<void (MyQDnsLookup::*)(const QHostAddress &)>(&MyQDnsLookup::Signal_NameserverChanged));;
+}
+
+void QDnsLookup_DisconnectNameserverChanged(void* ptr){
+	QObject::disconnect(static_cast<QDnsLookup*>(ptr), static_cast<void (QDnsLookup::*)(const QHostAddress &)>(&QDnsLookup::nameserverChanged), static_cast<MyQDnsLookup*>(ptr), static_cast<void (MyQDnsLookup::*)(const QHostAddress &)>(&MyQDnsLookup::Signal_NameserverChanged));;
+}
+
+void QDnsLookup_NameserverChanged(void* ptr, void* nameserver){
+	static_cast<QDnsLookup*>(ptr)->nameserverChanged(*static_cast<QHostAddress*>(nameserver));
+}
+
 void QDnsLookup_ConnectTypeChanged(void* ptr){
 	QObject::connect(static_cast<QDnsLookup*>(ptr), static_cast<void (QDnsLookup::*)(QDnsLookup::Type)>(&QDnsLookup::typeChanged), static_cast<MyQDnsLookup*>(ptr), static_cast<void (MyQDnsLookup::*)(QDnsLookup::Type)>(&MyQDnsLookup::Signal_TypeChanged));;
 }
@@ -720,6 +770,10 @@ char* QHostInfo_ErrorString(void* ptr){
 	return static_cast<QHostInfo*>(ptr)->errorString().toUtf8().data();
 }
 
+void* QHostInfo_QHostInfo_FromName(char* name){
+	return new QHostInfo(QHostInfo::fromName(QString(name)));
+}
+
 char* QHostInfo_HostName(void* ptr){
 	return static_cast<QHostInfo*>(ptr)->hostName().toUtf8().data();
 }
@@ -772,12 +826,12 @@ void QHttpMultiPart_Append(void* ptr, void* httpPart){
 	static_cast<QHttpMultiPart*>(ptr)->append(*static_cast<QHttpPart*>(httpPart));
 }
 
-void* QHttpMultiPart_Boundary(void* ptr){
-	return new QByteArray(static_cast<QHttpMultiPart*>(ptr)->boundary());
+char* QHttpMultiPart_Boundary(void* ptr){
+	return QString(static_cast<QHttpMultiPart*>(ptr)->boundary()).toUtf8().data();
 }
 
-void QHttpMultiPart_SetBoundary(void* ptr, void* boundary){
-	static_cast<QHttpMultiPart*>(ptr)->setBoundary(*static_cast<QByteArray*>(boundary));
+void QHttpMultiPart_SetBoundary(void* ptr, char* boundary){
+	static_cast<QHttpMultiPart*>(ptr)->setBoundary(QByteArray(boundary));
 }
 
 void QHttpMultiPart_SetContentType(void* ptr, int contentType){
@@ -820,8 +874,8 @@ void* QHttpPart_NewQHttpPart2(void* other){
 	return new QHttpPart(*static_cast<QHttpPart*>(other));
 }
 
-void QHttpPart_SetBody(void* ptr, void* body){
-	static_cast<QHttpPart*>(ptr)->setBody(*static_cast<QByteArray*>(body));
+void QHttpPart_SetBody(void* ptr, char* body){
+	static_cast<QHttpPart*>(ptr)->setBody(QByteArray(body));
 }
 
 void QHttpPart_SetBodyDevice(void* ptr, void* device){
@@ -832,8 +886,8 @@ void QHttpPart_SetHeader(void* ptr, int header, void* value){
 	static_cast<QHttpPart*>(ptr)->setHeader(static_cast<QNetworkRequest::KnownHeaders>(header), *static_cast<QVariant*>(value));
 }
 
-void QHttpPart_SetRawHeader(void* ptr, void* headerName, void* headerValue){
-	static_cast<QHttpPart*>(ptr)->setRawHeader(*static_cast<QByteArray*>(headerName), *static_cast<QByteArray*>(headerValue));
+void QHttpPart_SetRawHeader(void* ptr, char* headerName, char* headerValue){
+	static_cast<QHttpPart*>(ptr)->setRawHeader(QByteArray(headerName), QByteArray(headerValue));
 }
 
 void QHttpPart_Swap(void* ptr, void* other){
@@ -1162,6 +1216,7 @@ public:
 	void Signal_Finished(QNetworkReply * reply) { callbackQNetworkAccessManagerFinished(this, this->objectName().toUtf8().data(), reply); };
 	void Signal_NetworkAccessibleChanged(QNetworkAccessManager::NetworkAccessibility accessible) { callbackQNetworkAccessManagerNetworkAccessibleChanged(this, this->objectName().toUtf8().data(), accessible); };
 	void Signal_PreSharedKeyAuthenticationRequired(QNetworkReply * reply, QSslPreSharedKeyAuthenticator * authenticator) { callbackQNetworkAccessManagerPreSharedKeyAuthenticationRequired(this, this->objectName().toUtf8().data(), reply, authenticator); };
+	void Signal_ProxyAuthenticationRequired(const QNetworkProxy & proxy, QAuthenticator * authenticator) { callbackQNetworkAccessManagerProxyAuthenticationRequired(this, this->objectName().toUtf8().data(), new QNetworkProxy(proxy), authenticator); };
 	void timerEvent(QTimerEvent * event) { callbackQNetworkAccessManagerTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQNetworkAccessManagerChildEvent(this, this->objectName().toUtf8().data(), event); };
 	void customEvent(QEvent * event) { callbackQNetworkAccessManagerCustomEvent(this, this->objectName().toUtf8().data(), event); };
@@ -1175,6 +1230,10 @@ void* QNetworkAccessManager_NewQNetworkAccessManager(void* parent){
 	return new MyQNetworkAccessManager(static_cast<QObject*>(parent));
 }
 
+void* QNetworkAccessManager_ActiveConfiguration(void* ptr){
+	return new QNetworkConfiguration(static_cast<QNetworkAccessManager*>(ptr)->activeConfiguration());
+}
+
 void QNetworkAccessManager_ConnectAuthenticationRequired(void* ptr){
 	QObject::connect(static_cast<QNetworkAccessManager*>(ptr), static_cast<void (QNetworkAccessManager::*)(QNetworkReply *, QAuthenticator *)>(&QNetworkAccessManager::authenticationRequired), static_cast<MyQNetworkAccessManager*>(ptr), static_cast<void (MyQNetworkAccessManager::*)(QNetworkReply *, QAuthenticator *)>(&MyQNetworkAccessManager::Signal_AuthenticationRequired));;
 }
@@ -1195,6 +1254,10 @@ void QNetworkAccessManager_ClearAccessCache(void* ptr){
 	static_cast<QNetworkAccessManager*>(ptr)->clearAccessCache();
 }
 
+void* QNetworkAccessManager_Configuration(void* ptr){
+	return new QNetworkConfiguration(static_cast<QNetworkAccessManager*>(ptr)->configuration());
+}
+
 void* QNetworkAccessManager_CookieJar(void* ptr){
 	return static_cast<QNetworkAccessManager*>(ptr)->cookieJar();
 }
@@ -1263,8 +1326,8 @@ void* QNetworkAccessManager_Post(void* ptr, void* request, void* data){
 	return static_cast<QNetworkAccessManager*>(ptr)->post(*static_cast<QNetworkRequest*>(request), static_cast<QIODevice*>(data));
 }
 
-void* QNetworkAccessManager_Post2(void* ptr, void* request, void* data){
-	return static_cast<QNetworkAccessManager*>(ptr)->post(*static_cast<QNetworkRequest*>(request), *static_cast<QByteArray*>(data));
+void* QNetworkAccessManager_Post2(void* ptr, void* request, char* data){
+	return static_cast<QNetworkAccessManager*>(ptr)->post(*static_cast<QNetworkRequest*>(request), QByteArray(data));
 }
 
 void QNetworkAccessManager_ConnectPreSharedKeyAuthenticationRequired(void* ptr){
@@ -1279,6 +1342,22 @@ void QNetworkAccessManager_PreSharedKeyAuthenticationRequired(void* ptr, void* r
 	static_cast<QNetworkAccessManager*>(ptr)->preSharedKeyAuthenticationRequired(static_cast<QNetworkReply*>(reply), static_cast<QSslPreSharedKeyAuthenticator*>(authenticator));
 }
 
+void* QNetworkAccessManager_Proxy(void* ptr){
+	return new QNetworkProxy(static_cast<QNetworkAccessManager*>(ptr)->proxy());
+}
+
+void QNetworkAccessManager_ConnectProxyAuthenticationRequired(void* ptr){
+	QObject::connect(static_cast<QNetworkAccessManager*>(ptr), static_cast<void (QNetworkAccessManager::*)(const QNetworkProxy &, QAuthenticator *)>(&QNetworkAccessManager::proxyAuthenticationRequired), static_cast<MyQNetworkAccessManager*>(ptr), static_cast<void (MyQNetworkAccessManager::*)(const QNetworkProxy &, QAuthenticator *)>(&MyQNetworkAccessManager::Signal_ProxyAuthenticationRequired));;
+}
+
+void QNetworkAccessManager_DisconnectProxyAuthenticationRequired(void* ptr){
+	QObject::disconnect(static_cast<QNetworkAccessManager*>(ptr), static_cast<void (QNetworkAccessManager::*)(const QNetworkProxy &, QAuthenticator *)>(&QNetworkAccessManager::proxyAuthenticationRequired), static_cast<MyQNetworkAccessManager*>(ptr), static_cast<void (MyQNetworkAccessManager::*)(const QNetworkProxy &, QAuthenticator *)>(&MyQNetworkAccessManager::Signal_ProxyAuthenticationRequired));;
+}
+
+void QNetworkAccessManager_ProxyAuthenticationRequired(void* ptr, void* proxy, void* authenticator){
+	static_cast<QNetworkAccessManager*>(ptr)->proxyAuthenticationRequired(*static_cast<QNetworkProxy*>(proxy), static_cast<QAuthenticator*>(authenticator));
+}
+
 void* QNetworkAccessManager_Put2(void* ptr, void* request, void* multiPart){
 	return static_cast<QNetworkAccessManager*>(ptr)->put(*static_cast<QNetworkRequest*>(request), static_cast<QHttpMultiPart*>(multiPart));
 }
@@ -1287,12 +1366,12 @@ void* QNetworkAccessManager_Put(void* ptr, void* request, void* data){
 	return static_cast<QNetworkAccessManager*>(ptr)->put(*static_cast<QNetworkRequest*>(request), static_cast<QIODevice*>(data));
 }
 
-void* QNetworkAccessManager_Put3(void* ptr, void* request, void* data){
-	return static_cast<QNetworkAccessManager*>(ptr)->put(*static_cast<QNetworkRequest*>(request), *static_cast<QByteArray*>(data));
+void* QNetworkAccessManager_Put3(void* ptr, void* request, char* data){
+	return static_cast<QNetworkAccessManager*>(ptr)->put(*static_cast<QNetworkRequest*>(request), QByteArray(data));
 }
 
-void* QNetworkAccessManager_SendCustomRequest(void* ptr, void* request, void* verb, void* data){
-	return static_cast<QNetworkAccessManager*>(ptr)->sendCustomRequest(*static_cast<QNetworkRequest*>(request), *static_cast<QByteArray*>(verb), static_cast<QIODevice*>(data));
+void* QNetworkAccessManager_SendCustomRequest(void* ptr, void* request, char* verb, void* data){
+	return static_cast<QNetworkAccessManager*>(ptr)->sendCustomRequest(*static_cast<QNetworkRequest*>(request), QByteArray(verb), static_cast<QIODevice*>(data));
 }
 
 void QNetworkAccessManager_SetCache(void* ptr, void* cache){
@@ -1359,6 +1438,18 @@ void* QNetworkAddressEntry_NewQNetworkAddressEntry2(void* other){
 	return new QNetworkAddressEntry(*static_cast<QNetworkAddressEntry*>(other));
 }
 
+void* QNetworkAddressEntry_Broadcast(void* ptr){
+	return new QHostAddress(static_cast<QNetworkAddressEntry*>(ptr)->broadcast());
+}
+
+void* QNetworkAddressEntry_Ip(void* ptr){
+	return new QHostAddress(static_cast<QNetworkAddressEntry*>(ptr)->ip());
+}
+
+void* QNetworkAddressEntry_Netmask(void* ptr){
+	return new QHostAddress(static_cast<QNetworkAddressEntry*>(ptr)->netmask());
+}
+
 int QNetworkAddressEntry_PrefixLength(void* ptr){
 	return static_cast<QNetworkAddressEntry*>(ptr)->prefixLength();
 }
@@ -1498,6 +1589,9 @@ void QNetworkConfiguration_DestroyQNetworkConfiguration(void* ptr){
 class MyQNetworkConfigurationManager: public QNetworkConfigurationManager {
 public:
 	MyQNetworkConfigurationManager(QObject *parent) : QNetworkConfigurationManager(parent) {};
+	void Signal_ConfigurationAdded(const QNetworkConfiguration & config) { callbackQNetworkConfigurationManagerConfigurationAdded(this, this->objectName().toUtf8().data(), new QNetworkConfiguration(config)); };
+	void Signal_ConfigurationChanged(const QNetworkConfiguration & config) { callbackQNetworkConfigurationManagerConfigurationChanged(this, this->objectName().toUtf8().data(), new QNetworkConfiguration(config)); };
+	void Signal_ConfigurationRemoved(const QNetworkConfiguration & config) { callbackQNetworkConfigurationManagerConfigurationRemoved(this, this->objectName().toUtf8().data(), new QNetworkConfiguration(config)); };
 	void Signal_OnlineStateChanged(bool isOnline) { callbackQNetworkConfigurationManagerOnlineStateChanged(this, this->objectName().toUtf8().data(), isOnline); };
 	void Signal_UpdateCompleted() { callbackQNetworkConfigurationManagerUpdateCompleted(this, this->objectName().toUtf8().data()); };
 	void timerEvent(QTimerEvent * event) { callbackQNetworkConfigurationManagerTimerEvent(this, this->objectName().toUtf8().data(), event); };
@@ -1513,6 +1607,50 @@ int QNetworkConfigurationManager_Capabilities(void* ptr){
 	return static_cast<QNetworkConfigurationManager*>(ptr)->capabilities();
 }
 
+void QNetworkConfigurationManager_ConnectConfigurationAdded(void* ptr){
+	QObject::connect(static_cast<QNetworkConfigurationManager*>(ptr), static_cast<void (QNetworkConfigurationManager::*)(const QNetworkConfiguration &)>(&QNetworkConfigurationManager::configurationAdded), static_cast<MyQNetworkConfigurationManager*>(ptr), static_cast<void (MyQNetworkConfigurationManager::*)(const QNetworkConfiguration &)>(&MyQNetworkConfigurationManager::Signal_ConfigurationAdded));;
+}
+
+void QNetworkConfigurationManager_DisconnectConfigurationAdded(void* ptr){
+	QObject::disconnect(static_cast<QNetworkConfigurationManager*>(ptr), static_cast<void (QNetworkConfigurationManager::*)(const QNetworkConfiguration &)>(&QNetworkConfigurationManager::configurationAdded), static_cast<MyQNetworkConfigurationManager*>(ptr), static_cast<void (MyQNetworkConfigurationManager::*)(const QNetworkConfiguration &)>(&MyQNetworkConfigurationManager::Signal_ConfigurationAdded));;
+}
+
+void QNetworkConfigurationManager_ConfigurationAdded(void* ptr, void* config){
+	static_cast<QNetworkConfigurationManager*>(ptr)->configurationAdded(*static_cast<QNetworkConfiguration*>(config));
+}
+
+void QNetworkConfigurationManager_ConnectConfigurationChanged(void* ptr){
+	QObject::connect(static_cast<QNetworkConfigurationManager*>(ptr), static_cast<void (QNetworkConfigurationManager::*)(const QNetworkConfiguration &)>(&QNetworkConfigurationManager::configurationChanged), static_cast<MyQNetworkConfigurationManager*>(ptr), static_cast<void (MyQNetworkConfigurationManager::*)(const QNetworkConfiguration &)>(&MyQNetworkConfigurationManager::Signal_ConfigurationChanged));;
+}
+
+void QNetworkConfigurationManager_DisconnectConfigurationChanged(void* ptr){
+	QObject::disconnect(static_cast<QNetworkConfigurationManager*>(ptr), static_cast<void (QNetworkConfigurationManager::*)(const QNetworkConfiguration &)>(&QNetworkConfigurationManager::configurationChanged), static_cast<MyQNetworkConfigurationManager*>(ptr), static_cast<void (MyQNetworkConfigurationManager::*)(const QNetworkConfiguration &)>(&MyQNetworkConfigurationManager::Signal_ConfigurationChanged));;
+}
+
+void QNetworkConfigurationManager_ConfigurationChanged(void* ptr, void* config){
+	static_cast<QNetworkConfigurationManager*>(ptr)->configurationChanged(*static_cast<QNetworkConfiguration*>(config));
+}
+
+void* QNetworkConfigurationManager_ConfigurationFromIdentifier(void* ptr, char* identifier){
+	return new QNetworkConfiguration(static_cast<QNetworkConfigurationManager*>(ptr)->configurationFromIdentifier(QString(identifier)));
+}
+
+void QNetworkConfigurationManager_ConnectConfigurationRemoved(void* ptr){
+	QObject::connect(static_cast<QNetworkConfigurationManager*>(ptr), static_cast<void (QNetworkConfigurationManager::*)(const QNetworkConfiguration &)>(&QNetworkConfigurationManager::configurationRemoved), static_cast<MyQNetworkConfigurationManager*>(ptr), static_cast<void (MyQNetworkConfigurationManager::*)(const QNetworkConfiguration &)>(&MyQNetworkConfigurationManager::Signal_ConfigurationRemoved));;
+}
+
+void QNetworkConfigurationManager_DisconnectConfigurationRemoved(void* ptr){
+	QObject::disconnect(static_cast<QNetworkConfigurationManager*>(ptr), static_cast<void (QNetworkConfigurationManager::*)(const QNetworkConfiguration &)>(&QNetworkConfigurationManager::configurationRemoved), static_cast<MyQNetworkConfigurationManager*>(ptr), static_cast<void (MyQNetworkConfigurationManager::*)(const QNetworkConfiguration &)>(&MyQNetworkConfigurationManager::Signal_ConfigurationRemoved));;
+}
+
+void QNetworkConfigurationManager_ConfigurationRemoved(void* ptr, void* config){
+	static_cast<QNetworkConfigurationManager*>(ptr)->configurationRemoved(*static_cast<QNetworkConfiguration*>(config));
+}
+
+void* QNetworkConfigurationManager_DefaultConfiguration(void* ptr){
+	return new QNetworkConfiguration(static_cast<QNetworkConfigurationManager*>(ptr)->defaultConfiguration());
+}
+
 int QNetworkConfigurationManager_IsOnline(void* ptr){
 	return static_cast<QNetworkConfigurationManager*>(ptr)->isOnline();
 }
@@ -1573,8 +1711,8 @@ void QNetworkConfigurationManager_CustomEventDefault(void* ptr, void* event){
 	static_cast<QNetworkConfigurationManager*>(ptr)->QNetworkConfigurationManager::customEvent(static_cast<QEvent*>(event));
 }
 
-void* QNetworkCookie_NewQNetworkCookie(void* name, void* value){
-	return new QNetworkCookie(*static_cast<QByteArray*>(name), *static_cast<QByteArray*>(value));
+void* QNetworkCookie_NewQNetworkCookie(char* name, char* value){
+	return new QNetworkCookie(QByteArray(name), QByteArray(value));
 }
 
 void* QNetworkCookie_NewQNetworkCookie2(void* other){
@@ -1605,8 +1743,8 @@ int QNetworkCookie_IsSessionCookie(void* ptr){
 	return static_cast<QNetworkCookie*>(ptr)->isSessionCookie();
 }
 
-void* QNetworkCookie_Name(void* ptr){
-	return new QByteArray(static_cast<QNetworkCookie*>(ptr)->name());
+char* QNetworkCookie_Name(void* ptr){
+	return QString(static_cast<QNetworkCookie*>(ptr)->name()).toUtf8().data();
 }
 
 void QNetworkCookie_Normalize(void* ptr, void* url){
@@ -1629,8 +1767,8 @@ void QNetworkCookie_SetHttpOnly(void* ptr, int enable){
 	static_cast<QNetworkCookie*>(ptr)->setHttpOnly(enable != 0);
 }
 
-void QNetworkCookie_SetName(void* ptr, void* cookieName){
-	static_cast<QNetworkCookie*>(ptr)->setName(*static_cast<QByteArray*>(cookieName));
+void QNetworkCookie_SetName(void* ptr, char* cookieName){
+	static_cast<QNetworkCookie*>(ptr)->setName(QByteArray(cookieName));
 }
 
 void QNetworkCookie_SetPath(void* ptr, char* path){
@@ -1641,20 +1779,20 @@ void QNetworkCookie_SetSecure(void* ptr, int enable){
 	static_cast<QNetworkCookie*>(ptr)->setSecure(enable != 0);
 }
 
-void QNetworkCookie_SetValue(void* ptr, void* value){
-	static_cast<QNetworkCookie*>(ptr)->setValue(*static_cast<QByteArray*>(value));
+void QNetworkCookie_SetValue(void* ptr, char* value){
+	static_cast<QNetworkCookie*>(ptr)->setValue(QByteArray(value));
 }
 
 void QNetworkCookie_Swap(void* ptr, void* other){
 	static_cast<QNetworkCookie*>(ptr)->swap(*static_cast<QNetworkCookie*>(other));
 }
 
-void* QNetworkCookie_ToRawForm(void* ptr, int form){
-	return new QByteArray(static_cast<QNetworkCookie*>(ptr)->toRawForm(static_cast<QNetworkCookie::RawForm>(form)));
+char* QNetworkCookie_ToRawForm(void* ptr, int form){
+	return QString(static_cast<QNetworkCookie*>(ptr)->toRawForm(static_cast<QNetworkCookie::RawForm>(form))).toUtf8().data();
 }
 
-void* QNetworkCookie_Value(void* ptr){
-	return new QByteArray(static_cast<QNetworkCookie*>(ptr)->value());
+char* QNetworkCookie_Value(void* ptr){
+	return QString(static_cast<QNetworkCookie*>(ptr)->value()).toUtf8().data();
 }
 
 void QNetworkCookie_DestroyQNetworkCookie(void* ptr){
@@ -1721,6 +1859,7 @@ class MyQNetworkDiskCache: public QNetworkDiskCache {
 public:
 	MyQNetworkDiskCache(QObject *parent) : QNetworkDiskCache(parent) {};
 	void clear() { callbackQNetworkDiskCacheClear(this, this->objectName().toUtf8().data()); };
+	void updateMetaData(const QNetworkCacheMetaData & metaData) { callbackQNetworkDiskCacheUpdateMetaData(this, this->objectName().toUtf8().data(), new QNetworkCacheMetaData(metaData)); };
 	void timerEvent(QTimerEvent * event) { callbackQNetworkDiskCacheTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQNetworkDiskCacheChildEvent(this, this->objectName().toUtf8().data(), event); };
 	void customEvent(QEvent * event) { callbackQNetworkDiskCacheCustomEvent(this, this->objectName().toUtf8().data(), event); };
@@ -1754,10 +1893,18 @@ long long QNetworkDiskCache_Expire(void* ptr){
 	return static_cast<long long>(static_cast<QNetworkDiskCache*>(ptr)->expire());
 }
 
+void* QNetworkDiskCache_FileMetaData(void* ptr, char* fileName){
+	return new QNetworkCacheMetaData(static_cast<QNetworkDiskCache*>(ptr)->fileMetaData(QString(fileName)));
+}
+
 long long QNetworkDiskCache_MaximumCacheSize(void* ptr){
 	return static_cast<long long>(static_cast<QNetworkDiskCache*>(ptr)->maximumCacheSize());
 }
 
+void* QNetworkDiskCache_MetaData(void* ptr, void* url){
+	return new QNetworkCacheMetaData(static_cast<QNetworkDiskCache*>(ptr)->metaData(*static_cast<QUrl*>(url)));
+}
+
 void* QNetworkDiskCache_Prepare(void* ptr, void* metaData){
 	return static_cast<QNetworkDiskCache*>(ptr)->prepare(*static_cast<QNetworkCacheMetaData*>(metaData));
 }
@@ -1770,6 +1917,14 @@ void QNetworkDiskCache_SetMaximumCacheSize(void* ptr, long long size){
 	static_cast<QNetworkDiskCache*>(ptr)->setMaximumCacheSize(static_cast<long long>(size));
 }
 
+void QNetworkDiskCache_UpdateMetaData(void* ptr, void* metaData){
+	static_cast<MyQNetworkDiskCache*>(ptr)->updateMetaData(*static_cast<QNetworkCacheMetaData*>(metaData));
+}
+
+void QNetworkDiskCache_UpdateMetaDataDefault(void* ptr, void* metaData){
+	static_cast<QNetworkDiskCache*>(ptr)->QNetworkDiskCache::updateMetaData(*static_cast<QNetworkCacheMetaData*>(metaData));
+}
+
 void QNetworkDiskCache_DestroyQNetworkDiskCache(void* ptr){
 	static_cast<QNetworkDiskCache*>(ptr)->~QNetworkDiskCache();
 }
@@ -1822,6 +1977,14 @@ int QNetworkInterface_Index(void* ptr){
 	return static_cast<QNetworkInterface*>(ptr)->index();
 }
 
+void* QNetworkInterface_QNetworkInterface_InterfaceFromIndex(int index){
+	return new QNetworkInterface(QNetworkInterface::interfaceFromIndex(index));
+}
+
+void* QNetworkInterface_QNetworkInterface_InterfaceFromName(char* name){
+	return new QNetworkInterface(QNetworkInterface::interfaceFromName(QString(name)));
+}
+
 int QNetworkInterface_IsValid(void* ptr){
 	return static_cast<QNetworkInterface*>(ptr)->isValid();
 }
@@ -1846,12 +2009,16 @@ void* QNetworkProxy_NewQNetworkProxy3(void* other){
 	return new QNetworkProxy(*static_cast<QNetworkProxy*>(other));
 }
 
+void* QNetworkProxy_QNetworkProxy_ApplicationProxy(){
+	return new QNetworkProxy(QNetworkProxy::applicationProxy());
+}
+
 int QNetworkProxy_Capabilities(void* ptr){
 	return static_cast<QNetworkProxy*>(ptr)->capabilities();
 }
 
-int QNetworkProxy_HasRawHeader(void* ptr, void* headerName){
-	return static_cast<QNetworkProxy*>(ptr)->hasRawHeader(*static_cast<QByteArray*>(headerName));
+int QNetworkProxy_HasRawHeader(void* ptr, char* headerName){
+	return static_cast<QNetworkProxy*>(ptr)->hasRawHeader(QByteArray(headerName));
 }
 
 void* QNetworkProxy_Header(void* ptr, int header){
@@ -1874,8 +2041,8 @@ char* QNetworkProxy_Password(void* ptr){
 	return static_cast<QNetworkProxy*>(ptr)->password().toUtf8().data();
 }
 
-void* QNetworkProxy_RawHeader(void* ptr, void* headerName){
-	return new QByteArray(static_cast<QNetworkProxy*>(ptr)->rawHeader(*static_cast<QByteArray*>(headerName)));
+char* QNetworkProxy_RawHeader(void* ptr, char* headerName){
+	return QString(static_cast<QNetworkProxy*>(ptr)->rawHeader(QByteArray(headerName))).toUtf8().data();
 }
 
 void QNetworkProxy_QNetworkProxy_SetApplicationProxy(void* networkProxy){
@@ -1898,8 +2065,8 @@ void QNetworkProxy_SetPassword(void* ptr, char* password){
 	static_cast<QNetworkProxy*>(ptr)->setPassword(QString(password));
 }
 
-void QNetworkProxy_SetRawHeader(void* ptr, void* headerName, void* headerValue){
-	static_cast<QNetworkProxy*>(ptr)->setRawHeader(*static_cast<QByteArray*>(headerName), *static_cast<QByteArray*>(headerValue));
+void QNetworkProxy_SetRawHeader(void* ptr, char* headerName, char* headerValue){
+	static_cast<QNetworkProxy*>(ptr)->setRawHeader(QByteArray(headerName), QByteArray(headerValue));
 }
 
 void QNetworkProxy_SetType(void* ptr, int ty){
@@ -1986,6 +2153,10 @@ int QNetworkProxyQuery_LocalPort(void* ptr){
 	return static_cast<QNetworkProxyQuery*>(ptr)->localPort();
 }
 
+void* QNetworkProxyQuery_NetworkConfiguration(void* ptr){
+	return new QNetworkConfiguration(static_cast<QNetworkProxyQuery*>(ptr)->networkConfiguration());
+}
+
 char* QNetworkProxyQuery_PeerHostName(void* ptr){
 	return static_cast<QNetworkProxyQuery*>(ptr)->peerHostName().toUtf8().data();
 }
@@ -2044,6 +2215,8 @@ void QNetworkProxyQuery_DestroyQNetworkProxyQuery(void* ptr){
 
 class MyQNetworkReply: public QNetworkReply {
 public:
+	void setSslConfigurationImplementation(const QSslConfiguration & configuration) { callbackQNetworkReplySetSslConfigurationImplementation(this, this->objectName().toUtf8().data(), new QSslConfiguration(configuration)); };
+	void sslConfigurationImplementation(QSslConfiguration & configuration) const { callbackQNetworkReplySslConfigurationImplementation(const_cast<MyQNetworkReply*>(this), this->objectName().toUtf8().data(), new QSslConfiguration(configuration)); };
 	void close() { callbackQNetworkReplyClose(this, this->objectName().toUtf8().data()); };
 	void Signal_DownloadProgress(qint64 bytesReceived, qint64 bytesTotal) { callbackQNetworkReplyDownloadProgress(this, this->objectName().toUtf8().data(), static_cast<long long>(bytesReceived), static_cast<long long>(bytesTotal)); };
 	void Signal_Encrypted() { callbackQNetworkReplyEncrypted(this, this->objectName().toUtf8().data()); };
@@ -2059,6 +2232,22 @@ public:
 	void customEvent(QEvent * event) { callbackQNetworkReplyCustomEvent(this, this->objectName().toUtf8().data(), event); };
 };
 
+void QNetworkReply_SetSslConfigurationImplementation(void* ptr, void* configuration){
+	static_cast<MyQNetworkReply*>(ptr)->setSslConfigurationImplementation(*static_cast<QSslConfiguration*>(configuration));
+}
+
+void QNetworkReply_SetSslConfigurationImplementationDefault(void* ptr, void* configuration){
+	static_cast<QNetworkReply*>(ptr)->QNetworkReply::setSslConfigurationImplementation(*static_cast<QSslConfiguration*>(configuration));
+}
+
+void QNetworkReply_SslConfigurationImplementation(void* ptr, void* configuration){
+	static_cast<MyQNetworkReply*>(ptr)->sslConfigurationImplementation(*static_cast<QSslConfiguration*>(configuration));
+}
+
+void QNetworkReply_SslConfigurationImplementationDefault(void* ptr, void* configuration){
+	static_cast<QNetworkReply*>(ptr)->QNetworkReply::sslConfigurationImplementation(*static_cast<QSslConfiguration*>(configuration));
+}
+
 void QNetworkReply_Abort(void* ptr){
 	QMetaObject::invokeMethod(static_cast<QNetworkReply*>(ptr), "abort");
 }
@@ -2127,8 +2316,8 @@ void QNetworkReply_Finished(void* ptr){
 	static_cast<QNetworkReply*>(ptr)->finished();
 }
 
-int QNetworkReply_HasRawHeader(void* ptr, void* headerName){
-	return static_cast<QNetworkReply*>(ptr)->hasRawHeader(*static_cast<QByteArray*>(headerName));
+int QNetworkReply_HasRawHeader(void* ptr, char* headerName){
+	return static_cast<QNetworkReply*>(ptr)->hasRawHeader(QByteArray(headerName));
 }
 
 void* QNetworkReply_Header(void* ptr, int header){
@@ -2183,14 +2372,18 @@ void QNetworkReply_PreSharedKeyAuthenticationRequired(void* ptr, void* authentic
 	static_cast<QNetworkReply*>(ptr)->preSharedKeyAuthenticationRequired(static_cast<QSslPreSharedKeyAuthenticator*>(authenticator));
 }
 
-void* QNetworkReply_RawHeader(void* ptr, void* headerName){
-	return new QByteArray(static_cast<QNetworkReply*>(ptr)->rawHeader(*static_cast<QByteArray*>(headerName)));
+char* QNetworkReply_RawHeader(void* ptr, char* headerName){
+	return QString(static_cast<QNetworkReply*>(ptr)->rawHeader(QByteArray(headerName))).toUtf8().data();
 }
 
 long long QNetworkReply_ReadBufferSize(void* ptr){
 	return static_cast<long long>(static_cast<QNetworkReply*>(ptr)->readBufferSize());
 }
 
+void* QNetworkReply_Request(void* ptr){
+	return new QNetworkRequest(static_cast<QNetworkReply*>(ptr)->request());
+}
+
 void QNetworkReply_SetReadBufferSize(void* ptr, long long size){
 	static_cast<MyQNetworkReply*>(ptr)->setReadBufferSize(static_cast<long long>(size));
 }
@@ -2203,6 +2396,10 @@ void QNetworkReply_SetSslConfiguration(void* ptr, void* config){
 	static_cast<QNetworkReply*>(ptr)->setSslConfiguration(*static_cast<QSslConfiguration*>(config));
 }
 
+void* QNetworkReply_SslConfiguration(void* ptr){
+	return new QSslConfiguration(static_cast<QNetworkReply*>(ptr)->sslConfiguration());
+}
+
 void QNetworkReply_ConnectUploadProgress(void* ptr){
 	QObject::connect(static_cast<QNetworkReply*>(ptr), static_cast<void (QNetworkReply::*)(qint64, qint64)>(&QNetworkReply::uploadProgress), static_cast<MyQNetworkReply*>(ptr), static_cast<void (MyQNetworkReply::*)(qint64, qint64)>(&MyQNetworkReply::Signal_UploadProgress));;
 }
@@ -2259,8 +2456,8 @@ void* QNetworkRequest_Attribute(void* ptr, int code, void* defaultValue){
 	return new QVariant(static_cast<QNetworkRequest*>(ptr)->attribute(static_cast<QNetworkRequest::Attribute>(code), *static_cast<QVariant*>(defaultValue)));
 }
 
-int QNetworkRequest_HasRawHeader(void* ptr, void* headerName){
-	return static_cast<QNetworkRequest*>(ptr)->hasRawHeader(*static_cast<QByteArray*>(headerName));
+int QNetworkRequest_HasRawHeader(void* ptr, char* headerName){
+	return static_cast<QNetworkRequest*>(ptr)->hasRawHeader(QByteArray(headerName));
 }
 
 void* QNetworkRequest_Header(void* ptr, int header){
@@ -2275,8 +2472,8 @@ int QNetworkRequest_Priority(void* ptr){
 	return static_cast<QNetworkRequest*>(ptr)->priority();
 }
 
-void* QNetworkRequest_RawHeader(void* ptr, void* headerName){
-	return new QByteArray(static_cast<QNetworkRequest*>(ptr)->rawHeader(*static_cast<QByteArray*>(headerName)));
+char* QNetworkRequest_RawHeader(void* ptr, char* headerName){
+	return QString(static_cast<QNetworkRequest*>(ptr)->rawHeader(QByteArray(headerName))).toUtf8().data();
 }
 
 void QNetworkRequest_SetAttribute(void* ptr, int code, void* value){
@@ -2295,8 +2492,8 @@ void QNetworkRequest_SetPriority(void* ptr, int priority){
 	static_cast<QNetworkRequest*>(ptr)->setPriority(static_cast<QNetworkRequest::Priority>(priority));
 }
 
-void QNetworkRequest_SetRawHeader(void* ptr, void* headerName, void* headerValue){
-	static_cast<QNetworkRequest*>(ptr)->setRawHeader(*static_cast<QByteArray*>(headerName), *static_cast<QByteArray*>(headerValue));
+void QNetworkRequest_SetRawHeader(void* ptr, char* headerName, char* headerValue){
+	static_cast<QNetworkRequest*>(ptr)->setRawHeader(QByteArray(headerName), QByteArray(headerValue));
 }
 
 void QNetworkRequest_SetSslConfiguration(void* ptr, void* config){
@@ -2307,6 +2504,10 @@ void QNetworkRequest_SetUrl(void* ptr, void* url){
 	static_cast<QNetworkRequest*>(ptr)->setUrl(*static_cast<QUrl*>(url));
 }
 
+void* QNetworkRequest_SslConfiguration(void* ptr){
+	return new QSslConfiguration(static_cast<QNetworkRequest*>(ptr)->sslConfiguration());
+}
+
 void QNetworkRequest_Swap(void* ptr, void* other){
 	static_cast<QNetworkRequest*>(ptr)->swap(*static_cast<QNetworkRequest*>(other));
 }
@@ -2326,6 +2527,7 @@ public:
 	void Signal_Error2(QNetworkSession::SessionError error) { callbackQNetworkSessionError2(this, this->objectName().toUtf8().data(), error); };
 	void Signal_NewConfigurationActivated() { callbackQNetworkSessionNewConfigurationActivated(this, this->objectName().toUtf8().data()); };
 	void Signal_Opened() { callbackQNetworkSessionOpened(this, this->objectName().toUtf8().data()); };
+	void Signal_PreferredConfigurationChanged(const QNetworkConfiguration & config, bool isSeamless) { callbackQNetworkSessionPreferredConfigurationChanged(this, this->objectName().toUtf8().data(), new QNetworkConfiguration(config), isSeamless); };
 	void Signal_StateChanged(QNetworkSession::State state) { callbackQNetworkSessionStateChanged(this, this->objectName().toUtf8().data(), state); };
 	void Signal_UsagePoliciesChanged(QNetworkSession::UsagePolicies usagePolicies) { callbackQNetworkSessionUsagePoliciesChanged(this, this->objectName().toUtf8().data(), usagePolicies); };
 	void timerEvent(QTimerEvent * event) { callbackQNetworkSessionTimerEvent(this, this->objectName().toUtf8().data(), event); };
@@ -2357,6 +2559,10 @@ void QNetworkSession_Closed(void* ptr){
 	static_cast<QNetworkSession*>(ptr)->closed();
 }
 
+void* QNetworkSession_Configuration(void* ptr){
+	return new QNetworkConfiguration(static_cast<QNetworkSession*>(ptr)->configuration());
+}
+
 void QNetworkSession_ConnectError2(void* ptr){
 	QObject::connect(static_cast<QNetworkSession*>(ptr), static_cast<void (QNetworkSession::*)(QNetworkSession::SessionError)>(&QNetworkSession::error), static_cast<MyQNetworkSession*>(ptr), static_cast<void (MyQNetworkSession::*)(QNetworkSession::SessionError)>(&MyQNetworkSession::Signal_Error2));;
 }
@@ -2381,6 +2587,10 @@ void QNetworkSession_Ignore(void* ptr){
 	QMetaObject::invokeMethod(static_cast<QNetworkSession*>(ptr), "ignore");
 }
 
+void* QNetworkSession_Interface(void* ptr){
+	return new QNetworkInterface(static_cast<QNetworkSession*>(ptr)->interface());
+}
+
 int QNetworkSession_IsOpen(void* ptr){
 	return static_cast<QNetworkSession*>(ptr)->isOpen();
 }
@@ -2417,6 +2627,18 @@ void QNetworkSession_Opened(void* ptr){
 	static_cast<QNetworkSession*>(ptr)->opened();
 }
 
+void QNetworkSession_ConnectPreferredConfigurationChanged(void* ptr){
+	QObject::connect(static_cast<QNetworkSession*>(ptr), static_cast<void (QNetworkSession::*)(const QNetworkConfiguration &, bool)>(&QNetworkSession::preferredConfigurationChanged), static_cast<MyQNetworkSession*>(ptr), static_cast<void (MyQNetworkSession::*)(const QNetworkConfiguration &, bool)>(&MyQNetworkSession::Signal_PreferredConfigurationChanged));;
+}
+
+void QNetworkSession_DisconnectPreferredConfigurationChanged(void* ptr){
+	QObject::disconnect(static_cast<QNetworkSession*>(ptr), static_cast<void (QNetworkSession::*)(const QNetworkConfiguration &, bool)>(&QNetworkSession::preferredConfigurationChanged), static_cast<MyQNetworkSession*>(ptr), static_cast<void (MyQNetworkSession::*)(const QNetworkConfiguration &, bool)>(&MyQNetworkSession::Signal_PreferredConfigurationChanged));;
+}
+
+void QNetworkSession_PreferredConfigurationChanged(void* ptr, void* config, int isSeamless){
+	static_cast<QNetworkSession*>(ptr)->preferredConfigurationChanged(*static_cast<QNetworkConfiguration*>(config), isSeamless != 0);
+}
+
 void QNetworkSession_Reject(void* ptr){
 	QMetaObject::invokeMethod(static_cast<QNetworkSession*>(ptr), "reject");
 }
@@ -2505,8 +2727,8 @@ void QSslCertificate_Clear(void* ptr){
 	static_cast<QSslCertificate*>(ptr)->clear();
 }
 
-void* QSslCertificate_Digest(void* ptr, int algorithm){
-	return new QByteArray(static_cast<QSslCertificate*>(ptr)->digest(static_cast<QCryptographicHash::Algorithm>(algorithm)));
+char* QSslCertificate_Digest(void* ptr, int algorithm){
+	return QString(static_cast<QSslCertificate*>(ptr)->digest(static_cast<QCryptographicHash::Algorithm>(algorithm))).toUtf8().data();
 }
 
 int QSslCertificate_IsBlacklisted(void* ptr){
@@ -2541,36 +2763,40 @@ char* QSslCertificate_IssuerInfo(void* ptr, int subject){
 	return static_cast<QSslCertificate*>(ptr)->issuerInfo(static_cast<QSslCertificate::SubjectInfo>(subject)).join("|").toUtf8().data();
 }
 
-char* QSslCertificate_IssuerInfo2(void* ptr, void* attribute){
-	return static_cast<QSslCertificate*>(ptr)->issuerInfo(*static_cast<QByteArray*>(attribute)).join("|").toUtf8().data();
+char* QSslCertificate_IssuerInfo2(void* ptr, char* attribute){
+	return static_cast<QSslCertificate*>(ptr)->issuerInfo(QByteArray(attribute)).join("|").toUtf8().data();
 }
 
-void* QSslCertificate_SerialNumber(void* ptr){
-	return new QByteArray(static_cast<QSslCertificate*>(ptr)->serialNumber());
+void* QSslCertificate_PublicKey(void* ptr){
+	return new QSslKey(static_cast<QSslCertificate*>(ptr)->publicKey());
+}
+
+char* QSslCertificate_SerialNumber(void* ptr){
+	return QString(static_cast<QSslCertificate*>(ptr)->serialNumber()).toUtf8().data();
 }
 
 char* QSslCertificate_SubjectInfo(void* ptr, int subject){
 	return static_cast<QSslCertificate*>(ptr)->subjectInfo(static_cast<QSslCertificate::SubjectInfo>(subject)).join("|").toUtf8().data();
 }
 
-char* QSslCertificate_SubjectInfo2(void* ptr, void* attribute){
-	return static_cast<QSslCertificate*>(ptr)->subjectInfo(*static_cast<QByteArray*>(attribute)).join("|").toUtf8().data();
+char* QSslCertificate_SubjectInfo2(void* ptr, char* attribute){
+	return static_cast<QSslCertificate*>(ptr)->subjectInfo(QByteArray(attribute)).join("|").toUtf8().data();
 }
 
-void* QSslCertificate_ToDer(void* ptr){
-	return new QByteArray(static_cast<QSslCertificate*>(ptr)->toDer());
+char* QSslCertificate_ToDer(void* ptr){
+	return QString(static_cast<QSslCertificate*>(ptr)->toDer()).toUtf8().data();
 }
 
-void* QSslCertificate_ToPem(void* ptr){
-	return new QByteArray(static_cast<QSslCertificate*>(ptr)->toPem());
+char* QSslCertificate_ToPem(void* ptr){
+	return QString(static_cast<QSslCertificate*>(ptr)->toPem()).toUtf8().data();
 }
 
 char* QSslCertificate_ToText(void* ptr){
 	return static_cast<QSslCertificate*>(ptr)->toText().toUtf8().data();
 }
 
-void* QSslCertificate_Version(void* ptr){
-	return new QByteArray(static_cast<QSslCertificate*>(ptr)->version());
+char* QSslCertificate_Version(void* ptr){
+	return QString(static_cast<QSslCertificate*>(ptr)->version()).toUtf8().data();
 }
 
 void* QSslCertificateExtension_NewQSslCertificateExtension(){
@@ -2669,18 +2895,30 @@ void* QSslConfiguration_NewQSslConfiguration2(void* other){
 	return new QSslConfiguration(*static_cast<QSslConfiguration*>(other));
 }
 
+void* QSslConfiguration_QSslConfiguration_DefaultConfiguration(){
+	return new QSslConfiguration(QSslConfiguration::defaultConfiguration());
+}
+
 int QSslConfiguration_IsNull(void* ptr){
 	return static_cast<QSslConfiguration*>(ptr)->isNull();
 }
 
-void* QSslConfiguration_NextNegotiatedProtocol(void* ptr){
-	return new QByteArray(static_cast<QSslConfiguration*>(ptr)->nextNegotiatedProtocol());
+void* QSslConfiguration_LocalCertificate(void* ptr){
+	return new QSslCertificate(static_cast<QSslConfiguration*>(ptr)->localCertificate());
+}
+
+char* QSslConfiguration_NextNegotiatedProtocol(void* ptr){
+	return QString(static_cast<QSslConfiguration*>(ptr)->nextNegotiatedProtocol()).toUtf8().data();
 }
 
 int QSslConfiguration_NextProtocolNegotiationStatus(void* ptr){
 	return static_cast<QSslConfiguration*>(ptr)->nextProtocolNegotiationStatus();
 }
 
+void* QSslConfiguration_PeerCertificate(void* ptr){
+	return new QSslCertificate(static_cast<QSslConfiguration*>(ptr)->peerCertificate());
+}
+
 int QSslConfiguration_PeerVerifyDepth(void* ptr){
 	return static_cast<QSslConfiguration*>(ptr)->peerVerifyDepth();
 }
@@ -2689,8 +2927,16 @@ int QSslConfiguration_PeerVerifyMode(void* ptr){
 	return static_cast<QSslConfiguration*>(ptr)->peerVerifyMode();
 }
 
-void* QSslConfiguration_SessionTicket(void* ptr){
-	return new QByteArray(static_cast<QSslConfiguration*>(ptr)->sessionTicket());
+void* QSslConfiguration_PrivateKey(void* ptr){
+	return new QSslKey(static_cast<QSslConfiguration*>(ptr)->privateKey());
+}
+
+void* QSslConfiguration_SessionCipher(void* ptr){
+	return new QSslCipher(static_cast<QSslConfiguration*>(ptr)->sessionCipher());
+}
+
+char* QSslConfiguration_SessionTicket(void* ptr){
+	return QString(static_cast<QSslConfiguration*>(ptr)->sessionTicket()).toUtf8().data();
 }
 
 int QSslConfiguration_SessionTicketLifeTimeHint(void* ptr){
@@ -2717,8 +2963,8 @@ void QSslConfiguration_SetPrivateKey(void* ptr, void* key){
 	static_cast<QSslConfiguration*>(ptr)->setPrivateKey(*static_cast<QSslKey*>(key));
 }
 
-void QSslConfiguration_SetSessionTicket(void* ptr, void* sessionTicket){
-	static_cast<QSslConfiguration*>(ptr)->setSessionTicket(*static_cast<QByteArray*>(sessionTicket));
+void QSslConfiguration_SetSessionTicket(void* ptr, char* sessionTicket){
+	static_cast<QSslConfiguration*>(ptr)->setSessionTicket(QByteArray(sessionTicket));
 }
 
 void QSslConfiguration_Swap(void* ptr, void* other){
@@ -2765,6 +3011,10 @@ void* QSslError_NewQSslError4(void* other){
 	return new QSslError(*static_cast<QSslError*>(other));
 }
 
+void* QSslError_Certificate(void* ptr){
+	return new QSslCertificate(static_cast<QSslError*>(ptr)->certificate());
+}
+
 int QSslError_Error(void* ptr){
 	return static_cast<QSslError*>(ptr)->error();
 }
@@ -2805,12 +3055,12 @@ void QSslKey_Swap(void* ptr, void* other){
 	static_cast<QSslKey*>(ptr)->swap(*static_cast<QSslKey*>(other));
 }
 
-void* QSslKey_ToDer(void* ptr, void* passPhrase){
-	return new QByteArray(static_cast<QSslKey*>(ptr)->toDer(*static_cast<QByteArray*>(passPhrase)));
+char* QSslKey_ToDer(void* ptr, char* passPhrase){
+	return QString(static_cast<QSslKey*>(ptr)->toDer(QByteArray(passPhrase))).toUtf8().data();
 }
 
-void* QSslKey_ToPem(void* ptr, void* passPhrase){
-	return new QByteArray(static_cast<QSslKey*>(ptr)->toPem(*static_cast<QByteArray*>(passPhrase)));
+char* QSslKey_ToPem(void* ptr, char* passPhrase){
+	return QString(static_cast<QSslKey*>(ptr)->toPem(QByteArray(passPhrase))).toUtf8().data();
 }
 
 void QSslKey_DestroyQSslKey(void* ptr){
@@ -2825,12 +3075,12 @@ void* QSslPreSharedKeyAuthenticator_NewQSslPreSharedKeyAuthenticator2(void* auth
 	return new QSslPreSharedKeyAuthenticator(*static_cast<QSslPreSharedKeyAuthenticator*>(authenticator));
 }
 
-void* QSslPreSharedKeyAuthenticator_Identity(void* ptr){
-	return new QByteArray(static_cast<QSslPreSharedKeyAuthenticator*>(ptr)->identity());
+char* QSslPreSharedKeyAuthenticator_Identity(void* ptr){
+	return QString(static_cast<QSslPreSharedKeyAuthenticator*>(ptr)->identity()).toUtf8().data();
 }
 
-void* QSslPreSharedKeyAuthenticator_IdentityHint(void* ptr){
-	return new QByteArray(static_cast<QSslPreSharedKeyAuthenticator*>(ptr)->identityHint());
+char* QSslPreSharedKeyAuthenticator_IdentityHint(void* ptr){
+	return QString(static_cast<QSslPreSharedKeyAuthenticator*>(ptr)->identityHint()).toUtf8().data();
 }
 
 int QSslPreSharedKeyAuthenticator_MaximumIdentityLength(void* ptr){
@@ -2841,16 +3091,16 @@ int QSslPreSharedKeyAuthenticator_MaximumPreSharedKeyLength(void* ptr){
 	return static_cast<QSslPreSharedKeyAuthenticator*>(ptr)->maximumPreSharedKeyLength();
 }
 
-void* QSslPreSharedKeyAuthenticator_PreSharedKey(void* ptr){
-	return new QByteArray(static_cast<QSslPreSharedKeyAuthenticator*>(ptr)->preSharedKey());
+char* QSslPreSharedKeyAuthenticator_PreSharedKey(void* ptr){
+	return QString(static_cast<QSslPreSharedKeyAuthenticator*>(ptr)->preSharedKey()).toUtf8().data();
 }
 
-void QSslPreSharedKeyAuthenticator_SetIdentity(void* ptr, void* identity){
-	static_cast<QSslPreSharedKeyAuthenticator*>(ptr)->setIdentity(*static_cast<QByteArray*>(identity));
+void QSslPreSharedKeyAuthenticator_SetIdentity(void* ptr, char* identity){
+	static_cast<QSslPreSharedKeyAuthenticator*>(ptr)->setIdentity(QByteArray(identity));
 }
 
-void QSslPreSharedKeyAuthenticator_SetPreSharedKey(void* ptr, void* preSharedKey){
-	static_cast<QSslPreSharedKeyAuthenticator*>(ptr)->setPreSharedKey(*static_cast<QByteArray*>(preSharedKey));
+void QSslPreSharedKeyAuthenticator_SetPreSharedKey(void* ptr, char* preSharedKey){
+	static_cast<QSslPreSharedKeyAuthenticator*>(ptr)->setPreSharedKey(QByteArray(preSharedKey));
 }
 
 void QSslPreSharedKeyAuthenticator_Swap(void* ptr, void* authenticator){
@@ -2868,6 +3118,7 @@ public:
 	void Signal_Encrypted() { callbackQSslSocketEncrypted(this, this->objectName().toUtf8().data()); };
 	void Signal_EncryptedBytesWritten(qint64 written) { callbackQSslSocketEncryptedBytesWritten(this, this->objectName().toUtf8().data(), static_cast<long long>(written)); };
 	void Signal_ModeChanged(QSslSocket::SslMode mode) { callbackQSslSocketModeChanged(this, this->objectName().toUtf8().data(), mode); };
+	void Signal_PeerVerifyError(const QSslError & error) { callbackQSslSocketPeerVerifyError(this, this->objectName().toUtf8().data(), new QSslError(error)); };
 	void Signal_PreSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator * authenticator) { callbackQSslSocketPreSharedKeyAuthenticationRequired(this, this->objectName().toUtf8().data(), authenticator); };
 	void resume() { callbackQSslSocketResume(this, this->objectName().toUtf8().data()); };
 	void setReadBufferSize(qint64 size) { callbackQSslSocketSetReadBufferSize(this, this->objectName().toUtf8().data(), static_cast<long long>(size)); };
@@ -2962,6 +3213,10 @@ int QSslSocket_IsEncrypted(void* ptr){
 	return static_cast<QSslSocket*>(ptr)->isEncrypted();
 }
 
+void* QSslSocket_LocalCertificate(void* ptr){
+	return new QSslCertificate(static_cast<QSslSocket*>(ptr)->localCertificate());
+}
+
 int QSslSocket_Mode(void* ptr){
 	return static_cast<QSslSocket*>(ptr)->mode();
 }
@@ -2978,10 +3233,26 @@ void QSslSocket_ModeChanged(void* ptr, int mode){
 	static_cast<QSslSocket*>(ptr)->modeChanged(static_cast<QSslSocket::SslMode>(mode));
 }
 
+void* QSslSocket_PeerCertificate(void* ptr){
+	return new QSslCertificate(static_cast<QSslSocket*>(ptr)->peerCertificate());
+}
+
 int QSslSocket_PeerVerifyDepth(void* ptr){
 	return static_cast<QSslSocket*>(ptr)->peerVerifyDepth();
 }
 
+void QSslSocket_ConnectPeerVerifyError(void* ptr){
+	QObject::connect(static_cast<QSslSocket*>(ptr), static_cast<void (QSslSocket::*)(const QSslError &)>(&QSslSocket::peerVerifyError), static_cast<MyQSslSocket*>(ptr), static_cast<void (MyQSslSocket::*)(const QSslError &)>(&MyQSslSocket::Signal_PeerVerifyError));;
+}
+
+void QSslSocket_DisconnectPeerVerifyError(void* ptr){
+	QObject::disconnect(static_cast<QSslSocket*>(ptr), static_cast<void (QSslSocket::*)(const QSslError &)>(&QSslSocket::peerVerifyError), static_cast<MyQSslSocket*>(ptr), static_cast<void (MyQSslSocket::*)(const QSslError &)>(&MyQSslSocket::Signal_PeerVerifyError));;
+}
+
+void QSslSocket_PeerVerifyError(void* ptr, void* error){
+	static_cast<QSslSocket*>(ptr)->peerVerifyError(*static_cast<QSslError*>(error));
+}
+
 int QSslSocket_PeerVerifyMode(void* ptr){
 	return static_cast<QSslSocket*>(ptr)->peerVerifyMode();
 }
@@ -3002,6 +3273,10 @@ void QSslSocket_PreSharedKeyAuthenticationRequired(void* ptr, void* authenticato
 	static_cast<QSslSocket*>(ptr)->preSharedKeyAuthenticationRequired(static_cast<QSslPreSharedKeyAuthenticator*>(authenticator));
 }
 
+void* QSslSocket_PrivateKey(void* ptr){
+	return new QSslKey(static_cast<QSslSocket*>(ptr)->privateKey());
+}
+
 long long QSslSocket_ReadData(void* ptr, char* data, long long maxlen){
 	return static_cast<long long>(static_cast<QSslSocket*>(ptr)->readData(data, static_cast<long long>(maxlen)));
 }
@@ -3014,6 +3289,10 @@ void QSslSocket_ResumeDefault(void* ptr){
 	static_cast<QSslSocket*>(ptr)->QSslSocket::resume();
 }
 
+void* QSslSocket_SessionCipher(void* ptr){
+	return new QSslCipher(static_cast<QSslSocket*>(ptr)->sessionCipher());
+}
+
 void QSslSocket_SetLocalCertificate(void* ptr, void* certificate){
 	static_cast<QSslSocket*>(ptr)->setLocalCertificate(*static_cast<QSslCertificate*>(certificate));
 }
@@ -3058,6 +3337,10 @@ void* QSslSocket_SocketOption(void* ptr, int option){
 	return new QVariant(static_cast<QSslSocket*>(ptr)->socketOption(static_cast<QAbstractSocket::SocketOption>(option)));
 }
 
+void* QSslSocket_SslConfiguration(void* ptr){
+	return new QSslConfiguration(static_cast<QSslSocket*>(ptr)->sslConfiguration());
+}
+
 char* QSslSocket_QSslSocket_SslLibraryBuildVersionString(){
 	return QSslSocket::sslLibraryBuildVersionString().toUtf8().data();
 }
@@ -3204,10 +3487,18 @@ void QTcpServer_PauseAccepting(void* ptr){
 	static_cast<QTcpServer*>(ptr)->pauseAccepting();
 }
 
+void* QTcpServer_Proxy(void* ptr){
+	return new QNetworkProxy(static_cast<QTcpServer*>(ptr)->proxy());
+}
+
 void QTcpServer_ResumeAccepting(void* ptr){
 	static_cast<QTcpServer*>(ptr)->resumeAccepting();
 }
 
+void* QTcpServer_ServerAddress(void* ptr){
+	return new QHostAddress(static_cast<QTcpServer*>(ptr)->serverAddress());
+}
+
 int QTcpServer_ServerError(void* ptr){
 	return static_cast<QTcpServer*>(ptr)->serverError();
 }
@@ -3374,6 +3665,10 @@ int QUdpSocket_LeaveMulticastGroup2(void* ptr, void* groupAddress, void* iface){
 	return static_cast<QUdpSocket*>(ptr)->leaveMulticastGroup(*static_cast<QHostAddress*>(groupAddress), *static_cast<QNetworkInterface*>(iface));
 }
 
+void* QUdpSocket_MulticastInterface(void* ptr){
+	return new QNetworkInterface(static_cast<QUdpSocket*>(ptr)->multicastInterface());
+}
+
 long long QUdpSocket_PendingDatagramSize(void* ptr){
 	return static_cast<long long>(static_cast<QUdpSocket*>(ptr)->pendingDatagramSize());
 }

network/network.h

@@ -10,6 +10,7 @@ extern "C" {
 long long QAbstractNetworkCache_CacheSize(void* ptr);
 void QAbstractNetworkCache_Clear(void* ptr);
 void* QAbstractNetworkCache_Data(void* ptr, void* url);
+void* QAbstractNetworkCache_MetaData(void* ptr, void* url);
 void* QAbstractNetworkCache_Prepare(void* ptr, void* metaData);
 void QAbstractNetworkCache_UpdateMetaData(void* ptr, void* metaData);
 void QAbstractNetworkCache_DestroyQAbstractNetworkCache(void* ptr);
@@ -50,8 +51,14 @@ void QAbstractSocket_HostFound(void* ptr);
 int QAbstractSocket_IsSequential(void* ptr);
 int QAbstractSocket_IsSequentialDefault(void* ptr);
 int QAbstractSocket_IsValid(void* ptr);
+void* QAbstractSocket_LocalAddress(void* ptr);
 int QAbstractSocket_PauseMode(void* ptr);
+void* QAbstractSocket_PeerAddress(void* ptr);
 char* QAbstractSocket_PeerName(void* ptr);
+void* QAbstractSocket_Proxy(void* ptr);
+void QAbstractSocket_ConnectProxyAuthenticationRequired(void* ptr);
+void QAbstractSocket_DisconnectProxyAuthenticationRequired(void* ptr);
+void QAbstractSocket_ProxyAuthenticationRequired(void* ptr, void* proxy, void* authenticator);
 long long QAbstractSocket_ReadBufferSize(void* ptr);
 long long QAbstractSocket_ReadData(void* ptr, char* data, long long maxSize);
 long long QAbstractSocket_ReadDataDefault(void* ptr, char* data, long long maxSize);
@@ -110,11 +117,13 @@ void* QDnsHostAddressRecord_NewQDnsHostAddressRecord();
 void* QDnsHostAddressRecord_NewQDnsHostAddressRecord2(void* other);
 char* QDnsHostAddressRecord_Name(void* ptr);
 void QDnsHostAddressRecord_Swap(void* ptr, void* other);
+void* QDnsHostAddressRecord_Value(void* ptr);
 void QDnsHostAddressRecord_DestroyQDnsHostAddressRecord(void* ptr);
 void* QDnsLookup_NewQDnsLookup3(int ty, char* name, void* nameserver, void* parent);
 int QDnsLookup_Error(void* ptr);
 char* QDnsLookup_ErrorString(void* ptr);
 char* QDnsLookup_Name(void* ptr);
+void* QDnsLookup_Nameserver(void* ptr);
 void QDnsLookup_SetName(void* ptr, char* name);
 void QDnsLookup_SetNameserver(void* ptr, void* nameserver);
 void QDnsLookup_SetType(void* ptr, int v);
@@ -130,6 +139,9 @@ void QDnsLookup_Lookup(void* ptr);
 void QDnsLookup_ConnectNameChanged(void* ptr);
 void QDnsLookup_DisconnectNameChanged(void* ptr);
 void QDnsLookup_NameChanged(void* ptr, char* name);
+void QDnsLookup_ConnectNameserverChanged(void* ptr);
+void QDnsLookup_DisconnectNameserverChanged(void* ptr);
+void QDnsLookup_NameserverChanged(void* ptr, void* nameserver);
 void QDnsLookup_ConnectTypeChanged(void* ptr);
 void QDnsLookup_DisconnectTypeChanged(void* ptr);
 void QDnsLookup_TypeChanged(void* ptr, int ty);
@@ -176,6 +188,7 @@ void* QHostInfo_NewQHostInfo(int id);
 void QHostInfo_QHostInfo_AbortHostLookup(int id);
 int QHostInfo_Error(void* ptr);
 char* QHostInfo_ErrorString(void* ptr);
+void* QHostInfo_QHostInfo_FromName(char* name);
 char* QHostInfo_HostName(void* ptr);
 int QHostInfo_QHostInfo_LookupHost(char* name, void* receiver, char* member);
 int QHostInfo_LookupId(void* ptr);
@@ -189,8 +202,8 @@ char* QHostInfo_QHostInfo_LocalDomainName();
 void* QHttpMultiPart_NewQHttpMultiPart2(int contentType, void* parent);
 void* QHttpMultiPart_NewQHttpMultiPart(void* parent);
 void QHttpMultiPart_Append(void* ptr, void* httpPart);
-void* QHttpMultiPart_Boundary(void* ptr);
-void QHttpMultiPart_SetBoundary(void* ptr, void* boundary);
+char* QHttpMultiPart_Boundary(void* ptr);
+void QHttpMultiPart_SetBoundary(void* ptr, char* boundary);
 void QHttpMultiPart_SetContentType(void* ptr, int contentType);
 void QHttpMultiPart_DestroyQHttpMultiPart(void* ptr);
 void QHttpMultiPart_TimerEvent(void* ptr, void* event);
@@ -201,10 +214,10 @@ void QHttpMultiPart_CustomEvent(void* ptr, void* event);
 void QHttpMultiPart_CustomEventDefault(void* ptr, void* event);
 void* QHttpPart_NewQHttpPart();
 void* QHttpPart_NewQHttpPart2(void* other);
-void QHttpPart_SetBody(void* ptr, void* body);
+void QHttpPart_SetBody(void* ptr, char* body);
 void QHttpPart_SetBodyDevice(void* ptr, void* device);
 void QHttpPart_SetHeader(void* ptr, int header, void* value);
-void QHttpPart_SetRawHeader(void* ptr, void* headerName, void* headerValue);
+void QHttpPart_SetRawHeader(void* ptr, char* headerName, char* headerValue);
 void QHttpPart_Swap(void* ptr, void* other);
 void QHttpPart_DestroyQHttpPart(void* ptr);
 void QLocalServer_SetSocketOptions(void* ptr, int options);
@@ -292,11 +305,13 @@ void QLocalSocket_CustomEvent(void* ptr, void* event);
 void QLocalSocket_CustomEventDefault(void* ptr, void* event);
 void* QNetworkAccessManager_ProxyFactory(void* ptr);
 void* QNetworkAccessManager_NewQNetworkAccessManager(void* parent);
+void* QNetworkAccessManager_ActiveConfiguration(void* ptr);
 void QNetworkAccessManager_ConnectAuthenticationRequired(void* ptr);
 void QNetworkAccessManager_DisconnectAuthenticationRequired(void* ptr);
 void QNetworkAccessManager_AuthenticationRequired(void* ptr, void* reply, void* authenticator);
 void* QNetworkAccessManager_Cache(void* ptr);
 void QNetworkAccessManager_ClearAccessCache(void* ptr);
+void* QNetworkAccessManager_Configuration(void* ptr);
 void* QNetworkAccessManager_CookieJar(void* ptr);
 void* QNetworkAccessManager_CreateRequest(void* ptr, int op, void* req, void* outgoingData);
 void* QNetworkAccessManager_CreateRequestDefault(void* ptr, int op, void* req, void* outgoingData);
@@ -315,14 +330,18 @@ void QNetworkAccessManager_DisconnectNetworkAccessibleChanged(void* ptr);
 void QNetworkAccessManager_NetworkAccessibleChanged(void* ptr, int accessible);
 void* QNetworkAccessManager_Post3(void* ptr, void* request, void* multiPart);
 void* QNetworkAccessManager_Post(void* ptr, void* request, void* data);
-void* QNetworkAccessManager_Post2(void* ptr, void* request, void* data);
+void* QNetworkAccessManager_Post2(void* ptr, void* request, char* data);
 void QNetworkAccessManager_ConnectPreSharedKeyAuthenticationRequired(void* ptr);
 void QNetworkAccessManager_DisconnectPreSharedKeyAuthenticationRequired(void* ptr);
 void QNetworkAccessManager_PreSharedKeyAuthenticationRequired(void* ptr, void* reply, void* authenticator);
+void* QNetworkAccessManager_Proxy(void* ptr);
+void QNetworkAccessManager_ConnectProxyAuthenticationRequired(void* ptr);
+void QNetworkAccessManager_DisconnectProxyAuthenticationRequired(void* ptr);
+void QNetworkAccessManager_ProxyAuthenticationRequired(void* ptr, void* proxy, void* authenticator);
 void* QNetworkAccessManager_Put2(void* ptr, void* request, void* multiPart);
 void* QNetworkAccessManager_Put(void* ptr, void* request, void* data);
-void* QNetworkAccessManager_Put3(void* ptr, void* request, void* data);
-void* QNetworkAccessManager_SendCustomRequest(void* ptr, void* request, void* verb, void* data);
+void* QNetworkAccessManager_Put3(void* ptr, void* request, char* data);
+void* QNetworkAccessManager_SendCustomRequest(void* ptr, void* request, char* verb, void* data);
 void QNetworkAccessManager_SetCache(void* ptr, void* cache);
 void QNetworkAccessManager_SetConfiguration(void* ptr, void* config);
 void QNetworkAccessManager_SetCookieJar(void* ptr, void* cookieJar);
@@ -339,6 +358,9 @@ void QNetworkAccessManager_CustomEvent(void* ptr, void* event);
 void QNetworkAccessManager_CustomEventDefault(void* ptr, void* event);
 void* QNetworkAddressEntry_NewQNetworkAddressEntry();
 void* QNetworkAddressEntry_NewQNetworkAddressEntry2(void* other);
+void* QNetworkAddressEntry_Broadcast(void* ptr);
+void* QNetworkAddressEntry_Ip(void* ptr);
+void* QNetworkAddressEntry_Netmask(void* ptr);
 int QNetworkAddressEntry_PrefixLength(void* ptr);
 void QNetworkAddressEntry_SetBroadcast(void* ptr, void* newBroadcast);
 void QNetworkAddressEntry_SetIp(void* ptr, void* newIp);
@@ -375,6 +397,17 @@ int QNetworkConfiguration_Type(void* ptr);
 void QNetworkConfiguration_DestroyQNetworkConfiguration(void* ptr);
 void* QNetworkConfigurationManager_NewQNetworkConfigurationManager(void* parent);
 int QNetworkConfigurationManager_Capabilities(void* ptr);
+void QNetworkConfigurationManager_ConnectConfigurationAdded(void* ptr);
+void QNetworkConfigurationManager_DisconnectConfigurationAdded(void* ptr);
+void QNetworkConfigurationManager_ConfigurationAdded(void* ptr, void* config);
+void QNetworkConfigurationManager_ConnectConfigurationChanged(void* ptr);
+void QNetworkConfigurationManager_DisconnectConfigurationChanged(void* ptr);
+void QNetworkConfigurationManager_ConfigurationChanged(void* ptr, void* config);
+void* QNetworkConfigurationManager_ConfigurationFromIdentifier(void* ptr, char* identifier);
+void QNetworkConfigurationManager_ConnectConfigurationRemoved(void* ptr);
+void QNetworkConfigurationManager_DisconnectConfigurationRemoved(void* ptr);
+void QNetworkConfigurationManager_ConfigurationRemoved(void* ptr, void* config);
+void* QNetworkConfigurationManager_DefaultConfiguration(void* ptr);
 int QNetworkConfigurationManager_IsOnline(void* ptr);
 void QNetworkConfigurationManager_ConnectOnlineStateChanged(void* ptr);
 void QNetworkConfigurationManager_DisconnectOnlineStateChanged(void* ptr);
@@ -390,7 +423,7 @@ void QNetworkConfigurationManager_ChildEvent(void* ptr, void* event);
 void QNetworkConfigurationManager_ChildEventDefault(void* ptr, void* event);
 void QNetworkConfigurationManager_CustomEvent(void* ptr, void* event);
 void QNetworkConfigurationManager_CustomEventDefault(void* ptr, void* event);
-void* QNetworkCookie_NewQNetworkCookie(void* name, void* value);
+void* QNetworkCookie_NewQNetworkCookie(char* name, char* value);
 void* QNetworkCookie_NewQNetworkCookie2(void* other);
 char* QNetworkCookie_Domain(void* ptr);
 void* QNetworkCookie_ExpirationDate(void* ptr);
@@ -398,19 +431,19 @@ int QNetworkCookie_HasSameIdentifier(void* ptr, void* other);
 int QNetworkCookie_IsHttpOnly(void* ptr);
 int QNetworkCookie_IsSecure(void* ptr);
 int QNetworkCookie_IsSessionCookie(void* ptr);
-void* QNetworkCookie_Name(void* ptr);
+char* QNetworkCookie_Name(void* ptr);
 void QNetworkCookie_Normalize(void* ptr, void* url);
 char* QNetworkCookie_Path(void* ptr);
 void QNetworkCookie_SetDomain(void* ptr, char* domain);
 void QNetworkCookie_SetExpirationDate(void* ptr, void* date);
 void QNetworkCookie_SetHttpOnly(void* ptr, int enable);
-void QNetworkCookie_SetName(void* ptr, void* cookieName);
+void QNetworkCookie_SetName(void* ptr, char* cookieName);
 void QNetworkCookie_SetPath(void* ptr, char* path);
 void QNetworkCookie_SetSecure(void* ptr, int enable);
-void QNetworkCookie_SetValue(void* ptr, void* value);
+void QNetworkCookie_SetValue(void* ptr, char* value);
 void QNetworkCookie_Swap(void* ptr, void* other);
-void* QNetworkCookie_ToRawForm(void* ptr, int form);
-void* QNetworkCookie_Value(void* ptr);
+char* QNetworkCookie_ToRawForm(void* ptr, int form);
+char* QNetworkCookie_Value(void* ptr);
 void QNetworkCookie_DestroyQNetworkCookie(void* ptr);
 void* QNetworkCookieJar_NewQNetworkCookieJar(void* parent);
 int QNetworkCookieJar_DeleteCookie(void* ptr, void* cookie);
@@ -438,11 +471,16 @@ void* QNetworkDiskCache_Data(void* ptr, void* url);
 void* QNetworkDiskCache_DataDefault(void* ptr, void* url);
 long long QNetworkDiskCache_Expire(void* ptr);
 long long QNetworkDiskCache_ExpireDefault(void* ptr);
+void* QNetworkDiskCache_FileMetaData(void* ptr, char* fileName);
 long long QNetworkDiskCache_MaximumCacheSize(void* ptr);
+void* QNetworkDiskCache_MetaData(void* ptr, void* url);
+void* QNetworkDiskCache_MetaDataDefault(void* ptr, void* url);
 void* QNetworkDiskCache_Prepare(void* ptr, void* metaData);
 void* QNetworkDiskCache_PrepareDefault(void* ptr, void* metaData);
 void QNetworkDiskCache_SetCacheDirectory(void* ptr, char* cacheDir);
 void QNetworkDiskCache_SetMaximumCacheSize(void* ptr, long long size);
+void QNetworkDiskCache_UpdateMetaData(void* ptr, void* metaData);
+void QNetworkDiskCache_UpdateMetaDataDefault(void* ptr, void* metaData);
 void QNetworkDiskCache_DestroyQNetworkDiskCache(void* ptr);
 void QNetworkDiskCache_TimerEvent(void* ptr, void* event);
 void QNetworkDiskCache_TimerEventDefault(void* ptr, void* event);
@@ -456,26 +494,29 @@ int QNetworkInterface_Flags(void* ptr);
 char* QNetworkInterface_HardwareAddress(void* ptr);
 char* QNetworkInterface_HumanReadableName(void* ptr);
 int QNetworkInterface_Index(void* ptr);
+void* QNetworkInterface_QNetworkInterface_InterfaceFromIndex(int index);
+void* QNetworkInterface_QNetworkInterface_InterfaceFromName(char* name);
 int QNetworkInterface_IsValid(void* ptr);
 char* QNetworkInterface_Name(void* ptr);
 void QNetworkInterface_Swap(void* ptr, void* other);
 void QNetworkInterface_DestroyQNetworkInterface(void* ptr);
 void* QNetworkProxy_NewQNetworkProxy();
 void* QNetworkProxy_NewQNetworkProxy3(void* other);
+void* QNetworkProxy_QNetworkProxy_ApplicationProxy();
 int QNetworkProxy_Capabilities(void* ptr);
-int QNetworkProxy_HasRawHeader(void* ptr, void* headerName);
+int QNetworkProxy_HasRawHeader(void* ptr, char* headerName);
 void* QNetworkProxy_Header(void* ptr, int header);
 char* QNetworkProxy_HostName(void* ptr);
 int QNetworkProxy_IsCachingProxy(void* ptr);
 int QNetworkProxy_IsTransparentProxy(void* ptr);
 char* QNetworkProxy_Password(void* ptr);
-void* QNetworkProxy_RawHeader(void* ptr, void* headerName);
+char* QNetworkProxy_RawHeader(void* ptr, char* headerName);
 void QNetworkProxy_QNetworkProxy_SetApplicationProxy(void* networkProxy);
 void QNetworkProxy_SetCapabilities(void* ptr, int capabilities);
 void QNetworkProxy_SetHeader(void* ptr, int header, void* value);
 void QNetworkProxy_SetHostName(void* ptr, char* hostName);
 void QNetworkProxy_SetPassword(void* ptr, char* password);
-void QNetworkProxy_SetRawHeader(void* ptr, void* headerName, void* headerValue);
+void QNetworkProxy_SetRawHeader(void* ptr, char* headerName, char* headerValue);
 void QNetworkProxy_SetType(void* ptr, int ty);
 void QNetworkProxy_SetUser(void* ptr, char* user);
 void QNetworkProxy_Swap(void* ptr, void* other);
@@ -494,6 +535,7 @@ void* QNetworkProxyQuery_NewQNetworkProxyQuery5(void* other);
 void* QNetworkProxyQuery_NewQNetworkProxyQuery3(char* hostname, int port, char* protocolTag, int queryType);
 void* QNetworkProxyQuery_NewQNetworkProxyQuery2(void* requestUrl, int queryType);
 int QNetworkProxyQuery_LocalPort(void* ptr);
+void* QNetworkProxyQuery_NetworkConfiguration(void* ptr);
 char* QNetworkProxyQuery_PeerHostName(void* ptr);
 int QNetworkProxyQuery_PeerPort(void* ptr);
 char* QNetworkProxyQuery_ProtocolTag(void* ptr);
@@ -508,6 +550,10 @@ void QNetworkProxyQuery_SetUrl(void* ptr, void* url);
 void QNetworkProxyQuery_Swap(void* ptr, void* other);
 void* QNetworkProxyQuery_Url(void* ptr);
 void QNetworkProxyQuery_DestroyQNetworkProxyQuery(void* ptr);
+void QNetworkReply_SetSslConfigurationImplementation(void* ptr, void* configuration);
+void QNetworkReply_SetSslConfigurationImplementationDefault(void* ptr, void* configuration);
+void QNetworkReply_SslConfigurationImplementation(void* ptr, void* configuration);
+void QNetworkReply_SslConfigurationImplementationDefault(void* ptr, void* configuration);
 void QNetworkReply_Abort(void* ptr);
 void* QNetworkReply_Attribute(void* ptr, int code);
 void QNetworkReply_Close(void* ptr);
@@ -525,7 +571,7 @@ int QNetworkReply_Error(void* ptr);
 void QNetworkReply_ConnectFinished(void* ptr);
 void QNetworkReply_DisconnectFinished(void* ptr);
 void QNetworkReply_Finished(void* ptr);
-int QNetworkReply_HasRawHeader(void* ptr, void* headerName);
+int QNetworkReply_HasRawHeader(void* ptr, char* headerName);
 void* QNetworkReply_Header(void* ptr, int header);
 void QNetworkReply_IgnoreSslErrors(void* ptr);
 void QNetworkReply_IgnoreSslErrorsDefault(void* ptr);
@@ -539,11 +585,13 @@ int QNetworkReply_Operation(void* ptr);
 void QNetworkReply_ConnectPreSharedKeyAuthenticationRequired(void* ptr);
 void QNetworkReply_DisconnectPreSharedKeyAuthenticationRequired(void* ptr);
 void QNetworkReply_PreSharedKeyAuthenticationRequired(void* ptr, void* authenticator);
-void* QNetworkReply_RawHeader(void* ptr, void* headerName);
+char* QNetworkReply_RawHeader(void* ptr, char* headerName);
 long long QNetworkReply_ReadBufferSize(void* ptr);
+void* QNetworkReply_Request(void* ptr);
 void QNetworkReply_SetReadBufferSize(void* ptr, long long size);
 void QNetworkReply_SetReadBufferSizeDefault(void* ptr, long long size);
 void QNetworkReply_SetSslConfiguration(void* ptr, void* config);
+void* QNetworkReply_SslConfiguration(void* ptr);
 void QNetworkReply_ConnectUploadProgress(void* ptr);
 void QNetworkReply_DisconnectUploadProgress(void* ptr);
 void QNetworkReply_UploadProgress(void* ptr, long long bytesSent, long long bytesTotal);
@@ -558,18 +606,19 @@ void QNetworkReply_CustomEventDefault(void* ptr, void* event);
 void* QNetworkRequest_NewQNetworkRequest2(void* other);
 void* QNetworkRequest_NewQNetworkRequest(void* url);
 void* QNetworkRequest_Attribute(void* ptr, int code, void* defaultValue);
-int QNetworkRequest_HasRawHeader(void* ptr, void* headerName);
+int QNetworkRequest_HasRawHeader(void* ptr, char* headerName);
 void* QNetworkRequest_Header(void* ptr, int header);
 void* QNetworkRequest_OriginatingObject(void* ptr);
 int QNetworkRequest_Priority(void* ptr);
-void* QNetworkRequest_RawHeader(void* ptr, void* headerName);
+char* QNetworkRequest_RawHeader(void* ptr, char* headerName);
 void QNetworkRequest_SetAttribute(void* ptr, int code, void* value);
 void QNetworkRequest_SetHeader(void* ptr, int header, void* value);
 void QNetworkRequest_SetOriginatingObject(void* ptr, void* object);
 void QNetworkRequest_SetPriority(void* ptr, int priority);
-void QNetworkRequest_SetRawHeader(void* ptr, void* headerName, void* headerValue);
+void QNetworkRequest_SetRawHeader(void* ptr, char* headerName, char* headerValue);
 void QNetworkRequest_SetSslConfiguration(void* ptr, void* config);
 void QNetworkRequest_SetUrl(void* ptr, void* url);
+void* QNetworkRequest_SslConfiguration(void* ptr);
 void QNetworkRequest_Swap(void* ptr, void* other);
 void* QNetworkRequest_Url(void* ptr);
 void QNetworkRequest_DestroyQNetworkRequest(void* ptr);
@@ -579,12 +628,14 @@ void QNetworkSession_Close(void* ptr);
 void QNetworkSession_ConnectClosed(void* ptr);
 void QNetworkSession_DisconnectClosed(void* ptr);
 void QNetworkSession_Closed(void* ptr);
+void* QNetworkSession_Configuration(void* ptr);
 void QNetworkSession_ConnectError2(void* ptr);
 void QNetworkSession_DisconnectError2(void* ptr);
 void QNetworkSession_Error2(void* ptr, int error);
 int QNetworkSession_Error(void* ptr);
 char* QNetworkSession_ErrorString(void* ptr);
 void QNetworkSession_Ignore(void* ptr);
+void* QNetworkSession_Interface(void* ptr);
 int QNetworkSession_IsOpen(void* ptr);
 void QNetworkSession_Migrate(void* ptr);
 void QNetworkSession_ConnectNewConfigurationActivated(void* ptr);
@@ -594,6 +645,9 @@ void QNetworkSession_Open(void* ptr);
 void QNetworkSession_ConnectOpened(void* ptr);
 void QNetworkSession_DisconnectOpened(void* ptr);
 void QNetworkSession_Opened(void* ptr);
+void QNetworkSession_ConnectPreferredConfigurationChanged(void* ptr);
+void QNetworkSession_DisconnectPreferredConfigurationChanged(void* ptr);
+void QNetworkSession_PreferredConfigurationChanged(void* ptr, void* config, int isSeamless);
 void QNetworkSession_Reject(void* ptr);
 void* QNetworkSession_SessionProperty(void* ptr, char* key);
 void QNetworkSession_SetSessionProperty(void* ptr, char* key, void* value);
@@ -616,7 +670,7 @@ void QNetworkSession_CustomEvent(void* ptr, void* event);
 void QNetworkSession_CustomEventDefault(void* ptr, void* event);
 void* QSslCertificate_NewQSslCertificate3(void* other);
 void QSslCertificate_Clear(void* ptr);
-void* QSslCertificate_Digest(void* ptr, int algorithm);
+char* QSslCertificate_Digest(void* ptr, int algorithm);
 int QSslCertificate_IsBlacklisted(void* ptr);
 void QSslCertificate_Swap(void* ptr, void* other);
 void QSslCertificate_DestroyQSslCertificate(void* ptr);
@@ -625,14 +679,15 @@ void* QSslCertificate_ExpiryDate(void* ptr);
 int QSslCertificate_IsNull(void* ptr);
 int QSslCertificate_IsSelfSigned(void* ptr);
 char* QSslCertificate_IssuerInfo(void* ptr, int subject);
-char* QSslCertificate_IssuerInfo2(void* ptr, void* attribute);
-void* QSslCertificate_SerialNumber(void* ptr);
+char* QSslCertificate_IssuerInfo2(void* ptr, char* attribute);
+void* QSslCertificate_PublicKey(void* ptr);
+char* QSslCertificate_SerialNumber(void* ptr);
 char* QSslCertificate_SubjectInfo(void* ptr, int subject);
-char* QSslCertificate_SubjectInfo2(void* ptr, void* attribute);
-void* QSslCertificate_ToDer(void* ptr);
-void* QSslCertificate_ToPem(void* ptr);
+char* QSslCertificate_SubjectInfo2(void* ptr, char* attribute);
+char* QSslCertificate_ToDer(void* ptr);
+char* QSslCertificate_ToPem(void* ptr);
 char* QSslCertificate_ToText(void* ptr);
-void* QSslCertificate_Version(void* ptr);
+char* QSslCertificate_Version(void* ptr);
 void* QSslCertificateExtension_NewQSslCertificateExtension();
 void* QSslCertificateExtension_NewQSslCertificateExtension2(void* other);
 int QSslCertificateExtension_IsCritical(void* ptr);
@@ -657,19 +712,24 @@ int QSslCipher_UsedBits(void* ptr);
 void QSslCipher_DestroyQSslCipher(void* ptr);
 void* QSslConfiguration_NewQSslConfiguration();
 void* QSslConfiguration_NewQSslConfiguration2(void* other);
+void* QSslConfiguration_QSslConfiguration_DefaultConfiguration();
 int QSslConfiguration_IsNull(void* ptr);
-void* QSslConfiguration_NextNegotiatedProtocol(void* ptr);
+void* QSslConfiguration_LocalCertificate(void* ptr);
+char* QSslConfiguration_NextNegotiatedProtocol(void* ptr);
 int QSslConfiguration_NextProtocolNegotiationStatus(void* ptr);
+void* QSslConfiguration_PeerCertificate(void* ptr);
 int QSslConfiguration_PeerVerifyDepth(void* ptr);
 int QSslConfiguration_PeerVerifyMode(void* ptr);
-void* QSslConfiguration_SessionTicket(void* ptr);
+void* QSslConfiguration_PrivateKey(void* ptr);
+void* QSslConfiguration_SessionCipher(void* ptr);
+char* QSslConfiguration_SessionTicket(void* ptr);
 int QSslConfiguration_SessionTicketLifeTimeHint(void* ptr);
 void QSslConfiguration_QSslConfiguration_SetDefaultConfiguration(void* configuration);
 void QSslConfiguration_SetLocalCertificate(void* ptr, void* certificate);
 void QSslConfiguration_SetPeerVerifyDepth(void* ptr, int depth);
 void QSslConfiguration_SetPeerVerifyMode(void* ptr, int mode);
 void QSslConfiguration_SetPrivateKey(void* ptr, void* key);
-void QSslConfiguration_SetSessionTicket(void* ptr, void* sessionTicket);
+void QSslConfiguration_SetSessionTicket(void* ptr, char* sessionTicket);
 void QSslConfiguration_Swap(void* ptr, void* other);
 void QSslConfiguration_DestroyQSslConfiguration(void* ptr);
 void* QSslEllipticCurve_NewQSslEllipticCurve();
@@ -681,6 +741,7 @@ void* QSslError_NewQSslError();
 void* QSslError_NewQSslError2(int error);
 void* QSslError_NewQSslError3(int error, void* certificate);
 void* QSslError_NewQSslError4(void* other);
+void* QSslError_Certificate(void* ptr);
 int QSslError_Error(void* ptr);
 char* QSslError_ErrorString(void* ptr);
 void QSslError_Swap(void* ptr, void* other);
@@ -691,18 +752,18 @@ void QSslKey_Clear(void* ptr);
 int QSslKey_IsNull(void* ptr);
 int QSslKey_Length(void* ptr);
 void QSslKey_Swap(void* ptr, void* other);
-void* QSslKey_ToDer(void* ptr, void* passPhrase);
-void* QSslKey_ToPem(void* ptr, void* passPhrase);
+char* QSslKey_ToDer(void* ptr, char* passPhrase);
+char* QSslKey_ToPem(void* ptr, char* passPhrase);
 void QSslKey_DestroyQSslKey(void* ptr);
 void* QSslPreSharedKeyAuthenticator_NewQSslPreSharedKeyAuthenticator();
 void* QSslPreSharedKeyAuthenticator_NewQSslPreSharedKeyAuthenticator2(void* authenticator);
-void* QSslPreSharedKeyAuthenticator_Identity(void* ptr);
-void* QSslPreSharedKeyAuthenticator_IdentityHint(void* ptr);
+char* QSslPreSharedKeyAuthenticator_Identity(void* ptr);
+char* QSslPreSharedKeyAuthenticator_IdentityHint(void* ptr);
 int QSslPreSharedKeyAuthenticator_MaximumIdentityLength(void* ptr);
 int QSslPreSharedKeyAuthenticator_MaximumPreSharedKeyLength(void* ptr);
-void* QSslPreSharedKeyAuthenticator_PreSharedKey(void* ptr);
-void QSslPreSharedKeyAuthenticator_SetIdentity(void* ptr, void* identity);
-void QSslPreSharedKeyAuthenticator_SetPreSharedKey(void* ptr, void* preSharedKey);
+char* QSslPreSharedKeyAuthenticator_PreSharedKey(void* ptr);
+void QSslPreSharedKeyAuthenticator_SetIdentity(void* ptr, char* identity);
+void QSslPreSharedKeyAuthenticator_SetPreSharedKey(void* ptr, char* preSharedKey);
 void QSslPreSharedKeyAuthenticator_Swap(void* ptr, void* authenticator);
 void QSslPreSharedKeyAuthenticator_DestroyQSslPreSharedKeyAuthenticator(void* ptr);
 void* QSslSocket_NewQSslSocket(void* parent);
@@ -730,20 +791,27 @@ void QSslSocket_EncryptedBytesWritten(void* ptr, long long written);
 int QSslSocket_Flush(void* ptr);
 void QSslSocket_IgnoreSslErrors(void* ptr);
 int QSslSocket_IsEncrypted(void* ptr);
+void* QSslSocket_LocalCertificate(void* ptr);
 int QSslSocket_Mode(void* ptr);
 void QSslSocket_ConnectModeChanged(void* ptr);
 void QSslSocket_DisconnectModeChanged(void* ptr);
 void QSslSocket_ModeChanged(void* ptr, int mode);
+void* QSslSocket_PeerCertificate(void* ptr);
 int QSslSocket_PeerVerifyDepth(void* ptr);
+void QSslSocket_ConnectPeerVerifyError(void* ptr);
+void QSslSocket_DisconnectPeerVerifyError(void* ptr);
+void QSslSocket_PeerVerifyError(void* ptr, void* error);
 int QSslSocket_PeerVerifyMode(void* ptr);
 char* QSslSocket_PeerVerifyName(void* ptr);
 void QSslSocket_ConnectPreSharedKeyAuthenticationRequired(void* ptr);
 void QSslSocket_DisconnectPreSharedKeyAuthenticationRequired(void* ptr);
 void QSslSocket_PreSharedKeyAuthenticationRequired(void* ptr, void* authenticator);
+void* QSslSocket_PrivateKey(void* ptr);
 long long QSslSocket_ReadData(void* ptr, char* data, long long maxlen);
 long long QSslSocket_ReadDataDefault(void* ptr, char* data, long long maxlen);
 void QSslSocket_Resume(void* ptr);
 void QSslSocket_ResumeDefault(void* ptr);
+void* QSslSocket_SessionCipher(void* ptr);
 void QSslSocket_SetLocalCertificate(void* ptr, void* certificate);
 void QSslSocket_SetPeerVerifyDepth(void* ptr, int depth);
 void QSslSocket_SetPeerVerifyMode(void* ptr, int mode);
@@ -756,6 +824,7 @@ void QSslSocket_SetSocketOptionDefault(void* ptr, int option, void* value);
 void QSslSocket_SetSslConfiguration(void* ptr, void* configuration);
 void* QSslSocket_SocketOption(void* ptr, int option);
 void* QSslSocket_SocketOptionDefault(void* ptr, int option);
+void* QSslSocket_SslConfiguration(void* ptr);
 char* QSslSocket_QSslSocket_SslLibraryBuildVersionString();
 char* QSslSocket_QSslSocket_SslLibraryVersionString();
 void QSslSocket_StartClientEncryption(void* ptr);
@@ -797,7 +866,9 @@ void QTcpServer_NewConnection(void* ptr);
 void* QTcpServer_NextPendingConnection(void* ptr);
 void* QTcpServer_NextPendingConnectionDefault(void* ptr);
 void QTcpServer_PauseAccepting(void* ptr);
+void* QTcpServer_Proxy(void* ptr);
 void QTcpServer_ResumeAccepting(void* ptr);
+void* QTcpServer_ServerAddress(void* ptr);
 int QTcpServer_ServerError(void* ptr);
 void QTcpServer_SetMaxPendingConnections(void* ptr, int numConnections);
 void QTcpServer_SetProxy(void* ptr, void* networkProxy);
@@ -833,6 +904,7 @@ int QUdpSocket_JoinMulticastGroup(void* ptr, void* groupAddress);
 int QUdpSocket_JoinMulticastGroup2(void* ptr, void* groupAddress, void* iface);
 int QUdpSocket_LeaveMulticastGroup(void* ptr, void* groupAddress);
 int QUdpSocket_LeaveMulticastGroup2(void* ptr, void* groupAddress, void* iface);
+void* QUdpSocket_MulticastInterface(void* ptr);
 long long QUdpSocket_PendingDatagramSize(void* ptr);
 void QUdpSocket_SetMulticastInterface(void* ptr, void* iface);
 void QUdpSocket_DestroyQUdpSocket(void* ptr);

nfc/nfc.cpp

@@ -64,8 +64,12 @@ void* QNdefMessage_NewQNdefMessage2(void* record){
 	return new QNdefMessage(*static_cast<QNdefRecord*>(record));
 }
 
-void* QNdefMessage_ToByteArray(void* ptr){
-	return new QByteArray(static_cast<QNdefMessage*>(ptr)->toByteArray());
+void* QNdefMessage_QNdefMessage_FromByteArray(char* message){
+	return new QNdefMessage(QNdefMessage::fromByteArray(QByteArray(message)));
+}
+
+char* QNdefMessage_ToByteArray(void* ptr){
+	return QString(static_cast<QNdefMessage*>(ptr)->toByteArray()).toUtf8().data();
 }
 
 void* QNdefNfcSmartPosterRecord_NewQNdefNfcSmartPosterRecord(){
@@ -84,8 +88,8 @@ int QNdefNfcSmartPosterRecord_Action(void* ptr){
 	return static_cast<QNdefNfcSmartPosterRecord*>(ptr)->action();
 }
 
-void QNdefNfcSmartPosterRecord_AddIcon2(void* ptr, void* ty, void* data){
-	static_cast<QNdefNfcSmartPosterRecord*>(ptr)->addIcon(*static_cast<QByteArray*>(ty), *static_cast<QByteArray*>(data));
+void QNdefNfcSmartPosterRecord_AddIcon2(void* ptr, char* ty, char* data){
+	static_cast<QNdefNfcSmartPosterRecord*>(ptr)->addIcon(QByteArray(ty), QByteArray(data));
 }
 
 int QNdefNfcSmartPosterRecord_AddTitle(void* ptr, void* text){
@@ -100,8 +104,8 @@ int QNdefNfcSmartPosterRecord_HasAction(void* ptr){
 	return static_cast<QNdefNfcSmartPosterRecord*>(ptr)->hasAction();
 }
 
-int QNdefNfcSmartPosterRecord_HasIcon(void* ptr, void* mimetype){
-	return static_cast<QNdefNfcSmartPosterRecord*>(ptr)->hasIcon(*static_cast<QByteArray*>(mimetype));
+int QNdefNfcSmartPosterRecord_HasIcon(void* ptr, char* mimetype){
+	return static_cast<QNdefNfcSmartPosterRecord*>(ptr)->hasIcon(QByteArray(mimetype));
 }
 
 int QNdefNfcSmartPosterRecord_HasSize(void* ptr){
@@ -116,16 +120,16 @@ int QNdefNfcSmartPosterRecord_HasTypeInfo(void* ptr){
 	return static_cast<QNdefNfcSmartPosterRecord*>(ptr)->hasTypeInfo();
 }
 
-void* QNdefNfcSmartPosterRecord_Icon(void* ptr, void* mimetype){
-	return new QByteArray(static_cast<QNdefNfcSmartPosterRecord*>(ptr)->icon(*static_cast<QByteArray*>(mimetype)));
+char* QNdefNfcSmartPosterRecord_Icon(void* ptr, char* mimetype){
+	return QString(static_cast<QNdefNfcSmartPosterRecord*>(ptr)->icon(QByteArray(mimetype))).toUtf8().data();
 }
 
 int QNdefNfcSmartPosterRecord_IconCount(void* ptr){
 	return static_cast<QNdefNfcSmartPosterRecord*>(ptr)->iconCount();
 }
 
-int QNdefNfcSmartPosterRecord_RemoveIcon2(void* ptr, void* ty){
-	return static_cast<QNdefNfcSmartPosterRecord*>(ptr)->removeIcon(*static_cast<QByteArray*>(ty));
+int QNdefNfcSmartPosterRecord_RemoveIcon2(void* ptr, char* ty){
+	return static_cast<QNdefNfcSmartPosterRecord*>(ptr)->removeIcon(QByteArray(ty));
 }
 
 int QNdefNfcSmartPosterRecord_RemoveTitle(void* ptr, void* text){
@@ -140,8 +144,8 @@ void QNdefNfcSmartPosterRecord_SetAction(void* ptr, int act){
 	static_cast<QNdefNfcSmartPosterRecord*>(ptr)->setAction(static_cast<QNdefNfcSmartPosterRecord::Action>(act));
 }
 
-void QNdefNfcSmartPosterRecord_SetTypeInfo(void* ptr, void* ty){
-	static_cast<QNdefNfcSmartPosterRecord*>(ptr)->setTypeInfo(*static_cast<QByteArray*>(ty));
+void QNdefNfcSmartPosterRecord_SetTypeInfo(void* ptr, char* ty){
+	static_cast<QNdefNfcSmartPosterRecord*>(ptr)->setTypeInfo(QByteArray(ty));
 }
 
 void QNdefNfcSmartPosterRecord_SetUri(void* ptr, void* url){
@@ -160,8 +164,8 @@ int QNdefNfcSmartPosterRecord_TitleCount(void* ptr){
 	return static_cast<QNdefNfcSmartPosterRecord*>(ptr)->titleCount();
 }
 
-void* QNdefNfcSmartPosterRecord_TypeInfo(void* ptr){
-	return new QByteArray(static_cast<QNdefNfcSmartPosterRecord*>(ptr)->typeInfo());
+char* QNdefNfcSmartPosterRecord_TypeInfo(void* ptr){
+	return QString(static_cast<QNdefNfcSmartPosterRecord*>(ptr)->typeInfo()).toUtf8().data();
 }
 
 void* QNdefNfcSmartPosterRecord_Uri(void* ptr){
@@ -228,36 +232,36 @@ void* QNdefRecord_NewQNdefRecord2(void* other){
 	return new QNdefRecord(*static_cast<QNdefRecord*>(other));
 }
 
-void* QNdefRecord_Id(void* ptr){
-	return new QByteArray(static_cast<QNdefRecord*>(ptr)->id());
+char* QNdefRecord_Id(void* ptr){
+	return QString(static_cast<QNdefRecord*>(ptr)->id()).toUtf8().data();
 }
 
 int QNdefRecord_IsEmpty(void* ptr){
 	return static_cast<QNdefRecord*>(ptr)->isEmpty();
 }
 
-void* QNdefRecord_Payload(void* ptr){
-	return new QByteArray(static_cast<QNdefRecord*>(ptr)->payload());
+char* QNdefRecord_Payload(void* ptr){
+	return QString(static_cast<QNdefRecord*>(ptr)->payload()).toUtf8().data();
 }
 
-void QNdefRecord_SetId(void* ptr, void* id){
-	static_cast<QNdefRecord*>(ptr)->setId(*static_cast<QByteArray*>(id));
+void QNdefRecord_SetId(void* ptr, char* id){
+	static_cast<QNdefRecord*>(ptr)->setId(QByteArray(id));
 }
 
-void QNdefRecord_SetPayload(void* ptr, void* payload){
-	static_cast<QNdefRecord*>(ptr)->setPayload(*static_cast<QByteArray*>(payload));
+void QNdefRecord_SetPayload(void* ptr, char* payload){
+	static_cast<QNdefRecord*>(ptr)->setPayload(QByteArray(payload));
 }
 
-void QNdefRecord_SetType(void* ptr, void* ty){
-	static_cast<QNdefRecord*>(ptr)->setType(*static_cast<QByteArray*>(ty));
+void QNdefRecord_SetType(void* ptr, char* ty){
+	static_cast<QNdefRecord*>(ptr)->setType(QByteArray(ty));
 }
 
 void QNdefRecord_SetTypeNameFormat(void* ptr, int typeNameFormat){
 	static_cast<QNdefRecord*>(ptr)->setTypeNameFormat(static_cast<QNdefRecord::TypeNameFormat>(typeNameFormat));
 }
 
-void* QNdefRecord_Type(void* ptr){
-	return new QByteArray(static_cast<QNdefRecord*>(ptr)->type());
+char* QNdefRecord_Type(void* ptr){
+	return QString(static_cast<QNdefRecord*>(ptr)->type()).toUtf8().data();
 }
 
 int QNdefRecord_TypeNameFormat(void* ptr){
@@ -293,8 +297,8 @@ int QNearFieldManager_IsAvailable(void* ptr){
 	return static_cast<QNearFieldManager*>(ptr)->isAvailable();
 }
 
-int QNearFieldManager_RegisterNdefMessageHandler2(void* ptr, int typeNameFormat, void* ty, void* object, char* method){
-	return static_cast<QNearFieldManager*>(ptr)->registerNdefMessageHandler(static_cast<QNdefRecord::TypeNameFormat>(typeNameFormat), *static_cast<QByteArray*>(ty), static_cast<QObject*>(object), const_cast<const char*>(method));
+int QNearFieldManager_RegisterNdefMessageHandler2(void* ptr, int typeNameFormat, char* ty, void* object, char* method){
+	return static_cast<QNearFieldManager*>(ptr)->registerNdefMessageHandler(static_cast<QNdefRecord::TypeNameFormat>(typeNameFormat), QByteArray(ty), static_cast<QObject*>(object), const_cast<const char*>(method));
 }
 
 int QNearFieldManager_RegisterNdefMessageHandler3(void* ptr, void* filter, void* object, char* method){
@@ -547,6 +551,7 @@ void QNearFieldShareTarget_CustomEventDefault(void* ptr, void* event){
 class MyQNearFieldTarget: public QNearFieldTarget {
 public:
 	void Signal_Disconnected() { callbackQNearFieldTargetDisconnected(this, this->objectName().toUtf8().data()); };
+	void Signal_NdefMessageRead(const QNdefMessage & message) { callbackQNearFieldTargetNdefMessageRead(this, this->objectName().toUtf8().data(), new QNdefMessage(message)); };
 	void Signal_NdefMessagesWritten() { callbackQNearFieldTargetNdefMessagesWritten(this, this->objectName().toUtf8().data()); };
 	void timerEvent(QTimerEvent * event) { callbackQNearFieldTargetTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQNearFieldTargetChildEvent(this, this->objectName().toUtf8().data(), event); };
@@ -577,6 +582,18 @@ int QNearFieldTarget_IsProcessingCommand(void* ptr){
 	return static_cast<QNearFieldTarget*>(ptr)->isProcessingCommand();
 }
 
+void QNearFieldTarget_ConnectNdefMessageRead(void* ptr){
+	QObject::connect(static_cast<QNearFieldTarget*>(ptr), static_cast<void (QNearFieldTarget::*)(const QNdefMessage &)>(&QNearFieldTarget::ndefMessageRead), static_cast<MyQNearFieldTarget*>(ptr), static_cast<void (MyQNearFieldTarget::*)(const QNdefMessage &)>(&MyQNearFieldTarget::Signal_NdefMessageRead));;
+}
+
+void QNearFieldTarget_DisconnectNdefMessageRead(void* ptr){
+	QObject::disconnect(static_cast<QNearFieldTarget*>(ptr), static_cast<void (QNearFieldTarget::*)(const QNdefMessage &)>(&QNearFieldTarget::ndefMessageRead), static_cast<MyQNearFieldTarget*>(ptr), static_cast<void (MyQNearFieldTarget::*)(const QNdefMessage &)>(&MyQNearFieldTarget::Signal_NdefMessageRead));;
+}
+
+void QNearFieldTarget_NdefMessageRead(void* ptr, void* message){
+	static_cast<QNearFieldTarget*>(ptr)->ndefMessageRead(*static_cast<QNdefMessage*>(message));
+}
+
 void QNearFieldTarget_ConnectNdefMessagesWritten(void* ptr){
 	QObject::connect(static_cast<QNearFieldTarget*>(ptr), static_cast<void (QNearFieldTarget::*)()>(&QNearFieldTarget::ndefMessagesWritten), static_cast<MyQNearFieldTarget*>(ptr), static_cast<void (MyQNearFieldTarget::*)()>(&MyQNearFieldTarget::Signal_NdefMessagesWritten));;
 }
@@ -593,8 +610,8 @@ int QNearFieldTarget_Type(void* ptr){
 	return static_cast<QNearFieldTarget*>(ptr)->type();
 }
 
-void* QNearFieldTarget_Uid(void* ptr){
-	return new QByteArray(static_cast<QNearFieldTarget*>(ptr)->uid());
+char* QNearFieldTarget_Uid(void* ptr){
+	return QString(static_cast<QNearFieldTarget*>(ptr)->uid()).toUtf8().data();
 }
 
 void* QNearFieldTarget_Url(void* ptr){
@@ -651,6 +668,10 @@ void* QQmlNdefRecord_NewQQmlNdefRecord2(void* record, void* parent){
 	return new QQmlNdefRecord(*static_cast<QNdefRecord*>(record), static_cast<QObject*>(parent));
 }
 
+void* QQmlNdefRecord_Record(void* ptr){
+	return new QNdefRecord(static_cast<QQmlNdefRecord*>(ptr)->record());
+}
+
 void QQmlNdefRecord_ConnectRecordChanged(void* ptr){
 	QObject::connect(static_cast<QQmlNdefRecord*>(ptr), static_cast<void (QQmlNdefRecord::*)()>(&QQmlNdefRecord::recordChanged), static_cast<MyQQmlNdefRecord*>(ptr), static_cast<void (MyQQmlNdefRecord::*)()>(&MyQQmlNdefRecord::Signal_RecordChanged));;
 }

nfc/nfc.go

@@ -149,13 +149,19 @@ func NewQNdefMessage2(record QNdefRecord_ITF) *QNdefMessage {
 	return newQNdefMessageFromPointer(C.QNdefMessage_NewQNdefMessage2(PointerFromQNdefRecord(record)))
 }
 
-func (ptr *QNdefMessage) ToByteArray() *core.QByteArray {
+func QNdefMessage_FromByteArray(message string) *QNdefMessage {
+	defer qt.Recovering("QNdefMessage::fromByteArray")
+
+	return NewQNdefMessageFromPointer(C.QNdefMessage_QNdefMessage_FromByteArray(C.CString(message)))
+}
+
+func (ptr *QNdefMessage) ToByteArray() string {
 	defer qt.Recovering("QNdefMessage::toByteArray")
 
 	if ptr.Pointer() != nil {
-		return core.NewQByteArrayFromPointer(C.QNdefMessage_ToByteArray(ptr.Pointer()))
+		return C.GoString(C.QNdefMessage_ToByteArray(ptr.Pointer()))
 	}
-	return nil
+	return ""
 }
 
 type QNdefNfcSmartPosterRecord struct {
@@ -226,11 +232,11 @@ func (ptr *QNdefNfcSmartPosterRecord) Action() QNdefNfcSmartPosterRecord__Action
 	return 0
 }
 
-func (ptr *QNdefNfcSmartPosterRecord) AddIcon2(ty core.QByteArray_ITF, data core.QByteArray_ITF) {
+func (ptr *QNdefNfcSmartPosterRecord) AddIcon2(ty string, data string) {
 	defer qt.Recovering("QNdefNfcSmartPosterRecord::addIcon")
 
 	if ptr.Pointer() != nil {
-		C.QNdefNfcSmartPosterRecord_AddIcon2(ptr.Pointer(), core.PointerFromQByteArray(ty), core.PointerFromQByteArray(data))
+		C.QNdefNfcSmartPosterRecord_AddIcon2(ptr.Pointer(), C.CString(ty), C.CString(data))
 	}
 }
 
@@ -261,11 +267,11 @@ func (ptr *QNdefNfcSmartPosterRecord) HasAction() bool {
 	return false
 }
 
-func (ptr *QNdefNfcSmartPosterRecord) HasIcon(mimetype core.QByteArray_ITF) bool {
+func (ptr *QNdefNfcSmartPosterRecord) HasIcon(mimetype string) bool {
 	defer qt.Recovering("QNdefNfcSmartPosterRecord::hasIcon")
 
 	if ptr.Pointer() != nil {
-		return C.QNdefNfcSmartPosterRecord_HasIcon(ptr.Pointer(), core.PointerFromQByteArray(mimetype)) != 0
+		return C.QNdefNfcSmartPosterRecord_HasIcon(ptr.Pointer(), C.CString(mimetype)) != 0
 	}
 	return false
 }
@@ -297,13 +303,13 @@ func (ptr *QNdefNfcSmartPosterRecord) HasTypeInfo() bool {
 	return false
 }
 
-func (ptr *QNdefNfcSmartPosterRecord) Icon(mimetype core.QByteArray_ITF) *core.QByteArray {
+func (ptr *QNdefNfcSmartPosterRecord) Icon(mimetype string) string {
 	defer qt.Recovering("QNdefNfcSmartPosterRecord::icon")
 
 	if ptr.Pointer() != nil {
-		return core.NewQByteArrayFromPointer(C.QNdefNfcSmartPosterRecord_Icon(ptr.Pointer(), core.PointerFromQByteArray(mimetype)))
+		return C.GoString(C.QNdefNfcSmartPosterRecord_Icon(ptr.Pointer(), C.CString(mimetype)))
 	}
-	return nil
+	return ""
 }
 
 func (ptr *QNdefNfcSmartPosterRecord) IconCount() int {
@@ -315,11 +321,11 @@ func (ptr *QNdefNfcSmartPosterRecord) IconCount() int {
 	return 0
 }
 
-func (ptr *QNdefNfcSmartPosterRecord) RemoveIcon2(ty core.QByteArray_ITF) bool {
+func (ptr *QNdefNfcSmartPosterRecord) RemoveIcon2(ty string) bool {
 	defer qt.Recovering("QNdefNfcSmartPosterRecord::removeIcon")
 
 	if ptr.Pointer() != nil {
-		return C.QNdefNfcSmartPosterRecord_RemoveIcon2(ptr.Pointer(), core.PointerFromQByteArray(ty)) != 0
+		return C.QNdefNfcSmartPosterRecord_RemoveIcon2(ptr.Pointer(), C.CString(ty)) != 0
 	}
 	return false
 }
@@ -350,11 +356,11 @@ func (ptr *QNdefNfcSmartPosterRecord) SetAction(act QNdefNfcSmartPosterRecord__A
 	}
 }
 
-func (ptr *QNdefNfcSmartPosterRecord) SetTypeInfo(ty core.QByteArray_ITF) {
+func (ptr *QNdefNfcSmartPosterRecord) SetTypeInfo(ty string) {
 	defer qt.Recovering("QNdefNfcSmartPosterRecord::setTypeInfo")
 
 	if ptr.Pointer() != nil {
-		C.QNdefNfcSmartPosterRecord_SetTypeInfo(ptr.Pointer(), core.PointerFromQByteArray(ty))
+		C.QNdefNfcSmartPosterRecord_SetTypeInfo(ptr.Pointer(), C.CString(ty))
 	}
 }
 
@@ -392,13 +398,13 @@ func (ptr *QNdefNfcSmartPosterRecord) TitleCount() int {
 	return 0
 }
 
-func (ptr *QNdefNfcSmartPosterRecord) TypeInfo() *core.QByteArray {
+func (ptr *QNdefNfcSmartPosterRecord) TypeInfo() string {
 	defer qt.Recovering("QNdefNfcSmartPosterRecord::typeInfo")
 
 	if ptr.Pointer() != nil {
-		return core.NewQByteArrayFromPointer(C.QNdefNfcSmartPosterRecord_TypeInfo(ptr.Pointer()))
+		return C.GoString(C.QNdefNfcSmartPosterRecord_TypeInfo(ptr.Pointer()))
 	}
-	return nil
+	return ""
 }
 
 func (ptr *QNdefNfcSmartPosterRecord) Uri() *core.QUrl {
@@ -642,13 +648,13 @@ func NewQNdefRecord2(other QNdefRecord_ITF) *QNdefRecord {
 	return newQNdefRecordFromPointer(C.QNdefRecord_NewQNdefRecord2(PointerFromQNdefRecord(other)))
 }
 
-func (ptr *QNdefRecord) Id() *core.QByteArray {
+func (ptr *QNdefRecord) Id() string {
 	defer qt.Recovering("QNdefRecord::id")
 
 	if ptr.Pointer() != nil {
-		return core.NewQByteArrayFromPointer(C.QNdefRecord_Id(ptr.Pointer()))
+		return C.GoString(C.QNdefRecord_Id(ptr.Pointer()))
 	}
-	return nil
+	return ""
 }
 
 func (ptr *QNdefRecord) IsEmpty() bool {
@@ -660,36 +666,36 @@ func (ptr *QNdefRecord) IsEmpty() bool {
 	return false
 }
 
-func (ptr *QNdefRecord) Payload() *core.QByteArray {
+func (ptr *QNdefRecord) Payload() string {
 	defer qt.Recovering("QNdefRecord::payload")
 
 	if ptr.Pointer() != nil {
-		return core.NewQByteArrayFromPointer(C.QNdefRecord_Payload(ptr.Pointer()))
+		return C.GoString(C.QNdefRecord_Payload(ptr.Pointer()))
 	}
-	return nil
+	return ""
 }
 
-func (ptr *QNdefRecord) SetId(id core.QByteArray_ITF) {
+func (ptr *QNdefRecord) SetId(id string) {
 	defer qt.Recovering("QNdefRecord::setId")
 
 	if ptr.Pointer() != nil {
-		C.QNdefRecord_SetId(ptr.Pointer(), core.PointerFromQByteArray(id))
+		C.QNdefRecord_SetId(ptr.Pointer(), C.CString(id))
 	}
 }
 
-func (ptr *QNdefRecord) SetPayload(payload core.QByteArray_ITF) {
+func (ptr *QNdefRecord) SetPayload(payload string) {
 	defer qt.Recovering("QNdefRecord::setPayload")
 
 	if ptr.Pointer() != nil {
-		C.QNdefRecord_SetPayload(ptr.Pointer(), core.PointerFromQByteArray(payload))
+		C.QNdefRecord_SetPayload(ptr.Pointer(), C.CString(payload))
 	}
 }
 
-func (ptr *QNdefRecord) SetType(ty core.QByteArray_ITF) {
+func (ptr *QNdefRecord) SetType(ty string) {
 	defer qt.Recovering("QNdefRecord::setType")
 
 	if ptr.Pointer() != nil {
-		C.QNdefRecord_SetType(ptr.Pointer(), core.PointerFromQByteArray(ty))
+		C.QNdefRecord_SetType(ptr.Pointer(), C.CString(ty))
 	}
 }
 
@@ -701,13 +707,13 @@ func (ptr *QNdefRecord) SetTypeNameFormat(typeNameFormat QNdefRecord__TypeNameFo
 	}
 }
 
-func (ptr *QNdefRecord) Type() *core.QByteArray {
+func (ptr *QNdefRecord) Type() string {
 	defer qt.Recovering("QNdefRecord::type")
 
 	if ptr.Pointer() != nil {
-		return core.NewQByteArrayFromPointer(C.QNdefRecord_Type(ptr.Pointer()))
+		return C.GoString(C.QNdefRecord_Type(ptr.Pointer()))
 	}
-	return nil
+	return ""
 }
 
 func (ptr *QNdefRecord) TypeNameFormat() QNdefRecord__TypeNameFormat {
@@ -804,11 +810,11 @@ func (ptr *QNearFieldManager) IsAvailable() bool {
 	return false
 }
 
-func (ptr *QNearFieldManager) RegisterNdefMessageHandler2(typeNameFormat QNdefRecord__TypeNameFormat, ty core.QByteArray_ITF, object core.QObject_ITF, method string) int {
+func (ptr *QNearFieldManager) RegisterNdefMessageHandler2(typeNameFormat QNdefRecord__TypeNameFormat, ty string, object core.QObject_ITF, method string) int {
 	defer qt.Recovering("QNearFieldManager::registerNdefMessageHandler")
 
 	if ptr.Pointer() != nil {
-		return int(C.QNearFieldManager_RegisterNdefMessageHandler2(ptr.Pointer(), C.int(typeNameFormat), core.PointerFromQByteArray(ty), core.PointerFromQObject(object), C.CString(method)))
+		return int(C.QNearFieldManager_RegisterNdefMessageHandler2(ptr.Pointer(), C.int(typeNameFormat), C.CString(ty), core.PointerFromQObject(object), C.CString(method)))
 	}
 	return 0
 }
@@ -1848,6 +1854,42 @@ func (ptr *QNearFieldTarget) IsProcessingCommand() bool {
 	return false
 }
 
+func (ptr *QNearFieldTarget) ConnectNdefMessageRead(f func(message *QNdefMessage)) {
+	defer qt.Recovering("connect QNearFieldTarget::ndefMessageRead")
+
+	if ptr.Pointer() != nil {
+		C.QNearFieldTarget_ConnectNdefMessageRead(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "ndefMessageRead", f)
+	}
+}
+
+func (ptr *QNearFieldTarget) DisconnectNdefMessageRead() {
+	defer qt.Recovering("disconnect QNearFieldTarget::ndefMessageRead")
+
+	if ptr.Pointer() != nil {
+		C.QNearFieldTarget_DisconnectNdefMessageRead(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "ndefMessageRead")
+	}
+}
+
+//export callbackQNearFieldTargetNdefMessageRead
+func callbackQNearFieldTargetNdefMessageRead(ptr unsafe.Pointer, ptrName *C.char, message unsafe.Pointer) {
+	defer qt.Recovering("callback QNearFieldTarget::ndefMessageRead")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "ndefMessageRead"); signal != nil {
+		signal.(func(*QNdefMessage))(NewQNdefMessageFromPointer(message))
+	}
+
+}
+
+func (ptr *QNearFieldTarget) NdefMessageRead(message QNdefMessage_ITF) {
+	defer qt.Recovering("QNearFieldTarget::ndefMessageRead")
+
+	if ptr.Pointer() != nil {
+		C.QNearFieldTarget_NdefMessageRead(ptr.Pointer(), PointerFromQNdefMessage(message))
+	}
+}
+
 func (ptr *QNearFieldTarget) ConnectNdefMessagesWritten(f func()) {
 	defer qt.Recovering("connect QNearFieldTarget::ndefMessagesWritten")
 
@@ -1893,13 +1935,13 @@ func (ptr *QNearFieldTarget) Type() QNearFieldTarget__Type {
 	return 0
 }
 
-func (ptr *QNearFieldTarget) Uid() *core.QByteArray {
+func (ptr *QNearFieldTarget) Uid() string {
 	defer qt.Recovering("QNearFieldTarget::uid")
 
 	if ptr.Pointer() != nil {
-		return core.NewQByteArrayFromPointer(C.QNearFieldTarget_Uid(ptr.Pointer()))
+		return C.GoString(C.QNearFieldTarget_Uid(ptr.Pointer()))
 	}
-	return nil
+	return ""
 }
 
 func (ptr *QNearFieldTarget) Url() *core.QUrl {
@@ -2122,6 +2164,15 @@ func NewQQmlNdefRecord2(record QNdefRecord_ITF, parent core.QObject_ITF) *QQmlNd
 	return newQQmlNdefRecordFromPointer(C.QQmlNdefRecord_NewQQmlNdefRecord2(PointerFromQNdefRecord(record), core.PointerFromQObject(parent)))
 }
 
+func (ptr *QQmlNdefRecord) Record() *QNdefRecord {
+	defer qt.Recovering("QQmlNdefRecord::record")
+
+	if ptr.Pointer() != nil {
+		return NewQNdefRecordFromPointer(C.QQmlNdefRecord_Record(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QQmlNdefRecord) ConnectRecordChanged(f func()) {
 	defer qt.Recovering("connect QQmlNdefRecord::recordChanged")
 

nfc/nfc.h

@@ -17,31 +17,32 @@ void QNdefFilter_DestroyQNdefFilter(void* ptr);
 void* QNdefMessage_NewQNdefMessage();
 void* QNdefMessage_NewQNdefMessage3(void* message);
 void* QNdefMessage_NewQNdefMessage2(void* record);
-void* QNdefMessage_ToByteArray(void* ptr);
+void* QNdefMessage_QNdefMessage_FromByteArray(char* message);
+char* QNdefMessage_ToByteArray(void* ptr);
 void* QNdefNfcSmartPosterRecord_NewQNdefNfcSmartPosterRecord();
 void* QNdefNfcSmartPosterRecord_NewQNdefNfcSmartPosterRecord3(void* other);
 void* QNdefNfcSmartPosterRecord_NewQNdefNfcSmartPosterRecord2(void* other);
 int QNdefNfcSmartPosterRecord_Action(void* ptr);
-void QNdefNfcSmartPosterRecord_AddIcon2(void* ptr, void* ty, void* data);
+void QNdefNfcSmartPosterRecord_AddIcon2(void* ptr, char* ty, char* data);
 int QNdefNfcSmartPosterRecord_AddTitle(void* ptr, void* text);
 int QNdefNfcSmartPosterRecord_AddTitle2(void* ptr, char* text, char* locale, int encoding);
 int QNdefNfcSmartPosterRecord_HasAction(void* ptr);
-int QNdefNfcSmartPosterRecord_HasIcon(void* ptr, void* mimetype);
+int QNdefNfcSmartPosterRecord_HasIcon(void* ptr, char* mimetype);
 int QNdefNfcSmartPosterRecord_HasSize(void* ptr);
 int QNdefNfcSmartPosterRecord_HasTitle(void* ptr, char* locale);
 int QNdefNfcSmartPosterRecord_HasTypeInfo(void* ptr);
-void* QNdefNfcSmartPosterRecord_Icon(void* ptr, void* mimetype);
+char* QNdefNfcSmartPosterRecord_Icon(void* ptr, char* mimetype);
 int QNdefNfcSmartPosterRecord_IconCount(void* ptr);
-int QNdefNfcSmartPosterRecord_RemoveIcon2(void* ptr, void* ty);
+int QNdefNfcSmartPosterRecord_RemoveIcon2(void* ptr, char* ty);
 int QNdefNfcSmartPosterRecord_RemoveTitle(void* ptr, void* text);
 int QNdefNfcSmartPosterRecord_RemoveTitle2(void* ptr, char* locale);
 void QNdefNfcSmartPosterRecord_SetAction(void* ptr, int act);
-void QNdefNfcSmartPosterRecord_SetTypeInfo(void* ptr, void* ty);
+void QNdefNfcSmartPosterRecord_SetTypeInfo(void* ptr, char* ty);
 void QNdefNfcSmartPosterRecord_SetUri(void* ptr, void* url);
 void QNdefNfcSmartPosterRecord_SetUri2(void* ptr, void* url);
 char* QNdefNfcSmartPosterRecord_Title(void* ptr, char* locale);
 int QNdefNfcSmartPosterRecord_TitleCount(void* ptr);
-void* QNdefNfcSmartPosterRecord_TypeInfo(void* ptr);
+char* QNdefNfcSmartPosterRecord_TypeInfo(void* ptr);
 void* QNdefNfcSmartPosterRecord_Uri(void* ptr);
 void QNdefNfcSmartPosterRecord_DestroyQNdefNfcSmartPosterRecord(void* ptr);
 void* QNdefNfcTextRecord_NewQNdefNfcTextRecord();
@@ -58,21 +59,21 @@ void QNdefNfcUriRecord_SetUri(void* ptr, void* uri);
 void* QNdefNfcUriRecord_Uri(void* ptr);
 void* QNdefRecord_NewQNdefRecord();
 void* QNdefRecord_NewQNdefRecord2(void* other);
-void* QNdefRecord_Id(void* ptr);
+char* QNdefRecord_Id(void* ptr);
 int QNdefRecord_IsEmpty(void* ptr);
-void* QNdefRecord_Payload(void* ptr);
-void QNdefRecord_SetId(void* ptr, void* id);
-void QNdefRecord_SetPayload(void* ptr, void* payload);
-void QNdefRecord_SetType(void* ptr, void* ty);
+char* QNdefRecord_Payload(void* ptr);
+void QNdefRecord_SetId(void* ptr, char* id);
+void QNdefRecord_SetPayload(void* ptr, char* payload);
+void QNdefRecord_SetType(void* ptr, char* ty);
 void QNdefRecord_SetTypeNameFormat(void* ptr, int typeNameFormat);
-void* QNdefRecord_Type(void* ptr);
+char* QNdefRecord_Type(void* ptr);
 int QNdefRecord_TypeNameFormat(void* ptr);
 void QNdefRecord_DestroyQNdefRecord(void* ptr);
 int QNearFieldManager_RegisterNdefMessageHandler(void* ptr, void* object, char* method);
 int QNearFieldManager_StartTargetDetection(void* ptr);
 void* QNearFieldManager_NewQNearFieldManager(void* parent);
 int QNearFieldManager_IsAvailable(void* ptr);
-int QNearFieldManager_RegisterNdefMessageHandler2(void* ptr, int typeNameFormat, void* ty, void* object, char* method);
+int QNearFieldManager_RegisterNdefMessageHandler2(void* ptr, int typeNameFormat, char* ty, void* object, char* method);
 int QNearFieldManager_RegisterNdefMessageHandler3(void* ptr, void* filter, void* object, char* method);
 void QNearFieldManager_SetTargetAccessModes(void* ptr, int accessModes);
 void QNearFieldManager_StopTargetDetection(void* ptr);
@@ -137,11 +138,14 @@ void QNearFieldTarget_Disconnected(void* ptr);
 int QNearFieldTarget_HasNdefMessage(void* ptr);
 int QNearFieldTarget_HasNdefMessageDefault(void* ptr);
 int QNearFieldTarget_IsProcessingCommand(void* ptr);
+void QNearFieldTarget_ConnectNdefMessageRead(void* ptr);
+void QNearFieldTarget_DisconnectNdefMessageRead(void* ptr);
+void QNearFieldTarget_NdefMessageRead(void* ptr, void* message);
 void QNearFieldTarget_ConnectNdefMessagesWritten(void* ptr);
 void QNearFieldTarget_DisconnectNdefMessagesWritten(void* ptr);
 void QNearFieldTarget_NdefMessagesWritten(void* ptr);
 int QNearFieldTarget_Type(void* ptr);
-void* QNearFieldTarget_Uid(void* ptr);
+char* QNearFieldTarget_Uid(void* ptr);
 void* QNearFieldTarget_Url(void* ptr);
 void* QNearFieldTarget_UrlDefault(void* ptr);
 void QNearFieldTarget_DestroyQNearFieldTarget(void* ptr);
@@ -154,6 +158,7 @@ void QNearFieldTarget_CustomEventDefault(void* ptr, void* event);
 int QQmlNdefRecord_TypeNameFormat(void* ptr);
 void* QQmlNdefRecord_NewQQmlNdefRecord(void* parent);
 void* QQmlNdefRecord_NewQQmlNdefRecord2(void* record, void* parent);
+void* QQmlNdefRecord_Record(void* ptr);
 void QQmlNdefRecord_ConnectRecordChanged(void* ptr);
 void QQmlNdefRecord_DisconnectRecordChanged(void* ptr);
 void QQmlNdefRecord_RecordChanged(void* ptr);

positioning/positioning.cpp

@@ -132,6 +132,10 @@ void* QGeoAreaMonitorInfo_NewQGeoAreaMonitorInfo(char* name){
 	return new QGeoAreaMonitorInfo(QString(name));
 }
 
+void* QGeoAreaMonitorInfo_Area(void* ptr){
+	return new QGeoShape(static_cast<QGeoAreaMonitorInfo*>(ptr)->area());
+}
+
 void* QGeoAreaMonitorInfo_Expiration(void* ptr){
 	return new QDateTime(static_cast<QGeoAreaMonitorInfo*>(ptr)->expiration());
 }
@@ -174,13 +178,40 @@ void QGeoAreaMonitorInfo_DestroyQGeoAreaMonitorInfo(void* ptr){
 
 class MyQGeoAreaMonitorSource: public QGeoAreaMonitorSource {
 public:
+	void Signal_AreaEntered(const QGeoAreaMonitorInfo & monitor, const QGeoPositionInfo & update) { callbackQGeoAreaMonitorSourceAreaEntered(this, this->objectName().toUtf8().data(), new QGeoAreaMonitorInfo(monitor), new QGeoPositionInfo(update)); };
+	void Signal_AreaExited(const QGeoAreaMonitorInfo & monitor, const QGeoPositionInfo & update) { callbackQGeoAreaMonitorSourceAreaExited(this, this->objectName().toUtf8().data(), new QGeoAreaMonitorInfo(monitor), new QGeoPositionInfo(update)); };
 	void Signal_Error2(QGeoAreaMonitorSource::Error areaMonitoringError) { callbackQGeoAreaMonitorSourceError2(this, this->objectName().toUtf8().data(), areaMonitoringError); };
+	void Signal_MonitorExpired(const QGeoAreaMonitorInfo & monitor) { callbackQGeoAreaMonitorSourceMonitorExpired(this, this->objectName().toUtf8().data(), new QGeoAreaMonitorInfo(monitor)); };
 	void setPositionInfoSource(QGeoPositionInfoSource * newSource) { callbackQGeoAreaMonitorSourceSetPositionInfoSource(this, this->objectName().toUtf8().data(), newSource); };
 	void timerEvent(QTimerEvent * event) { callbackQGeoAreaMonitorSourceTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQGeoAreaMonitorSourceChildEvent(this, this->objectName().toUtf8().data(), event); };
 	void customEvent(QEvent * event) { callbackQGeoAreaMonitorSourceCustomEvent(this, this->objectName().toUtf8().data(), event); };
 };
 
+void QGeoAreaMonitorSource_ConnectAreaEntered(void* ptr){
+	QObject::connect(static_cast<QGeoAreaMonitorSource*>(ptr), static_cast<void (QGeoAreaMonitorSource::*)(const QGeoAreaMonitorInfo &, const QGeoPositionInfo &)>(&QGeoAreaMonitorSource::areaEntered), static_cast<MyQGeoAreaMonitorSource*>(ptr), static_cast<void (MyQGeoAreaMonitorSource::*)(const QGeoAreaMonitorInfo &, const QGeoPositionInfo &)>(&MyQGeoAreaMonitorSource::Signal_AreaEntered));;
+}
+
+void QGeoAreaMonitorSource_DisconnectAreaEntered(void* ptr){
+	QObject::disconnect(static_cast<QGeoAreaMonitorSource*>(ptr), static_cast<void (QGeoAreaMonitorSource::*)(const QGeoAreaMonitorInfo &, const QGeoPositionInfo &)>(&QGeoAreaMonitorSource::areaEntered), static_cast<MyQGeoAreaMonitorSource*>(ptr), static_cast<void (MyQGeoAreaMonitorSource::*)(const QGeoAreaMonitorInfo &, const QGeoPositionInfo &)>(&MyQGeoAreaMonitorSource::Signal_AreaEntered));;
+}
+
+void QGeoAreaMonitorSource_AreaEntered(void* ptr, void* monitor, void* update){
+	static_cast<QGeoAreaMonitorSource*>(ptr)->areaEntered(*static_cast<QGeoAreaMonitorInfo*>(monitor), *static_cast<QGeoPositionInfo*>(update));
+}
+
+void QGeoAreaMonitorSource_ConnectAreaExited(void* ptr){
+	QObject::connect(static_cast<QGeoAreaMonitorSource*>(ptr), static_cast<void (QGeoAreaMonitorSource::*)(const QGeoAreaMonitorInfo &, const QGeoPositionInfo &)>(&QGeoAreaMonitorSource::areaExited), static_cast<MyQGeoAreaMonitorSource*>(ptr), static_cast<void (MyQGeoAreaMonitorSource::*)(const QGeoAreaMonitorInfo &, const QGeoPositionInfo &)>(&MyQGeoAreaMonitorSource::Signal_AreaExited));;
+}
+
+void QGeoAreaMonitorSource_DisconnectAreaExited(void* ptr){
+	QObject::disconnect(static_cast<QGeoAreaMonitorSource*>(ptr), static_cast<void (QGeoAreaMonitorSource::*)(const QGeoAreaMonitorInfo &, const QGeoPositionInfo &)>(&QGeoAreaMonitorSource::areaExited), static_cast<MyQGeoAreaMonitorSource*>(ptr), static_cast<void (MyQGeoAreaMonitorSource::*)(const QGeoAreaMonitorInfo &, const QGeoPositionInfo &)>(&MyQGeoAreaMonitorSource::Signal_AreaExited));;
+}
+
+void QGeoAreaMonitorSource_AreaExited(void* ptr, void* monitor, void* update){
+	static_cast<QGeoAreaMonitorSource*>(ptr)->areaExited(*static_cast<QGeoAreaMonitorInfo*>(monitor), *static_cast<QGeoPositionInfo*>(update));
+}
+
 char* QGeoAreaMonitorSource_QGeoAreaMonitorSource_AvailableSources(){
 	return QGeoAreaMonitorSource::availableSources().join("|").toUtf8().data();
 }
@@ -209,6 +240,18 @@ int QGeoAreaMonitorSource_Error(void* ptr){
 	return static_cast<QGeoAreaMonitorSource*>(ptr)->error();
 }
 
+void QGeoAreaMonitorSource_ConnectMonitorExpired(void* ptr){
+	QObject::connect(static_cast<QGeoAreaMonitorSource*>(ptr), static_cast<void (QGeoAreaMonitorSource::*)(const QGeoAreaMonitorInfo &)>(&QGeoAreaMonitorSource::monitorExpired), static_cast<MyQGeoAreaMonitorSource*>(ptr), static_cast<void (MyQGeoAreaMonitorSource::*)(const QGeoAreaMonitorInfo &)>(&MyQGeoAreaMonitorSource::Signal_MonitorExpired));;
+}
+
+void QGeoAreaMonitorSource_DisconnectMonitorExpired(void* ptr){
+	QObject::disconnect(static_cast<QGeoAreaMonitorSource*>(ptr), static_cast<void (QGeoAreaMonitorSource::*)(const QGeoAreaMonitorInfo &)>(&QGeoAreaMonitorSource::monitorExpired), static_cast<MyQGeoAreaMonitorSource*>(ptr), static_cast<void (MyQGeoAreaMonitorSource::*)(const QGeoAreaMonitorInfo &)>(&MyQGeoAreaMonitorSource::Signal_MonitorExpired));;
+}
+
+void QGeoAreaMonitorSource_MonitorExpired(void* ptr, void* monitor){
+	static_cast<QGeoAreaMonitorSource*>(ptr)->monitorExpired(*static_cast<QGeoAreaMonitorInfo*>(monitor));
+}
+
 void* QGeoAreaMonitorSource_PositionInfoSource(void* ptr){
 	return static_cast<QGeoAreaMonitorSource*>(ptr)->positionInfoSource();
 }
@@ -285,6 +328,10 @@ void* QGeoCircle_NewQGeoCircle4(void* other){
 	return new QGeoCircle(*static_cast<QGeoShape*>(other));
 }
 
+void* QGeoCircle_Center(void* ptr){
+	return new QGeoCoordinate(static_cast<QGeoCircle*>(ptr)->center());
+}
+
 double QGeoCircle_Radius(void* ptr){
 	return static_cast<double>(static_cast<QGeoCircle*>(ptr)->radius());
 }
@@ -313,6 +360,10 @@ void* QGeoCoordinate_NewQGeoCoordinate4(void* other){
 	return new QGeoCoordinate(*static_cast<QGeoCoordinate*>(other));
 }
 
+void* QGeoCoordinate_AtDistanceAndAzimuth(void* ptr, double distance, double azimuth, double distanceUp){
+	return new QGeoCoordinate(static_cast<QGeoCoordinate*>(ptr)->atDistanceAndAzimuth(static_cast<double>(distance), static_cast<double>(azimuth), static_cast<double>(distanceUp)));
+}
+
 double QGeoCoordinate_AzimuthTo(void* ptr, void* other){
 	return static_cast<double>(static_cast<QGeoCoordinate*>(ptr)->azimuthTo(*static_cast<QGeoCoordinate*>(other)));
 }
@@ -353,6 +404,10 @@ double QGeoPositionInfo_Attribute(void* ptr, int attribute){
 	return static_cast<double>(static_cast<QGeoPositionInfo*>(ptr)->attribute(static_cast<QGeoPositionInfo::Attribute>(attribute)));
 }
 
+void* QGeoPositionInfo_Coordinate(void* ptr){
+	return new QGeoCoordinate(static_cast<QGeoPositionInfo*>(ptr)->coordinate());
+}
+
 int QGeoPositionInfo_HasAttribute(void* ptr, int attribute){
 	return static_cast<QGeoPositionInfo*>(ptr)->hasAttribute(static_cast<QGeoPositionInfo::Attribute>(attribute));
 }
@@ -389,6 +444,7 @@ class MyQGeoPositionInfoSource: public QGeoPositionInfoSource {
 public:
 	void setUpdateInterval(int msec) { callbackQGeoPositionInfoSourceSetUpdateInterval(this, this->objectName().toUtf8().data(), msec); };
 	void Signal_Error2(QGeoPositionInfoSource::Error positioningError) { callbackQGeoPositionInfoSourceError2(this, this->objectName().toUtf8().data(), positioningError); };
+	void Signal_PositionUpdated(const QGeoPositionInfo & update) { callbackQGeoPositionInfoSourcePositionUpdated(this, this->objectName().toUtf8().data(), new QGeoPositionInfo(update)); };
 	void setPreferredPositioningMethods(QGeoPositionInfoSource::PositioningMethods methods) { callbackQGeoPositionInfoSourceSetPreferredPositioningMethods(this, this->objectName().toUtf8().data(), methods); };
 	void Signal_UpdateTimeout() { callbackQGeoPositionInfoSourceUpdateTimeout(this, this->objectName().toUtf8().data()); };
 	void timerEvent(QTimerEvent * event) { callbackQGeoPositionInfoSourceTimerEvent(this, this->objectName().toUtf8().data(), event); };
@@ -440,10 +496,26 @@ int QGeoPositionInfoSource_Error(void* ptr){
 	return static_cast<QGeoPositionInfoSource*>(ptr)->error();
 }
 
+void* QGeoPositionInfoSource_LastKnownPosition(void* ptr, int fromSatellitePositioningMethodsOnly){
+	return new QGeoPositionInfo(static_cast<QGeoPositionInfoSource*>(ptr)->lastKnownPosition(fromSatellitePositioningMethodsOnly != 0));
+}
+
 int QGeoPositionInfoSource_MinimumUpdateInterval(void* ptr){
 	return static_cast<QGeoPositionInfoSource*>(ptr)->minimumUpdateInterval();
 }
 
+void QGeoPositionInfoSource_ConnectPositionUpdated(void* ptr){
+	QObject::connect(static_cast<QGeoPositionInfoSource*>(ptr), static_cast<void (QGeoPositionInfoSource::*)(const QGeoPositionInfo &)>(&QGeoPositionInfoSource::positionUpdated), static_cast<MyQGeoPositionInfoSource*>(ptr), static_cast<void (MyQGeoPositionInfoSource::*)(const QGeoPositionInfo &)>(&MyQGeoPositionInfoSource::Signal_PositionUpdated));;
+}
+
+void QGeoPositionInfoSource_DisconnectPositionUpdated(void* ptr){
+	QObject::disconnect(static_cast<QGeoPositionInfoSource*>(ptr), static_cast<void (QGeoPositionInfoSource::*)(const QGeoPositionInfo &)>(&QGeoPositionInfoSource::positionUpdated), static_cast<MyQGeoPositionInfoSource*>(ptr), static_cast<void (MyQGeoPositionInfoSource::*)(const QGeoPositionInfo &)>(&MyQGeoPositionInfoSource::Signal_PositionUpdated));;
+}
+
+void QGeoPositionInfoSource_PositionUpdated(void* ptr, void* update){
+	static_cast<QGeoPositionInfoSource*>(ptr)->positionUpdated(*static_cast<QGeoPositionInfo*>(update));
+}
+
 int QGeoPositionInfoSource_PreferredPositioningMethods(void* ptr){
 	return static_cast<QGeoPositionInfoSource*>(ptr)->preferredPositioningMethods();
 }
@@ -564,6 +636,18 @@ void* QGeoRectangle_NewQGeoRectangle6(void* other){
 	return new QGeoRectangle(*static_cast<QGeoShape*>(other));
 }
 
+void* QGeoRectangle_BottomLeft(void* ptr){
+	return new QGeoCoordinate(static_cast<QGeoRectangle*>(ptr)->bottomLeft());
+}
+
+void* QGeoRectangle_BottomRight(void* ptr){
+	return new QGeoCoordinate(static_cast<QGeoRectangle*>(ptr)->bottomRight());
+}
+
+void* QGeoRectangle_Center(void* ptr){
+	return new QGeoCoordinate(static_cast<QGeoRectangle*>(ptr)->center());
+}
+
 int QGeoRectangle_Contains(void* ptr, void* rectangle){
 	return static_cast<QGeoRectangle*>(ptr)->contains(*static_cast<QGeoRectangle*>(rectangle));
 }
@@ -596,6 +680,18 @@ char* QGeoRectangle_ToString(void* ptr){
 	return static_cast<QGeoRectangle*>(ptr)->toString().toUtf8().data();
 }
 
+void* QGeoRectangle_TopLeft(void* ptr){
+	return new QGeoCoordinate(static_cast<QGeoRectangle*>(ptr)->topLeft());
+}
+
+void* QGeoRectangle_TopRight(void* ptr){
+	return new QGeoCoordinate(static_cast<QGeoRectangle*>(ptr)->topRight());
+}
+
+void* QGeoRectangle_United(void* ptr, void* rectangle){
+	return new QGeoRectangle(static_cast<QGeoRectangle*>(ptr)->united(*static_cast<QGeoRectangle*>(rectangle)));
+}
+
 void QGeoRectangle_DestroyQGeoRectangle(void* ptr){
 	static_cast<QGeoRectangle*>(ptr)->~QGeoRectangle();
 }
@@ -770,6 +866,10 @@ void* QGeoShape_NewQGeoShape2(void* other){
 	return new QGeoShape(*static_cast<QGeoShape*>(other));
 }
 
+void* QGeoShape_Center(void* ptr){
+	return new QGeoCoordinate(static_cast<QGeoShape*>(ptr)->center());
+}
+
 int QGeoShape_Contains(void* ptr, void* coordinate){
 	return static_cast<QGeoShape*>(ptr)->contains(*static_cast<QGeoCoordinate*>(coordinate));
 }
@@ -823,6 +923,10 @@ int QNmeaPositionInfoSource_Error(void* ptr){
 	return static_cast<QNmeaPositionInfoSource*>(ptr)->error();
 }
 
+void* QNmeaPositionInfoSource_LastKnownPosition(void* ptr, int fromSatellitePositioningMethodsOnly){
+	return new QGeoPositionInfo(static_cast<QNmeaPositionInfoSource*>(ptr)->lastKnownPosition(fromSatellitePositioningMethodsOnly != 0));
+}
+
 int QNmeaPositionInfoSource_MinimumUpdateInterval(void* ptr){
 	return static_cast<QNmeaPositionInfoSource*>(ptr)->minimumUpdateInterval();
 }

positioning/positioning.go

@@ -296,6 +296,15 @@ func NewQGeoAreaMonitorInfo(name string) *QGeoAreaMonitorInfo {
 	return newQGeoAreaMonitorInfoFromPointer(C.QGeoAreaMonitorInfo_NewQGeoAreaMonitorInfo(C.CString(name)))
 }
 
+func (ptr *QGeoAreaMonitorInfo) Area() *QGeoShape {
+	defer qt.Recovering("QGeoAreaMonitorInfo::area")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoShapeFromPointer(C.QGeoAreaMonitorInfo_Area(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QGeoAreaMonitorInfo) Expiration() *core.QDateTime {
 	defer qt.Recovering("QGeoAreaMonitorInfo::expiration")
 
@@ -433,6 +442,78 @@ const (
 	QGeoAreaMonitorSource__NoError                  = QGeoAreaMonitorSource__Error(3)
 )
 
+func (ptr *QGeoAreaMonitorSource) ConnectAreaEntered(f func(monitor *QGeoAreaMonitorInfo, update *QGeoPositionInfo)) {
+	defer qt.Recovering("connect QGeoAreaMonitorSource::areaEntered")
+
+	if ptr.Pointer() != nil {
+		C.QGeoAreaMonitorSource_ConnectAreaEntered(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "areaEntered", f)
+	}
+}
+
+func (ptr *QGeoAreaMonitorSource) DisconnectAreaEntered() {
+	defer qt.Recovering("disconnect QGeoAreaMonitorSource::areaEntered")
+
+	if ptr.Pointer() != nil {
+		C.QGeoAreaMonitorSource_DisconnectAreaEntered(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "areaEntered")
+	}
+}
+
+//export callbackQGeoAreaMonitorSourceAreaEntered
+func callbackQGeoAreaMonitorSourceAreaEntered(ptr unsafe.Pointer, ptrName *C.char, monitor unsafe.Pointer, update unsafe.Pointer) {
+	defer qt.Recovering("callback QGeoAreaMonitorSource::areaEntered")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "areaEntered"); signal != nil {
+		signal.(func(*QGeoAreaMonitorInfo, *QGeoPositionInfo))(NewQGeoAreaMonitorInfoFromPointer(monitor), NewQGeoPositionInfoFromPointer(update))
+	}
+
+}
+
+func (ptr *QGeoAreaMonitorSource) AreaEntered(monitor QGeoAreaMonitorInfo_ITF, update QGeoPositionInfo_ITF) {
+	defer qt.Recovering("QGeoAreaMonitorSource::areaEntered")
+
+	if ptr.Pointer() != nil {
+		C.QGeoAreaMonitorSource_AreaEntered(ptr.Pointer(), PointerFromQGeoAreaMonitorInfo(monitor), PointerFromQGeoPositionInfo(update))
+	}
+}
+
+func (ptr *QGeoAreaMonitorSource) ConnectAreaExited(f func(monitor *QGeoAreaMonitorInfo, update *QGeoPositionInfo)) {
+	defer qt.Recovering("connect QGeoAreaMonitorSource::areaExited")
+
+	if ptr.Pointer() != nil {
+		C.QGeoAreaMonitorSource_ConnectAreaExited(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "areaExited", f)
+	}
+}
+
+func (ptr *QGeoAreaMonitorSource) DisconnectAreaExited() {
+	defer qt.Recovering("disconnect QGeoAreaMonitorSource::areaExited")
+
+	if ptr.Pointer() != nil {
+		C.QGeoAreaMonitorSource_DisconnectAreaExited(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "areaExited")
+	}
+}
+
+//export callbackQGeoAreaMonitorSourceAreaExited
+func callbackQGeoAreaMonitorSourceAreaExited(ptr unsafe.Pointer, ptrName *C.char, monitor unsafe.Pointer, update unsafe.Pointer) {
+	defer qt.Recovering("callback QGeoAreaMonitorSource::areaExited")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "areaExited"); signal != nil {
+		signal.(func(*QGeoAreaMonitorInfo, *QGeoPositionInfo))(NewQGeoAreaMonitorInfoFromPointer(monitor), NewQGeoPositionInfoFromPointer(update))
+	}
+
+}
+
+func (ptr *QGeoAreaMonitorSource) AreaExited(monitor QGeoAreaMonitorInfo_ITF, update QGeoPositionInfo_ITF) {
+	defer qt.Recovering("QGeoAreaMonitorSource::areaExited")
+
+	if ptr.Pointer() != nil {
+		C.QGeoAreaMonitorSource_AreaExited(ptr.Pointer(), PointerFromQGeoAreaMonitorInfo(monitor), PointerFromQGeoPositionInfo(update))
+	}
+}
+
 func QGeoAreaMonitorSource_AvailableSources() []string {
 	defer qt.Recovering("QGeoAreaMonitorSource::availableSources")
 
@@ -496,6 +577,42 @@ func (ptr *QGeoAreaMonitorSource) Error() QGeoAreaMonitorSource__Error {
 	return 0
 }
 
+func (ptr *QGeoAreaMonitorSource) ConnectMonitorExpired(f func(monitor *QGeoAreaMonitorInfo)) {
+	defer qt.Recovering("connect QGeoAreaMonitorSource::monitorExpired")
+
+	if ptr.Pointer() != nil {
+		C.QGeoAreaMonitorSource_ConnectMonitorExpired(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "monitorExpired", f)
+	}
+}
+
+func (ptr *QGeoAreaMonitorSource) DisconnectMonitorExpired() {
+	defer qt.Recovering("disconnect QGeoAreaMonitorSource::monitorExpired")
+
+	if ptr.Pointer() != nil {
+		C.QGeoAreaMonitorSource_DisconnectMonitorExpired(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "monitorExpired")
+	}
+}
+
+//export callbackQGeoAreaMonitorSourceMonitorExpired
+func callbackQGeoAreaMonitorSourceMonitorExpired(ptr unsafe.Pointer, ptrName *C.char, monitor unsafe.Pointer) {
+	defer qt.Recovering("callback QGeoAreaMonitorSource::monitorExpired")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "monitorExpired"); signal != nil {
+		signal.(func(*QGeoAreaMonitorInfo))(NewQGeoAreaMonitorInfoFromPointer(monitor))
+	}
+
+}
+
+func (ptr *QGeoAreaMonitorSource) MonitorExpired(monitor QGeoAreaMonitorInfo_ITF) {
+	defer qt.Recovering("QGeoAreaMonitorSource::monitorExpired")
+
+	if ptr.Pointer() != nil {
+		C.QGeoAreaMonitorSource_MonitorExpired(ptr.Pointer(), PointerFromQGeoAreaMonitorInfo(monitor))
+	}
+}
+
 func (ptr *QGeoAreaMonitorSource) PositionInfoSource() *QGeoPositionInfoSource {
 	defer qt.Recovering("QGeoAreaMonitorSource::positionInfoSource")
 
@@ -794,6 +911,15 @@ func NewQGeoCircle4(other QGeoShape_ITF) *QGeoCircle {
 	return newQGeoCircleFromPointer(C.QGeoCircle_NewQGeoCircle4(PointerFromQGeoShape(other)))
 }
 
+func (ptr *QGeoCircle) Center() *QGeoCoordinate {
+	defer qt.Recovering("QGeoCircle::center")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoCoordinateFromPointer(C.QGeoCircle_Center(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QGeoCircle) Radius() float64 {
 	defer qt.Recovering("QGeoCircle::radius")
 
@@ -907,6 +1033,15 @@ func NewQGeoCoordinate4(other QGeoCoordinate_ITF) *QGeoCoordinate {
 	return newQGeoCoordinateFromPointer(C.QGeoCoordinate_NewQGeoCoordinate4(PointerFromQGeoCoordinate(other)))
 }
 
+func (ptr *QGeoCoordinate) AtDistanceAndAzimuth(distance float64, azimuth float64, distanceUp float64) *QGeoCoordinate {
+	defer qt.Recovering("QGeoCoordinate::atDistanceAndAzimuth")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoCoordinateFromPointer(C.QGeoCoordinate_AtDistanceAndAzimuth(ptr.Pointer(), C.double(distance), C.double(azimuth), C.double(distanceUp)))
+	}
+	return nil
+}
+
 func (ptr *QGeoCoordinate) AzimuthTo(other QGeoCoordinate_ITF) float64 {
 	defer qt.Recovering("QGeoCoordinate::azimuthTo")
 
@@ -1075,6 +1210,15 @@ func (ptr *QGeoPositionInfo) Attribute(attribute QGeoPositionInfo__Attribute) fl
 	return 0
 }
 
+func (ptr *QGeoPositionInfo) Coordinate() *QGeoCoordinate {
+	defer qt.Recovering("QGeoPositionInfo::coordinate")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoCoordinateFromPointer(C.QGeoPositionInfo_Coordinate(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QGeoPositionInfo) HasAttribute(attribute QGeoPositionInfo__Attribute) bool {
 	defer qt.Recovering("QGeoPositionInfo::hasAttribute")
 
@@ -1322,6 +1466,15 @@ func (ptr *QGeoPositionInfoSource) Error() QGeoPositionInfoSource__Error {
 	return 0
 }
 
+func (ptr *QGeoPositionInfoSource) LastKnownPosition(fromSatellitePositioningMethodsOnly bool) *QGeoPositionInfo {
+	defer qt.Recovering("QGeoPositionInfoSource::lastKnownPosition")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoPositionInfoFromPointer(C.QGeoPositionInfoSource_LastKnownPosition(ptr.Pointer(), C.int(qt.GoBoolToInt(fromSatellitePositioningMethodsOnly))))
+	}
+	return nil
+}
+
 func (ptr *QGeoPositionInfoSource) MinimumUpdateInterval() int {
 	defer qt.Recovering("QGeoPositionInfoSource::minimumUpdateInterval")
 
@@ -1331,6 +1484,42 @@ func (ptr *QGeoPositionInfoSource) MinimumUpdateInterval() int {
 	return 0
 }
 
+func (ptr *QGeoPositionInfoSource) ConnectPositionUpdated(f func(update *QGeoPositionInfo)) {
+	defer qt.Recovering("connect QGeoPositionInfoSource::positionUpdated")
+
+	if ptr.Pointer() != nil {
+		C.QGeoPositionInfoSource_ConnectPositionUpdated(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "positionUpdated", f)
+	}
+}
+
+func (ptr *QGeoPositionInfoSource) DisconnectPositionUpdated() {
+	defer qt.Recovering("disconnect QGeoPositionInfoSource::positionUpdated")
+
+	if ptr.Pointer() != nil {
+		C.QGeoPositionInfoSource_DisconnectPositionUpdated(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "positionUpdated")
+	}
+}
+
+//export callbackQGeoPositionInfoSourcePositionUpdated
+func callbackQGeoPositionInfoSourcePositionUpdated(ptr unsafe.Pointer, ptrName *C.char, update unsafe.Pointer) {
+	defer qt.Recovering("callback QGeoPositionInfoSource::positionUpdated")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "positionUpdated"); signal != nil {
+		signal.(func(*QGeoPositionInfo))(NewQGeoPositionInfoFromPointer(update))
+	}
+
+}
+
+func (ptr *QGeoPositionInfoSource) PositionUpdated(update QGeoPositionInfo_ITF) {
+	defer qt.Recovering("QGeoPositionInfoSource::positionUpdated")
+
+	if ptr.Pointer() != nil {
+		C.QGeoPositionInfoSource_PositionUpdated(ptr.Pointer(), PointerFromQGeoPositionInfo(update))
+	}
+}
+
 func (ptr *QGeoPositionInfoSource) PreferredPositioningMethods() QGeoPositionInfoSource__PositioningMethod {
 	defer qt.Recovering("QGeoPositionInfoSource::preferredPositioningMethods")
 
@@ -1746,6 +1935,33 @@ func NewQGeoRectangle6(other QGeoShape_ITF) *QGeoRectangle {
 	return newQGeoRectangleFromPointer(C.QGeoRectangle_NewQGeoRectangle6(PointerFromQGeoShape(other)))
 }
 
+func (ptr *QGeoRectangle) BottomLeft() *QGeoCoordinate {
+	defer qt.Recovering("QGeoRectangle::bottomLeft")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoCoordinateFromPointer(C.QGeoRectangle_BottomLeft(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QGeoRectangle) BottomRight() *QGeoCoordinate {
+	defer qt.Recovering("QGeoRectangle::bottomRight")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoCoordinateFromPointer(C.QGeoRectangle_BottomRight(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QGeoRectangle) Center() *QGeoCoordinate {
+	defer qt.Recovering("QGeoRectangle::center")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoCoordinateFromPointer(C.QGeoRectangle_Center(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QGeoRectangle) Contains(rectangle QGeoRectangle_ITF) bool {
 	defer qt.Recovering("QGeoRectangle::contains")
 
@@ -1813,6 +2029,33 @@ func (ptr *QGeoRectangle) ToString() string {
 	return ""
 }
 
+func (ptr *QGeoRectangle) TopLeft() *QGeoCoordinate {
+	defer qt.Recovering("QGeoRectangle::topLeft")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoCoordinateFromPointer(C.QGeoRectangle_TopLeft(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QGeoRectangle) TopRight() *QGeoCoordinate {
+	defer qt.Recovering("QGeoRectangle::topRight")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoCoordinateFromPointer(C.QGeoRectangle_TopRight(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QGeoRectangle) United(rectangle QGeoRectangle_ITF) *QGeoRectangle {
+	defer qt.Recovering("QGeoRectangle::united")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoRectangleFromPointer(C.QGeoRectangle_United(ptr.Pointer(), PointerFromQGeoRectangle(rectangle)))
+	}
+	return nil
+}
+
 func (ptr *QGeoRectangle) DestroyQGeoRectangle() {
 	defer qt.Recovering("QGeoRectangle::~QGeoRectangle")
 
@@ -2423,6 +2666,15 @@ func NewQGeoShape2(other QGeoShape_ITF) *QGeoShape {
 	return newQGeoShapeFromPointer(C.QGeoShape_NewQGeoShape2(PointerFromQGeoShape(other)))
 }
 
+func (ptr *QGeoShape) Center() *QGeoCoordinate {
+	defer qt.Recovering("QGeoShape::center")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoCoordinateFromPointer(C.QGeoShape_Center(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QGeoShape) Contains(coordinate QGeoCoordinate_ITF) bool {
 	defer qt.Recovering("QGeoShape::contains")
 
@@ -2550,6 +2802,15 @@ func (ptr *QNmeaPositionInfoSource) Error() QGeoPositionInfoSource__Error {
 	return 0
 }
 
+func (ptr *QNmeaPositionInfoSource) LastKnownPosition(fromSatellitePositioningMethodsOnly bool) *QGeoPositionInfo {
+	defer qt.Recovering("QNmeaPositionInfoSource::lastKnownPosition")
+
+	if ptr.Pointer() != nil {
+		return NewQGeoPositionInfoFromPointer(C.QNmeaPositionInfoSource_LastKnownPosition(ptr.Pointer(), C.int(qt.GoBoolToInt(fromSatellitePositioningMethodsOnly))))
+	}
+	return nil
+}
+
 func (ptr *QNmeaPositionInfoSource) MinimumUpdateInterval() int {
 	defer qt.Recovering("QNmeaPositionInfoSource::minimumUpdateInterval")
 

positioning/positioning.h

@@ -33,6 +33,7 @@ char* QGeoAddress_Text(void* ptr);
 void QGeoAddress_DestroyQGeoAddress(void* ptr);
 void* QGeoAreaMonitorInfo_NewQGeoAreaMonitorInfo2(void* other);
 void* QGeoAreaMonitorInfo_NewQGeoAreaMonitorInfo(char* name);
+void* QGeoAreaMonitorInfo_Area(void* ptr);
 void* QGeoAreaMonitorInfo_Expiration(void* ptr);
 char* QGeoAreaMonitorInfo_Identifier(void* ptr);
 int QGeoAreaMonitorInfo_IsPersistent(void* ptr);
@@ -43,6 +44,12 @@ void QGeoAreaMonitorInfo_SetExpiration(void* ptr, void* expiry);
 void QGeoAreaMonitorInfo_SetName(void* ptr, char* name);
 void QGeoAreaMonitorInfo_SetPersistent(void* ptr, int isPersistent);
 void QGeoAreaMonitorInfo_DestroyQGeoAreaMonitorInfo(void* ptr);
+void QGeoAreaMonitorSource_ConnectAreaEntered(void* ptr);
+void QGeoAreaMonitorSource_DisconnectAreaEntered(void* ptr);
+void QGeoAreaMonitorSource_AreaEntered(void* ptr, void* monitor, void* update);
+void QGeoAreaMonitorSource_ConnectAreaExited(void* ptr);
+void QGeoAreaMonitorSource_DisconnectAreaExited(void* ptr);
+void QGeoAreaMonitorSource_AreaExited(void* ptr, void* monitor, void* update);
 char* QGeoAreaMonitorSource_QGeoAreaMonitorSource_AvailableSources();
 void* QGeoAreaMonitorSource_QGeoAreaMonitorSource_CreateDefaultSource(void* parent);
 void* QGeoAreaMonitorSource_QGeoAreaMonitorSource_CreateSource(char* sourceName, void* parent);
@@ -50,6 +57,9 @@ void QGeoAreaMonitorSource_ConnectError2(void* ptr);
 void QGeoAreaMonitorSource_DisconnectError2(void* ptr);
 void QGeoAreaMonitorSource_Error2(void* ptr, int areaMonitoringError);
 int QGeoAreaMonitorSource_Error(void* ptr);
+void QGeoAreaMonitorSource_ConnectMonitorExpired(void* ptr);
+void QGeoAreaMonitorSource_DisconnectMonitorExpired(void* ptr);
+void QGeoAreaMonitorSource_MonitorExpired(void* ptr, void* monitor);
 void* QGeoAreaMonitorSource_PositionInfoSource(void* ptr);
 void* QGeoAreaMonitorSource_PositionInfoSourceDefault(void* ptr);
 int QGeoAreaMonitorSource_RequestUpdate(void* ptr, void* monitor, char* signal);
@@ -70,6 +80,7 @@ void* QGeoCircle_NewQGeoCircle();
 void* QGeoCircle_NewQGeoCircle3(void* other);
 void* QGeoCircle_NewQGeoCircle2(void* center, double radius);
 void* QGeoCircle_NewQGeoCircle4(void* other);
+void* QGeoCircle_Center(void* ptr);
 double QGeoCircle_Radius(void* ptr);
 void QGeoCircle_SetCenter(void* ptr, void* center);
 void QGeoCircle_SetRadius(void* ptr, double radius);
@@ -77,6 +88,7 @@ char* QGeoCircle_ToString(void* ptr);
 void QGeoCircle_DestroyQGeoCircle(void* ptr);
 void* QGeoCoordinate_NewQGeoCoordinate();
 void* QGeoCoordinate_NewQGeoCoordinate4(void* other);
+void* QGeoCoordinate_AtDistanceAndAzimuth(void* ptr, double distance, double azimuth, double distanceUp);
 double QGeoCoordinate_AzimuthTo(void* ptr, void* other);
 double QGeoCoordinate_DistanceTo(void* ptr, void* other);
 int QGeoCoordinate_IsValid(void* ptr);
@@ -87,6 +99,7 @@ void* QGeoPositionInfo_NewQGeoPositionInfo();
 void* QGeoPositionInfo_NewQGeoPositionInfo2(void* coordinate, void* timestamp);
 void* QGeoPositionInfo_NewQGeoPositionInfo3(void* other);
 double QGeoPositionInfo_Attribute(void* ptr, int attribute);
+void* QGeoPositionInfo_Coordinate(void* ptr);
 int QGeoPositionInfo_HasAttribute(void* ptr, int attribute);
 int QGeoPositionInfo_IsValid(void* ptr);
 void QGeoPositionInfo_RemoveAttribute(void* ptr, int attribute);
@@ -106,7 +119,11 @@ void QGeoPositionInfoSource_ConnectError2(void* ptr);
 void QGeoPositionInfoSource_DisconnectError2(void* ptr);
 void QGeoPositionInfoSource_Error2(void* ptr, int positioningError);
 int QGeoPositionInfoSource_Error(void* ptr);
+void* QGeoPositionInfoSource_LastKnownPosition(void* ptr, int fromSatellitePositioningMethodsOnly);
 int QGeoPositionInfoSource_MinimumUpdateInterval(void* ptr);
+void QGeoPositionInfoSource_ConnectPositionUpdated(void* ptr);
+void QGeoPositionInfoSource_DisconnectPositionUpdated(void* ptr);
+void QGeoPositionInfoSource_PositionUpdated(void* ptr, void* update);
 int QGeoPositionInfoSource_PreferredPositioningMethods(void* ptr);
 void QGeoPositionInfoSource_RequestUpdate(void* ptr, int timeout);
 void QGeoPositionInfoSource_SetPreferredPositioningMethods(void* ptr, int methods);
@@ -134,6 +151,9 @@ void* QGeoRectangle_NewQGeoRectangle();
 void* QGeoRectangle_NewQGeoRectangle3(void* topLeft, void* bottomRight);
 void* QGeoRectangle_NewQGeoRectangle5(void* other);
 void* QGeoRectangle_NewQGeoRectangle6(void* other);
+void* QGeoRectangle_BottomLeft(void* ptr);
+void* QGeoRectangle_BottomRight(void* ptr);
+void* QGeoRectangle_Center(void* ptr);
 int QGeoRectangle_Contains(void* ptr, void* rectangle);
 int QGeoRectangle_Intersects(void* ptr, void* rectangle);
 void QGeoRectangle_SetBottomLeft(void* ptr, void* bottomLeft);
@@ -142,6 +162,9 @@ void QGeoRectangle_SetCenter(void* ptr, void* center);
 void QGeoRectangle_SetTopLeft(void* ptr, void* topLeft);
 void QGeoRectangle_SetTopRight(void* ptr, void* topRight);
 char* QGeoRectangle_ToString(void* ptr);
+void* QGeoRectangle_TopLeft(void* ptr);
+void* QGeoRectangle_TopRight(void* ptr);
+void* QGeoRectangle_United(void* ptr, void* rectangle);
 void QGeoRectangle_DestroyQGeoRectangle(void* ptr);
 void* QGeoSatelliteInfo_NewQGeoSatelliteInfo();
 void* QGeoSatelliteInfo_NewQGeoSatelliteInfo2(void* other);
@@ -183,6 +206,7 @@ void QGeoSatelliteInfoSource_CustomEvent(void* ptr, void* event);
 void QGeoSatelliteInfoSource_CustomEventDefault(void* ptr, void* event);
 void* QGeoShape_NewQGeoShape();
 void* QGeoShape_NewQGeoShape2(void* other);
+void* QGeoShape_Center(void* ptr);
 int QGeoShape_Contains(void* ptr, void* coordinate);
 void QGeoShape_ExtendShape(void* ptr, void* coordinate);
 int QGeoShape_IsEmpty(void* ptr);
@@ -194,6 +218,8 @@ void* QNmeaPositionInfoSource_NewQNmeaPositionInfoSource(int updateMode, void* p
 void* QNmeaPositionInfoSource_Device(void* ptr);
 int QNmeaPositionInfoSource_Error(void* ptr);
 int QNmeaPositionInfoSource_ErrorDefault(void* ptr);
+void* QNmeaPositionInfoSource_LastKnownPosition(void* ptr, int fromSatellitePositioningMethodsOnly);
+void* QNmeaPositionInfoSource_LastKnownPositionDefault(void* ptr, int fromSatellitePositioningMethodsOnly);
 int QNmeaPositionInfoSource_MinimumUpdateInterval(void* ptr);
 int QNmeaPositionInfoSource_MinimumUpdateIntervalDefault(void* ptr);
 int QNmeaPositionInfoSource_ParsePosInfoFromNmeaData(void* ptr, char* data, int size, void* posInfo, int hasFix);

qml/qml.cpp

@@ -310,8 +310,8 @@ void QQmlApplicationEngine_Load(void* ptr, void* url){
 	QMetaObject::invokeMethod(static_cast<QQmlApplicationEngine*>(ptr), "load", Q_ARG(QUrl, *static_cast<QUrl*>(url)));
 }
 
-void QQmlApplicationEngine_LoadData(void* ptr, void* data, void* url){
-	QMetaObject::invokeMethod(static_cast<QQmlApplicationEngine*>(ptr), "loadData", Q_ARG(QByteArray, *static_cast<QByteArray*>(data)), Q_ARG(QUrl, *static_cast<QUrl*>(url)));
+void QQmlApplicationEngine_LoadData(void* ptr, char* data, void* url){
+	QMetaObject::invokeMethod(static_cast<QQmlApplicationEngine*>(ptr), "loadData", Q_ARG(QByteArray, QByteArray(data)), Q_ARG(QUrl, *static_cast<QUrl*>(url)));
 }
 
 void QQmlApplicationEngine_ConnectObjectCreated(void* ptr){
@@ -461,8 +461,8 @@ void QQmlComponent_ProgressChanged(void* ptr, double progress){
 	static_cast<QQmlComponent*>(ptr)->progressChanged(static_cast<double>(progress));
 }
 
-void QQmlComponent_SetData(void* ptr, void* data, void* url){
-	QMetaObject::invokeMethod(static_cast<QQmlComponent*>(ptr), "setData", Q_ARG(QByteArray, *static_cast<QByteArray*>(data)), Q_ARG(QUrl, *static_cast<QUrl*>(url)));
+void QQmlComponent_SetData(void* ptr, char* data, void* url){
+	QMetaObject::invokeMethod(static_cast<QQmlComponent*>(ptr), "setData", Q_ARG(QByteArray, QByteArray(data)), Q_ARG(QUrl, *static_cast<QUrl*>(url)));
 }
 
 void QQmlComponent_ConnectStatusChanged(void* ptr){
@@ -858,6 +858,10 @@ void* QQmlExpression_Engine(void* ptr){
 	return static_cast<QQmlExpression*>(ptr)->engine();
 }
 
+void* QQmlExpression_Error(void* ptr){
+	return new QQmlError(static_cast<QQmlExpression*>(ptr)->error());
+}
+
 void* QQmlExpression_Evaluate(void* ptr, int valueIsUndefined){
 	return new QVariant(static_cast<QQmlExpression*>(ptr)->evaluate(NULL));
 }

qml/qml.go

@@ -786,11 +786,11 @@ func (ptr *QQmlApplicationEngine) Load(url core.QUrl_ITF) {
 	}
 }
 
-func (ptr *QQmlApplicationEngine) LoadData(data core.QByteArray_ITF, url core.QUrl_ITF) {
+func (ptr *QQmlApplicationEngine) LoadData(data string, url core.QUrl_ITF) {
 	defer qt.Recovering("QQmlApplicationEngine::loadData")
 
 	if ptr.Pointer() != nil {
-		C.QQmlApplicationEngine_LoadData(ptr.Pointer(), core.PointerFromQByteArray(data), core.PointerFromQUrl(url))
+		C.QQmlApplicationEngine_LoadData(ptr.Pointer(), C.CString(data), core.PointerFromQUrl(url))
 	}
 }
 
@@ -1251,11 +1251,11 @@ func (ptr *QQmlComponent) ProgressChanged(progress float64) {
 	}
 }
 
-func (ptr *QQmlComponent) SetData(data core.QByteArray_ITF, url core.QUrl_ITF) {
+func (ptr *QQmlComponent) SetData(data string, url core.QUrl_ITF) {
 	defer qt.Recovering("QQmlComponent::setData")
 
 	if ptr.Pointer() != nil {
-		C.QQmlComponent_SetData(ptr.Pointer(), core.PointerFromQByteArray(data), core.PointerFromQUrl(url))
+		C.QQmlComponent_SetData(ptr.Pointer(), C.CString(data), core.PointerFromQUrl(url))
 	}
 }
 
@@ -2428,6 +2428,15 @@ func (ptr *QQmlExpression) Engine() *QQmlEngine {
 	return nil
 }
 
+func (ptr *QQmlExpression) Error() *QQmlError {
+	defer qt.Recovering("QQmlExpression::error")
+
+	if ptr.Pointer() != nil {
+		return NewQQmlErrorFromPointer(C.QQmlExpression_Error(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QQmlExpression) Evaluate(valueIsUndefined bool) *core.QVariant {
 	defer qt.Recovering("QQmlExpression::evaluate")
 

qml/qml.h

@@ -67,7 +67,7 @@ void* QQmlApplicationEngine_NewQQmlApplicationEngine3(char* filePath, void* pare
 void* QQmlApplicationEngine_NewQQmlApplicationEngine2(void* url, void* parent);
 void QQmlApplicationEngine_Load2(void* ptr, char* filePath);
 void QQmlApplicationEngine_Load(void* ptr, void* url);
-void QQmlApplicationEngine_LoadData(void* ptr, void* data, void* url);
+void QQmlApplicationEngine_LoadData(void* ptr, char* data, void* url);
 void QQmlApplicationEngine_ConnectObjectCreated(void* ptr);
 void QQmlApplicationEngine_DisconnectObjectCreated(void* ptr);
 void QQmlApplicationEngine_ObjectCreated(void* ptr, void* object, void* url);
@@ -103,7 +103,7 @@ void QQmlComponent_LoadUrl2(void* ptr, void* url, int mode);
 void QQmlComponent_ConnectProgressChanged(void* ptr);
 void QQmlComponent_DisconnectProgressChanged(void* ptr);
 void QQmlComponent_ProgressChanged(void* ptr, double progress);
-void QQmlComponent_SetData(void* ptr, void* data, void* url);
+void QQmlComponent_SetData(void* ptr, char* data, void* url);
 void QQmlComponent_ConnectStatusChanged(void* ptr);
 void QQmlComponent_DisconnectStatusChanged(void* ptr);
 void QQmlComponent_StatusChanged(void* ptr, int status);
@@ -196,6 +196,7 @@ void QQmlExpression_ClearError(void* ptr);
 int QQmlExpression_ColumnNumber(void* ptr);
 void* QQmlExpression_Context(void* ptr);
 void* QQmlExpression_Engine(void* ptr);
+void* QQmlExpression_Error(void* ptr);
 void* QQmlExpression_Evaluate(void* ptr, int valueIsUndefined);
 char* QQmlExpression_Expression(void* ptr);
 int QQmlExpression_HasError(void* ptr);

quick/quick.cpp

@@ -33,6 +33,7 @@
 #include <QOpenGLFramebufferObject>
 #include <QPaintEvent>
 #include <QPainter>
+#include <QPixmap>
 #include <QPoint>
 #include <QPointF>
 #include <QQmlEngine>
@@ -383,6 +384,14 @@ int QQuickImageProvider_ImageType(void* ptr){
 	return static_cast<QQuickImageProvider*>(ptr)->imageType();
 }
 
+void* QQuickImageProvider_RequestImage(void* ptr, char* id, void* size, void* requestedSize){
+	return new QImage(static_cast<QQuickImageProvider*>(ptr)->requestImage(QString(id), static_cast<QSize*>(size), *static_cast<QSize*>(requestedSize)));
+}
+
+void* QQuickImageProvider_RequestPixmap(void* ptr, char* id, void* size, void* requestedSize){
+	return new QPixmap(static_cast<QQuickImageProvider*>(ptr)->requestPixmap(QString(id), static_cast<QSize*>(size), *static_cast<QSize*>(requestedSize)));
+}
+
 void QQuickImageProvider_DestroyQQuickImageProvider(void* ptr){
 	static_cast<QQuickImageProvider*>(ptr)->~QQuickImageProvider();
 }
@@ -665,6 +674,10 @@ int QQuickItem_Contains(void* ptr, void* point){
 	return static_cast<QQuickItem*>(ptr)->contains(*static_cast<QPointF*>(point));
 }
 
+void* QQuickItem_Cursor(void* ptr){
+	return new QCursor(static_cast<QQuickItem*>(ptr)->cursor());
+}
+
 void QQuickItem_DragEnterEvent(void* ptr, void* event){
 	static_cast<MyQQuickItem*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
 }
@@ -1005,6 +1018,10 @@ public:
 	void customEvent(QEvent * event) { callbackQQuickItemGrabResultCustomEvent(this, this->objectName().toUtf8().data(), event); };
 };
 
+void* QQuickItemGrabResult_Image(void* ptr){
+	return new QImage(static_cast<QQuickItemGrabResult*>(ptr)->image());
+}
+
 void* QQuickItemGrabResult_Url(void* ptr){
 	return new QUrl(static_cast<QQuickItemGrabResult*>(ptr)->url());
 }
@@ -1454,6 +1471,10 @@ void* QQuickRenderControl_NewQQuickRenderControl(void* parent){
 	return new MyQQuickRenderControl(static_cast<QObject*>(parent));
 }
 
+void* QQuickRenderControl_Grab(void* ptr){
+	return new QImage(static_cast<QQuickRenderControl*>(ptr)->grab());
+}
+
 void QQuickRenderControl_Initialize(void* ptr, void* gl){
 	static_cast<QQuickRenderControl*>(ptr)->initialize(static_cast<QOpenGLContext*>(gl));
 }
@@ -1577,6 +1598,10 @@ public:
 	void customEvent(QEvent * event) { callbackQQuickTextureFactoryCustomEvent(this, this->objectName().toUtf8().data(), event); };
 };
 
+void* QQuickTextureFactory_Image(void* ptr){
+	return new QImage(static_cast<QQuickTextureFactory*>(ptr)->image());
+}
+
 void* QQuickTextureFactory_CreateTexture(void* ptr, void* window){
 	return static_cast<QQuickTextureFactory*>(ptr)->createTexture(static_cast<QQuickWindow*>(window));
 }
@@ -1980,6 +2005,14 @@ int QQuickWidget_Event(void* ptr, void* e){
 	return static_cast<QQuickWidget*>(ptr)->event(static_cast<QEvent*>(e));
 }
 
+void* QQuickWidget_Format(void* ptr){
+	return new QSurfaceFormat(static_cast<QQuickWidget*>(ptr)->format());
+}
+
+void* QQuickWidget_GrabFramebuffer(void* ptr){
+	return new QImage(static_cast<QQuickWidget*>(ptr)->grabFramebuffer());
+}
+
 void QQuickWidget_HideEvent(void* ptr, void* v){
 	static_cast<MyQQuickWidget*>(ptr)->hideEvent(static_cast<QHideEvent*>(v));
 }
@@ -2441,6 +2474,10 @@ void QQuickWindow_FrameSwapped(void* ptr){
 	static_cast<QQuickWindow*>(ptr)->frameSwapped();
 }
 
+void* QQuickWindow_GrabWindow(void* ptr){
+	return new QImage(static_cast<QQuickWindow*>(ptr)->grabWindow());
+}
+
 int QQuickWindow_QQuickWindow_HasDefaultAlphaBuffer(){
 	return QQuickWindow::hasDefaultAlphaBuffer();
 }

quick/quick.go

@@ -1389,6 +1389,24 @@ func (ptr *QQuickImageProvider) ImageType() qml.QQmlImageProviderBase__ImageType
 	return 0
 }
 
+func (ptr *QQuickImageProvider) RequestImage(id string, size core.QSize_ITF, requestedSize core.QSize_ITF) *gui.QImage {
+	defer qt.Recovering("QQuickImageProvider::requestImage")
+
+	if ptr.Pointer() != nil {
+		return gui.NewQImageFromPointer(C.QQuickImageProvider_RequestImage(ptr.Pointer(), C.CString(id), core.PointerFromQSize(size), core.PointerFromQSize(requestedSize)))
+	}
+	return nil
+}
+
+func (ptr *QQuickImageProvider) RequestPixmap(id string, size core.QSize_ITF, requestedSize core.QSize_ITF) *gui.QPixmap {
+	defer qt.Recovering("QQuickImageProvider::requestPixmap")
+
+	if ptr.Pointer() != nil {
+		return gui.NewQPixmapFromPointer(C.QQuickImageProvider_RequestPixmap(ptr.Pointer(), C.CString(id), core.PointerFromQSize(size), core.PointerFromQSize(requestedSize)))
+	}
+	return nil
+}
+
 func (ptr *QQuickImageProvider) DestroyQQuickImageProvider() {
 	defer qt.Recovering("QQuickImageProvider::~QQuickImageProvider")
 
@@ -2048,6 +2066,15 @@ func (ptr *QQuickItem) Contains(point core.QPointF_ITF) bool {
 	return false
 }
 
+func (ptr *QQuickItem) Cursor() *gui.QCursor {
+	defer qt.Recovering("QQuickItem::cursor")
+
+	if ptr.Pointer() != nil {
+		return gui.NewQCursorFromPointer(C.QQuickItem_Cursor(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QQuickItem) ConnectDragEnterEvent(f func(event *gui.QDragEnterEvent)) {
 	defer qt.Recovering("connect QQuickItem::dragEnterEvent")
 
@@ -3495,6 +3522,15 @@ func (ptr *QQuickItemGrabResult) QQuickItemGrabResult_PTR() *QQuickItemGrabResul
 	return ptr
 }
 
+func (ptr *QQuickItemGrabResult) Image() *gui.QImage {
+	defer qt.Recovering("QQuickItemGrabResult::image")
+
+	if ptr.Pointer() != nil {
+		return gui.NewQImageFromPointer(C.QQuickItemGrabResult_Image(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QQuickItemGrabResult) Url() *core.QUrl {
 	defer qt.Recovering("QQuickItemGrabResult::url")
 
@@ -5328,6 +5364,15 @@ func NewQQuickRenderControl(parent core.QObject_ITF) *QQuickRenderControl {
 	return newQQuickRenderControlFromPointer(C.QQuickRenderControl_NewQQuickRenderControl(core.PointerFromQObject(parent)))
 }
 
+func (ptr *QQuickRenderControl) Grab() *gui.QImage {
+	defer qt.Recovering("QQuickRenderControl::grab")
+
+	if ptr.Pointer() != nil {
+		return gui.NewQImageFromPointer(C.QQuickRenderControl_Grab(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QQuickRenderControl) Initialize(gl gui.QOpenGLContext_ITF) {
 	defer qt.Recovering("QQuickRenderControl::initialize")
 
@@ -5826,6 +5871,15 @@ func (ptr *QQuickTextureFactory) QQuickTextureFactory_PTR() *QQuickTextureFactor
 	return ptr
 }
 
+func (ptr *QQuickTextureFactory) Image() *gui.QImage {
+	defer qt.Recovering("QQuickTextureFactory::image")
+
+	if ptr.Pointer() != nil {
+		return gui.NewQImageFromPointer(C.QQuickTextureFactory_Image(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QQuickTextureFactory) CreateTexture(window QQuickWindow_ITF) *QSGTexture {
 	defer qt.Recovering("QQuickTextureFactory::createTexture")
 
@@ -7430,6 +7484,24 @@ func (ptr *QQuickWidget) Event(e core.QEvent_ITF) bool {
 	return false
 }
 
+func (ptr *QQuickWidget) Format() *gui.QSurfaceFormat {
+	defer qt.Recovering("QQuickWidget::format")
+
+	if ptr.Pointer() != nil {
+		return gui.NewQSurfaceFormatFromPointer(C.QQuickWidget_Format(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QQuickWidget) GrabFramebuffer() *gui.QImage {
+	defer qt.Recovering("QQuickWidget::grabFramebuffer")
+
+	if ptr.Pointer() != nil {
+		return gui.NewQImageFromPointer(C.QQuickWidget_GrabFramebuffer(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QQuickWidget) ConnectHideEvent(f func(v *gui.QHideEvent)) {
 	defer qt.Recovering("connect QQuickWidget::hideEvent")
 
@@ -9286,6 +9358,15 @@ func (ptr *QQuickWindow) FrameSwapped() {
 	}
 }
 
+func (ptr *QQuickWindow) GrabWindow() *gui.QImage {
+	defer qt.Recovering("QQuickWindow::grabWindow")
+
+	if ptr.Pointer() != nil {
+		return gui.NewQImageFromPointer(C.QQuickWindow_GrabWindow(ptr.Pointer()))
+	}
+	return nil
+}
+
 func QQuickWindow_HasDefaultAlphaBuffer() bool {
 	defer qt.Recovering("QQuickWindow::hasDefaultAlphaBuffer")
 

quick/quick.h

@@ -75,6 +75,10 @@ int QQuickImageProvider_Flags(void* ptr);
 int QQuickImageProvider_FlagsDefault(void* ptr);
 int QQuickImageProvider_ImageType(void* ptr);
 int QQuickImageProvider_ImageTypeDefault(void* ptr);
+void* QQuickImageProvider_RequestImage(void* ptr, char* id, void* size, void* requestedSize);
+void* QQuickImageProvider_RequestImageDefault(void* ptr, char* id, void* size, void* requestedSize);
+void* QQuickImageProvider_RequestPixmap(void* ptr, char* id, void* size, void* requestedSize);
+void* QQuickImageProvider_RequestPixmapDefault(void* ptr, char* id, void* size, void* requestedSize);
 void QQuickImageProvider_DestroyQQuickImageProvider(void* ptr);
 char* QQuickImageProvider_ObjectNameAbs(void* ptr);
 void QQuickImageProvider_SetObjectNameAbs(void* ptr, char* name);
@@ -140,6 +144,7 @@ void QQuickItem_ComponentComplete(void* ptr);
 void QQuickItem_ComponentCompleteDefault(void* ptr);
 int QQuickItem_Contains(void* ptr, void* point);
 int QQuickItem_ContainsDefault(void* ptr, void* point);
+void* QQuickItem_Cursor(void* ptr);
 void QQuickItem_DragEnterEvent(void* ptr, void* event);
 void QQuickItem_DragEnterEventDefault(void* ptr, void* event);
 void QQuickItem_DragLeaveEvent(void* ptr, void* event);
@@ -225,6 +230,7 @@ void QQuickItem_ChildEvent(void* ptr, void* event);
 void QQuickItem_ChildEventDefault(void* ptr, void* event);
 void QQuickItem_CustomEvent(void* ptr, void* event);
 void QQuickItem_CustomEventDefault(void* ptr, void* event);
+void* QQuickItemGrabResult_Image(void* ptr);
 void* QQuickItemGrabResult_Url(void* ptr);
 void QQuickItemGrabResult_ConnectReady(void* ptr);
 void QQuickItemGrabResult_DisconnectReady(void* ptr);
@@ -328,6 +334,7 @@ void QQuickPaintedItem_ChildEventDefault(void* ptr, void* event);
 void QQuickPaintedItem_CustomEvent(void* ptr, void* event);
 void QQuickPaintedItem_CustomEventDefault(void* ptr, void* event);
 void* QQuickRenderControl_NewQQuickRenderControl(void* parent);
+void* QQuickRenderControl_Grab(void* ptr);
 void QQuickRenderControl_Initialize(void* ptr, void* gl);
 void QQuickRenderControl_Invalidate(void* ptr);
 void QQuickRenderControl_PolishItems(void* ptr);
@@ -358,6 +365,8 @@ void QQuickTextDocument_ChildEvent(void* ptr, void* event);
 void QQuickTextDocument_ChildEventDefault(void* ptr, void* event);
 void QQuickTextDocument_CustomEvent(void* ptr, void* event);
 void QQuickTextDocument_CustomEventDefault(void* ptr, void* event);
+void* QQuickTextureFactory_Image(void* ptr);
+void* QQuickTextureFactory_ImageDefault(void* ptr);
 void* QQuickTextureFactory_CreateTexture(void* ptr, void* window);
 int QQuickTextureFactory_TextureByteCount(void* ptr);
 void* QQuickTextureFactory_TextureSize(void* ptr);
@@ -443,6 +452,8 @@ void QQuickWidget_DropEventDefault(void* ptr, void* e);
 void* QQuickWidget_Engine(void* ptr);
 int QQuickWidget_Event(void* ptr, void* e);
 int QQuickWidget_EventDefault(void* ptr, void* e);
+void* QQuickWidget_Format(void* ptr);
+void* QQuickWidget_GrabFramebuffer(void* ptr);
 void QQuickWidget_HideEvent(void* ptr, void* v);
 void QQuickWidget_HideEventDefault(void* ptr, void* v);
 void* QQuickWidget_InitialSize(void* ptr);
@@ -551,6 +562,7 @@ void QQuickWindow_FocusOutEventDefault(void* ptr, void* ev);
 void QQuickWindow_ConnectFrameSwapped(void* ptr);
 void QQuickWindow_DisconnectFrameSwapped(void* ptr);
 void QQuickWindow_FrameSwapped(void* ptr);
+void* QQuickWindow_GrabWindow(void* ptr);
 int QQuickWindow_QQuickWindow_HasDefaultAlphaBuffer();
 void QQuickWindow_HideEvent(void* ptr, void* v);
 void QQuickWindow_HideEventDefault(void* ptr, void* v);

script/script.cpp

@@ -239,6 +239,10 @@ char* QScriptEngine_AvailableExtensions(void* ptr){
 	return static_cast<QScriptEngine*>(ptr)->availableExtensions().join("|").toUtf8().data();
 }
 
+void* QScriptEngine_QScriptEngine_CheckSyntax(char* program){
+	return new QScriptSyntaxCheckResult(QScriptEngine::checkSyntax(QString(program)));
+}
+
 void QScriptEngine_ClearExceptions(void* ptr){
 	static_cast<QScriptEngine*>(ptr)->clearExceptions();
 }
@@ -379,6 +383,10 @@ void* QScriptEngine_ToObject(void* ptr, void* value){
 	return new QScriptValue(static_cast<QScriptEngine*>(ptr)->toObject(*static_cast<QScriptValue*>(value)));
 }
 
+void* QScriptEngine_ToStringHandle(void* ptr, char* str){
+	return new QScriptString(static_cast<QScriptEngine*>(ptr)->toStringHandle(QString(str)));
+}
+
 void* QScriptEngine_UncaughtException(void* ptr){
 	return new QScriptValue(static_cast<QScriptEngine*>(ptr)->uncaughtException());
 }

script/script.go

@@ -666,6 +666,12 @@ func (ptr *QScriptEngine) AvailableExtensions() []string {
 	return make([]string, 0)
 }
 
+func QScriptEngine_CheckSyntax(program string) *QScriptSyntaxCheckResult {
+	defer qt.Recovering("QScriptEngine::checkSyntax")
+
+	return NewQScriptSyntaxCheckResultFromPointer(C.QScriptEngine_QScriptEngine_CheckSyntax(C.CString(program)))
+}
+
 func (ptr *QScriptEngine) ClearExceptions() {
 	defer qt.Recovering("QScriptEngine::clearExceptions")
 
@@ -981,6 +987,15 @@ func (ptr *QScriptEngine) ToObject(value QScriptValue_ITF) *QScriptValue {
 	return nil
 }
 
+func (ptr *QScriptEngine) ToStringHandle(str string) *QScriptString {
+	defer qt.Recovering("QScriptEngine::toStringHandle")
+
+	if ptr.Pointer() != nil {
+		return NewQScriptStringFromPointer(C.QScriptEngine_ToStringHandle(ptr.Pointer(), C.CString(str)))
+	}
+	return nil
+}
+
 func (ptr *QScriptEngine) UncaughtException() *QScriptValue {
 	defer qt.Recovering("QScriptEngine::uncaughtException")
 

script/script.h

@@ -59,6 +59,7 @@ void* QScriptEngine_NewQScriptEngine2(void* parent);
 void QScriptEngine_AbortEvaluation(void* ptr, void* result);
 void* QScriptEngine_Agent(void* ptr);
 char* QScriptEngine_AvailableExtensions(void* ptr);
+void* QScriptEngine_QScriptEngine_CheckSyntax(char* program);
 void QScriptEngine_ClearExceptions(void* ptr);
 void QScriptEngine_CollectGarbage(void* ptr);
 void* QScriptEngine_CurrentContext(void* ptr);
@@ -94,6 +95,7 @@ void QScriptEngine_ConnectSignalHandlerException(void* ptr);
 void QScriptEngine_DisconnectSignalHandlerException(void* ptr);
 void QScriptEngine_SignalHandlerException(void* ptr, void* exception);
 void* QScriptEngine_ToObject(void* ptr, void* value);
+void* QScriptEngine_ToStringHandle(void* ptr, char* str);
 void* QScriptEngine_UncaughtException(void* ptr);
 char* QScriptEngine_UncaughtExceptionBacktrace(void* ptr);
 int QScriptEngine_UncaughtExceptionLineNumber(void* ptr);

sensors/sensors.cpp

@@ -1451,8 +1451,8 @@ int QSensor_Error(void* ptr){
 	return static_cast<QSensor*>(ptr)->error();
 }
 
-void* QSensor_Identifier(void* ptr){
-	return new QByteArray(static_cast<QSensor*>(ptr)->identifier());
+char* QSensor_Identifier(void* ptr){
+	return QString(static_cast<QSensor*>(ptr)->identifier()).toUtf8().data();
 }
 
 int QSensor_IsActive(void* ptr){
@@ -1503,8 +1503,8 @@ void QSensor_SetDataRate(void* ptr, int rate){
 	static_cast<QSensor*>(ptr)->setDataRate(rate);
 }
 
-void QSensor_SetIdentifier(void* ptr, void* identifier){
-	static_cast<QSensor*>(ptr)->setIdentifier(*static_cast<QByteArray*>(identifier));
+void QSensor_SetIdentifier(void* ptr, char* identifier){
+	static_cast<QSensor*>(ptr)->setIdentifier(QByteArray(identifier));
 }
 
 void QSensor_SetOutputRange(void* ptr, int index){
@@ -1519,16 +1519,16 @@ int QSensor_SkipDuplicates(void* ptr){
 	return static_cast<QSensor*>(ptr)->skipDuplicates();
 }
 
-void* QSensor_Type(void* ptr){
-	return new QByteArray(static_cast<QSensor*>(ptr)->type());
+char* QSensor_Type(void* ptr){
+	return QString(static_cast<QSensor*>(ptr)->type()).toUtf8().data();
 }
 
 int QSensor_UserOrientation(void* ptr){
 	return static_cast<QSensor*>(ptr)->userOrientation();
 }
 
-void* QSensor_NewQSensor(void* ty, void* parent){
-	return new MyQSensor(*static_cast<QByteArray*>(ty), static_cast<QObject*>(parent));
+void* QSensor_NewQSensor(char* ty, void* parent){
+	return new MyQSensor(QByteArray(ty), static_cast<QObject*>(parent));
 }
 
 void QSensor_ConnectActiveChanged(void* ptr){
@@ -1635,8 +1635,8 @@ void QSensor_DataRateChanged(void* ptr){
 	static_cast<QSensor*>(ptr)->dataRateChanged();
 }
 
-void* QSensor_QSensor_DefaultSensorForType(void* ty){
-	return new QByteArray(QSensor::defaultSensorForType(*static_cast<QByteArray*>(ty)));
+char* QSensor_QSensor_DefaultSensorForType(char* ty){
+	return QString(QSensor::defaultSensorForType(QByteArray(ty))).toUtf8().data();
 }
 
 void QSensor_ConnectEfficientBufferSizeChanged(void* ptr){
@@ -2116,20 +2116,20 @@ void* QSensorManager_QSensorManager_CreateBackend(void* sensor){
 	return QSensorManager::createBackend(static_cast<QSensor*>(sensor));
 }
 
-int QSensorManager_QSensorManager_IsBackendRegistered(void* ty, void* identifier){
-	return QSensorManager::isBackendRegistered(*static_cast<QByteArray*>(ty), *static_cast<QByteArray*>(identifier));
+int QSensorManager_QSensorManager_IsBackendRegistered(char* ty, char* identifier){
+	return QSensorManager::isBackendRegistered(QByteArray(ty), QByteArray(identifier));
 }
 
-void QSensorManager_QSensorManager_RegisterBackend(void* ty, void* identifier, void* factory){
-	QSensorManager::registerBackend(*static_cast<QByteArray*>(ty), *static_cast<QByteArray*>(identifier), static_cast<QSensorBackendFactory*>(factory));
+void QSensorManager_QSensorManager_RegisterBackend(char* ty, char* identifier, void* factory){
+	QSensorManager::registerBackend(QByteArray(ty), QByteArray(identifier), static_cast<QSensorBackendFactory*>(factory));
 }
 
-void QSensorManager_QSensorManager_SetDefaultBackend(void* ty, void* identifier){
-	QSensorManager::setDefaultBackend(*static_cast<QByteArray*>(ty), *static_cast<QByteArray*>(identifier));
+void QSensorManager_QSensorManager_SetDefaultBackend(char* ty, char* identifier){
+	QSensorManager::setDefaultBackend(QByteArray(ty), QByteArray(identifier));
 }
 
-void QSensorManager_QSensorManager_UnregisterBackend(void* ty, void* identifier){
-	QSensorManager::unregisterBackend(*static_cast<QByteArray*>(ty), *static_cast<QByteArray*>(identifier));
+void QSensorManager_QSensorManager_UnregisterBackend(char* ty, char* identifier){
+	QSensorManager::unregisterBackend(QByteArray(ty), QByteArray(identifier));
 }
 
 void QSensorPluginInterface_RegisterSensors(void* ptr){

sensors/sensors.go

@@ -6832,13 +6832,13 @@ func (ptr *QSensor) Error() int {
 	return 0
 }
 
-func (ptr *QSensor) Identifier() *core.QByteArray {
+func (ptr *QSensor) Identifier() string {
 	defer qt.Recovering("QSensor::identifier")
 
 	if ptr.Pointer() != nil {
-		return core.NewQByteArrayFromPointer(C.QSensor_Identifier(ptr.Pointer()))
+		return C.GoString(C.QSensor_Identifier(ptr.Pointer()))
 	}
-	return nil
+	return ""
 }
 
 func (ptr *QSensor) IsActive() bool {
@@ -6944,11 +6944,11 @@ func (ptr *QSensor) SetDataRate(rate int) {
 	}
 }
 
-func (ptr *QSensor) SetIdentifier(identifier core.QByteArray_ITF) {
+func (ptr *QSensor) SetIdentifier(identifier string) {
 	defer qt.Recovering("QSensor::setIdentifier")
 
 	if ptr.Pointer() != nil {
-		C.QSensor_SetIdentifier(ptr.Pointer(), core.PointerFromQByteArray(identifier))
+		C.QSensor_SetIdentifier(ptr.Pointer(), C.CString(identifier))
 	}
 }
 
@@ -6977,13 +6977,13 @@ func (ptr *QSensor) SkipDuplicates() bool {
 	return false
 }
 
-func (ptr *QSensor) Type() *core.QByteArray {
+func (ptr *QSensor) Type() string {
 	defer qt.Recovering("QSensor::type")
 
 	if ptr.Pointer() != nil {
-		return core.NewQByteArrayFromPointer(C.QSensor_Type(ptr.Pointer()))
+		return C.GoString(C.QSensor_Type(ptr.Pointer()))
 	}
-	return nil
+	return ""
 }
 
 func (ptr *QSensor) UserOrientation() int {
@@ -6995,10 +6995,10 @@ func (ptr *QSensor) UserOrientation() int {
 	return 0
 }
 
-func NewQSensor(ty core.QByteArray_ITF, parent core.QObject_ITF) *QSensor {
+func NewQSensor(ty string, parent core.QObject_ITF) *QSensor {
 	defer qt.Recovering("QSensor::QSensor")
 
-	return newQSensorFromPointer(C.QSensor_NewQSensor(core.PointerFromQByteArray(ty), core.PointerFromQObject(parent)))
+	return newQSensorFromPointer(C.QSensor_NewQSensor(C.CString(ty), core.PointerFromQObject(parent)))
 }
 
 func (ptr *QSensor) ConnectActiveChanged(f func()) {
@@ -7306,10 +7306,10 @@ func (ptr *QSensor) DataRateChanged() {
 	}
 }
 
-func QSensor_DefaultSensorForType(ty core.QByteArray_ITF) *core.QByteArray {
+func QSensor_DefaultSensorForType(ty string) string {
 	defer qt.Recovering("QSensor::defaultSensorForType")
 
-	return core.NewQByteArrayFromPointer(C.QSensor_QSensor_DefaultSensorForType(core.PointerFromQByteArray(ty)))
+	return C.GoString(C.QSensor_QSensor_DefaultSensorForType(C.CString(ty)))
 }
 
 func (ptr *QSensor) ConnectEfficientBufferSizeChanged(f func(efficientBufferSize int)) {
@@ -9028,28 +9028,28 @@ func QSensorManager_CreateBackend(sensor QSensor_ITF) *QSensorBackend {
 	return NewQSensorBackendFromPointer(C.QSensorManager_QSensorManager_CreateBackend(PointerFromQSensor(sensor)))
 }
 
-func QSensorManager_IsBackendRegistered(ty core.QByteArray_ITF, identifier core.QByteArray_ITF) bool {
+func QSensorManager_IsBackendRegistered(ty string, identifier string) bool {
 	defer qt.Recovering("QSensorManager::isBackendRegistered")
 
-	return C.QSensorManager_QSensorManager_IsBackendRegistered(core.PointerFromQByteArray(ty), core.PointerFromQByteArray(identifier)) != 0
+	return C.QSensorManager_QSensorManager_IsBackendRegistered(C.CString(ty), C.CString(identifier)) != 0
 }
 
-func QSensorManager_RegisterBackend(ty core.QByteArray_ITF, identifier core.QByteArray_ITF, factory QSensorBackendFactory_ITF) {
+func QSensorManager_RegisterBackend(ty string, identifier string, factory QSensorBackendFactory_ITF) {
 	defer qt.Recovering("QSensorManager::registerBackend")
 
-	C.QSensorManager_QSensorManager_RegisterBackend(core.PointerFromQByteArray(ty), core.PointerFromQByteArray(identifier), PointerFromQSensorBackendFactory(factory))
+	C.QSensorManager_QSensorManager_RegisterBackend(C.CString(ty), C.CString(identifier), PointerFromQSensorBackendFactory(factory))
 }
 
-func QSensorManager_SetDefaultBackend(ty core.QByteArray_ITF, identifier core.QByteArray_ITF) {
+func QSensorManager_SetDefaultBackend(ty string, identifier string) {
 	defer qt.Recovering("QSensorManager::setDefaultBackend")
 
-	C.QSensorManager_QSensorManager_SetDefaultBackend(core.PointerFromQByteArray(ty), core.PointerFromQByteArray(identifier))
+	C.QSensorManager_QSensorManager_SetDefaultBackend(C.CString(ty), C.CString(identifier))
 }
 
-func QSensorManager_UnregisterBackend(ty core.QByteArray_ITF, identifier core.QByteArray_ITF) {
+func QSensorManager_UnregisterBackend(ty string, identifier string) {
 	defer qt.Recovering("QSensorManager::unregisterBackend")
 
-	C.QSensorManager_QSensorManager_UnregisterBackend(core.PointerFromQByteArray(ty), core.PointerFromQByteArray(identifier))
+	C.QSensorManager_QSensorManager_UnregisterBackend(C.CString(ty), C.CString(identifier))
 }
 
 type QSensorPluginInterface struct {

sensors/sensors.h

@@ -324,7 +324,7 @@ int QSensor_DataRate(void* ptr);
 char* QSensor_Description(void* ptr);
 int QSensor_EfficientBufferSize(void* ptr);
 int QSensor_Error(void* ptr);
-void* QSensor_Identifier(void* ptr);
+char* QSensor_Identifier(void* ptr);
 int QSensor_IsActive(void* ptr);
 int QSensor_IsAlwaysOn(void* ptr);
 int QSensor_IsBusy(void* ptr);
@@ -337,13 +337,13 @@ void QSensor_SetAlwaysOn(void* ptr, int alwaysOn);
 void QSensor_SetAxesOrientationMode(void* ptr, int axesOrientationMode);
 void QSensor_SetBufferSize(void* ptr, int bufferSize);
 void QSensor_SetDataRate(void* ptr, int rate);
-void QSensor_SetIdentifier(void* ptr, void* identifier);
+void QSensor_SetIdentifier(void* ptr, char* identifier);
 void QSensor_SetOutputRange(void* ptr, int index);
 void QSensor_SetUserOrientation(void* ptr, int userOrientation);
 int QSensor_SkipDuplicates(void* ptr);
-void* QSensor_Type(void* ptr);
+char* QSensor_Type(void* ptr);
 int QSensor_UserOrientation(void* ptr);
-void* QSensor_NewQSensor(void* ty, void* parent);
+void* QSensor_NewQSensor(char* ty, void* parent);
 void QSensor_ConnectActiveChanged(void* ptr);
 void QSensor_DisconnectActiveChanged(void* ptr);
 void QSensor_ActiveChanged(void* ptr);
@@ -370,7 +370,7 @@ void QSensor_CurrentOrientationChanged(void* ptr, int currentOrientation);
 void QSensor_ConnectDataRateChanged(void* ptr);
 void QSensor_DisconnectDataRateChanged(void* ptr);
 void QSensor_DataRateChanged(void* ptr);
-void* QSensor_QSensor_DefaultSensorForType(void* ty);
+char* QSensor_QSensor_DefaultSensorForType(char* ty);
 void QSensor_ConnectEfficientBufferSizeChanged(void* ptr);
 void QSensor_DisconnectEfficientBufferSizeChanged(void* ptr);
 void QSensor_EfficientBufferSizeChanged(void* ptr, int efficientBufferSize);
@@ -478,10 +478,10 @@ void QSensorGestureRecognizer_ChildEventDefault(void* ptr, void* event);
 void QSensorGestureRecognizer_CustomEvent(void* ptr, void* event);
 void QSensorGestureRecognizer_CustomEventDefault(void* ptr, void* event);
 void* QSensorManager_QSensorManager_CreateBackend(void* sensor);
-int QSensorManager_QSensorManager_IsBackendRegistered(void* ty, void* identifier);
-void QSensorManager_QSensorManager_RegisterBackend(void* ty, void* identifier, void* factory);
-void QSensorManager_QSensorManager_SetDefaultBackend(void* ty, void* identifier);
-void QSensorManager_QSensorManager_UnregisterBackend(void* ty, void* identifier);
+int QSensorManager_QSensorManager_IsBackendRegistered(char* ty, char* identifier);
+void QSensorManager_QSensorManager_RegisterBackend(char* ty, char* identifier, void* factory);
+void QSensorManager_QSensorManager_SetDefaultBackend(char* ty, char* identifier);
+void QSensorManager_QSensorManager_UnregisterBackend(char* ty, char* identifier);
 void QSensorPluginInterface_RegisterSensors(void* ptr);
 void* QSensorReading_Value(void* ptr, int index);
 int QSensorReading_ValueCount(void* ptr);

sql/sql.cpp

@@ -29,6 +29,14 @@
 #include <QTimerEvent>
 #include <QVariant>
 
+void* QSqlDatabase_QSqlDatabase_AddDatabase2(void* driver, char* connectionName){
+	return new QSqlDatabase(QSqlDatabase::addDatabase(static_cast<QSqlDriver*>(driver), QString(connectionName)));
+}
+
+void* QSqlDatabase_QSqlDatabase_AddDatabase(char* ty, char* connectionName){
+	return new QSqlDatabase(QSqlDatabase::addDatabase(QString(ty), QString(connectionName)));
+}
+
 void* QSqlDatabase_NewQSqlDatabase(){
 	return new QSqlDatabase();
 }
@@ -37,6 +45,10 @@ void* QSqlDatabase_NewQSqlDatabase2(void* other){
 	return new QSqlDatabase(*static_cast<QSqlDatabase*>(other));
 }
 
+void* QSqlDatabase_QSqlDatabase_CloneDatabase(void* other, char* connectionName){
+	return new QSqlDatabase(QSqlDatabase::cloneDatabase(*static_cast<QSqlDatabase*>(other), QString(connectionName)));
+}
+
 void QSqlDatabase_Close(void* ptr){
 	static_cast<QSqlDatabase*>(ptr)->close();
 }
@@ -61,6 +73,10 @@ int QSqlDatabase_QSqlDatabase_Contains(char* connectionName){
 	return QSqlDatabase::contains(QString(connectionName));
 }
 
+void* QSqlDatabase_QSqlDatabase_Database(char* connectionName, int open){
+	return new QSqlDatabase(QSqlDatabase::database(QString(connectionName), open != 0));
+}
+
 char* QSqlDatabase_DatabaseName(void* ptr){
 	return static_cast<QSqlDatabase*>(ptr)->databaseName().toUtf8().data();
 }
@@ -77,6 +93,10 @@ char* QSqlDatabase_QSqlDatabase_Drivers(){
 	return QSqlDatabase::drivers().join("|").toUtf8().data();
 }
 
+void* QSqlDatabase_Exec(void* ptr, char* query){
+	return new QSqlQuery(static_cast<QSqlDatabase*>(ptr)->exec(QString(query)));
+}
+
 char* QSqlDatabase_HostName(void* ptr){
 	return static_cast<QSqlDatabase*>(ptr)->hostName().toUtf8().data();
 }
@@ -97,6 +117,10 @@ int QSqlDatabase_IsValid(void* ptr){
 	return static_cast<QSqlDatabase*>(ptr)->isValid();
 }
 
+void* QSqlDatabase_LastError(void* ptr){
+	return new QSqlError(static_cast<QSqlDatabase*>(ptr)->lastError());
+}
+
 int QSqlDatabase_Open(void* ptr){
 	return static_cast<QSqlDatabase*>(ptr)->open();
 }
@@ -113,6 +137,14 @@ int QSqlDatabase_Port(void* ptr){
 	return static_cast<QSqlDatabase*>(ptr)->port();
 }
 
+void* QSqlDatabase_PrimaryIndex(void* ptr, char* tablename){
+	return new QSqlIndex(static_cast<QSqlDatabase*>(ptr)->primaryIndex(QString(tablename)));
+}
+
+void* QSqlDatabase_Record(void* ptr, char* tablename){
+	return new QSqlRecord(static_cast<QSqlDatabase*>(ptr)->record(QString(tablename)));
+}
+
 void QSqlDatabase_QSqlDatabase_RegisterSqlDriver(char* name, void* creator){
 	QSqlDatabase::registerSqlDriver(QString(name), static_cast<QSqlDriverCreatorBase*>(creator));
 }
@@ -165,6 +197,7 @@ class MyQSqlDriver: public QSqlDriver {
 public:
 	void Signal_Notification(const QString & name) { callbackQSqlDriverNotification(this, this->objectName().toUtf8().data(), name.toUtf8().data()); };
 	void Signal_Notification2(const QString & name, QSqlDriver::NotificationSource source, const QVariant & payload) { callbackQSqlDriverNotification2(this, this->objectName().toUtf8().data(), name.toUtf8().data(), source, new QVariant(payload)); };
+	void setLastError(const QSqlError & error) { callbackQSqlDriverSetLastError(this, this->objectName().toUtf8().data(), new QSqlError(error)); };
 	void setOpen(bool open) { callbackQSqlDriverSetOpen(this, this->objectName().toUtf8().data(), open); };
 	void setOpenError(bool error) { callbackQSqlDriverSetOpenError(this, this->objectName().toUtf8().data(), error); };
 	void timerEvent(QTimerEvent * event) { callbackQSqlDriverTimerEvent(this, this->objectName().toUtf8().data(), event); };
@@ -220,6 +253,10 @@ int QSqlDriver_IsOpenError(void* ptr){
 	return static_cast<QSqlDriver*>(ptr)->isOpenError();
 }
 
+void* QSqlDriver_LastError(void* ptr){
+	return new QSqlError(static_cast<QSqlDriver*>(ptr)->lastError());
+}
+
 void QSqlDriver_ConnectNotification(void* ptr){
 	QObject::connect(static_cast<QSqlDriver*>(ptr), static_cast<void (QSqlDriver::*)(const QString &)>(&QSqlDriver::notification), static_cast<MyQSqlDriver*>(ptr), static_cast<void (MyQSqlDriver::*)(const QString &)>(&MyQSqlDriver::Signal_Notification));;
 }
@@ -248,10 +285,26 @@ int QSqlDriver_Open(void* ptr, char* db, char* user, char* password, char* host,
 	return static_cast<QSqlDriver*>(ptr)->open(QString(db), QString(user), QString(password), QString(host), port, QString(options));
 }
 
+void* QSqlDriver_PrimaryIndex(void* ptr, char* tableName){
+	return new QSqlIndex(static_cast<QSqlDriver*>(ptr)->primaryIndex(QString(tableName)));
+}
+
+void* QSqlDriver_Record(void* ptr, char* tableName){
+	return new QSqlRecord(static_cast<QSqlDriver*>(ptr)->record(QString(tableName)));
+}
+
 int QSqlDriver_RollbackTransaction(void* ptr){
 	return static_cast<QSqlDriver*>(ptr)->rollbackTransaction();
 }
 
+void QSqlDriver_SetLastError(void* ptr, void* error){
+	static_cast<MyQSqlDriver*>(ptr)->setLastError(*static_cast<QSqlError*>(error));
+}
+
+void QSqlDriver_SetLastErrorDefault(void* ptr, void* error){
+	static_cast<QSqlDriver*>(ptr)->QSqlDriver::setLastError(*static_cast<QSqlError*>(error));
+}
+
 void QSqlDriver_SetOpen(void* ptr, int open){
 	static_cast<MyQSqlDriver*>(ptr)->setOpen(open != 0);
 }
@@ -640,6 +693,10 @@ int QSqlQuery_Last(void* ptr){
 	return static_cast<QSqlQuery*>(ptr)->last();
 }
 
+void* QSqlQuery_LastError(void* ptr){
+	return new QSqlError(static_cast<QSqlQuery*>(ptr)->lastError());
+}
+
 void* QSqlQuery_LastInsertId(void* ptr){
 	return new QVariant(static_cast<QSqlQuery*>(ptr)->lastInsertId());
 }
@@ -668,6 +725,10 @@ int QSqlQuery_Previous(void* ptr){
 	return static_cast<QSqlQuery*>(ptr)->previous();
 }
 
+void* QSqlQuery_Record(void* ptr){
+	return new QSqlRecord(static_cast<QSqlQuery*>(ptr)->record());
+}
+
 void* QSqlQuery_Result(void* ptr){
 	return const_cast<QSqlResult*>(static_cast<QSqlQuery*>(ptr)->result());
 }
@@ -699,7 +760,6 @@ void QSqlQuery_DestroyQSqlQuery(void* ptr){
 class MyQSqlQueryModel: public QSqlQueryModel {
 public:
 	void clear() { callbackQSqlQueryModelClear(this, this->objectName().toUtf8().data()); };
-	void fetchMore(const QModelIndex & parent) { callbackQSqlQueryModelFetchMore(this, this->objectName().toUtf8().data(), new QModelIndex(parent)); };
 	void queryChange() { callbackQSqlQueryModelQueryChange(this, this->objectName().toUtf8().data()); };
 	void revert() { if (!callbackQSqlQueryModelRevert(this, this->objectName().toUtf8().data())) { QSqlQueryModel::revert(); }; };
 	void sort(int column, Qt::SortOrder order) { callbackQSqlQueryModelSort(this, this->objectName().toUtf8().data(), column, order); };
@@ -732,26 +792,22 @@ int QSqlQueryModel_ColumnCount(void* ptr, void* index){
 	return static_cast<QSqlQueryModel*>(ptr)->columnCount(*static_cast<QModelIndex*>(index));
 }
 
-void QSqlQueryModel_FetchMore(void* ptr, void* parent){
-	static_cast<MyQSqlQueryModel*>(ptr)->fetchMore(*static_cast<QModelIndex*>(parent));
-}
-
-void QSqlQueryModel_FetchMoreDefault(void* ptr, void* parent){
-	static_cast<QSqlQueryModel*>(ptr)->QSqlQueryModel::fetchMore(*static_cast<QModelIndex*>(parent));
-}
-
 void* QSqlQueryModel_HeaderData(void* ptr, int section, int orientation, int role){
 	return new QVariant(static_cast<QSqlQueryModel*>(ptr)->headerData(section, static_cast<Qt::Orientation>(orientation), role));
 }
 
-void* QSqlQueryModel_IndexInQuery(void* ptr, void* item){
-	return new QModelIndex(static_cast<QSqlQueryModel*>(ptr)->indexInQuery(*static_cast<QModelIndex*>(item)));
-}
-
 int QSqlQueryModel_InsertColumns(void* ptr, int column, int count, void* parent){
 	return static_cast<QSqlQueryModel*>(ptr)->insertColumns(column, count, *static_cast<QModelIndex*>(parent));
 }
 
+void* QSqlQueryModel_LastError(void* ptr){
+	return new QSqlError(static_cast<QSqlQueryModel*>(ptr)->lastError());
+}
+
+void* QSqlQueryModel_Query(void* ptr){
+	return new QSqlQuery(static_cast<QSqlQueryModel*>(ptr)->query());
+}
+
 void QSqlQueryModel_QueryChange(void* ptr){
 	static_cast<MyQSqlQueryModel*>(ptr)->queryChange();
 }
@@ -760,6 +816,14 @@ void QSqlQueryModel_QueryChangeDefault(void* ptr){
 	static_cast<QSqlQueryModel*>(ptr)->QSqlQueryModel::queryChange();
 }
 
+void* QSqlQueryModel_Record2(void* ptr){
+	return new QSqlRecord(static_cast<QSqlQueryModel*>(ptr)->record());
+}
+
+void* QSqlQueryModel_Record(void* ptr, int row){
+	return new QSqlRecord(static_cast<QSqlQueryModel*>(ptr)->record(row));
+}
+
 int QSqlQueryModel_RemoveColumns(void* ptr, int column, int count, void* parent){
 	return static_cast<QSqlQueryModel*>(ptr)->removeColumns(column, count, *static_cast<QModelIndex*>(parent));
 }
@@ -848,6 +912,14 @@ int QSqlRecord_Count(void* ptr){
 	return static_cast<QSqlRecord*>(ptr)->count();
 }
 
+void* QSqlRecord_Field2(void* ptr, char* name){
+	return new QSqlField(static_cast<QSqlRecord*>(ptr)->field(QString(name)));
+}
+
+void* QSqlRecord_Field(void* ptr, int index){
+	return new QSqlField(static_cast<QSqlRecord*>(ptr)->field(index));
+}
+
 char* QSqlRecord_FieldName(void* ptr, int index){
 	return static_cast<QSqlRecord*>(ptr)->fieldName(index).toUtf8().data();
 }
@@ -876,6 +948,10 @@ int QSqlRecord_IsNull2(void* ptr, int index){
 	return static_cast<QSqlRecord*>(ptr)->isNull(index);
 }
 
+void* QSqlRecord_KeyValues(void* ptr, void* keyFields){
+	return new QSqlRecord(static_cast<QSqlRecord*>(ptr)->keyValues(*static_cast<QSqlRecord*>(keyFields)));
+}
+
 void QSqlRecord_SetGenerated(void* ptr, char* name, int generated){
 	static_cast<QSqlRecord*>(ptr)->setGenerated(QString(name), generated != 0);
 }
@@ -946,7 +1022,6 @@ public:
 	void setFilter(const QString & filter) { callbackQSqlRelationalTableModelSetFilter(this, this->objectName().toUtf8().data(), filter.toUtf8().data()); };
 	void setSort(int column, Qt::SortOrder order) { callbackQSqlRelationalTableModelSetSort(this, this->objectName().toUtf8().data(), column, order); };
 	void sort(int column, Qt::SortOrder order) { callbackQSqlRelationalTableModelSort(this, this->objectName().toUtf8().data(), column, order); };
-	void fetchMore(const QModelIndex & parent) { callbackQSqlRelationalTableModelFetchMore(this, this->objectName().toUtf8().data(), new QModelIndex(parent)); };
 	void queryChange() { callbackQSqlRelationalTableModelQueryChange(this, this->objectName().toUtf8().data()); };
 	void timerEvent(QTimerEvent * event) { callbackQSqlRelationalTableModelTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQSqlRelationalTableModelChildEvent(this, this->objectName().toUtf8().data(), event); };
@@ -1061,14 +1136,6 @@ void QSqlRelationalTableModel_SortDefault(void* ptr, int column, int order){
 	static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::sort(column, static_cast<Qt::SortOrder>(order));
 }
 
-void QSqlRelationalTableModel_FetchMore(void* ptr, void* parent){
-	static_cast<MyQSqlRelationalTableModel*>(ptr)->fetchMore(*static_cast<QModelIndex*>(parent));
-}
-
-void QSqlRelationalTableModel_FetchMoreDefault(void* ptr, void* parent){
-	static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::fetchMore(*static_cast<QModelIndex*>(parent));
-}
-
 void QSqlRelationalTableModel_QueryChange(void* ptr){
 	static_cast<MyQSqlRelationalTableModel*>(ptr)->queryChange();
 }
@@ -1109,6 +1176,7 @@ public:
 	void setActive(bool active) { callbackQSqlResultSetActive(this, this->objectNameAbs().toUtf8().data(), active); };
 	void setAt(int index) { callbackQSqlResultSetAt(this, this->objectNameAbs().toUtf8().data(), index); };
 	void setForwardOnly(bool forward) { callbackQSqlResultSetForwardOnly(this, this->objectNameAbs().toUtf8().data(), forward); };
+	void setLastError(const QSqlError & error) { callbackQSqlResultSetLastError(this, this->objectNameAbs().toUtf8().data(), new QSqlError(error)); };
 	void setQuery(const QString & query) { callbackQSqlResultSetQuery(this, this->objectNameAbs().toUtf8().data(), query.toUtf8().data()); };
 };
 
@@ -1136,6 +1204,10 @@ int QSqlResult_Prepare(void* ptr, char* query){
 	return static_cast<QSqlResult*>(ptr)->prepare(QString(query));
 }
 
+void* QSqlResult_Record(void* ptr){
+	return new QSqlRecord(static_cast<QSqlResult*>(ptr)->record());
+}
+
 int QSqlResult_SavePrepare(void* ptr, char* query){
 	return static_cast<QSqlResult*>(ptr)->savePrepare(QString(query));
 }
@@ -1164,6 +1236,14 @@ void QSqlResult_SetForwardOnlyDefault(void* ptr, int forward){
 	static_cast<QSqlResult*>(ptr)->QSqlResult::setForwardOnly(forward != 0);
 }
 
+void QSqlResult_SetLastError(void* ptr, void* error){
+	static_cast<MyQSqlResult*>(ptr)->setLastError(*static_cast<QSqlError*>(error));
+}
+
+void QSqlResult_SetLastErrorDefault(void* ptr, void* error){
+	static_cast<QSqlResult*>(ptr)->QSqlResult::setLastError(*static_cast<QSqlError*>(error));
+}
+
 void QSqlResult_SetQuery(void* ptr, char* query){
 	static_cast<MyQSqlResult*>(ptr)->setQuery(QString(query));
 }
@@ -1192,7 +1272,10 @@ void QSqlResult_SetObjectNameAbs(void* ptr, char* name){
 class MyQSqlTableModel: public QSqlTableModel {
 public:
 	void Signal_BeforeDelete(int row) { callbackQSqlTableModelBeforeDelete(this, this->objectName().toUtf8().data(), row); };
+	void Signal_BeforeInsert(QSqlRecord & record) { callbackQSqlTableModelBeforeInsert(this, this->objectName().toUtf8().data(), new QSqlRecord(record)); };
+	void Signal_BeforeUpdate(int row, QSqlRecord & record) { callbackQSqlTableModelBeforeUpdate(this, this->objectName().toUtf8().data(), row, new QSqlRecord(record)); };
 	void clear() { callbackQSqlTableModelClear(this, this->objectName().toUtf8().data()); };
+	void Signal_PrimeInsert(int row, QSqlRecord & record) { callbackQSqlTableModelPrimeInsert(this, this->objectName().toUtf8().data(), row, new QSqlRecord(record)); };
 	void revert() { if (!callbackQSqlTableModelRevert(this, this->objectName().toUtf8().data())) { QSqlTableModel::revert(); }; };
 	void revertRow(int row) { callbackQSqlTableModelRevertRow(this, this->objectName().toUtf8().data(), row); };
 	void setEditStrategy(QSqlTableModel::EditStrategy strategy) { callbackQSqlTableModelSetEditStrategy(this, this->objectName().toUtf8().data(), strategy); };
@@ -1200,7 +1283,6 @@ public:
 	void setSort(int column, Qt::SortOrder order) { callbackQSqlTableModelSetSort(this, this->objectName().toUtf8().data(), column, order); };
 	void setTable(const QString & tableName) { callbackQSqlTableModelSetTable(this, this->objectName().toUtf8().data(), tableName.toUtf8().data()); };
 	void sort(int column, Qt::SortOrder order) { callbackQSqlTableModelSort(this, this->objectName().toUtf8().data(), column, order); };
-	void fetchMore(const QModelIndex & parent) { callbackQSqlTableModelFetchMore(this, this->objectName().toUtf8().data(), new QModelIndex(parent)); };
 	void queryChange() { callbackQSqlTableModelQueryChange(this, this->objectName().toUtf8().data()); };
 	void timerEvent(QTimerEvent * event) { callbackQSqlTableModelTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQSqlTableModelChildEvent(this, this->objectName().toUtf8().data(), event); };
@@ -1219,6 +1301,30 @@ void QSqlTableModel_BeforeDelete(void* ptr, int row){
 	static_cast<QSqlTableModel*>(ptr)->beforeDelete(row);
 }
 
+void QSqlTableModel_ConnectBeforeInsert(void* ptr){
+	QObject::connect(static_cast<QSqlTableModel*>(ptr), static_cast<void (QSqlTableModel::*)(QSqlRecord &)>(&QSqlTableModel::beforeInsert), static_cast<MyQSqlTableModel*>(ptr), static_cast<void (MyQSqlTableModel::*)(QSqlRecord &)>(&MyQSqlTableModel::Signal_BeforeInsert));;
+}
+
+void QSqlTableModel_DisconnectBeforeInsert(void* ptr){
+	QObject::disconnect(static_cast<QSqlTableModel*>(ptr), static_cast<void (QSqlTableModel::*)(QSqlRecord &)>(&QSqlTableModel::beforeInsert), static_cast<MyQSqlTableModel*>(ptr), static_cast<void (MyQSqlTableModel::*)(QSqlRecord &)>(&MyQSqlTableModel::Signal_BeforeInsert));;
+}
+
+void QSqlTableModel_BeforeInsert(void* ptr, void* record){
+	static_cast<QSqlTableModel*>(ptr)->beforeInsert(*static_cast<QSqlRecord*>(record));
+}
+
+void QSqlTableModel_ConnectBeforeUpdate(void* ptr){
+	QObject::connect(static_cast<QSqlTableModel*>(ptr), static_cast<void (QSqlTableModel::*)(int, QSqlRecord &)>(&QSqlTableModel::beforeUpdate), static_cast<MyQSqlTableModel*>(ptr), static_cast<void (MyQSqlTableModel::*)(int, QSqlRecord &)>(&MyQSqlTableModel::Signal_BeforeUpdate));;
+}
+
+void QSqlTableModel_DisconnectBeforeUpdate(void* ptr){
+	QObject::disconnect(static_cast<QSqlTableModel*>(ptr), static_cast<void (QSqlTableModel::*)(int, QSqlRecord &)>(&QSqlTableModel::beforeUpdate), static_cast<MyQSqlTableModel*>(ptr), static_cast<void (MyQSqlTableModel::*)(int, QSqlRecord &)>(&MyQSqlTableModel::Signal_BeforeUpdate));;
+}
+
+void QSqlTableModel_BeforeUpdate(void* ptr, int row, void* record){
+	static_cast<QSqlTableModel*>(ptr)->beforeUpdate(row, *static_cast<QSqlRecord*>(record));
+}
+
 void QSqlTableModel_Clear(void* ptr){
 	static_cast<MyQSqlTableModel*>(ptr)->clear();
 }
@@ -1231,6 +1337,10 @@ void* QSqlTableModel_Data(void* ptr, void* index, int role){
 	return new QVariant(static_cast<QSqlTableModel*>(ptr)->data(*static_cast<QModelIndex*>(index), role));
 }
 
+void* QSqlTableModel_Database(void* ptr){
+	return new QSqlDatabase(static_cast<QSqlTableModel*>(ptr)->database());
+}
+
 int QSqlTableModel_DeleteRowFromTable(void* ptr, int row){
 	return static_cast<QSqlTableModel*>(ptr)->deleteRowFromTable(row);
 }
@@ -1255,10 +1365,6 @@ void* QSqlTableModel_HeaderData(void* ptr, int section, int orientation, int rol
 	return new QVariant(static_cast<QSqlTableModel*>(ptr)->headerData(section, static_cast<Qt::Orientation>(orientation), role));
 }
 
-void* QSqlTableModel_IndexInQuery(void* ptr, void* item){
-	return new QModelIndex(static_cast<QSqlTableModel*>(ptr)->indexInQuery(*static_cast<QModelIndex*>(item)));
-}
-
 int QSqlTableModel_InsertRecord(void* ptr, int row, void* record){
 	return static_cast<QSqlTableModel*>(ptr)->insertRecord(row, *static_cast<QSqlRecord*>(record));
 }
@@ -1283,6 +1389,30 @@ char* QSqlTableModel_OrderByClause(void* ptr){
 	return static_cast<QSqlTableModel*>(ptr)->orderByClause().toUtf8().data();
 }
 
+void* QSqlTableModel_PrimaryKey(void* ptr){
+	return new QSqlIndex(static_cast<QSqlTableModel*>(ptr)->primaryKey());
+}
+
+void QSqlTableModel_ConnectPrimeInsert(void* ptr){
+	QObject::connect(static_cast<QSqlTableModel*>(ptr), static_cast<void (QSqlTableModel::*)(int, QSqlRecord &)>(&QSqlTableModel::primeInsert), static_cast<MyQSqlTableModel*>(ptr), static_cast<void (MyQSqlTableModel::*)(int, QSqlRecord &)>(&MyQSqlTableModel::Signal_PrimeInsert));;
+}
+
+void QSqlTableModel_DisconnectPrimeInsert(void* ptr){
+	QObject::disconnect(static_cast<QSqlTableModel*>(ptr), static_cast<void (QSqlTableModel::*)(int, QSqlRecord &)>(&QSqlTableModel::primeInsert), static_cast<MyQSqlTableModel*>(ptr), static_cast<void (MyQSqlTableModel::*)(int, QSqlRecord &)>(&MyQSqlTableModel::Signal_PrimeInsert));;
+}
+
+void QSqlTableModel_PrimeInsert(void* ptr, int row, void* record){
+	static_cast<QSqlTableModel*>(ptr)->primeInsert(row, *static_cast<QSqlRecord*>(record));
+}
+
+void* QSqlTableModel_Record(void* ptr){
+	return new QSqlRecord(static_cast<QSqlTableModel*>(ptr)->record());
+}
+
+void* QSqlTableModel_Record2(void* ptr, int row){
+	return new QSqlRecord(static_cast<QSqlTableModel*>(ptr)->record(row));
+}
+
 int QSqlTableModel_RemoveColumns(void* ptr, int column, int count, void* parent){
 	return static_cast<QSqlTableModel*>(ptr)->removeColumns(column, count, *static_cast<QModelIndex*>(parent));
 }
@@ -1395,14 +1525,6 @@ void QSqlTableModel_DestroyQSqlTableModel(void* ptr){
 	static_cast<QSqlTableModel*>(ptr)->~QSqlTableModel();
 }
 
-void QSqlTableModel_FetchMore(void* ptr, void* parent){
-	static_cast<MyQSqlTableModel*>(ptr)->fetchMore(*static_cast<QModelIndex*>(parent));
-}
-
-void QSqlTableModel_FetchMoreDefault(void* ptr, void* parent){
-	static_cast<QSqlTableModel*>(ptr)->QSqlTableModel::fetchMore(*static_cast<QModelIndex*>(parent));
-}
-
 void QSqlTableModel_QueryChange(void* ptr){
 	static_cast<MyQSqlTableModel*>(ptr)->queryChange();
 }

sql/sql.go

@@ -47,6 +47,18 @@ func (ptr *QSqlDatabase) QSqlDatabase_PTR() *QSqlDatabase {
 	return ptr
 }
 
+func QSqlDatabase_AddDatabase2(driver QSqlDriver_ITF, connectionName string) *QSqlDatabase {
+	defer qt.Recovering("QSqlDatabase::addDatabase")
+
+	return NewQSqlDatabaseFromPointer(C.QSqlDatabase_QSqlDatabase_AddDatabase2(PointerFromQSqlDriver(driver), C.CString(connectionName)))
+}
+
+func QSqlDatabase_AddDatabase(ty string, connectionName string) *QSqlDatabase {
+	defer qt.Recovering("QSqlDatabase::addDatabase")
+
+	return NewQSqlDatabaseFromPointer(C.QSqlDatabase_QSqlDatabase_AddDatabase(C.CString(ty), C.CString(connectionName)))
+}
+
 func NewQSqlDatabase() *QSqlDatabase {
 	defer qt.Recovering("QSqlDatabase::QSqlDatabase")
 
@@ -59,6 +71,12 @@ func NewQSqlDatabase2(other QSqlDatabase_ITF) *QSqlDatabase {
 	return newQSqlDatabaseFromPointer(C.QSqlDatabase_NewQSqlDatabase2(PointerFromQSqlDatabase(other)))
 }
 
+func QSqlDatabase_CloneDatabase(other QSqlDatabase_ITF, connectionName string) *QSqlDatabase {
+	defer qt.Recovering("QSqlDatabase::cloneDatabase")
+
+	return NewQSqlDatabaseFromPointer(C.QSqlDatabase_QSqlDatabase_CloneDatabase(PointerFromQSqlDatabase(other), C.CString(connectionName)))
+}
+
 func (ptr *QSqlDatabase) Close() {
 	defer qt.Recovering("QSqlDatabase::close")
 
@@ -106,6 +124,12 @@ func QSqlDatabase_Contains(connectionName string) bool {
 	return C.QSqlDatabase_QSqlDatabase_Contains(C.CString(connectionName)) != 0
 }
 
+func QSqlDatabase_Database(connectionName string, open bool) *QSqlDatabase {
+	defer qt.Recovering("QSqlDatabase::database")
+
+	return NewQSqlDatabaseFromPointer(C.QSqlDatabase_QSqlDatabase_Database(C.CString(connectionName), C.int(qt.GoBoolToInt(open))))
+}
+
 func (ptr *QSqlDatabase) DatabaseName() string {
 	defer qt.Recovering("QSqlDatabase::databaseName")
 
@@ -139,6 +163,15 @@ func QSqlDatabase_Drivers() []string {
 	return strings.Split(C.GoString(C.QSqlDatabase_QSqlDatabase_Drivers()), "|")
 }
 
+func (ptr *QSqlDatabase) Exec(query string) *QSqlQuery {
+	defer qt.Recovering("QSqlDatabase::exec")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlQueryFromPointer(C.QSqlDatabase_Exec(ptr.Pointer(), C.CString(query)))
+	}
+	return nil
+}
+
 func (ptr *QSqlDatabase) HostName() string {
 	defer qt.Recovering("QSqlDatabase::hostName")
 
@@ -181,6 +214,15 @@ func (ptr *QSqlDatabase) IsValid() bool {
 	return false
 }
 
+func (ptr *QSqlDatabase) LastError() *QSqlError {
+	defer qt.Recovering("QSqlDatabase::lastError")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlErrorFromPointer(C.QSqlDatabase_LastError(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QSqlDatabase) Open() bool {
 	defer qt.Recovering("QSqlDatabase::open")
 
@@ -217,6 +259,24 @@ func (ptr *QSqlDatabase) Port() int {
 	return 0
 }
 
+func (ptr *QSqlDatabase) PrimaryIndex(tablename string) *QSqlIndex {
+	defer qt.Recovering("QSqlDatabase::primaryIndex")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlIndexFromPointer(C.QSqlDatabase_PrimaryIndex(ptr.Pointer(), C.CString(tablename)))
+	}
+	return nil
+}
+
+func (ptr *QSqlDatabase) Record(tablename string) *QSqlRecord {
+	defer qt.Recovering("QSqlDatabase::record")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlRecordFromPointer(C.QSqlDatabase_Record(ptr.Pointer(), C.CString(tablename)))
+	}
+	return nil
+}
+
 func QSqlDatabase_RegisterSqlDriver(name string, creator QSqlDriverCreatorBase_ITF) {
 	defer qt.Recovering("QSqlDatabase::registerSqlDriver")
 
@@ -517,6 +577,15 @@ func (ptr *QSqlDriver) IsOpenError() bool {
 	return false
 }
 
+func (ptr *QSqlDriver) LastError() *QSqlError {
+	defer qt.Recovering("QSqlDriver::lastError")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlErrorFromPointer(C.QSqlDriver_LastError(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QSqlDriver) ConnectNotification(f func(name string)) {
 	defer qt.Recovering("connect QSqlDriver::notification")
 
@@ -598,6 +667,24 @@ func (ptr *QSqlDriver) Open(db string, user string, password string, host string
 	return false
 }
 
+func (ptr *QSqlDriver) PrimaryIndex(tableName string) *QSqlIndex {
+	defer qt.Recovering("QSqlDriver::primaryIndex")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlIndexFromPointer(C.QSqlDriver_PrimaryIndex(ptr.Pointer(), C.CString(tableName)))
+	}
+	return nil
+}
+
+func (ptr *QSqlDriver) Record(tableName string) *QSqlRecord {
+	defer qt.Recovering("QSqlDriver::record")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlRecordFromPointer(C.QSqlDriver_Record(ptr.Pointer(), C.CString(tableName)))
+	}
+	return nil
+}
+
 func (ptr *QSqlDriver) RollbackTransaction() bool {
 	defer qt.Recovering("QSqlDriver::rollbackTransaction")
 
@@ -607,6 +694,51 @@ func (ptr *QSqlDriver) RollbackTransaction() bool {
 	return false
 }
 
+func (ptr *QSqlDriver) ConnectSetLastError(f func(error *QSqlError)) {
+	defer qt.Recovering("connect QSqlDriver::setLastError")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "setLastError", f)
+	}
+}
+
+func (ptr *QSqlDriver) DisconnectSetLastError() {
+	defer qt.Recovering("disconnect QSqlDriver::setLastError")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "setLastError")
+	}
+}
+
+//export callbackQSqlDriverSetLastError
+func callbackQSqlDriverSetLastError(ptr unsafe.Pointer, ptrName *C.char, error unsafe.Pointer) {
+	defer qt.Recovering("callback QSqlDriver::setLastError")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "setLastError"); signal != nil {
+		signal.(func(*QSqlError))(NewQSqlErrorFromPointer(error))
+	} else {
+		NewQSqlDriverFromPointer(ptr).SetLastErrorDefault(NewQSqlErrorFromPointer(error))
+	}
+}
+
+func (ptr *QSqlDriver) SetLastError(error QSqlError_ITF) {
+	defer qt.Recovering("QSqlDriver::setLastError")
+
+	if ptr.Pointer() != nil {
+		C.QSqlDriver_SetLastError(ptr.Pointer(), PointerFromQSqlError(error))
+	}
+}
+
+func (ptr *QSqlDriver) SetLastErrorDefault(error QSqlError_ITF) {
+	defer qt.Recovering("QSqlDriver::setLastError")
+
+	if ptr.Pointer() != nil {
+		C.QSqlDriver_SetLastErrorDefault(ptr.Pointer(), PointerFromQSqlError(error))
+	}
+}
+
 func (ptr *QSqlDriver) ConnectSetOpen(f func(open bool)) {
 	defer qt.Recovering("connect QSqlDriver::setOpen")
 
@@ -1898,6 +2030,15 @@ func (ptr *QSqlQuery) Last() bool {
 	return false
 }
 
+func (ptr *QSqlQuery) LastError() *QSqlError {
+	defer qt.Recovering("QSqlQuery::lastError")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlErrorFromPointer(C.QSqlQuery_LastError(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QSqlQuery) LastInsertId() *core.QVariant {
 	defer qt.Recovering("QSqlQuery::lastInsertId")
 
@@ -1961,6 +2102,15 @@ func (ptr *QSqlQuery) Previous() bool {
 	return false
 }
 
+func (ptr *QSqlQuery) Record() *QSqlRecord {
+	defer qt.Recovering("QSqlQuery::record")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlRecordFromPointer(C.QSqlQuery_Record(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QSqlQuery) Result() *QSqlResult {
 	defer qt.Recovering("QSqlQuery::result")
 
@@ -2137,51 +2287,6 @@ func (ptr *QSqlQueryModel) ColumnCount(index core.QModelIndex_ITF) int {
 	return 0
 }
 
-func (ptr *QSqlQueryModel) ConnectFetchMore(f func(parent *core.QModelIndex)) {
-	defer qt.Recovering("connect QSqlQueryModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-
-		qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
-	}
-}
-
-func (ptr *QSqlQueryModel) DisconnectFetchMore() {
-	defer qt.Recovering("disconnect QSqlQueryModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-
-		qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
-	}
-}
-
-//export callbackQSqlQueryModelFetchMore
-func callbackQSqlQueryModelFetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) {
-	defer qt.Recovering("callback QSqlQueryModel::fetchMore")
-
-	if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
-		signal.(func(*core.QModelIndex))(core.NewQModelIndexFromPointer(parent))
-	} else {
-		NewQSqlQueryModelFromPointer(ptr).FetchMoreDefault(core.NewQModelIndexFromPointer(parent))
-	}
-}
-
-func (ptr *QSqlQueryModel) FetchMore(parent core.QModelIndex_ITF) {
-	defer qt.Recovering("QSqlQueryModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-		C.QSqlQueryModel_FetchMore(ptr.Pointer(), core.PointerFromQModelIndex(parent))
-	}
-}
-
-func (ptr *QSqlQueryModel) FetchMoreDefault(parent core.QModelIndex_ITF) {
-	defer qt.Recovering("QSqlQueryModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-		C.QSqlQueryModel_FetchMoreDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))
-	}
-}
-
 func (ptr *QSqlQueryModel) HeaderData(section int, orientation core.Qt__Orientation, role int) *core.QVariant {
 	defer qt.Recovering("QSqlQueryModel::headerData")
 
@@ -2191,15 +2296,6 @@ func (ptr *QSqlQueryModel) HeaderData(section int, orientation core.Qt__Orientat
 	return nil
 }
 
-func (ptr *QSqlQueryModel) IndexInQuery(item core.QModelIndex_ITF) *core.QModelIndex {
-	defer qt.Recovering("QSqlQueryModel::indexInQuery")
-
-	if ptr.Pointer() != nil {
-		return core.NewQModelIndexFromPointer(C.QSqlQueryModel_IndexInQuery(ptr.Pointer(), core.PointerFromQModelIndex(item)))
-	}
-	return nil
-}
-
 func (ptr *QSqlQueryModel) InsertColumns(column int, count int, parent core.QModelIndex_ITF) bool {
 	defer qt.Recovering("QSqlQueryModel::insertColumns")
 
@@ -2209,6 +2305,24 @@ func (ptr *QSqlQueryModel) InsertColumns(column int, count int, parent core.QMod
 	return false
 }
 
+func (ptr *QSqlQueryModel) LastError() *QSqlError {
+	defer qt.Recovering("QSqlQueryModel::lastError")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlErrorFromPointer(C.QSqlQueryModel_LastError(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QSqlQueryModel) Query() *QSqlQuery {
+	defer qt.Recovering("QSqlQueryModel::query")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlQueryFromPointer(C.QSqlQueryModel_Query(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QSqlQueryModel) ConnectQueryChange(f func()) {
 	defer qt.Recovering("connect QSqlQueryModel::queryChange")
 
@@ -2254,6 +2368,24 @@ func (ptr *QSqlQueryModel) QueryChangeDefault() {
 	}
 }
 
+func (ptr *QSqlQueryModel) Record2() *QSqlRecord {
+	defer qt.Recovering("QSqlQueryModel::record")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlRecordFromPointer(C.QSqlQueryModel_Record2(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QSqlQueryModel) Record(row int) *QSqlRecord {
+	defer qt.Recovering("QSqlQueryModel::record")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlRecordFromPointer(C.QSqlQueryModel_Record(ptr.Pointer(), C.int(row)))
+	}
+	return nil
+}
+
 func (ptr *QSqlQueryModel) RemoveColumns(column int, count int, parent core.QModelIndex_ITF) bool {
 	defer qt.Recovering("QSqlQueryModel::removeColumns")
 
@@ -2615,6 +2747,24 @@ func (ptr *QSqlRecord) Count() int {
 	return 0
 }
 
+func (ptr *QSqlRecord) Field2(name string) *QSqlField {
+	defer qt.Recovering("QSqlRecord::field")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlFieldFromPointer(C.QSqlRecord_Field2(ptr.Pointer(), C.CString(name)))
+	}
+	return nil
+}
+
+func (ptr *QSqlRecord) Field(index int) *QSqlField {
+	defer qt.Recovering("QSqlRecord::field")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlFieldFromPointer(C.QSqlRecord_Field(ptr.Pointer(), C.int(index)))
+	}
+	return nil
+}
+
 func (ptr *QSqlRecord) FieldName(index int) string {
 	defer qt.Recovering("QSqlRecord::fieldName")
 
@@ -2678,6 +2828,15 @@ func (ptr *QSqlRecord) IsNull2(index int) bool {
 	return false
 }
 
+func (ptr *QSqlRecord) KeyValues(keyFields QSqlRecord_ITF) *QSqlRecord {
+	defer qt.Recovering("QSqlRecord::keyValues")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlRecordFromPointer(C.QSqlRecord_KeyValues(ptr.Pointer(), PointerFromQSqlRecord(keyFields)))
+	}
+	return nil
+}
+
 func (ptr *QSqlRecord) SetGenerated(name string, generated bool) {
 	defer qt.Recovering("QSqlRecord::setGenerated")
 
@@ -3378,51 +3537,6 @@ func (ptr *QSqlRelationalTableModel) SortDefault(column int, order core.Qt__Sort
 	}
 }
 
-func (ptr *QSqlRelationalTableModel) ConnectFetchMore(f func(parent *core.QModelIndex)) {
-	defer qt.Recovering("connect QSqlRelationalTableModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-
-		qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
-	}
-}
-
-func (ptr *QSqlRelationalTableModel) DisconnectFetchMore() {
-	defer qt.Recovering("disconnect QSqlRelationalTableModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-
-		qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
-	}
-}
-
-//export callbackQSqlRelationalTableModelFetchMore
-func callbackQSqlRelationalTableModelFetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) {
-	defer qt.Recovering("callback QSqlRelationalTableModel::fetchMore")
-
-	if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
-		signal.(func(*core.QModelIndex))(core.NewQModelIndexFromPointer(parent))
-	} else {
-		NewQSqlRelationalTableModelFromPointer(ptr).FetchMoreDefault(core.NewQModelIndexFromPointer(parent))
-	}
-}
-
-func (ptr *QSqlRelationalTableModel) FetchMore(parent core.QModelIndex_ITF) {
-	defer qt.Recovering("QSqlRelationalTableModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-		C.QSqlRelationalTableModel_FetchMore(ptr.Pointer(), core.PointerFromQModelIndex(parent))
-	}
-}
-
-func (ptr *QSqlRelationalTableModel) FetchMoreDefault(parent core.QModelIndex_ITF) {
-	defer qt.Recovering("QSqlRelationalTableModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-		C.QSqlRelationalTableModel_FetchMoreDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))
-	}
-}
-
 func (ptr *QSqlRelationalTableModel) ConnectQueryChange(f func()) {
 	defer qt.Recovering("connect QSqlRelationalTableModel::queryChange")
 
@@ -3706,6 +3820,15 @@ func (ptr *QSqlResult) Prepare(query string) bool {
 	return false
 }
 
+func (ptr *QSqlResult) Record() *QSqlRecord {
+	defer qt.Recovering("QSqlResult::record")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlRecordFromPointer(C.QSqlResult_Record(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QSqlResult) SavePrepare(query string) bool {
 	defer qt.Recovering("QSqlResult::savePrepare")
 
@@ -3850,6 +3973,51 @@ func (ptr *QSqlResult) SetForwardOnlyDefault(forward bool) {
 	}
 }
 
+func (ptr *QSqlResult) ConnectSetLastError(f func(error *QSqlError)) {
+	defer qt.Recovering("connect QSqlResult::setLastError")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectNameAbs(), "setLastError", f)
+	}
+}
+
+func (ptr *QSqlResult) DisconnectSetLastError() {
+	defer qt.Recovering("disconnect QSqlResult::setLastError")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectNameAbs(), "setLastError")
+	}
+}
+
+//export callbackQSqlResultSetLastError
+func callbackQSqlResultSetLastError(ptr unsafe.Pointer, ptrName *C.char, error unsafe.Pointer) {
+	defer qt.Recovering("callback QSqlResult::setLastError")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "setLastError"); signal != nil {
+		signal.(func(*QSqlError))(NewQSqlErrorFromPointer(error))
+	} else {
+		NewQSqlResultFromPointer(ptr).SetLastErrorDefault(NewQSqlErrorFromPointer(error))
+	}
+}
+
+func (ptr *QSqlResult) SetLastError(error QSqlError_ITF) {
+	defer qt.Recovering("QSqlResult::setLastError")
+
+	if ptr.Pointer() != nil {
+		C.QSqlResult_SetLastError(ptr.Pointer(), PointerFromQSqlError(error))
+	}
+}
+
+func (ptr *QSqlResult) SetLastErrorDefault(error QSqlError_ITF) {
+	defer qt.Recovering("QSqlResult::setLastError")
+
+	if ptr.Pointer() != nil {
+		C.QSqlResult_SetLastErrorDefault(ptr.Pointer(), PointerFromQSqlError(error))
+	}
+}
+
 func (ptr *QSqlResult) ConnectSetQuery(f func(query string)) {
 	defer qt.Recovering("connect QSqlResult::setQuery")
 
@@ -3999,6 +4167,78 @@ func (ptr *QSqlTableModel) BeforeDelete(row int) {
 	}
 }
 
+func (ptr *QSqlTableModel) ConnectBeforeInsert(f func(record *QSqlRecord)) {
+	defer qt.Recovering("connect QSqlTableModel::beforeInsert")
+
+	if ptr.Pointer() != nil {
+		C.QSqlTableModel_ConnectBeforeInsert(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "beforeInsert", f)
+	}
+}
+
+func (ptr *QSqlTableModel) DisconnectBeforeInsert() {
+	defer qt.Recovering("disconnect QSqlTableModel::beforeInsert")
+
+	if ptr.Pointer() != nil {
+		C.QSqlTableModel_DisconnectBeforeInsert(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "beforeInsert")
+	}
+}
+
+//export callbackQSqlTableModelBeforeInsert
+func callbackQSqlTableModelBeforeInsert(ptr unsafe.Pointer, ptrName *C.char, record unsafe.Pointer) {
+	defer qt.Recovering("callback QSqlTableModel::beforeInsert")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "beforeInsert"); signal != nil {
+		signal.(func(*QSqlRecord))(NewQSqlRecordFromPointer(record))
+	}
+
+}
+
+func (ptr *QSqlTableModel) BeforeInsert(record QSqlRecord_ITF) {
+	defer qt.Recovering("QSqlTableModel::beforeInsert")
+
+	if ptr.Pointer() != nil {
+		C.QSqlTableModel_BeforeInsert(ptr.Pointer(), PointerFromQSqlRecord(record))
+	}
+}
+
+func (ptr *QSqlTableModel) ConnectBeforeUpdate(f func(row int, record *QSqlRecord)) {
+	defer qt.Recovering("connect QSqlTableModel::beforeUpdate")
+
+	if ptr.Pointer() != nil {
+		C.QSqlTableModel_ConnectBeforeUpdate(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "beforeUpdate", f)
+	}
+}
+
+func (ptr *QSqlTableModel) DisconnectBeforeUpdate() {
+	defer qt.Recovering("disconnect QSqlTableModel::beforeUpdate")
+
+	if ptr.Pointer() != nil {
+		C.QSqlTableModel_DisconnectBeforeUpdate(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "beforeUpdate")
+	}
+}
+
+//export callbackQSqlTableModelBeforeUpdate
+func callbackQSqlTableModelBeforeUpdate(ptr unsafe.Pointer, ptrName *C.char, row C.int, record unsafe.Pointer) {
+	defer qt.Recovering("callback QSqlTableModel::beforeUpdate")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "beforeUpdate"); signal != nil {
+		signal.(func(int, *QSqlRecord))(int(row), NewQSqlRecordFromPointer(record))
+	}
+
+}
+
+func (ptr *QSqlTableModel) BeforeUpdate(row int, record QSqlRecord_ITF) {
+	defer qt.Recovering("QSqlTableModel::beforeUpdate")
+
+	if ptr.Pointer() != nil {
+		C.QSqlTableModel_BeforeUpdate(ptr.Pointer(), C.int(row), PointerFromQSqlRecord(record))
+	}
+}
+
 func (ptr *QSqlTableModel) ConnectClear(f func()) {
 	defer qt.Recovering("connect QSqlTableModel::clear")
 
@@ -4053,6 +4293,15 @@ func (ptr *QSqlTableModel) Data(index core.QModelIndex_ITF, role int) *core.QVar
 	return nil
 }
 
+func (ptr *QSqlTableModel) Database() *QSqlDatabase {
+	defer qt.Recovering("QSqlTableModel::database")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlDatabaseFromPointer(C.QSqlTableModel_Database(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QSqlTableModel) DeleteRowFromTable(row int) bool {
 	defer qt.Recovering("QSqlTableModel::deleteRowFromTable")
 
@@ -4107,15 +4356,6 @@ func (ptr *QSqlTableModel) HeaderData(section int, orientation core.Qt__Orientat
 	return nil
 }
 
-func (ptr *QSqlTableModel) IndexInQuery(item core.QModelIndex_ITF) *core.QModelIndex {
-	defer qt.Recovering("QSqlTableModel::indexInQuery")
-
-	if ptr.Pointer() != nil {
-		return core.NewQModelIndexFromPointer(C.QSqlTableModel_IndexInQuery(ptr.Pointer(), core.PointerFromQModelIndex(item)))
-	}
-	return nil
-}
-
 func (ptr *QSqlTableModel) InsertRecord(row int, record QSqlRecord_ITF) bool {
 	defer qt.Recovering("QSqlTableModel::insertRecord")
 
@@ -4170,6 +4410,69 @@ func (ptr *QSqlTableModel) OrderByClause() string {
 	return ""
 }
 
+func (ptr *QSqlTableModel) PrimaryKey() *QSqlIndex {
+	defer qt.Recovering("QSqlTableModel::primaryKey")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlIndexFromPointer(C.QSqlTableModel_PrimaryKey(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QSqlTableModel) ConnectPrimeInsert(f func(row int, record *QSqlRecord)) {
+	defer qt.Recovering("connect QSqlTableModel::primeInsert")
+
+	if ptr.Pointer() != nil {
+		C.QSqlTableModel_ConnectPrimeInsert(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "primeInsert", f)
+	}
+}
+
+func (ptr *QSqlTableModel) DisconnectPrimeInsert() {
+	defer qt.Recovering("disconnect QSqlTableModel::primeInsert")
+
+	if ptr.Pointer() != nil {
+		C.QSqlTableModel_DisconnectPrimeInsert(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "primeInsert")
+	}
+}
+
+//export callbackQSqlTableModelPrimeInsert
+func callbackQSqlTableModelPrimeInsert(ptr unsafe.Pointer, ptrName *C.char, row C.int, record unsafe.Pointer) {
+	defer qt.Recovering("callback QSqlTableModel::primeInsert")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "primeInsert"); signal != nil {
+		signal.(func(int, *QSqlRecord))(int(row), NewQSqlRecordFromPointer(record))
+	}
+
+}
+
+func (ptr *QSqlTableModel) PrimeInsert(row int, record QSqlRecord_ITF) {
+	defer qt.Recovering("QSqlTableModel::primeInsert")
+
+	if ptr.Pointer() != nil {
+		C.QSqlTableModel_PrimeInsert(ptr.Pointer(), C.int(row), PointerFromQSqlRecord(record))
+	}
+}
+
+func (ptr *QSqlTableModel) Record() *QSqlRecord {
+	defer qt.Recovering("QSqlTableModel::record")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlRecordFromPointer(C.QSqlTableModel_Record(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QSqlTableModel) Record2(row int) *QSqlRecord {
+	defer qt.Recovering("QSqlTableModel::record")
+
+	if ptr.Pointer() != nil {
+		return NewQSqlRecordFromPointer(C.QSqlTableModel_Record2(ptr.Pointer(), C.int(row)))
+	}
+	return nil
+}
+
 func (ptr *QSqlTableModel) RemoveColumns(column int, count int, parent core.QModelIndex_ITF) bool {
 	defer qt.Recovering("QSqlTableModel::removeColumns")
 
@@ -4611,51 +4914,6 @@ func (ptr *QSqlTableModel) DestroyQSqlTableModel() {
 	}
 }
 
-func (ptr *QSqlTableModel) ConnectFetchMore(f func(parent *core.QModelIndex)) {
-	defer qt.Recovering("connect QSqlTableModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-
-		qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
-	}
-}
-
-func (ptr *QSqlTableModel) DisconnectFetchMore() {
-	defer qt.Recovering("disconnect QSqlTableModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-
-		qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
-	}
-}
-
-//export callbackQSqlTableModelFetchMore
-func callbackQSqlTableModelFetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) {
-	defer qt.Recovering("callback QSqlTableModel::fetchMore")
-
-	if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
-		signal.(func(*core.QModelIndex))(core.NewQModelIndexFromPointer(parent))
-	} else {
-		NewQSqlTableModelFromPointer(ptr).FetchMoreDefault(core.NewQModelIndexFromPointer(parent))
-	}
-}
-
-func (ptr *QSqlTableModel) FetchMore(parent core.QModelIndex_ITF) {
-	defer qt.Recovering("QSqlTableModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-		C.QSqlTableModel_FetchMore(ptr.Pointer(), core.PointerFromQModelIndex(parent))
-	}
-}
-
-func (ptr *QSqlTableModel) FetchMoreDefault(parent core.QModelIndex_ITF) {
-	defer qt.Recovering("QSqlTableModel::fetchMore")
-
-	if ptr.Pointer() != nil {
-		C.QSqlTableModel_FetchMoreDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))
-	}
-}
-
 func (ptr *QSqlTableModel) ConnectQueryChange(f func()) {
 	defer qt.Recovering("connect QSqlTableModel::queryChange")
 

sql/sql.h

@@ -7,27 +7,35 @@
 extern "C" {
 #endif
 
+void* QSqlDatabase_QSqlDatabase_AddDatabase2(void* driver, char* connectionName);
+void* QSqlDatabase_QSqlDatabase_AddDatabase(char* ty, char* connectionName);
 void* QSqlDatabase_NewQSqlDatabase();
 void* QSqlDatabase_NewQSqlDatabase2(void* other);
+void* QSqlDatabase_QSqlDatabase_CloneDatabase(void* other, char* connectionName);
 void QSqlDatabase_Close(void* ptr);
 int QSqlDatabase_Commit(void* ptr);
 char* QSqlDatabase_ConnectOptions(void* ptr);
 char* QSqlDatabase_ConnectionName(void* ptr);
 char* QSqlDatabase_QSqlDatabase_ConnectionNames();
 int QSqlDatabase_QSqlDatabase_Contains(char* connectionName);
+void* QSqlDatabase_QSqlDatabase_Database(char* connectionName, int open);
 char* QSqlDatabase_DatabaseName(void* ptr);
 void* QSqlDatabase_Driver(void* ptr);
 char* QSqlDatabase_DriverName(void* ptr);
 char* QSqlDatabase_QSqlDatabase_Drivers();
+void* QSqlDatabase_Exec(void* ptr, char* query);
 char* QSqlDatabase_HostName(void* ptr);
 int QSqlDatabase_QSqlDatabase_IsDriverAvailable(char* name);
 int QSqlDatabase_IsOpen(void* ptr);
 int QSqlDatabase_IsOpenError(void* ptr);
 int QSqlDatabase_IsValid(void* ptr);
+void* QSqlDatabase_LastError(void* ptr);
 int QSqlDatabase_Open(void* ptr);
 int QSqlDatabase_Open2(void* ptr, char* user, char* password);
 char* QSqlDatabase_Password(void* ptr);
 int QSqlDatabase_Port(void* ptr);
+void* QSqlDatabase_PrimaryIndex(void* ptr, char* tablename);
+void* QSqlDatabase_Record(void* ptr, char* tablename);
 void QSqlDatabase_QSqlDatabase_RegisterSqlDriver(char* name, void* creator);
 void QSqlDatabase_QSqlDatabase_RemoveDatabase(char* connectionName);
 int QSqlDatabase_Rollback(void* ptr);
@@ -59,6 +67,7 @@ int QSqlDriver_IsIdentifierEscapedDefault(void* ptr, char* identifier, int ty);
 int QSqlDriver_IsOpen(void* ptr);
 int QSqlDriver_IsOpenDefault(void* ptr);
 int QSqlDriver_IsOpenError(void* ptr);
+void* QSqlDriver_LastError(void* ptr);
 void QSqlDriver_ConnectNotification(void* ptr);
 void QSqlDriver_DisconnectNotification(void* ptr);
 void QSqlDriver_Notification(void* ptr, char* name);
@@ -66,8 +75,14 @@ void QSqlDriver_ConnectNotification2(void* ptr);
 void QSqlDriver_DisconnectNotification2(void* ptr);
 void QSqlDriver_Notification2(void* ptr, char* name, int source, void* payload);
 int QSqlDriver_Open(void* ptr, char* db, char* user, char* password, char* host, int port, char* options);
+void* QSqlDriver_PrimaryIndex(void* ptr, char* tableName);
+void* QSqlDriver_PrimaryIndexDefault(void* ptr, char* tableName);
+void* QSqlDriver_Record(void* ptr, char* tableName);
+void* QSqlDriver_RecordDefault(void* ptr, char* tableName);
 int QSqlDriver_RollbackTransaction(void* ptr);
 int QSqlDriver_RollbackTransactionDefault(void* ptr);
+void QSqlDriver_SetLastError(void* ptr, void* error);
+void QSqlDriver_SetLastErrorDefault(void* ptr, void* error);
 void QSqlDriver_SetOpen(void* ptr, int open);
 void QSqlDriver_SetOpenDefault(void* ptr, int open);
 void QSqlDriver_SetOpenError(void* ptr, int error);
@@ -167,6 +182,7 @@ int QSqlQuery_IsNull(void* ptr, int field);
 int QSqlQuery_IsSelect(void* ptr);
 int QSqlQuery_IsValid(void* ptr);
 int QSqlQuery_Last(void* ptr);
+void* QSqlQuery_LastError(void* ptr);
 void* QSqlQuery_LastInsertId(void* ptr);
 char* QSqlQuery_LastQuery(void* ptr);
 int QSqlQuery_Next(void* ptr);
@@ -174,6 +190,7 @@ int QSqlQuery_NextResult(void* ptr);
 int QSqlQuery_NumRowsAffected(void* ptr);
 int QSqlQuery_Prepare(void* ptr, char* query);
 int QSqlQuery_Previous(void* ptr);
+void* QSqlQuery_Record(void* ptr);
 void* QSqlQuery_Result(void* ptr);
 int QSqlQuery_Seek(void* ptr, int index, int relative);
 void QSqlQuery_SetForwardOnly(void* ptr, int forward);
@@ -191,16 +208,16 @@ void QSqlQueryModel_Clear(void* ptr);
 void QSqlQueryModel_ClearDefault(void* ptr);
 int QSqlQueryModel_ColumnCount(void* ptr, void* index);
 int QSqlQueryModel_ColumnCountDefault(void* ptr, void* index);
-void QSqlQueryModel_FetchMore(void* ptr, void* parent);
-void QSqlQueryModel_FetchMoreDefault(void* ptr, void* parent);
 void* QSqlQueryModel_HeaderData(void* ptr, int section, int orientation, int role);
 void* QSqlQueryModel_HeaderDataDefault(void* ptr, int section, int orientation, int role);
-void* QSqlQueryModel_IndexInQuery(void* ptr, void* item);
-void* QSqlQueryModel_IndexInQueryDefault(void* ptr, void* item);
 int QSqlQueryModel_InsertColumns(void* ptr, int column, int count, void* parent);
 int QSqlQueryModel_InsertColumnsDefault(void* ptr, int column, int count, void* parent);
+void* QSqlQueryModel_LastError(void* ptr);
+void* QSqlQueryModel_Query(void* ptr);
 void QSqlQueryModel_QueryChange(void* ptr);
 void QSqlQueryModel_QueryChangeDefault(void* ptr);
+void* QSqlQueryModel_Record2(void* ptr);
+void* QSqlQueryModel_Record(void* ptr, int row);
 int QSqlQueryModel_RemoveColumns(void* ptr, int column, int count, void* parent);
 int QSqlQueryModel_RemoveColumnsDefault(void* ptr, int column, int count, void* parent);
 int QSqlQueryModel_SetHeaderData(void* ptr, int section, int orientation, void* value, int role);
@@ -225,6 +242,8 @@ void QSqlRecord_Clear(void* ptr);
 void QSqlRecord_ClearValues(void* ptr);
 int QSqlRecord_Contains(void* ptr, char* name);
 int QSqlRecord_Count(void* ptr);
+void* QSqlRecord_Field2(void* ptr, char* name);
+void* QSqlRecord_Field(void* ptr, int index);
 char* QSqlRecord_FieldName(void* ptr, int index);
 int QSqlRecord_IndexOf(void* ptr, char* name);
 int QSqlRecord_IsEmpty(void* ptr);
@@ -232,6 +251,7 @@ int QSqlRecord_IsGenerated(void* ptr, char* name);
 int QSqlRecord_IsGenerated2(void* ptr, int index);
 int QSqlRecord_IsNull(void* ptr, char* name);
 int QSqlRecord_IsNull2(void* ptr, int index);
+void* QSqlRecord_KeyValues(void* ptr, void* keyFields);
 void QSqlRecord_SetGenerated(void* ptr, char* name, int generated);
 void QSqlRecord_SetGenerated2(void* ptr, int index, int generated);
 void QSqlRecord_SetNull2(void* ptr, char* name);
@@ -283,8 +303,6 @@ void QSqlRelationalTableModel_SetSort(void* ptr, int column, int order);
 void QSqlRelationalTableModel_SetSortDefault(void* ptr, int column, int order);
 void QSqlRelationalTableModel_Sort(void* ptr, int column, int order);
 void QSqlRelationalTableModel_SortDefault(void* ptr, int column, int order);
-void QSqlRelationalTableModel_FetchMore(void* ptr, void* parent);
-void QSqlRelationalTableModel_FetchMoreDefault(void* ptr, void* parent);
 void QSqlRelationalTableModel_QueryChange(void* ptr);
 void QSqlRelationalTableModel_QueryChangeDefault(void* ptr);
 void QSqlRelationalTableModel_TimerEvent(void* ptr, void* event);
@@ -305,6 +323,8 @@ void* QSqlResult_LastInsertId(void* ptr);
 void* QSqlResult_LastInsertIdDefault(void* ptr);
 int QSqlResult_Prepare(void* ptr, char* query);
 int QSqlResult_PrepareDefault(void* ptr, char* query);
+void* QSqlResult_Record(void* ptr);
+void* QSqlResult_RecordDefault(void* ptr);
 int QSqlResult_SavePrepare(void* ptr, char* query);
 int QSqlResult_SavePrepareDefault(void* ptr, char* query);
 void QSqlResult_SetActive(void* ptr, int active);
@@ -313,6 +333,8 @@ void QSqlResult_SetAt(void* ptr, int index);
 void QSqlResult_SetAtDefault(void* ptr, int index);
 void QSqlResult_SetForwardOnly(void* ptr, int forward);
 void QSqlResult_SetForwardOnlyDefault(void* ptr, int forward);
+void QSqlResult_SetLastError(void* ptr, void* error);
+void QSqlResult_SetLastErrorDefault(void* ptr, void* error);
 void QSqlResult_SetQuery(void* ptr, char* query);
 void QSqlResult_SetQueryDefault(void* ptr, char* query);
 void QSqlResult_DestroyQSqlResult(void* ptr);
@@ -321,10 +343,17 @@ void QSqlResult_SetObjectNameAbs(void* ptr, char* name);
 void QSqlTableModel_ConnectBeforeDelete(void* ptr);
 void QSqlTableModel_DisconnectBeforeDelete(void* ptr);
 void QSqlTableModel_BeforeDelete(void* ptr, int row);
+void QSqlTableModel_ConnectBeforeInsert(void* ptr);
+void QSqlTableModel_DisconnectBeforeInsert(void* ptr);
+void QSqlTableModel_BeforeInsert(void* ptr, void* record);
+void QSqlTableModel_ConnectBeforeUpdate(void* ptr);
+void QSqlTableModel_DisconnectBeforeUpdate(void* ptr);
+void QSqlTableModel_BeforeUpdate(void* ptr, int row, void* record);
 void QSqlTableModel_Clear(void* ptr);
 void QSqlTableModel_ClearDefault(void* ptr);
 void* QSqlTableModel_Data(void* ptr, void* index, int role);
 void* QSqlTableModel_DataDefault(void* ptr, void* index, int role);
+void* QSqlTableModel_Database(void* ptr);
 int QSqlTableModel_DeleteRowFromTable(void* ptr, int row);
 int QSqlTableModel_DeleteRowFromTableDefault(void* ptr, int row);
 int QSqlTableModel_EditStrategy(void* ptr);
@@ -334,8 +363,6 @@ int QSqlTableModel_Flags(void* ptr, void* index);
 int QSqlTableModel_FlagsDefault(void* ptr, void* index);
 void* QSqlTableModel_HeaderData(void* ptr, int section, int orientation, int role);
 void* QSqlTableModel_HeaderDataDefault(void* ptr, int section, int orientation, int role);
-void* QSqlTableModel_IndexInQuery(void* ptr, void* item);
-void* QSqlTableModel_IndexInQueryDefault(void* ptr, void* item);
 int QSqlTableModel_InsertRecord(void* ptr, int row, void* record);
 int QSqlTableModel_InsertRowIntoTable(void* ptr, void* values);
 int QSqlTableModel_InsertRowIntoTableDefault(void* ptr, void* values);
@@ -345,6 +372,12 @@ int QSqlTableModel_IsDirty2(void* ptr);
 int QSqlTableModel_IsDirty(void* ptr, void* index);
 char* QSqlTableModel_OrderByClause(void* ptr);
 char* QSqlTableModel_OrderByClauseDefault(void* ptr);
+void* QSqlTableModel_PrimaryKey(void* ptr);
+void QSqlTableModel_ConnectPrimeInsert(void* ptr);
+void QSqlTableModel_DisconnectPrimeInsert(void* ptr);
+void QSqlTableModel_PrimeInsert(void* ptr, int row, void* record);
+void* QSqlTableModel_Record(void* ptr);
+void* QSqlTableModel_Record2(void* ptr, int row);
 int QSqlTableModel_RemoveColumns(void* ptr, int column, int count, void* parent);
 int QSqlTableModel_RemoveColumnsDefault(void* ptr, int column, int count, void* parent);
 int QSqlTableModel_RemoveRows(void* ptr, int row, int count, void* parent);
@@ -382,8 +415,6 @@ char* QSqlTableModel_TableName(void* ptr);
 int QSqlTableModel_UpdateRowInTable(void* ptr, int row, void* values);
 int QSqlTableModel_UpdateRowInTableDefault(void* ptr, int row, void* values);
 void QSqlTableModel_DestroyQSqlTableModel(void* ptr);
-void QSqlTableModel_FetchMore(void* ptr, void* parent);
-void QSqlTableModel_FetchMoreDefault(void* ptr, void* parent);
 void QSqlTableModel_QueryChange(void* ptr);
 void QSqlTableModel_QueryChangeDefault(void* ptr);
 void QSqlTableModel_TimerEvent(void* ptr, void* event);

svg/svg.cpp

@@ -246,8 +246,8 @@ void* QSvgRenderer_NewQSvgRenderer4(void* contents, void* parent){
 	return new QSvgRenderer(static_cast<QXmlStreamReader*>(contents), static_cast<QObject*>(parent));
 }
 
-void* QSvgRenderer_NewQSvgRenderer3(void* contents, void* parent){
-	return new QSvgRenderer(*static_cast<QByteArray*>(contents), static_cast<QObject*>(parent));
+void* QSvgRenderer_NewQSvgRenderer3(char* contents, void* parent){
+	return new QSvgRenderer(QByteArray(contents), static_cast<QObject*>(parent));
 }
 
 void* QSvgRenderer_NewQSvgRenderer2(char* filename, void* parent){
@@ -274,8 +274,8 @@ int QSvgRenderer_Load3(void* ptr, void* contents){
 	return QMetaObject::invokeMethod(static_cast<QSvgRenderer*>(ptr), "load", Q_ARG(QXmlStreamReader*, static_cast<QXmlStreamReader*>(contents)));
 }
 
-int QSvgRenderer_Load2(void* ptr, void* contents){
-	return QMetaObject::invokeMethod(static_cast<QSvgRenderer*>(ptr), "load", Q_ARG(QByteArray, *static_cast<QByteArray*>(contents)));
+int QSvgRenderer_Load2(void* ptr, char* contents){
+	return QMetaObject::invokeMethod(static_cast<QSvgRenderer*>(ptr), "load", Q_ARG(QByteArray, QByteArray(contents)));
 }
 
 int QSvgRenderer_Load(void* ptr, char* filename){
@@ -383,8 +383,8 @@ void* QSvgWidget_NewQSvgWidget2(char* file, void* parent){
 	return new MyQSvgWidget(QString(file), static_cast<QWidget*>(parent));
 }
 
-void QSvgWidget_Load2(void* ptr, void* contents){
-	QMetaObject::invokeMethod(static_cast<QSvgWidget*>(ptr), "load", Q_ARG(QByteArray, *static_cast<QByteArray*>(contents)));
+void QSvgWidget_Load2(void* ptr, char* contents){
+	QMetaObject::invokeMethod(static_cast<QSvgWidget*>(ptr), "load", Q_ARG(QByteArray, QByteArray(contents)));
 }
 
 void QSvgWidget_Load(void* ptr, char* file){

svg/svg.go

@@ -573,10 +573,10 @@ func NewQSvgRenderer4(contents core.QXmlStreamReader_ITF, parent core.QObject_IT
 	return newQSvgRendererFromPointer(C.QSvgRenderer_NewQSvgRenderer4(core.PointerFromQXmlStreamReader(contents), core.PointerFromQObject(parent)))
 }
 
-func NewQSvgRenderer3(contents core.QByteArray_ITF, parent core.QObject_ITF) *QSvgRenderer {
+func NewQSvgRenderer3(contents string, parent core.QObject_ITF) *QSvgRenderer {
 	defer qt.Recovering("QSvgRenderer::QSvgRenderer")
 
-	return newQSvgRendererFromPointer(C.QSvgRenderer_NewQSvgRenderer3(core.PointerFromQByteArray(contents), core.PointerFromQObject(parent)))
+	return newQSvgRendererFromPointer(C.QSvgRenderer_NewQSvgRenderer3(C.CString(contents), core.PointerFromQObject(parent)))
 }
 
 func NewQSvgRenderer2(filename string, parent core.QObject_ITF) *QSvgRenderer {
@@ -630,11 +630,11 @@ func (ptr *QSvgRenderer) Load3(contents core.QXmlStreamReader_ITF) bool {
 	return false
 }
 
-func (ptr *QSvgRenderer) Load2(contents core.QByteArray_ITF) bool {
+func (ptr *QSvgRenderer) Load2(contents string) bool {
 	defer qt.Recovering("QSvgRenderer::load")
 
 	if ptr.Pointer() != nil {
-		return C.QSvgRenderer_Load2(ptr.Pointer(), core.PointerFromQByteArray(contents)) != 0
+		return C.QSvgRenderer_Load2(ptr.Pointer(), C.CString(contents)) != 0
 	}
 	return false
 }
@@ -907,11 +907,11 @@ func NewQSvgWidget2(file string, parent widgets.QWidget_ITF) *QSvgWidget {
 	return newQSvgWidgetFromPointer(C.QSvgWidget_NewQSvgWidget2(C.CString(file), widgets.PointerFromQWidget(parent)))
 }
 
-func (ptr *QSvgWidget) Load2(contents core.QByteArray_ITF) {
+func (ptr *QSvgWidget) Load2(contents string) {
 	defer qt.Recovering("QSvgWidget::load")
 
 	if ptr.Pointer() != nil {
-		C.QSvgWidget_Load2(ptr.Pointer(), core.PointerFromQByteArray(contents))
+		C.QSvgWidget_Load2(ptr.Pointer(), C.CString(contents))
 	}
 }
 

svg/svg.h

@@ -52,14 +52,14 @@ void QSvgRenderer_SetViewBox(void* ptr, void* viewbox);
 void QSvgRenderer_SetViewBox2(void* ptr, void* viewbox);
 void* QSvgRenderer_NewQSvgRenderer(void* parent);
 void* QSvgRenderer_NewQSvgRenderer4(void* contents, void* parent);
-void* QSvgRenderer_NewQSvgRenderer3(void* contents, void* parent);
+void* QSvgRenderer_NewQSvgRenderer3(char* contents, void* parent);
 void* QSvgRenderer_NewQSvgRenderer2(char* filename, void* parent);
 int QSvgRenderer_Animated(void* ptr);
 void* QSvgRenderer_DefaultSize(void* ptr);
 int QSvgRenderer_ElementExists(void* ptr, char* id);
 int QSvgRenderer_IsValid(void* ptr);
 int QSvgRenderer_Load3(void* ptr, void* contents);
-int QSvgRenderer_Load2(void* ptr, void* contents);
+int QSvgRenderer_Load2(void* ptr, char* contents);
 int QSvgRenderer_Load(void* ptr, char* filename);
 void QSvgRenderer_Render(void* ptr, void* painter);
 void QSvgRenderer_Render2(void* ptr, void* painter, void* bounds);
@@ -77,7 +77,7 @@ void QSvgRenderer_CustomEvent(void* ptr, void* event);
 void QSvgRenderer_CustomEventDefault(void* ptr, void* event);
 void* QSvgWidget_NewQSvgWidget(void* parent);
 void* QSvgWidget_NewQSvgWidget2(char* file, void* parent);
-void QSvgWidget_Load2(void* ptr, void* contents);
+void QSvgWidget_Load2(void* ptr, char* contents);
 void QSvgWidget_Load(void* ptr, char* file);
 void QSvgWidget_PaintEvent(void* ptr, void* event);
 void QSvgWidget_PaintEventDefault(void* ptr, void* event);

websockets/websockets.cpp

@@ -4,14 +4,17 @@
 #include "_cgo_export.h"
 
 #include <QAbstractSocket>
+#include <QAuthenticator>
 #include <QByteArray>
 #include <QChildEvent>
 #include <QEvent>
+#include <QHostAddress>
 #include <QMaskGenerator>
 #include <QMetaObject>
 #include <QNetworkProxy>
 #include <QObject>
 #include <QSslConfiguration>
+#include <QSslError>
 #include <QString>
 #include <QTime>
 #include <QTimer>
@@ -63,12 +66,13 @@ void QMaskGenerator_CustomEventDefault(void* ptr, void* event){
 class MyQWebSocket: public QWebSocket {
 public:
 	void Signal_AboutToClose() { callbackQWebSocketAboutToClose(this, this->objectName().toUtf8().data()); };
-	void Signal_BinaryFrameReceived(const QByteArray & frame, bool isLastFrame) { callbackQWebSocketBinaryFrameReceived(this, this->objectName().toUtf8().data(), new QByteArray(frame), isLastFrame); };
-	void Signal_BinaryMessageReceived(const QByteArray & message) { callbackQWebSocketBinaryMessageReceived(this, this->objectName().toUtf8().data(), new QByteArray(message)); };
+	void Signal_BinaryFrameReceived(const QByteArray & frame, bool isLastFrame) { callbackQWebSocketBinaryFrameReceived(this, this->objectName().toUtf8().data(), QString(frame).toUtf8().data(), isLastFrame); };
+	void Signal_BinaryMessageReceived(const QByteArray & message) { callbackQWebSocketBinaryMessageReceived(this, this->objectName().toUtf8().data(), QString(message).toUtf8().data()); };
 	void Signal_BytesWritten(qint64 bytes) { callbackQWebSocketBytesWritten(this, this->objectName().toUtf8().data(), static_cast<long long>(bytes)); };
 	void Signal_Connected() { callbackQWebSocketConnected(this, this->objectName().toUtf8().data()); };
 	void Signal_Disconnected() { callbackQWebSocketDisconnected(this, this->objectName().toUtf8().data()); };
 	void Signal_Error2(QAbstractSocket::SocketError error) { callbackQWebSocketError2(this, this->objectName().toUtf8().data(), error); };
+	void Signal_ProxyAuthenticationRequired(const QNetworkProxy & proxy, QAuthenticator * authenticator) { callbackQWebSocketProxyAuthenticationRequired(this, this->objectName().toUtf8().data(), new QNetworkProxy(proxy), authenticator); };
 	void Signal_ReadChannelFinished() { callbackQWebSocketReadChannelFinished(this, this->objectName().toUtf8().data()); };
 	void Signal_StateChanged(QAbstractSocket::SocketState state) { callbackQWebSocketStateChanged(this, this->objectName().toUtf8().data(), state); };
 	void Signal_TextFrameReceived(const QString & frame, bool isLastFrame) { callbackQWebSocketTextFrameReceived(this, this->objectName().toUtf8().data(), frame.toUtf8().data(), isLastFrame); };
@@ -102,8 +106,8 @@ void QWebSocket_DisconnectBinaryFrameReceived(void* ptr){
 	QObject::disconnect(static_cast<QWebSocket*>(ptr), static_cast<void (QWebSocket::*)(const QByteArray &, bool)>(&QWebSocket::binaryFrameReceived), static_cast<MyQWebSocket*>(ptr), static_cast<void (MyQWebSocket::*)(const QByteArray &, bool)>(&MyQWebSocket::Signal_BinaryFrameReceived));;
 }
 
-void QWebSocket_BinaryFrameReceived(void* ptr, void* frame, int isLastFrame){
-	static_cast<QWebSocket*>(ptr)->binaryFrameReceived(*static_cast<QByteArray*>(frame), isLastFrame != 0);
+void QWebSocket_BinaryFrameReceived(void* ptr, char* frame, int isLastFrame){
+	static_cast<QWebSocket*>(ptr)->binaryFrameReceived(QByteArray(frame), isLastFrame != 0);
 }
 
 void QWebSocket_ConnectBinaryMessageReceived(void* ptr){
@@ -114,8 +118,8 @@ void QWebSocket_DisconnectBinaryMessageReceived(void* ptr){
 	QObject::disconnect(static_cast<QWebSocket*>(ptr), static_cast<void (QWebSocket::*)(const QByteArray &)>(&QWebSocket::binaryMessageReceived), static_cast<MyQWebSocket*>(ptr), static_cast<void (MyQWebSocket::*)(const QByteArray &)>(&MyQWebSocket::Signal_BinaryMessageReceived));;
 }
 
-void QWebSocket_BinaryMessageReceived(void* ptr, void* message){
-	static_cast<QWebSocket*>(ptr)->binaryMessageReceived(*static_cast<QByteArray*>(message));
+void QWebSocket_BinaryMessageReceived(void* ptr, char* message){
+	static_cast<QWebSocket*>(ptr)->binaryMessageReceived(QByteArray(message));
 }
 
 void QWebSocket_ConnectBytesWritten(void* ptr){
@@ -190,6 +194,10 @@ int QWebSocket_IsValid(void* ptr){
 	return static_cast<QWebSocket*>(ptr)->isValid();
 }
 
+void* QWebSocket_LocalAddress(void* ptr){
+	return new QHostAddress(static_cast<QWebSocket*>(ptr)->localAddress());
+}
+
 void* QWebSocket_MaskGenerator(void* ptr){
 	return const_cast<QMaskGenerator*>(static_cast<QWebSocket*>(ptr)->maskGenerator());
 }
@@ -206,12 +214,32 @@ int QWebSocket_PauseMode(void* ptr){
 	return static_cast<QWebSocket*>(ptr)->pauseMode();
 }
 
+void* QWebSocket_PeerAddress(void* ptr){
+	return new QHostAddress(static_cast<QWebSocket*>(ptr)->peerAddress());
+}
+
 char* QWebSocket_PeerName(void* ptr){
 	return static_cast<QWebSocket*>(ptr)->peerName().toUtf8().data();
 }
 
-void QWebSocket_Ping(void* ptr, void* payload){
-	QMetaObject::invokeMethod(static_cast<QWebSocket*>(ptr), "ping", Q_ARG(QByteArray, *static_cast<QByteArray*>(payload)));
+void QWebSocket_Ping(void* ptr, char* payload){
+	QMetaObject::invokeMethod(static_cast<QWebSocket*>(ptr), "ping", Q_ARG(QByteArray, QByteArray(payload)));
+}
+
+void* QWebSocket_Proxy(void* ptr){
+	return new QNetworkProxy(static_cast<QWebSocket*>(ptr)->proxy());
+}
+
+void QWebSocket_ConnectProxyAuthenticationRequired(void* ptr){
+	QObject::connect(static_cast<QWebSocket*>(ptr), static_cast<void (QWebSocket::*)(const QNetworkProxy &, QAuthenticator *)>(&QWebSocket::proxyAuthenticationRequired), static_cast<MyQWebSocket*>(ptr), static_cast<void (MyQWebSocket::*)(const QNetworkProxy &, QAuthenticator *)>(&MyQWebSocket::Signal_ProxyAuthenticationRequired));;
+}
+
+void QWebSocket_DisconnectProxyAuthenticationRequired(void* ptr){
+	QObject::disconnect(static_cast<QWebSocket*>(ptr), static_cast<void (QWebSocket::*)(const QNetworkProxy &, QAuthenticator *)>(&QWebSocket::proxyAuthenticationRequired), static_cast<MyQWebSocket*>(ptr), static_cast<void (MyQWebSocket::*)(const QNetworkProxy &, QAuthenticator *)>(&MyQWebSocket::Signal_ProxyAuthenticationRequired));;
+}
+
+void QWebSocket_ProxyAuthenticationRequired(void* ptr, void* proxy, void* authenticator){
+	static_cast<QWebSocket*>(ptr)->proxyAuthenticationRequired(*static_cast<QNetworkProxy*>(proxy), static_cast<QAuthenticator*>(authenticator));
 }
 
 long long QWebSocket_ReadBufferSize(void* ptr){
@@ -242,8 +270,8 @@ void QWebSocket_Resume(void* ptr){
 	static_cast<QWebSocket*>(ptr)->resume();
 }
 
-long long QWebSocket_SendBinaryMessage(void* ptr, void* data){
-	return static_cast<long long>(static_cast<QWebSocket*>(ptr)->sendBinaryMessage(*static_cast<QByteArray*>(data)));
+long long QWebSocket_SendBinaryMessage(void* ptr, char* data){
+	return static_cast<long long>(static_cast<QWebSocket*>(ptr)->sendBinaryMessage(QByteArray(data)));
 }
 
 long long QWebSocket_SendTextMessage(void* ptr, char* message){
@@ -270,6 +298,10 @@ void QWebSocket_SetSslConfiguration(void* ptr, void* sslConfiguration){
 	static_cast<QWebSocket*>(ptr)->setSslConfiguration(*static_cast<QSslConfiguration*>(sslConfiguration));
 }
 
+void* QWebSocket_SslConfiguration(void* ptr){
+	return new QSslConfiguration(static_cast<QWebSocket*>(ptr)->sslConfiguration());
+}
+
 int QWebSocket_State(void* ptr){
 	return static_cast<QWebSocket*>(ptr)->state();
 }
@@ -377,6 +409,7 @@ public:
 	void Signal_Closed() { callbackQWebSocketServerClosed(this, this->objectName().toUtf8().data()); };
 	void Signal_NewConnection() { callbackQWebSocketServerNewConnection(this, this->objectName().toUtf8().data()); };
 	void Signal_OriginAuthenticationRequired(QWebSocketCorsAuthenticator * authenticator) { callbackQWebSocketServerOriginAuthenticationRequired(this, this->objectName().toUtf8().data(), authenticator); };
+	void Signal_PeerVerifyError(const QSslError & error) { callbackQWebSocketServerPeerVerifyError(this, this->objectName().toUtf8().data(), new QSslError(error)); };
 	void timerEvent(QTimerEvent * event) { callbackQWebSocketServerTimerEvent(this, this->objectName().toUtf8().data(), event); };
 	void childEvent(QChildEvent * event) { callbackQWebSocketServerChildEvent(this, this->objectName().toUtf8().data(), event); };
 	void customEvent(QEvent * event) { callbackQWebSocketServerCustomEvent(this, this->objectName().toUtf8().data(), event); };
@@ -462,6 +495,22 @@ void QWebSocketServer_PauseAccepting(void* ptr){
 	static_cast<QWebSocketServer*>(ptr)->pauseAccepting();
 }
 
+void QWebSocketServer_ConnectPeerVerifyError(void* ptr){
+	QObject::connect(static_cast<QWebSocketServer*>(ptr), static_cast<void (QWebSocketServer::*)(const QSslError &)>(&QWebSocketServer::peerVerifyError), static_cast<MyQWebSocketServer*>(ptr), static_cast<void (MyQWebSocketServer::*)(const QSslError &)>(&MyQWebSocketServer::Signal_PeerVerifyError));;
+}
+
+void QWebSocketServer_DisconnectPeerVerifyError(void* ptr){
+	QObject::disconnect(static_cast<QWebSocketServer*>(ptr), static_cast<void (QWebSocketServer::*)(const QSslError &)>(&QWebSocketServer::peerVerifyError), static_cast<MyQWebSocketServer*>(ptr), static_cast<void (MyQWebSocketServer::*)(const QSslError &)>(&MyQWebSocketServer::Signal_PeerVerifyError));;
+}
+
+void QWebSocketServer_PeerVerifyError(void* ptr, void* error){
+	static_cast<QWebSocketServer*>(ptr)->peerVerifyError(*static_cast<QSslError*>(error));
+}
+
+void* QWebSocketServer_Proxy(void* ptr){
+	return new QNetworkProxy(static_cast<QWebSocketServer*>(ptr)->proxy());
+}
+
 void QWebSocketServer_ResumeAccepting(void* ptr){
 	static_cast<QWebSocketServer*>(ptr)->resumeAccepting();
 }
@@ -470,6 +519,10 @@ int QWebSocketServer_SecureMode(void* ptr){
 	return static_cast<QWebSocketServer*>(ptr)->secureMode();
 }
 
+void* QWebSocketServer_ServerAddress(void* ptr){
+	return new QHostAddress(static_cast<QWebSocketServer*>(ptr)->serverAddress());
+}
+
 char* QWebSocketServer_ServerName(void* ptr){
 	return static_cast<QWebSocketServer*>(ptr)->serverName().toUtf8().data();
 }
@@ -502,6 +555,10 @@ int QWebSocketServer_SocketDescriptor(void* ptr){
 	return static_cast<QWebSocketServer*>(ptr)->socketDescriptor();
 }
 
+void* QWebSocketServer_SslConfiguration(void* ptr){
+	return new QSslConfiguration(static_cast<QWebSocketServer*>(ptr)->sslConfiguration());
+}
+
 void QWebSocketServer_DestroyQWebSocketServer(void* ptr){
 	static_cast<QWebSocketServer*>(ptr)->~QWebSocketServer();
 }

websockets/websockets.go

@@ -274,7 +274,7 @@ func (ptr *QWebSocket) AboutToClose() {
 	}
 }
 
-func (ptr *QWebSocket) ConnectBinaryFrameReceived(f func(frame *core.QByteArray, isLastFrame bool)) {
+func (ptr *QWebSocket) ConnectBinaryFrameReceived(f func(frame string, isLastFrame bool)) {
 	defer qt.Recovering("connect QWebSocket::binaryFrameReceived")
 
 	if ptr.Pointer() != nil {
@@ -293,24 +293,24 @@ func (ptr *QWebSocket) DisconnectBinaryFrameReceived() {
 }
 
 //export callbackQWebSocketBinaryFrameReceived
-func callbackQWebSocketBinaryFrameReceived(ptr unsafe.Pointer, ptrName *C.char, frame unsafe.Pointer, isLastFrame C.int) {
+func callbackQWebSocketBinaryFrameReceived(ptr unsafe.Pointer, ptrName *C.char, frame *C.char, isLastFrame C.int) {
 	defer qt.Recovering("callback QWebSocket::binaryFrameReceived")
 
 	if signal := qt.GetSignal(C.GoString(ptrName), "binaryFrameReceived"); signal != nil {
-		signal.(func(*core.QByteArray, bool))(core.NewQByteArrayFromPointer(frame), int(isLastFrame) != 0)
+		signal.(func(string, bool))(C.GoString(frame), int(isLastFrame) != 0)
 	}
 
 }
 
-func (ptr *QWebSocket) BinaryFrameReceived(frame core.QByteArray_ITF, isLastFrame bool) {
+func (ptr *QWebSocket) BinaryFrameReceived(frame string, isLastFrame bool) {
 	defer qt.Recovering("QWebSocket::binaryFrameReceived")
 
 	if ptr.Pointer() != nil {
-		C.QWebSocket_BinaryFrameReceived(ptr.Pointer(), core.PointerFromQByteArray(frame), C.int(qt.GoBoolToInt(isLastFrame)))
+		C.QWebSocket_BinaryFrameReceived(ptr.Pointer(), C.CString(frame), C.int(qt.GoBoolToInt(isLastFrame)))
 	}
 }
 
-func (ptr *QWebSocket) ConnectBinaryMessageReceived(f func(message *core.QByteArray)) {
+func (ptr *QWebSocket) ConnectBinaryMessageReceived(f func(message string)) {
 	defer qt.Recovering("connect QWebSocket::binaryMessageReceived")
 
 	if ptr.Pointer() != nil {
@@ -329,20 +329,20 @@ func (ptr *QWebSocket) DisconnectBinaryMessageReceived() {
 }
 
 //export callbackQWebSocketBinaryMessageReceived
-func callbackQWebSocketBinaryMessageReceived(ptr unsafe.Pointer, ptrName *C.char, message unsafe.Pointer) {
+func callbackQWebSocketBinaryMessageReceived(ptr unsafe.Pointer, ptrName *C.char, message *C.char) {
 	defer qt.Recovering("callback QWebSocket::binaryMessageReceived")
 
 	if signal := qt.GetSignal(C.GoString(ptrName), "binaryMessageReceived"); signal != nil {
-		signal.(func(*core.QByteArray))(core.NewQByteArrayFromPointer(message))
+		signal.(func(string))(C.GoString(message))
 	}
 
 }
 
-func (ptr *QWebSocket) BinaryMessageReceived(message core.QByteArray_ITF) {
+func (ptr *QWebSocket) BinaryMessageReceived(message string) {
 	defer qt.Recovering("QWebSocket::binaryMessageReceived")
 
 	if ptr.Pointer() != nil {
-		C.QWebSocket_BinaryMessageReceived(ptr.Pointer(), core.PointerFromQByteArray(message))
+		C.QWebSocket_BinaryMessageReceived(ptr.Pointer(), C.CString(message))
 	}
 }
 
@@ -543,6 +543,15 @@ func (ptr *QWebSocket) IsValid() bool {
 	return false
 }
 
+func (ptr *QWebSocket) LocalAddress() *network.QHostAddress {
+	defer qt.Recovering("QWebSocket::localAddress")
+
+	if ptr.Pointer() != nil {
+		return network.NewQHostAddressFromPointer(C.QWebSocket_LocalAddress(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QWebSocket) MaskGenerator() *QMaskGenerator {
 	defer qt.Recovering("QWebSocket::maskGenerator")
 
@@ -578,6 +587,15 @@ func (ptr *QWebSocket) PauseMode() network.QAbstractSocket__PauseMode {
 	return 0
 }
 
+func (ptr *QWebSocket) PeerAddress() *network.QHostAddress {
+	defer qt.Recovering("QWebSocket::peerAddress")
+
+	if ptr.Pointer() != nil {
+		return network.NewQHostAddressFromPointer(C.QWebSocket_PeerAddress(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QWebSocket) PeerName() string {
 	defer qt.Recovering("QWebSocket::peerName")
 
@@ -587,11 +605,56 @@ func (ptr *QWebSocket) PeerName() string {
 	return ""
 }
 
-func (ptr *QWebSocket) Ping(payload core.QByteArray_ITF) {
+func (ptr *QWebSocket) Ping(payload string) {
 	defer qt.Recovering("QWebSocket::ping")
 
 	if ptr.Pointer() != nil {
-		C.QWebSocket_Ping(ptr.Pointer(), core.PointerFromQByteArray(payload))
+		C.QWebSocket_Ping(ptr.Pointer(), C.CString(payload))
+	}
+}
+
+func (ptr *QWebSocket) Proxy() *network.QNetworkProxy {
+	defer qt.Recovering("QWebSocket::proxy")
+
+	if ptr.Pointer() != nil {
+		return network.NewQNetworkProxyFromPointer(C.QWebSocket_Proxy(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QWebSocket) ConnectProxyAuthenticationRequired(f func(proxy *network.QNetworkProxy, authenticator *network.QAuthenticator)) {
+	defer qt.Recovering("connect QWebSocket::proxyAuthenticationRequired")
+
+	if ptr.Pointer() != nil {
+		C.QWebSocket_ConnectProxyAuthenticationRequired(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "proxyAuthenticationRequired", f)
+	}
+}
+
+func (ptr *QWebSocket) DisconnectProxyAuthenticationRequired() {
+	defer qt.Recovering("disconnect QWebSocket::proxyAuthenticationRequired")
+
+	if ptr.Pointer() != nil {
+		C.QWebSocket_DisconnectProxyAuthenticationRequired(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "proxyAuthenticationRequired")
+	}
+}
+
+//export callbackQWebSocketProxyAuthenticationRequired
+func callbackQWebSocketProxyAuthenticationRequired(ptr unsafe.Pointer, ptrName *C.char, proxy unsafe.Pointer, authenticator unsafe.Pointer) {
+	defer qt.Recovering("callback QWebSocket::proxyAuthenticationRequired")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "proxyAuthenticationRequired"); signal != nil {
+		signal.(func(*network.QNetworkProxy, *network.QAuthenticator))(network.NewQNetworkProxyFromPointer(proxy), network.NewQAuthenticatorFromPointer(authenticator))
+	}
+
+}
+
+func (ptr *QWebSocket) ProxyAuthenticationRequired(proxy network.QNetworkProxy_ITF, authenticator network.QAuthenticator_ITF) {
+	defer qt.Recovering("QWebSocket::proxyAuthenticationRequired")
+
+	if ptr.Pointer() != nil {
+		C.QWebSocket_ProxyAuthenticationRequired(ptr.Pointer(), network.PointerFromQNetworkProxy(proxy), network.PointerFromQAuthenticator(authenticator))
 	}
 }
 
@@ -666,11 +729,11 @@ func (ptr *QWebSocket) Resume() {
 	}
 }
 
-func (ptr *QWebSocket) SendBinaryMessage(data core.QByteArray_ITF) int64 {
+func (ptr *QWebSocket) SendBinaryMessage(data string) int64 {
 	defer qt.Recovering("QWebSocket::sendBinaryMessage")
 
 	if ptr.Pointer() != nil {
-		return int64(C.QWebSocket_SendBinaryMessage(ptr.Pointer(), core.PointerFromQByteArray(data)))
+		return int64(C.QWebSocket_SendBinaryMessage(ptr.Pointer(), C.CString(data)))
 	}
 	return 0
 }
@@ -724,6 +787,15 @@ func (ptr *QWebSocket) SetSslConfiguration(sslConfiguration network.QSslConfigur
 	}
 }
 
+func (ptr *QWebSocket) SslConfiguration() *network.QSslConfiguration {
+	defer qt.Recovering("QWebSocket::sslConfiguration")
+
+	if ptr.Pointer() != nil {
+		return network.NewQSslConfigurationFromPointer(C.QWebSocket_SslConfiguration(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QWebSocket) State() network.QAbstractSocket__SocketState {
 	defer qt.Recovering("QWebSocket::state")
 
@@ -1336,6 +1408,51 @@ func (ptr *QWebSocketServer) PauseAccepting() {
 	}
 }
 
+func (ptr *QWebSocketServer) ConnectPeerVerifyError(f func(error *network.QSslError)) {
+	defer qt.Recovering("connect QWebSocketServer::peerVerifyError")
+
+	if ptr.Pointer() != nil {
+		C.QWebSocketServer_ConnectPeerVerifyError(ptr.Pointer())
+		qt.ConnectSignal(ptr.ObjectName(), "peerVerifyError", f)
+	}
+}
+
+func (ptr *QWebSocketServer) DisconnectPeerVerifyError() {
+	defer qt.Recovering("disconnect QWebSocketServer::peerVerifyError")
+
+	if ptr.Pointer() != nil {
+		C.QWebSocketServer_DisconnectPeerVerifyError(ptr.Pointer())
+		qt.DisconnectSignal(ptr.ObjectName(), "peerVerifyError")
+	}
+}
+
+//export callbackQWebSocketServerPeerVerifyError
+func callbackQWebSocketServerPeerVerifyError(ptr unsafe.Pointer, ptrName *C.char, error unsafe.Pointer) {
+	defer qt.Recovering("callback QWebSocketServer::peerVerifyError")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "peerVerifyError"); signal != nil {
+		signal.(func(*network.QSslError))(network.NewQSslErrorFromPointer(error))
+	}
+
+}
+
+func (ptr *QWebSocketServer) PeerVerifyError(error network.QSslError_ITF) {
+	defer qt.Recovering("QWebSocketServer::peerVerifyError")
+
+	if ptr.Pointer() != nil {
+		C.QWebSocketServer_PeerVerifyError(ptr.Pointer(), network.PointerFromQSslError(error))
+	}
+}
+
+func (ptr *QWebSocketServer) Proxy() *network.QNetworkProxy {
+	defer qt.Recovering("QWebSocketServer::proxy")
+
+	if ptr.Pointer() != nil {
+		return network.NewQNetworkProxyFromPointer(C.QWebSocketServer_Proxy(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QWebSocketServer) ResumeAccepting() {
 	defer qt.Recovering("QWebSocketServer::resumeAccepting")
 
@@ -1353,6 +1470,15 @@ func (ptr *QWebSocketServer) SecureMode() QWebSocketServer__SslMode {
 	return 0
 }
 
+func (ptr *QWebSocketServer) ServerAddress() *network.QHostAddress {
+	defer qt.Recovering("QWebSocketServer::serverAddress")
+
+	if ptr.Pointer() != nil {
+		return network.NewQHostAddressFromPointer(C.QWebSocketServer_ServerAddress(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QWebSocketServer) ServerName() string {
 	defer qt.Recovering("QWebSocketServer::serverName")
 
@@ -1421,6 +1547,15 @@ func (ptr *QWebSocketServer) SocketDescriptor() int {
 	return 0
 }
 
+func (ptr *QWebSocketServer) SslConfiguration() *network.QSslConfiguration {
+	defer qt.Recovering("QWebSocketServer::sslConfiguration")
+
+	if ptr.Pointer() != nil {
+		return network.NewQSslConfigurationFromPointer(C.QWebSocketServer_SslConfiguration(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QWebSocketServer) DestroyQWebSocketServer() {
 	defer qt.Recovering("QWebSocketServer::~QWebSocketServer")
 

websockets/websockets.h

@@ -21,10 +21,10 @@ void QWebSocket_DisconnectAboutToClose(void* ptr);
 void QWebSocket_AboutToClose(void* ptr);
 void QWebSocket_ConnectBinaryFrameReceived(void* ptr);
 void QWebSocket_DisconnectBinaryFrameReceived(void* ptr);
-void QWebSocket_BinaryFrameReceived(void* ptr, void* frame, int isLastFrame);
+void QWebSocket_BinaryFrameReceived(void* ptr, char* frame, int isLastFrame);
 void QWebSocket_ConnectBinaryMessageReceived(void* ptr);
 void QWebSocket_DisconnectBinaryMessageReceived(void* ptr);
-void QWebSocket_BinaryMessageReceived(void* ptr, void* message);
+void QWebSocket_BinaryMessageReceived(void* ptr, char* message);
 void QWebSocket_ConnectBytesWritten(void* ptr);
 void QWebSocket_DisconnectBytesWritten(void* ptr);
 void QWebSocket_BytesWritten(void* ptr, long long bytes);
@@ -43,12 +43,18 @@ char* QWebSocket_ErrorString(void* ptr);
 int QWebSocket_Flush(void* ptr);
 void QWebSocket_IgnoreSslErrors(void* ptr);
 int QWebSocket_IsValid(void* ptr);
+void* QWebSocket_LocalAddress(void* ptr);
 void* QWebSocket_MaskGenerator(void* ptr);
 void QWebSocket_Open(void* ptr, void* url);
 char* QWebSocket_Origin(void* ptr);
 int QWebSocket_PauseMode(void* ptr);
+void* QWebSocket_PeerAddress(void* ptr);
 char* QWebSocket_PeerName(void* ptr);
-void QWebSocket_Ping(void* ptr, void* payload);
+void QWebSocket_Ping(void* ptr, char* payload);
+void* QWebSocket_Proxy(void* ptr);
+void QWebSocket_ConnectProxyAuthenticationRequired(void* ptr);
+void QWebSocket_DisconnectProxyAuthenticationRequired(void* ptr);
+void QWebSocket_ProxyAuthenticationRequired(void* ptr, void* proxy, void* authenticator);
 long long QWebSocket_ReadBufferSize(void* ptr);
 void QWebSocket_ConnectReadChannelFinished(void* ptr);
 void QWebSocket_DisconnectReadChannelFinished(void* ptr);
@@ -56,13 +62,14 @@ void QWebSocket_ReadChannelFinished(void* ptr);
 void* QWebSocket_RequestUrl(void* ptr);
 char* QWebSocket_ResourceName(void* ptr);
 void QWebSocket_Resume(void* ptr);
-long long QWebSocket_SendBinaryMessage(void* ptr, void* data);
+long long QWebSocket_SendBinaryMessage(void* ptr, char* data);
 long long QWebSocket_SendTextMessage(void* ptr, char* message);
 void QWebSocket_SetMaskGenerator(void* ptr, void* maskGenerator);
 void QWebSocket_SetPauseMode(void* ptr, int pauseMode);
 void QWebSocket_SetProxy(void* ptr, void* networkProxy);
 void QWebSocket_SetReadBufferSize(void* ptr, long long size);
 void QWebSocket_SetSslConfiguration(void* ptr, void* sslConfiguration);
+void* QWebSocket_SslConfiguration(void* ptr);
 int QWebSocket_State(void* ptr);
 void QWebSocket_ConnectStateChanged(void* ptr);
 void QWebSocket_DisconnectStateChanged(void* ptr);
@@ -109,8 +116,13 @@ void QWebSocketServer_ConnectOriginAuthenticationRequired(void* ptr);
 void QWebSocketServer_DisconnectOriginAuthenticationRequired(void* ptr);
 void QWebSocketServer_OriginAuthenticationRequired(void* ptr, void* authenticator);
 void QWebSocketServer_PauseAccepting(void* ptr);
+void QWebSocketServer_ConnectPeerVerifyError(void* ptr);
+void QWebSocketServer_DisconnectPeerVerifyError(void* ptr);
+void QWebSocketServer_PeerVerifyError(void* ptr, void* error);
+void* QWebSocketServer_Proxy(void* ptr);
 void QWebSocketServer_ResumeAccepting(void* ptr);
 int QWebSocketServer_SecureMode(void* ptr);
+void* QWebSocketServer_ServerAddress(void* ptr);
 char* QWebSocketServer_ServerName(void* ptr);
 void* QWebSocketServer_ServerUrl(void* ptr);
 void QWebSocketServer_SetMaxPendingConnections(void* ptr, int numConnections);
@@ -119,6 +131,7 @@ void QWebSocketServer_SetServerName(void* ptr, char* serverName);
 int QWebSocketServer_SetSocketDescriptor(void* ptr, int socketDescriptor);
 void QWebSocketServer_SetSslConfiguration(void* ptr, void* sslConfiguration);
 int QWebSocketServer_SocketDescriptor(void* ptr);
+void* QWebSocketServer_SslConfiguration(void* ptr);
 void QWebSocketServer_DestroyQWebSocketServer(void* ptr);
 void QWebSocketServer_TimerEvent(void* ptr, void* event);
 void QWebSocketServer_TimerEventDefault(void* ptr, void* event);

xml/xml.cpp

@@ -57,6 +57,10 @@ int QDomAttr_NodeType(void* ptr){
 	return static_cast<QDomAttr*>(ptr)->nodeType();
 }
 
+void* QDomAttr_OwnerElement(void* ptr){
+	return new QDomElement(static_cast<QDomAttr*>(ptr)->ownerElement());
+}
+
 void QDomAttr_SetValue(void* ptr, char* v){
 	static_cast<QDomAttr*>(ptr)->setValue(QString(v));
 }
@@ -137,6 +141,74 @@ void* QDomDocument_NewQDomDocument2(char* name){
 	return new QDomDocument(QString(name));
 }
 
+void* QDomDocument_CreateAttribute(void* ptr, char* name){
+	return new QDomAttr(static_cast<QDomDocument*>(ptr)->createAttribute(QString(name)));
+}
+
+void* QDomDocument_CreateAttributeNS(void* ptr, char* nsURI, char* qName){
+	return new QDomAttr(static_cast<QDomDocument*>(ptr)->createAttributeNS(QString(nsURI), QString(qName)));
+}
+
+void* QDomDocument_CreateCDATASection(void* ptr, char* value){
+	return new QDomCDATASection(static_cast<QDomDocument*>(ptr)->createCDATASection(QString(value)));
+}
+
+void* QDomDocument_CreateComment(void* ptr, char* value){
+	return new QDomComment(static_cast<QDomDocument*>(ptr)->createComment(QString(value)));
+}
+
+void* QDomDocument_CreateDocumentFragment(void* ptr){
+	return new QDomDocumentFragment(static_cast<QDomDocument*>(ptr)->createDocumentFragment());
+}
+
+void* QDomDocument_CreateElement(void* ptr, char* tagName){
+	return new QDomElement(static_cast<QDomDocument*>(ptr)->createElement(QString(tagName)));
+}
+
+void* QDomDocument_CreateElementNS(void* ptr, char* nsURI, char* qName){
+	return new QDomElement(static_cast<QDomDocument*>(ptr)->createElementNS(QString(nsURI), QString(qName)));
+}
+
+void* QDomDocument_CreateEntityReference(void* ptr, char* name){
+	return new QDomEntityReference(static_cast<QDomDocument*>(ptr)->createEntityReference(QString(name)));
+}
+
+void* QDomDocument_CreateProcessingInstruction(void* ptr, char* target, char* data){
+	return new QDomProcessingInstruction(static_cast<QDomDocument*>(ptr)->createProcessingInstruction(QString(target), QString(data)));
+}
+
+void* QDomDocument_CreateTextNode(void* ptr, char* value){
+	return new QDomText(static_cast<QDomDocument*>(ptr)->createTextNode(QString(value)));
+}
+
+void* QDomDocument_Doctype(void* ptr){
+	return new QDomDocumentType(static_cast<QDomDocument*>(ptr)->doctype());
+}
+
+void* QDomDocument_DocumentElement(void* ptr){
+	return new QDomElement(static_cast<QDomDocument*>(ptr)->documentElement());
+}
+
+void* QDomDocument_ElementById(void* ptr, char* elementId){
+	return new QDomElement(static_cast<QDomDocument*>(ptr)->elementById(QString(elementId)));
+}
+
+void* QDomDocument_ElementsByTagName(void* ptr, char* tagname){
+	return new QDomNodeList(static_cast<QDomDocument*>(ptr)->elementsByTagName(QString(tagname)));
+}
+
+void* QDomDocument_ElementsByTagNameNS(void* ptr, char* nsURI, char* localName){
+	return new QDomNodeList(static_cast<QDomDocument*>(ptr)->elementsByTagNameNS(QString(nsURI), QString(localName)));
+}
+
+void* QDomDocument_Implementation(void* ptr){
+	return new QDomImplementation(static_cast<QDomDocument*>(ptr)->implementation());
+}
+
+void* QDomDocument_ImportNode(void* ptr, void* importedNode, int deep){
+	return new QDomNode(static_cast<QDomDocument*>(ptr)->importNode(*static_cast<QDomNode*>(importedNode), deep != 0));
+}
+
 int QDomDocument_NodeType(void* ptr){
 	return static_cast<QDomDocument*>(ptr)->nodeType();
 }
@@ -157,12 +229,12 @@ int QDomDocument_SetContent4(void* ptr, void* source, int namespaceProcessing, c
 	return static_cast<QDomDocument*>(ptr)->setContent(static_cast<QXmlInputSource*>(source), namespaceProcessing != 0, new QString(errorMsg), &errorLine, &errorColumn);
 }
 
-int QDomDocument_SetContent6(void* ptr, void* buffer, char* errorMsg, int errorLine, int errorColumn){
-	return static_cast<QDomDocument*>(ptr)->setContent(*static_cast<QByteArray*>(buffer), new QString(errorMsg), &errorLine, &errorColumn);
+int QDomDocument_SetContent6(void* ptr, char* buffer, char* errorMsg, int errorLine, int errorColumn){
+	return static_cast<QDomDocument*>(ptr)->setContent(QByteArray(buffer), new QString(errorMsg), &errorLine, &errorColumn);
 }
 
-int QDomDocument_SetContent(void* ptr, void* data, int namespaceProcessing, char* errorMsg, int errorLine, int errorColumn){
-	return static_cast<QDomDocument*>(ptr)->setContent(*static_cast<QByteArray*>(data), namespaceProcessing != 0, new QString(errorMsg), &errorLine, &errorColumn);
+int QDomDocument_SetContent(void* ptr, char* data, int namespaceProcessing, char* errorMsg, int errorLine, int errorColumn){
+	return static_cast<QDomDocument*>(ptr)->setContent(QByteArray(data), namespaceProcessing != 0, new QString(errorMsg), &errorLine, &errorColumn);
 }
 
 int QDomDocument_SetContent5(void* ptr, char* text, char* errorMsg, int errorLine, int errorColumn){
@@ -173,8 +245,8 @@ int QDomDocument_SetContent2(void* ptr, char* text, int namespaceProcessing, cha
 	return static_cast<QDomDocument*>(ptr)->setContent(QString(text), namespaceProcessing != 0, new QString(errorMsg), &errorLine, &errorColumn);
 }
 
-void* QDomDocument_ToByteArray(void* ptr, int indent){
-	return new QByteArray(static_cast<QDomDocument*>(ptr)->toByteArray(indent));
+char* QDomDocument_ToByteArray(void* ptr, int indent){
+	return QString(static_cast<QDomDocument*>(ptr)->toByteArray(indent)).toUtf8().data();
 }
 
 char* QDomDocument_ToString(void* ptr, int indent){
@@ -205,6 +277,10 @@ void* QDomDocumentType_NewQDomDocumentType2(void* n){
 	return new QDomDocumentType(*static_cast<QDomDocumentType*>(n));
 }
 
+void* QDomDocumentType_Entities(void* ptr){
+	return new QDomNamedNodeMap(static_cast<QDomDocumentType*>(ptr)->entities());
+}
+
 char* QDomDocumentType_InternalSubset(void* ptr){
 	return static_cast<QDomDocumentType*>(ptr)->internalSubset().toUtf8().data();
 }
@@ -217,6 +293,10 @@ int QDomDocumentType_NodeType(void* ptr){
 	return static_cast<QDomDocumentType*>(ptr)->nodeType();
 }
 
+void* QDomDocumentType_Notations(void* ptr){
+	return new QDomNamedNodeMap(static_cast<QDomDocumentType*>(ptr)->notations());
+}
+
 char* QDomDocumentType_PublicId(void* ptr){
 	return static_cast<QDomDocumentType*>(ptr)->publicId().toUtf8().data();
 }
@@ -241,6 +321,26 @@ char* QDomElement_AttributeNS(void* ptr, char* nsURI, char* localName, char* def
 	return static_cast<QDomElement*>(ptr)->attributeNS(QString(nsURI), QString(localName), QString(defValue)).toUtf8().data();
 }
 
+void* QDomElement_AttributeNode(void* ptr, char* name){
+	return new QDomAttr(static_cast<QDomElement*>(ptr)->attributeNode(QString(name)));
+}
+
+void* QDomElement_AttributeNodeNS(void* ptr, char* nsURI, char* localName){
+	return new QDomAttr(static_cast<QDomElement*>(ptr)->attributeNodeNS(QString(nsURI), QString(localName)));
+}
+
+void* QDomElement_Attributes(void* ptr){
+	return new QDomNamedNodeMap(static_cast<QDomElement*>(ptr)->attributes());
+}
+
+void* QDomElement_ElementsByTagName(void* ptr, char* tagname){
+	return new QDomNodeList(static_cast<QDomElement*>(ptr)->elementsByTagName(QString(tagname)));
+}
+
+void* QDomElement_ElementsByTagNameNS(void* ptr, char* nsURI, char* localName){
+	return new QDomNodeList(static_cast<QDomElement*>(ptr)->elementsByTagNameNS(QString(nsURI), QString(localName)));
+}
+
 int QDomElement_HasAttribute(void* ptr, char* name){
 	return static_cast<QDomElement*>(ptr)->hasAttribute(QString(name));
 }
@@ -261,6 +361,10 @@ void QDomElement_RemoveAttributeNS(void* ptr, char* nsURI, char* localName){
 	static_cast<QDomElement*>(ptr)->removeAttributeNS(QString(nsURI), QString(localName));
 }
 
+void* QDomElement_RemoveAttributeNode(void* ptr, void* oldAttr){
+	return new QDomAttr(static_cast<QDomElement*>(ptr)->removeAttributeNode(*static_cast<QDomAttr*>(oldAttr)));
+}
+
 void QDomElement_SetAttribute(void* ptr, char* name, char* value){
 	static_cast<QDomElement*>(ptr)->setAttribute(QString(name), QString(value));
 }
@@ -277,6 +381,14 @@ void QDomElement_SetAttributeNS2(void* ptr, char* nsURI, char* qName, int value)
 	static_cast<QDomElement*>(ptr)->setAttributeNS(QString(nsURI), QString(qName), value);
 }
 
+void* QDomElement_SetAttributeNode(void* ptr, void* newAttr){
+	return new QDomAttr(static_cast<QDomElement*>(ptr)->setAttributeNode(*static_cast<QDomAttr*>(newAttr)));
+}
+
+void* QDomElement_SetAttributeNodeNS(void* ptr, void* newAttr){
+	return new QDomAttr(static_cast<QDomElement*>(ptr)->setAttributeNodeNS(*static_cast<QDomAttr*>(newAttr)));
+}
+
 void QDomElement_SetTagName(void* ptr, char* name){
 	static_cast<QDomElement*>(ptr)->setTagName(QString(name));
 }
@@ -333,6 +445,14 @@ void* QDomImplementation_NewQDomImplementation2(void* x){
 	return new QDomImplementation(*static_cast<QDomImplementation*>(x));
 }
 
+void* QDomImplementation_CreateDocument(void* ptr, char* nsURI, char* qName, void* doctype){
+	return new QDomDocument(static_cast<QDomImplementation*>(ptr)->createDocument(QString(nsURI), QString(qName), *static_cast<QDomDocumentType*>(doctype)));
+}
+
+void* QDomImplementation_CreateDocumentType(void* ptr, char* qName, char* publicId, char* systemId){
+	return new QDomDocumentType(static_cast<QDomImplementation*>(ptr)->createDocumentType(QString(qName), QString(publicId), QString(systemId)));
+}
+
 int QDomImplementation_HasFeature(void* ptr, char* feature, char* version){
 	return static_cast<QDomImplementation*>(ptr)->hasFeature(QString(feature), QString(version));
 }
@@ -373,10 +493,38 @@ int QDomNamedNodeMap_IsEmpty(void* ptr){
 	return static_cast<QDomNamedNodeMap*>(ptr)->isEmpty();
 }
 
+void* QDomNamedNodeMap_Item(void* ptr, int index){
+	return new QDomNode(static_cast<QDomNamedNodeMap*>(ptr)->item(index));
+}
+
 int QDomNamedNodeMap_Length(void* ptr){
 	return static_cast<QDomNamedNodeMap*>(ptr)->length();
 }
 
+void* QDomNamedNodeMap_NamedItem(void* ptr, char* name){
+	return new QDomNode(static_cast<QDomNamedNodeMap*>(ptr)->namedItem(QString(name)));
+}
+
+void* QDomNamedNodeMap_NamedItemNS(void* ptr, char* nsURI, char* localName){
+	return new QDomNode(static_cast<QDomNamedNodeMap*>(ptr)->namedItemNS(QString(nsURI), QString(localName)));
+}
+
+void* QDomNamedNodeMap_RemoveNamedItem(void* ptr, char* name){
+	return new QDomNode(static_cast<QDomNamedNodeMap*>(ptr)->removeNamedItem(QString(name)));
+}
+
+void* QDomNamedNodeMap_RemoveNamedItemNS(void* ptr, char* nsURI, char* localName){
+	return new QDomNode(static_cast<QDomNamedNodeMap*>(ptr)->removeNamedItemNS(QString(nsURI), QString(localName)));
+}
+
+void* QDomNamedNodeMap_SetNamedItem(void* ptr, void* newNode){
+	return new QDomNode(static_cast<QDomNamedNodeMap*>(ptr)->setNamedItem(*static_cast<QDomNode*>(newNode)));
+}
+
+void* QDomNamedNodeMap_SetNamedItemNS(void* ptr, void* newNode){
+	return new QDomNode(static_cast<QDomNamedNodeMap*>(ptr)->setNamedItemNS(*static_cast<QDomNode*>(newNode)));
+}
+
 int QDomNamedNodeMap_Size(void* ptr){
 	return static_cast<QDomNamedNodeMap*>(ptr)->size();
 }
@@ -393,14 +541,38 @@ void* QDomNode_NewQDomNode2(void* n){
 	return new QDomNode(*static_cast<QDomNode*>(n));
 }
 
+void* QDomNode_AppendChild(void* ptr, void* newChild){
+	return new QDomNode(static_cast<QDomNode*>(ptr)->appendChild(*static_cast<QDomNode*>(newChild)));
+}
+
+void* QDomNode_Attributes(void* ptr){
+	return new QDomNamedNodeMap(static_cast<QDomNode*>(ptr)->attributes());
+}
+
+void* QDomNode_ChildNodes(void* ptr){
+	return new QDomNodeList(static_cast<QDomNode*>(ptr)->childNodes());
+}
+
 void QDomNode_Clear(void* ptr){
 	static_cast<QDomNode*>(ptr)->clear();
 }
 
+void* QDomNode_CloneNode(void* ptr, int deep){
+	return new QDomNode(static_cast<QDomNode*>(ptr)->cloneNode(deep != 0));
+}
+
 int QDomNode_ColumnNumber(void* ptr){
 	return static_cast<QDomNode*>(ptr)->columnNumber();
 }
 
+void* QDomNode_FirstChild(void* ptr){
+	return new QDomNode(static_cast<QDomNode*>(ptr)->firstChild());
+}
+
+void* QDomNode_FirstChildElement(void* ptr, char* tagName){
+	return new QDomElement(static_cast<QDomNode*>(ptr)->firstChildElement(QString(tagName)));
+}
+
 int QDomNode_HasAttributes(void* ptr){
 	return static_cast<QDomNode*>(ptr)->hasAttributes();
 }
@@ -409,6 +581,14 @@ int QDomNode_HasChildNodes(void* ptr){
 	return static_cast<QDomNode*>(ptr)->hasChildNodes();
 }
 
+void* QDomNode_InsertAfter(void* ptr, void* newChild, void* refChild){
+	return new QDomNode(static_cast<QDomNode*>(ptr)->insertAfter(*static_cast<QDomNode*>(newChild), *static_cast<QDomNode*>(refChild)));
+}
+
+void* QDomNode_InsertBefore(void* ptr, void* newChild, void* refChild){
+	return new QDomNode(static_cast<QDomNode*>(ptr)->insertBefore(*static_cast<QDomNode*>(newChild), *static_cast<QDomNode*>(refChild)));
+}
+
 int QDomNode_IsAttr(void* ptr){
 	return static_cast<QDomNode*>(ptr)->isAttr();
 }
@@ -469,6 +649,14 @@ int QDomNode_IsText(void* ptr){
 	return static_cast<QDomNode*>(ptr)->isText();
 }
 
+void* QDomNode_LastChild(void* ptr){
+	return new QDomNode(static_cast<QDomNode*>(ptr)->lastChild());
+}
+
+void* QDomNode_LastChildElement(void* ptr, char* tagName){
+	return new QDomElement(static_cast<QDomNode*>(ptr)->lastChildElement(QString(tagName)));
+}
+
 int QDomNode_LineNumber(void* ptr){
 	return static_cast<QDomNode*>(ptr)->lineNumber();
 }
@@ -477,10 +665,22 @@ char* QDomNode_LocalName(void* ptr){
 	return static_cast<QDomNode*>(ptr)->localName().toUtf8().data();
 }
 
+void* QDomNode_NamedItem(void* ptr, char* name){
+	return new QDomNode(static_cast<QDomNode*>(ptr)->namedItem(QString(name)));
+}
+
 char* QDomNode_NamespaceURI(void* ptr){
 	return static_cast<QDomNode*>(ptr)->namespaceURI().toUtf8().data();
 }
 
+void* QDomNode_NextSibling(void* ptr){
+	return new QDomNode(static_cast<QDomNode*>(ptr)->nextSibling());
+}
+
+void* QDomNode_NextSiblingElement(void* ptr, char* tagName){
+	return new QDomElement(static_cast<QDomNode*>(ptr)->nextSiblingElement(QString(tagName)));
+}
+
 char* QDomNode_NodeName(void* ptr){
 	return static_cast<QDomNode*>(ptr)->nodeName().toUtf8().data();
 }
@@ -497,10 +697,34 @@ void QDomNode_Normalize(void* ptr){
 	static_cast<QDomNode*>(ptr)->normalize();
 }
 
+void* QDomNode_OwnerDocument(void* ptr){
+	return new QDomDocument(static_cast<QDomNode*>(ptr)->ownerDocument());
+}
+
+void* QDomNode_ParentNode(void* ptr){
+	return new QDomNode(static_cast<QDomNode*>(ptr)->parentNode());
+}
+
 char* QDomNode_Prefix(void* ptr){
 	return static_cast<QDomNode*>(ptr)->prefix().toUtf8().data();
 }
 
+void* QDomNode_PreviousSibling(void* ptr){
+	return new QDomNode(static_cast<QDomNode*>(ptr)->previousSibling());
+}
+
+void* QDomNode_PreviousSiblingElement(void* ptr, char* tagName){
+	return new QDomElement(static_cast<QDomNode*>(ptr)->previousSiblingElement(QString(tagName)));
+}
+
+void* QDomNode_RemoveChild(void* ptr, void* oldChild){
+	return new QDomNode(static_cast<QDomNode*>(ptr)->removeChild(*static_cast<QDomNode*>(oldChild)));
+}
+
+void* QDomNode_ReplaceChild(void* ptr, void* newChild, void* oldChild){
+	return new QDomNode(static_cast<QDomNode*>(ptr)->replaceChild(*static_cast<QDomNode*>(newChild), *static_cast<QDomNode*>(oldChild)));
+}
+
 void QDomNode_Save(void* ptr, void* stream, int indent, int encodingPolicy){
 	static_cast<QDomNode*>(ptr)->save(*static_cast<QTextStream*>(stream), indent, static_cast<QDomNode::EncodingPolicy>(encodingPolicy));
 }
@@ -513,6 +737,58 @@ void QDomNode_SetPrefix(void* ptr, char* pre){
 	static_cast<QDomNode*>(ptr)->setPrefix(QString(pre));
 }
 
+void* QDomNode_ToAttr(void* ptr){
+	return new QDomAttr(static_cast<QDomNode*>(ptr)->toAttr());
+}
+
+void* QDomNode_ToCDATASection(void* ptr){
+	return new QDomCDATASection(static_cast<QDomNode*>(ptr)->toCDATASection());
+}
+
+void* QDomNode_ToCharacterData(void* ptr){
+	return new QDomCharacterData(static_cast<QDomNode*>(ptr)->toCharacterData());
+}
+
+void* QDomNode_ToComment(void* ptr){
+	return new QDomComment(static_cast<QDomNode*>(ptr)->toComment());
+}
+
+void* QDomNode_ToDocument(void* ptr){
+	return new QDomDocument(static_cast<QDomNode*>(ptr)->toDocument());
+}
+
+void* QDomNode_ToDocumentFragment(void* ptr){
+	return new QDomDocumentFragment(static_cast<QDomNode*>(ptr)->toDocumentFragment());
+}
+
+void* QDomNode_ToDocumentType(void* ptr){
+	return new QDomDocumentType(static_cast<QDomNode*>(ptr)->toDocumentType());
+}
+
+void* QDomNode_ToElement(void* ptr){
+	return new QDomElement(static_cast<QDomNode*>(ptr)->toElement());
+}
+
+void* QDomNode_ToEntity(void* ptr){
+	return new QDomEntity(static_cast<QDomNode*>(ptr)->toEntity());
+}
+
+void* QDomNode_ToEntityReference(void* ptr){
+	return new QDomEntityReference(static_cast<QDomNode*>(ptr)->toEntityReference());
+}
+
+void* QDomNode_ToNotation(void* ptr){
+	return new QDomNotation(static_cast<QDomNode*>(ptr)->toNotation());
+}
+
+void* QDomNode_ToProcessingInstruction(void* ptr){
+	return new QDomProcessingInstruction(static_cast<QDomNode*>(ptr)->toProcessingInstruction());
+}
+
+void* QDomNode_ToText(void* ptr){
+	return new QDomText(static_cast<QDomNode*>(ptr)->toText());
+}
+
 void QDomNode_DestroyQDomNode(void* ptr){
 	static_cast<QDomNode*>(ptr)->~QDomNode();
 }
@@ -525,6 +801,10 @@ void* QDomNodeList_NewQDomNodeList2(void* n){
 	return new QDomNodeList(*static_cast<QDomNodeList*>(n));
 }
 
+void* QDomNodeList_At(void* ptr, int index){
+	return new QDomNode(static_cast<QDomNodeList*>(ptr)->at(index));
+}
+
 int QDomNodeList_Count(void* ptr){
 	return static_cast<QDomNodeList*>(ptr)->count();
 }
@@ -533,6 +813,10 @@ int QDomNodeList_IsEmpty(void* ptr){
 	return static_cast<QDomNodeList*>(ptr)->isEmpty();
 }
 
+void* QDomNodeList_Item(void* ptr, int index){
+	return new QDomNode(static_cast<QDomNodeList*>(ptr)->item(index));
+}
+
 int QDomNodeList_Length(void* ptr){
 	return static_cast<QDomNodeList*>(ptr)->length();
 }
@@ -601,6 +885,10 @@ int QDomText_NodeType(void* ptr){
 	return static_cast<QDomText*>(ptr)->nodeType();
 }
 
+void* QDomText_SplitText(void* ptr, int offset){
+	return new QDomText(static_cast<QDomText*>(ptr)->splitText(offset));
+}
+
 class MyQXmlAttributes: public QXmlAttributes {
 public:
 	QString _objectName;
@@ -1088,8 +1376,8 @@ void QXmlInputSource_FetchDataDefault(void* ptr){
 	static_cast<QXmlInputSource*>(ptr)->QXmlInputSource::fetchData();
 }
 
-char* QXmlInputSource_FromRawData(void* ptr, void* data, int beginning){
-	return static_cast<QXmlInputSource*>(ptr)->fromRawData(*static_cast<QByteArray*>(data), beginning != 0).toUtf8().data();
+char* QXmlInputSource_FromRawData(void* ptr, char* data, int beginning){
+	return static_cast<QXmlInputSource*>(ptr)->fromRawData(QByteArray(data), beginning != 0).toUtf8().data();
 }
 
 void QXmlInputSource_Reset(void* ptr){

xml/xml.go

@@ -70,6 +70,15 @@ func (ptr *QDomAttr) NodeType() QDomNode__NodeType {
 	return 0
 }
 
+func (ptr *QDomAttr) OwnerElement() *QDomElement {
+	defer qt.Recovering("QDomAttr::ownerElement")
+
+	if ptr.Pointer() != nil {
+		return NewQDomElementFromPointer(C.QDomAttr_OwnerElement(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QDomAttr) SetValue(v string) {
 	defer qt.Recovering("QDomAttr::setValue")
 
@@ -341,6 +350,159 @@ func NewQDomDocument2(name string) *QDomDocument {
 	return newQDomDocumentFromPointer(C.QDomDocument_NewQDomDocument2(C.CString(name)))
 }
 
+func (ptr *QDomDocument) CreateAttribute(name string) *QDomAttr {
+	defer qt.Recovering("QDomDocument::createAttribute")
+
+	if ptr.Pointer() != nil {
+		return NewQDomAttrFromPointer(C.QDomDocument_CreateAttribute(ptr.Pointer(), C.CString(name)))
+	}
+	return nil
+}
+
+func (ptr *QDomDocument) CreateAttributeNS(nsURI string, qName string) *QDomAttr {
+	defer qt.Recovering("QDomDocument::createAttributeNS")
+
+	if ptr.Pointer() != nil {
+		return NewQDomAttrFromPointer(C.QDomDocument_CreateAttributeNS(ptr.Pointer(), C.CString(nsURI), C.CString(qName)))
+	}
+	return nil
+}
+
+func (ptr *QDomDocument) CreateCDATASection(value string) *QDomCDATASection {
+	defer qt.Recovering("QDomDocument::createCDATASection")
+
+	if ptr.Pointer() != nil {
+		return NewQDomCDATASectionFromPointer(C.QDomDocument_CreateCDATASection(ptr.Pointer(), C.CString(value)))
+	}
+	return nil
+}
+
+func (ptr *QDomDocument) CreateComment(value string) *QDomComment {
+	defer qt.Recovering("QDomDocument::createComment")
+
+	if ptr.Pointer() != nil {
+		return NewQDomCommentFromPointer(C.QDomDocument_CreateComment(ptr.Pointer(), C.CString(value)))
+	}
+	return nil
+}
+
+func (ptr *QDomDocument) CreateDocumentFragment() *QDomDocumentFragment {
+	defer qt.Recovering("QDomDocument::createDocumentFragment")
+
+	if ptr.Pointer() != nil {
+		return NewQDomDocumentFragmentFromPointer(C.QDomDocument_CreateDocumentFragment(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomDocument) CreateElement(tagName string) *QDomElement {
+	defer qt.Recovering("QDomDocument::createElement")
+
+	if ptr.Pointer() != nil {
+		return NewQDomElementFromPointer(C.QDomDocument_CreateElement(ptr.Pointer(), C.CString(tagName)))
+	}
+	return nil
+}
+
+func (ptr *QDomDocument) CreateElementNS(nsURI string, qName string) *QDomElement {
+	defer qt.Recovering("QDomDocument::createElementNS")
+
+	if ptr.Pointer() != nil {
+		return NewQDomElementFromPointer(C.QDomDocument_CreateElementNS(ptr.Pointer(), C.CString(nsURI), C.CString(qName)))
+	}
+	return nil
+}
+
+func (ptr *QDomDocument) CreateEntityReference(name string) *QDomEntityReference {
+	defer qt.Recovering("QDomDocument::createEntityReference")
+
+	if ptr.Pointer() != nil {
+		return NewQDomEntityReferenceFromPointer(C.QDomDocument_CreateEntityReference(ptr.Pointer(), C.CString(name)))
+	}
+	return nil
+}
+
+func (ptr *QDomDocument) CreateProcessingInstruction(target string, data string) *QDomProcessingInstruction {
+	defer qt.Recovering("QDomDocument::createProcessingInstruction")
+
+	if ptr.Pointer() != nil {
+		return NewQDomProcessingInstructionFromPointer(C.QDomDocument_CreateProcessingInstruction(ptr.Pointer(), C.CString(target), C.CString(data)))
+	}
+	return nil
+}
+
+func (ptr *QDomDocument) CreateTextNode(value string) *QDomText {
+	defer qt.Recovering("QDomDocument::createTextNode")
+
+	if ptr.Pointer() != nil {
+		return NewQDomTextFromPointer(C.QDomDocument_CreateTextNode(ptr.Pointer(), C.CString(value)))
+	}
+	return nil
+}
+
+func (ptr *QDomDocument) Doctype() *QDomDocumentType {
+	defer qt.Recovering("QDomDocument::doctype")
+
+	if ptr.Pointer() != nil {
+		return NewQDomDocumentTypeFromPointer(C.QDomDocument_Doctype(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomDocument) DocumentElement() *QDomElement {
+	defer qt.Recovering("QDomDocument::documentElement")
+
+	if ptr.Pointer() != nil {
+		return NewQDomElementFromPointer(C.QDomDocument_DocumentElement(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomDocument) ElementById(elementId string) *QDomElement {
+	defer qt.Recovering("QDomDocument::elementById")
+
+	if ptr.Pointer() != nil {
+		return NewQDomElementFromPointer(C.QDomDocument_ElementById(ptr.Pointer(), C.CString(elementId)))
+	}
+	return nil
+}
+
+func (ptr *QDomDocument) ElementsByTagName(tagname string) *QDomNodeList {
+	defer qt.Recovering("QDomDocument::elementsByTagName")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeListFromPointer(C.QDomDocument_ElementsByTagName(ptr.Pointer(), C.CString(tagname)))
+	}
+	return nil
+}
+
+func (ptr *QDomDocument) ElementsByTagNameNS(nsURI string, localName string) *QDomNodeList {
+	defer qt.Recovering("QDomDocument::elementsByTagNameNS")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeListFromPointer(C.QDomDocument_ElementsByTagNameNS(ptr.Pointer(), C.CString(nsURI), C.CString(localName)))
+	}
+	return nil
+}
+
+func (ptr *QDomDocument) Implementation() *QDomImplementation {
+	defer qt.Recovering("QDomDocument::implementation")
+
+	if ptr.Pointer() != nil {
+		return NewQDomImplementationFromPointer(C.QDomDocument_Implementation(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomDocument) ImportNode(importedNode QDomNode_ITF, deep bool) *QDomNode {
+	defer qt.Recovering("QDomDocument::importNode")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomDocument_ImportNode(ptr.Pointer(), PointerFromQDomNode(importedNode), C.int(qt.GoBoolToInt(deep))))
+	}
+	return nil
+}
+
 func (ptr *QDomDocument) NodeType() QDomNode__NodeType {
 	defer qt.Recovering("QDomDocument::nodeType")
 
@@ -386,20 +548,20 @@ func (ptr *QDomDocument) SetContent4(source QXmlInputSource_ITF, namespaceProces
 	return false
 }
 
-func (ptr *QDomDocument) SetContent6(buffer core.QByteArray_ITF, errorMsg string, errorLine int, errorColumn int) bool {
+func (ptr *QDomDocument) SetContent6(buffer string, errorMsg string, errorLine int, errorColumn int) bool {
 	defer qt.Recovering("QDomDocument::setContent")
 
 	if ptr.Pointer() != nil {
-		return C.QDomDocument_SetContent6(ptr.Pointer(), core.PointerFromQByteArray(buffer), C.CString(errorMsg), C.int(errorLine), C.int(errorColumn)) != 0
+		return C.QDomDocument_SetContent6(ptr.Pointer(), C.CString(buffer), C.CString(errorMsg), C.int(errorLine), C.int(errorColumn)) != 0
 	}
 	return false
 }
 
-func (ptr *QDomDocument) SetContent(data core.QByteArray_ITF, namespaceProcessing bool, errorMsg string, errorLine int, errorColumn int) bool {
+func (ptr *QDomDocument) SetContent(data string, namespaceProcessing bool, errorMsg string, errorLine int, errorColumn int) bool {
 	defer qt.Recovering("QDomDocument::setContent")
 
 	if ptr.Pointer() != nil {
-		return C.QDomDocument_SetContent(ptr.Pointer(), core.PointerFromQByteArray(data), C.int(qt.GoBoolToInt(namespaceProcessing)), C.CString(errorMsg), C.int(errorLine), C.int(errorColumn)) != 0
+		return C.QDomDocument_SetContent(ptr.Pointer(), C.CString(data), C.int(qt.GoBoolToInt(namespaceProcessing)), C.CString(errorMsg), C.int(errorLine), C.int(errorColumn)) != 0
 	}
 	return false
 }
@@ -422,13 +584,13 @@ func (ptr *QDomDocument) SetContent2(text string, namespaceProcessing bool, erro
 	return false
 }
 
-func (ptr *QDomDocument) ToByteArray(indent int) *core.QByteArray {
+func (ptr *QDomDocument) ToByteArray(indent int) string {
 	defer qt.Recovering("QDomDocument::toByteArray")
 
 	if ptr.Pointer() != nil {
-		return core.NewQByteArrayFromPointer(C.QDomDocument_ToByteArray(ptr.Pointer(), C.int(indent)))
+		return C.GoString(C.QDomDocument_ToByteArray(ptr.Pointer(), C.int(indent)))
 	}
-	return nil
+	return ""
 }
 
 func (ptr *QDomDocument) ToString(indent int) string {
@@ -543,6 +705,15 @@ func NewQDomDocumentType2(n QDomDocumentType_ITF) *QDomDocumentType {
 	return newQDomDocumentTypeFromPointer(C.QDomDocumentType_NewQDomDocumentType2(PointerFromQDomDocumentType(n)))
 }
 
+func (ptr *QDomDocumentType) Entities() *QDomNamedNodeMap {
+	defer qt.Recovering("QDomDocumentType::entities")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNamedNodeMapFromPointer(C.QDomDocumentType_Entities(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QDomDocumentType) InternalSubset() string {
 	defer qt.Recovering("QDomDocumentType::internalSubset")
 
@@ -570,6 +741,15 @@ func (ptr *QDomDocumentType) NodeType() QDomNode__NodeType {
 	return 0
 }
 
+func (ptr *QDomDocumentType) Notations() *QDomNamedNodeMap {
+	defer qt.Recovering("QDomDocumentType::notations")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNamedNodeMapFromPointer(C.QDomDocumentType_Notations(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QDomDocumentType) PublicId() string {
 	defer qt.Recovering("QDomDocumentType::publicId")
 
@@ -649,6 +829,51 @@ func (ptr *QDomElement) AttributeNS(nsURI string, localName string, defValue str
 	return ""
 }
 
+func (ptr *QDomElement) AttributeNode(name string) *QDomAttr {
+	defer qt.Recovering("QDomElement::attributeNode")
+
+	if ptr.Pointer() != nil {
+		return NewQDomAttrFromPointer(C.QDomElement_AttributeNode(ptr.Pointer(), C.CString(name)))
+	}
+	return nil
+}
+
+func (ptr *QDomElement) AttributeNodeNS(nsURI string, localName string) *QDomAttr {
+	defer qt.Recovering("QDomElement::attributeNodeNS")
+
+	if ptr.Pointer() != nil {
+		return NewQDomAttrFromPointer(C.QDomElement_AttributeNodeNS(ptr.Pointer(), C.CString(nsURI), C.CString(localName)))
+	}
+	return nil
+}
+
+func (ptr *QDomElement) Attributes() *QDomNamedNodeMap {
+	defer qt.Recovering("QDomElement::attributes")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNamedNodeMapFromPointer(C.QDomElement_Attributes(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomElement) ElementsByTagName(tagname string) *QDomNodeList {
+	defer qt.Recovering("QDomElement::elementsByTagName")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeListFromPointer(C.QDomElement_ElementsByTagName(ptr.Pointer(), C.CString(tagname)))
+	}
+	return nil
+}
+
+func (ptr *QDomElement) ElementsByTagNameNS(nsURI string, localName string) *QDomNodeList {
+	defer qt.Recovering("QDomElement::elementsByTagNameNS")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeListFromPointer(C.QDomElement_ElementsByTagNameNS(ptr.Pointer(), C.CString(nsURI), C.CString(localName)))
+	}
+	return nil
+}
+
 func (ptr *QDomElement) HasAttribute(name string) bool {
 	defer qt.Recovering("QDomElement::hasAttribute")
 
@@ -692,6 +917,15 @@ func (ptr *QDomElement) RemoveAttributeNS(nsURI string, localName string) {
 	}
 }
 
+func (ptr *QDomElement) RemoveAttributeNode(oldAttr QDomAttr_ITF) *QDomAttr {
+	defer qt.Recovering("QDomElement::removeAttributeNode")
+
+	if ptr.Pointer() != nil {
+		return NewQDomAttrFromPointer(C.QDomElement_RemoveAttributeNode(ptr.Pointer(), PointerFromQDomAttr(oldAttr)))
+	}
+	return nil
+}
+
 func (ptr *QDomElement) SetAttribute(name string, value string) {
 	defer qt.Recovering("QDomElement::setAttribute")
 
@@ -724,6 +958,24 @@ func (ptr *QDomElement) SetAttributeNS2(nsURI string, qName string, value int) {
 	}
 }
 
+func (ptr *QDomElement) SetAttributeNode(newAttr QDomAttr_ITF) *QDomAttr {
+	defer qt.Recovering("QDomElement::setAttributeNode")
+
+	if ptr.Pointer() != nil {
+		return NewQDomAttrFromPointer(C.QDomElement_SetAttributeNode(ptr.Pointer(), PointerFromQDomAttr(newAttr)))
+	}
+	return nil
+}
+
+func (ptr *QDomElement) SetAttributeNodeNS(newAttr QDomAttr_ITF) *QDomAttr {
+	defer qt.Recovering("QDomElement::setAttributeNodeNS")
+
+	if ptr.Pointer() != nil {
+		return NewQDomAttrFromPointer(C.QDomElement_SetAttributeNodeNS(ptr.Pointer(), PointerFromQDomAttr(newAttr)))
+	}
+	return nil
+}
+
 func (ptr *QDomElement) SetTagName(name string) {
 	defer qt.Recovering("QDomElement::setTagName")
 
@@ -940,6 +1192,24 @@ func NewQDomImplementation2(x QDomImplementation_ITF) *QDomImplementation {
 	return newQDomImplementationFromPointer(C.QDomImplementation_NewQDomImplementation2(PointerFromQDomImplementation(x)))
 }
 
+func (ptr *QDomImplementation) CreateDocument(nsURI string, qName string, doctype QDomDocumentType_ITF) *QDomDocument {
+	defer qt.Recovering("QDomImplementation::createDocument")
+
+	if ptr.Pointer() != nil {
+		return NewQDomDocumentFromPointer(C.QDomImplementation_CreateDocument(ptr.Pointer(), C.CString(nsURI), C.CString(qName), PointerFromQDomDocumentType(doctype)))
+	}
+	return nil
+}
+
+func (ptr *QDomImplementation) CreateDocumentType(qName string, publicId string, systemId string) *QDomDocumentType {
+	defer qt.Recovering("QDomImplementation::createDocumentType")
+
+	if ptr.Pointer() != nil {
+		return NewQDomDocumentTypeFromPointer(C.QDomImplementation_CreateDocumentType(ptr.Pointer(), C.CString(qName), C.CString(publicId), C.CString(systemId)))
+	}
+	return nil
+}
+
 func (ptr *QDomImplementation) HasFeature(feature string, version string) bool {
 	defer qt.Recovering("QDomImplementation::hasFeature")
 
@@ -1055,6 +1325,15 @@ func (ptr *QDomNamedNodeMap) IsEmpty() bool {
 	return false
 }
 
+func (ptr *QDomNamedNodeMap) Item(index int) *QDomNode {
+	defer qt.Recovering("QDomNamedNodeMap::item")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNamedNodeMap_Item(ptr.Pointer(), C.int(index)))
+	}
+	return nil
+}
+
 func (ptr *QDomNamedNodeMap) Length() int {
 	defer qt.Recovering("QDomNamedNodeMap::length")
 
@@ -1064,6 +1343,60 @@ func (ptr *QDomNamedNodeMap) Length() int {
 	return 0
 }
 
+func (ptr *QDomNamedNodeMap) NamedItem(name string) *QDomNode {
+	defer qt.Recovering("QDomNamedNodeMap::namedItem")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNamedNodeMap_NamedItem(ptr.Pointer(), C.CString(name)))
+	}
+	return nil
+}
+
+func (ptr *QDomNamedNodeMap) NamedItemNS(nsURI string, localName string) *QDomNode {
+	defer qt.Recovering("QDomNamedNodeMap::namedItemNS")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNamedNodeMap_NamedItemNS(ptr.Pointer(), C.CString(nsURI), C.CString(localName)))
+	}
+	return nil
+}
+
+func (ptr *QDomNamedNodeMap) RemoveNamedItem(name string) *QDomNode {
+	defer qt.Recovering("QDomNamedNodeMap::removeNamedItem")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNamedNodeMap_RemoveNamedItem(ptr.Pointer(), C.CString(name)))
+	}
+	return nil
+}
+
+func (ptr *QDomNamedNodeMap) RemoveNamedItemNS(nsURI string, localName string) *QDomNode {
+	defer qt.Recovering("QDomNamedNodeMap::removeNamedItemNS")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNamedNodeMap_RemoveNamedItemNS(ptr.Pointer(), C.CString(nsURI), C.CString(localName)))
+	}
+	return nil
+}
+
+func (ptr *QDomNamedNodeMap) SetNamedItem(newNode QDomNode_ITF) *QDomNode {
+	defer qt.Recovering("QDomNamedNodeMap::setNamedItem")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNamedNodeMap_SetNamedItem(ptr.Pointer(), PointerFromQDomNode(newNode)))
+	}
+	return nil
+}
+
+func (ptr *QDomNamedNodeMap) SetNamedItemNS(newNode QDomNode_ITF) *QDomNode {
+	defer qt.Recovering("QDomNamedNodeMap::setNamedItemNS")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNamedNodeMap_SetNamedItemNS(ptr.Pointer(), PointerFromQDomNode(newNode)))
+	}
+	return nil
+}
+
 func (ptr *QDomNamedNodeMap) Size() int {
 	defer qt.Recovering("QDomNamedNodeMap::size")
 
@@ -1159,6 +1492,33 @@ func NewQDomNode2(n QDomNode_ITF) *QDomNode {
 	return newQDomNodeFromPointer(C.QDomNode_NewQDomNode2(PointerFromQDomNode(n)))
 }
 
+func (ptr *QDomNode) AppendChild(newChild QDomNode_ITF) *QDomNode {
+	defer qt.Recovering("QDomNode::appendChild")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNode_AppendChild(ptr.Pointer(), PointerFromQDomNode(newChild)))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) Attributes() *QDomNamedNodeMap {
+	defer qt.Recovering("QDomNode::attributes")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNamedNodeMapFromPointer(C.QDomNode_Attributes(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) ChildNodes() *QDomNodeList {
+	defer qt.Recovering("QDomNode::childNodes")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeListFromPointer(C.QDomNode_ChildNodes(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QDomNode) Clear() {
 	defer qt.Recovering("QDomNode::clear")
 
@@ -1167,6 +1527,15 @@ func (ptr *QDomNode) Clear() {
 	}
 }
 
+func (ptr *QDomNode) CloneNode(deep bool) *QDomNode {
+	defer qt.Recovering("QDomNode::cloneNode")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNode_CloneNode(ptr.Pointer(), C.int(qt.GoBoolToInt(deep))))
+	}
+	return nil
+}
+
 func (ptr *QDomNode) ColumnNumber() int {
 	defer qt.Recovering("QDomNode::columnNumber")
 
@@ -1176,6 +1545,24 @@ func (ptr *QDomNode) ColumnNumber() int {
 	return 0
 }
 
+func (ptr *QDomNode) FirstChild() *QDomNode {
+	defer qt.Recovering("QDomNode::firstChild")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNode_FirstChild(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) FirstChildElement(tagName string) *QDomElement {
+	defer qt.Recovering("QDomNode::firstChildElement")
+
+	if ptr.Pointer() != nil {
+		return NewQDomElementFromPointer(C.QDomNode_FirstChildElement(ptr.Pointer(), C.CString(tagName)))
+	}
+	return nil
+}
+
 func (ptr *QDomNode) HasAttributes() bool {
 	defer qt.Recovering("QDomNode::hasAttributes")
 
@@ -1194,6 +1581,24 @@ func (ptr *QDomNode) HasChildNodes() bool {
 	return false
 }
 
+func (ptr *QDomNode) InsertAfter(newChild QDomNode_ITF, refChild QDomNode_ITF) *QDomNode {
+	defer qt.Recovering("QDomNode::insertAfter")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNode_InsertAfter(ptr.Pointer(), PointerFromQDomNode(newChild), PointerFromQDomNode(refChild)))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) InsertBefore(newChild QDomNode_ITF, refChild QDomNode_ITF) *QDomNode {
+	defer qt.Recovering("QDomNode::insertBefore")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNode_InsertBefore(ptr.Pointer(), PointerFromQDomNode(newChild), PointerFromQDomNode(refChild)))
+	}
+	return nil
+}
+
 func (ptr *QDomNode) IsAttr() bool {
 	defer qt.Recovering("QDomNode::isAttr")
 
@@ -1329,6 +1734,24 @@ func (ptr *QDomNode) IsText() bool {
 	return false
 }
 
+func (ptr *QDomNode) LastChild() *QDomNode {
+	defer qt.Recovering("QDomNode::lastChild")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNode_LastChild(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) LastChildElement(tagName string) *QDomElement {
+	defer qt.Recovering("QDomNode::lastChildElement")
+
+	if ptr.Pointer() != nil {
+		return NewQDomElementFromPointer(C.QDomNode_LastChildElement(ptr.Pointer(), C.CString(tagName)))
+	}
+	return nil
+}
+
 func (ptr *QDomNode) LineNumber() int {
 	defer qt.Recovering("QDomNode::lineNumber")
 
@@ -1347,6 +1770,15 @@ func (ptr *QDomNode) LocalName() string {
 	return ""
 }
 
+func (ptr *QDomNode) NamedItem(name string) *QDomNode {
+	defer qt.Recovering("QDomNode::namedItem")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNode_NamedItem(ptr.Pointer(), C.CString(name)))
+	}
+	return nil
+}
+
 func (ptr *QDomNode) NamespaceURI() string {
 	defer qt.Recovering("QDomNode::namespaceURI")
 
@@ -1356,6 +1788,24 @@ func (ptr *QDomNode) NamespaceURI() string {
 	return ""
 }
 
+func (ptr *QDomNode) NextSibling() *QDomNode {
+	defer qt.Recovering("QDomNode::nextSibling")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNode_NextSibling(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) NextSiblingElement(tagName string) *QDomElement {
+	defer qt.Recovering("QDomNode::nextSiblingElement")
+
+	if ptr.Pointer() != nil {
+		return NewQDomElementFromPointer(C.QDomNode_NextSiblingElement(ptr.Pointer(), C.CString(tagName)))
+	}
+	return nil
+}
+
 func (ptr *QDomNode) NodeName() string {
 	defer qt.Recovering("QDomNode::nodeName")
 
@@ -1391,6 +1841,24 @@ func (ptr *QDomNode) Normalize() {
 	}
 }
 
+func (ptr *QDomNode) OwnerDocument() *QDomDocument {
+	defer qt.Recovering("QDomNode::ownerDocument")
+
+	if ptr.Pointer() != nil {
+		return NewQDomDocumentFromPointer(C.QDomNode_OwnerDocument(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) ParentNode() *QDomNode {
+	defer qt.Recovering("QDomNode::parentNode")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNode_ParentNode(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QDomNode) Prefix() string {
 	defer qt.Recovering("QDomNode::prefix")
 
@@ -1400,6 +1868,42 @@ func (ptr *QDomNode) Prefix() string {
 	return ""
 }
 
+func (ptr *QDomNode) PreviousSibling() *QDomNode {
+	defer qt.Recovering("QDomNode::previousSibling")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNode_PreviousSibling(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) PreviousSiblingElement(tagName string) *QDomElement {
+	defer qt.Recovering("QDomNode::previousSiblingElement")
+
+	if ptr.Pointer() != nil {
+		return NewQDomElementFromPointer(C.QDomNode_PreviousSiblingElement(ptr.Pointer(), C.CString(tagName)))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) RemoveChild(oldChild QDomNode_ITF) *QDomNode {
+	defer qt.Recovering("QDomNode::removeChild")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNode_RemoveChild(ptr.Pointer(), PointerFromQDomNode(oldChild)))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) ReplaceChild(newChild QDomNode_ITF, oldChild QDomNode_ITF) *QDomNode {
+	defer qt.Recovering("QDomNode::replaceChild")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNode_ReplaceChild(ptr.Pointer(), PointerFromQDomNode(newChild), PointerFromQDomNode(oldChild)))
+	}
+	return nil
+}
+
 func (ptr *QDomNode) Save(stream core.QTextStream_ITF, indent int, encodingPolicy QDomNode__EncodingPolicy) {
 	defer qt.Recovering("QDomNode::save")
 
@@ -1424,6 +1928,123 @@ func (ptr *QDomNode) SetPrefix(pre string) {
 	}
 }
 
+func (ptr *QDomNode) ToAttr() *QDomAttr {
+	defer qt.Recovering("QDomNode::toAttr")
+
+	if ptr.Pointer() != nil {
+		return NewQDomAttrFromPointer(C.QDomNode_ToAttr(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) ToCDATASection() *QDomCDATASection {
+	defer qt.Recovering("QDomNode::toCDATASection")
+
+	if ptr.Pointer() != nil {
+		return NewQDomCDATASectionFromPointer(C.QDomNode_ToCDATASection(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) ToCharacterData() *QDomCharacterData {
+	defer qt.Recovering("QDomNode::toCharacterData")
+
+	if ptr.Pointer() != nil {
+		return NewQDomCharacterDataFromPointer(C.QDomNode_ToCharacterData(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) ToComment() *QDomComment {
+	defer qt.Recovering("QDomNode::toComment")
+
+	if ptr.Pointer() != nil {
+		return NewQDomCommentFromPointer(C.QDomNode_ToComment(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) ToDocument() *QDomDocument {
+	defer qt.Recovering("QDomNode::toDocument")
+
+	if ptr.Pointer() != nil {
+		return NewQDomDocumentFromPointer(C.QDomNode_ToDocument(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) ToDocumentFragment() *QDomDocumentFragment {
+	defer qt.Recovering("QDomNode::toDocumentFragment")
+
+	if ptr.Pointer() != nil {
+		return NewQDomDocumentFragmentFromPointer(C.QDomNode_ToDocumentFragment(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) ToDocumentType() *QDomDocumentType {
+	defer qt.Recovering("QDomNode::toDocumentType")
+
+	if ptr.Pointer() != nil {
+		return NewQDomDocumentTypeFromPointer(C.QDomNode_ToDocumentType(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) ToElement() *QDomElement {
+	defer qt.Recovering("QDomNode::toElement")
+
+	if ptr.Pointer() != nil {
+		return NewQDomElementFromPointer(C.QDomNode_ToElement(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) ToEntity() *QDomEntity {
+	defer qt.Recovering("QDomNode::toEntity")
+
+	if ptr.Pointer() != nil {
+		return NewQDomEntityFromPointer(C.QDomNode_ToEntity(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) ToEntityReference() *QDomEntityReference {
+	defer qt.Recovering("QDomNode::toEntityReference")
+
+	if ptr.Pointer() != nil {
+		return NewQDomEntityReferenceFromPointer(C.QDomNode_ToEntityReference(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) ToNotation() *QDomNotation {
+	defer qt.Recovering("QDomNode::toNotation")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNotationFromPointer(C.QDomNode_ToNotation(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) ToProcessingInstruction() *QDomProcessingInstruction {
+	defer qt.Recovering("QDomNode::toProcessingInstruction")
+
+	if ptr.Pointer() != nil {
+		return NewQDomProcessingInstructionFromPointer(C.QDomNode_ToProcessingInstruction(ptr.Pointer()))
+	}
+	return nil
+}
+
+func (ptr *QDomNode) ToText() *QDomText {
+	defer qt.Recovering("QDomNode::toText")
+
+	if ptr.Pointer() != nil {
+		return NewQDomTextFromPointer(C.QDomNode_ToText(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QDomNode) DestroyQDomNode() {
 	defer qt.Recovering("QDomNode::~QDomNode")
 
@@ -1482,6 +2103,15 @@ func NewQDomNodeList2(n QDomNodeList_ITF) *QDomNodeList {
 	return newQDomNodeListFromPointer(C.QDomNodeList_NewQDomNodeList2(PointerFromQDomNodeList(n)))
 }
 
+func (ptr *QDomNodeList) At(index int) *QDomNode {
+	defer qt.Recovering("QDomNodeList::at")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNodeList_At(ptr.Pointer(), C.int(index)))
+	}
+	return nil
+}
+
 func (ptr *QDomNodeList) Count() int {
 	defer qt.Recovering("QDomNodeList::count")
 
@@ -1500,6 +2130,15 @@ func (ptr *QDomNodeList) IsEmpty() bool {
 	return false
 }
 
+func (ptr *QDomNodeList) Item(index int) *QDomNode {
+	defer qt.Recovering("QDomNodeList::item")
+
+	if ptr.Pointer() != nil {
+		return NewQDomNodeFromPointer(C.QDomNodeList_Item(ptr.Pointer(), C.int(index)))
+	}
+	return nil
+}
+
 func (ptr *QDomNodeList) Length() int {
 	defer qt.Recovering("QDomNodeList::length")
 
@@ -1726,6 +2365,15 @@ func (ptr *QDomText) NodeType() QDomNode__NodeType {
 	return 0
 }
 
+func (ptr *QDomText) SplitText(offset int) *QDomText {
+	defer qt.Recovering("QDomText::splitText")
+
+	if ptr.Pointer() != nil {
+		return NewQDomTextFromPointer(C.QDomText_SplitText(ptr.Pointer(), C.int(offset)))
+	}
+	return nil
+}
+
 type QXmlAttributes struct {
 	ptr unsafe.Pointer
 }
@@ -2968,11 +3616,11 @@ func (ptr *QXmlInputSource) FetchDataDefault() {
 	}
 }
 
-func (ptr *QXmlInputSource) FromRawData(data core.QByteArray_ITF, beginning bool) string {
+func (ptr *QXmlInputSource) FromRawData(data string, beginning bool) string {
 	defer qt.Recovering("QXmlInputSource::fromRawData")
 
 	if ptr.Pointer() != nil {
-		return C.GoString(C.QXmlInputSource_FromRawData(ptr.Pointer(), core.PointerFromQByteArray(data), C.int(qt.GoBoolToInt(beginning))))
+		return C.GoString(C.QXmlInputSource_FromRawData(ptr.Pointer(), C.CString(data), C.int(qt.GoBoolToInt(beginning))))
 	}
 	return ""
 }

xml/xml.h

@@ -11,6 +11,7 @@ void* QDomAttr_NewQDomAttr();
 void* QDomAttr_NewQDomAttr2(void* x);
 char* QDomAttr_Name(void* ptr);
 int QDomAttr_NodeType(void* ptr);
+void* QDomAttr_OwnerElement(void* ptr);
 void QDomAttr_SetValue(void* ptr, char* v);
 int QDomAttr_Specified(void* ptr);
 char* QDomAttr_Value(void* ptr);
@@ -31,16 +32,33 @@ void* QDomDocument_NewQDomDocument();
 void* QDomDocument_NewQDomDocument4(void* x);
 void* QDomDocument_NewQDomDocument3(void* doctype);
 void* QDomDocument_NewQDomDocument2(char* name);
+void* QDomDocument_CreateAttribute(void* ptr, char* name);
+void* QDomDocument_CreateAttributeNS(void* ptr, char* nsURI, char* qName);
+void* QDomDocument_CreateCDATASection(void* ptr, char* value);
+void* QDomDocument_CreateComment(void* ptr, char* value);
+void* QDomDocument_CreateDocumentFragment(void* ptr);
+void* QDomDocument_CreateElement(void* ptr, char* tagName);
+void* QDomDocument_CreateElementNS(void* ptr, char* nsURI, char* qName);
+void* QDomDocument_CreateEntityReference(void* ptr, char* name);
+void* QDomDocument_CreateProcessingInstruction(void* ptr, char* target, char* data);
+void* QDomDocument_CreateTextNode(void* ptr, char* value);
+void* QDomDocument_Doctype(void* ptr);
+void* QDomDocument_DocumentElement(void* ptr);
+void* QDomDocument_ElementById(void* ptr, char* elementId);
+void* QDomDocument_ElementsByTagName(void* ptr, char* tagname);
+void* QDomDocument_ElementsByTagNameNS(void* ptr, char* nsURI, char* localName);
+void* QDomDocument_Implementation(void* ptr);
+void* QDomDocument_ImportNode(void* ptr, void* importedNode, int deep);
 int QDomDocument_NodeType(void* ptr);
 int QDomDocument_SetContent7(void* ptr, void* dev, char* errorMsg, int errorLine, int errorColumn);
 int QDomDocument_SetContent3(void* ptr, void* dev, int namespaceProcessing, char* errorMsg, int errorLine, int errorColumn);
 int QDomDocument_SetContent8(void* ptr, void* source, void* reader, char* errorMsg, int errorLine, int errorColumn);
 int QDomDocument_SetContent4(void* ptr, void* source, int namespaceProcessing, char* errorMsg, int errorLine, int errorColumn);
-int QDomDocument_SetContent6(void* ptr, void* buffer, char* errorMsg, int errorLine, int errorColumn);
-int QDomDocument_SetContent(void* ptr, void* data, int namespaceProcessing, char* errorMsg, int errorLine, int errorColumn);
+int QDomDocument_SetContent6(void* ptr, char* buffer, char* errorMsg, int errorLine, int errorColumn);
+int QDomDocument_SetContent(void* ptr, char* data, int namespaceProcessing, char* errorMsg, int errorLine, int errorColumn);
 int QDomDocument_SetContent5(void* ptr, char* text, char* errorMsg, int errorLine, int errorColumn);
 int QDomDocument_SetContent2(void* ptr, char* text, int namespaceProcessing, char* errorMsg, int errorLine, int errorColumn);
-void* QDomDocument_ToByteArray(void* ptr, int indent);
+char* QDomDocument_ToByteArray(void* ptr, int indent);
 char* QDomDocument_ToString(void* ptr, int indent);
 void QDomDocument_DestroyQDomDocument(void* ptr);
 void* QDomDocumentFragment_NewQDomDocumentFragment();
@@ -48,24 +66,34 @@ void* QDomDocumentFragment_NewQDomDocumentFragment2(void* x);
 int QDomDocumentFragment_NodeType(void* ptr);
 void* QDomDocumentType_NewQDomDocumentType();
 void* QDomDocumentType_NewQDomDocumentType2(void* n);
+void* QDomDocumentType_Entities(void* ptr);
 char* QDomDocumentType_InternalSubset(void* ptr);
 char* QDomDocumentType_Name(void* ptr);
 int QDomDocumentType_NodeType(void* ptr);
+void* QDomDocumentType_Notations(void* ptr);
 char* QDomDocumentType_PublicId(void* ptr);
 char* QDomDocumentType_SystemId(void* ptr);
 void* QDomElement_NewQDomElement();
 void* QDomElement_NewQDomElement2(void* x);
 char* QDomElement_Attribute(void* ptr, char* name, char* defValue);
 char* QDomElement_AttributeNS(void* ptr, char* nsURI, char* localName, char* defValue);
+void* QDomElement_AttributeNode(void* ptr, char* name);
+void* QDomElement_AttributeNodeNS(void* ptr, char* nsURI, char* localName);
+void* QDomElement_Attributes(void* ptr);
+void* QDomElement_ElementsByTagName(void* ptr, char* tagname);
+void* QDomElement_ElementsByTagNameNS(void* ptr, char* nsURI, char* localName);
 int QDomElement_HasAttribute(void* ptr, char* name);
 int QDomElement_HasAttributeNS(void* ptr, char* nsURI, char* localName);
 int QDomElement_NodeType(void* ptr);
 void QDomElement_RemoveAttribute(void* ptr, char* name);
 void QDomElement_RemoveAttributeNS(void* ptr, char* nsURI, char* localName);
+void* QDomElement_RemoveAttributeNode(void* ptr, void* oldAttr);
 void QDomElement_SetAttribute(void* ptr, char* name, char* value);
 void QDomElement_SetAttribute2(void* ptr, char* name, int value);
 void QDomElement_SetAttributeNS(void* ptr, char* nsURI, char* qName, char* value);
 void QDomElement_SetAttributeNS2(void* ptr, char* nsURI, char* qName, int value);
+void* QDomElement_SetAttributeNode(void* ptr, void* newAttr);
+void* QDomElement_SetAttributeNodeNS(void* ptr, void* newAttr);
 void QDomElement_SetTagName(void* ptr, char* name);
 char* QDomElement_TagName(void* ptr);
 char* QDomElement_Text(void* ptr);
@@ -80,6 +108,8 @@ void* QDomEntityReference_NewQDomEntityReference2(void* x);
 int QDomEntityReference_NodeType(void* ptr);
 void* QDomImplementation_NewQDomImplementation();
 void* QDomImplementation_NewQDomImplementation2(void* x);
+void* QDomImplementation_CreateDocument(void* ptr, char* nsURI, char* qName, void* doctype);
+void* QDomImplementation_CreateDocumentType(void* ptr, char* qName, char* publicId, char* systemId);
 int QDomImplementation_HasFeature(void* ptr, char* feature, char* version);
 int QDomImplementation_QDomImplementation_InvalidDataPolicy();
 int QDomImplementation_IsNull(void* ptr);
@@ -90,15 +120,30 @@ void* QDomNamedNodeMap_NewQDomNamedNodeMap2(void* n);
 int QDomNamedNodeMap_Contains(void* ptr, char* name);
 int QDomNamedNodeMap_Count(void* ptr);
 int QDomNamedNodeMap_IsEmpty(void* ptr);
+void* QDomNamedNodeMap_Item(void* ptr, int index);
 int QDomNamedNodeMap_Length(void* ptr);
+void* QDomNamedNodeMap_NamedItem(void* ptr, char* name);
+void* QDomNamedNodeMap_NamedItemNS(void* ptr, char* nsURI, char* localName);
+void* QDomNamedNodeMap_RemoveNamedItem(void* ptr, char* name);
+void* QDomNamedNodeMap_RemoveNamedItemNS(void* ptr, char* nsURI, char* localName);
+void* QDomNamedNodeMap_SetNamedItem(void* ptr, void* newNode);
+void* QDomNamedNodeMap_SetNamedItemNS(void* ptr, void* newNode);
 int QDomNamedNodeMap_Size(void* ptr);
 void QDomNamedNodeMap_DestroyQDomNamedNodeMap(void* ptr);
 void* QDomNode_NewQDomNode();
 void* QDomNode_NewQDomNode2(void* n);
+void* QDomNode_AppendChild(void* ptr, void* newChild);
+void* QDomNode_Attributes(void* ptr);
+void* QDomNode_ChildNodes(void* ptr);
 void QDomNode_Clear(void* ptr);
+void* QDomNode_CloneNode(void* ptr, int deep);
 int QDomNode_ColumnNumber(void* ptr);
+void* QDomNode_FirstChild(void* ptr);
+void* QDomNode_FirstChildElement(void* ptr, char* tagName);
 int QDomNode_HasAttributes(void* ptr);
 int QDomNode_HasChildNodes(void* ptr);
+void* QDomNode_InsertAfter(void* ptr, void* newChild, void* refChild);
+void* QDomNode_InsertBefore(void* ptr, void* newChild, void* refChild);
 int QDomNode_IsAttr(void* ptr);
 int QDomNode_IsCDATASection(void* ptr);
 int QDomNode_IsCharacterData(void* ptr);
@@ -114,22 +159,48 @@ int QDomNode_IsNull(void* ptr);
 int QDomNode_IsProcessingInstruction(void* ptr);
 int QDomNode_IsSupported(void* ptr, char* feature, char* version);
 int QDomNode_IsText(void* ptr);
+void* QDomNode_LastChild(void* ptr);
+void* QDomNode_LastChildElement(void* ptr, char* tagName);
 int QDomNode_LineNumber(void* ptr);
 char* QDomNode_LocalName(void* ptr);
+void* QDomNode_NamedItem(void* ptr, char* name);
 char* QDomNode_NamespaceURI(void* ptr);
+void* QDomNode_NextSibling(void* ptr);
+void* QDomNode_NextSiblingElement(void* ptr, char* tagName);
 char* QDomNode_NodeName(void* ptr);
 int QDomNode_NodeType(void* ptr);
 char* QDomNode_NodeValue(void* ptr);
 void QDomNode_Normalize(void* ptr);
+void* QDomNode_OwnerDocument(void* ptr);
+void* QDomNode_ParentNode(void* ptr);
 char* QDomNode_Prefix(void* ptr);
+void* QDomNode_PreviousSibling(void* ptr);
+void* QDomNode_PreviousSiblingElement(void* ptr, char* tagName);
+void* QDomNode_RemoveChild(void* ptr, void* oldChild);
+void* QDomNode_ReplaceChild(void* ptr, void* newChild, void* oldChild);
 void QDomNode_Save(void* ptr, void* stream, int indent, int encodingPolicy);
 void QDomNode_SetNodeValue(void* ptr, char* v);
 void QDomNode_SetPrefix(void* ptr, char* pre);
+void* QDomNode_ToAttr(void* ptr);
+void* QDomNode_ToCDATASection(void* ptr);
+void* QDomNode_ToCharacterData(void* ptr);
+void* QDomNode_ToComment(void* ptr);
+void* QDomNode_ToDocument(void* ptr);
+void* QDomNode_ToDocumentFragment(void* ptr);
+void* QDomNode_ToDocumentType(void* ptr);
+void* QDomNode_ToElement(void* ptr);
+void* QDomNode_ToEntity(void* ptr);
+void* QDomNode_ToEntityReference(void* ptr);
+void* QDomNode_ToNotation(void* ptr);
+void* QDomNode_ToProcessingInstruction(void* ptr);
+void* QDomNode_ToText(void* ptr);
 void QDomNode_DestroyQDomNode(void* ptr);
 void* QDomNodeList_NewQDomNodeList();
 void* QDomNodeList_NewQDomNodeList2(void* n);
+void* QDomNodeList_At(void* ptr, int index);
 int QDomNodeList_Count(void* ptr);
 int QDomNodeList_IsEmpty(void* ptr);
+void* QDomNodeList_Item(void* ptr, int index);
 int QDomNodeList_Length(void* ptr);
 int QDomNodeList_Size(void* ptr);
 void QDomNodeList_DestroyQDomNodeList(void* ptr);
@@ -147,6 +218,7 @@ char* QDomProcessingInstruction_Target(void* ptr);
 void* QDomText_NewQDomText();
 void* QDomText_NewQDomText2(void* x);
 int QDomText_NodeType(void* ptr);
+void* QDomText_SplitText(void* ptr, int offset);
 void* QXmlAttributes_NewQXmlAttributes();
 void QXmlAttributes_DestroyQXmlAttributes(void* ptr);
 void QXmlAttributes_Append(void* ptr, char* qName, char* uri, char* localPart, char* value);
@@ -271,8 +343,8 @@ char* QXmlInputSource_Data(void* ptr);
 char* QXmlInputSource_DataDefault(void* ptr);
 void QXmlInputSource_FetchData(void* ptr);
 void QXmlInputSource_FetchDataDefault(void* ptr);
-char* QXmlInputSource_FromRawData(void* ptr, void* data, int beginning);
-char* QXmlInputSource_FromRawDataDefault(void* ptr, void* data, int beginning);
+char* QXmlInputSource_FromRawData(void* ptr, char* data, int beginning);
+char* QXmlInputSource_FromRawDataDefault(void* ptr, char* data, int beginning);
 void QXmlInputSource_Reset(void* ptr);
 void QXmlInputSource_ResetDefault(void* ptr);
 void QXmlInputSource_SetData(void* ptr, char* dat);

xmlpatterns/xmlpatterns.cpp

@@ -126,10 +126,22 @@ void* QAbstractXmlNodeModel_DocumentUri(void* ptr, void* n){
 	return new QUrl(static_cast<QAbstractXmlNodeModel*>(ptr)->documentUri(*static_cast<QXmlNodeModelIndex*>(n)));
 }
 
+void* QAbstractXmlNodeModel_ElementById(void* ptr, void* id){
+	return new QXmlNodeModelIndex(static_cast<QAbstractXmlNodeModel*>(ptr)->elementById(*static_cast<QXmlName*>(id)));
+}
+
 int QAbstractXmlNodeModel_Kind(void* ptr, void* ni){
 	return static_cast<QAbstractXmlNodeModel*>(ptr)->kind(*static_cast<QXmlNodeModelIndex*>(ni));
 }
 
+void* QAbstractXmlNodeModel_Root(void* ptr, void* n){
+	return new QXmlNodeModelIndex(static_cast<QAbstractXmlNodeModel*>(ptr)->root(*static_cast<QXmlNodeModelIndex*>(n)));
+}
+
+void* QAbstractXmlNodeModel_SourceLocation(void* ptr, void* index){
+	return new QSourceLocation(static_cast<QAbstractXmlNodeModel*>(ptr)->sourceLocation(*static_cast<QXmlNodeModelIndex*>(index)));
+}
+
 char* QAbstractXmlNodeModel_StringValue(void* ptr, void* n){
 	return static_cast<QAbstractXmlNodeModel*>(ptr)->stringValue(*static_cast<QXmlNodeModelIndex*>(n)).toUtf8().data();
 }
@@ -234,6 +246,14 @@ void* QSimpleXmlNodeModel_BaseUri(void* ptr, void* node){
 	return new QUrl(static_cast<QSimpleXmlNodeModel*>(ptr)->baseUri(*static_cast<QXmlNodeModelIndex*>(node)));
 }
 
+void* QSimpleXmlNodeModel_ElementById(void* ptr, void* id){
+	return new QXmlNodeModelIndex(static_cast<QSimpleXmlNodeModel*>(ptr)->elementById(*static_cast<QXmlName*>(id)));
+}
+
+void* QSimpleXmlNodeModel_NamePool(void* ptr){
+	return new QXmlNamePool(static_cast<QSimpleXmlNodeModel*>(ptr)->namePool());
+}
+
 char* QSimpleXmlNodeModel_StringValue(void* ptr, void* node){
 	return static_cast<QSimpleXmlNodeModel*>(ptr)->stringValue(*static_cast<QXmlNodeModelIndex*>(node)).toUtf8().data();
 }
@@ -419,6 +439,10 @@ int QXmlItem_IsNull(void* ptr){
 	return static_cast<QXmlItem*>(ptr)->isNull();
 }
 
+void* QXmlItem_ToNodeModelIndex(void* ptr){
+	return new QXmlNodeModelIndex(static_cast<QXmlItem*>(ptr)->toNodeModelIndex());
+}
+
 void QXmlItem_DestroyQXmlItem(void* ptr){
 	static_cast<QXmlItem*>(ptr)->~QXmlItem();
 }
@@ -543,6 +567,10 @@ void* QXmlQuery_MessageHandler(void* ptr){
 	return static_cast<QXmlQuery*>(ptr)->messageHandler();
 }
 
+void* QXmlQuery_NamePool(void* ptr){
+	return new QXmlNamePool(static_cast<QXmlQuery*>(ptr)->namePool());
+}
+
 void* QXmlQuery_NetworkAccessManager(void* ptr){
 	return static_cast<QXmlQuery*>(ptr)->networkAccessManager();
 }
@@ -619,10 +647,18 @@ void* QXmlResultItems_NewQXmlResultItems(){
 	return new MyQXmlResultItems();
 }
 
+void* QXmlResultItems_Current(void* ptr){
+	return new QXmlItem(static_cast<QXmlResultItems*>(ptr)->current());
+}
+
 int QXmlResultItems_HasError(void* ptr){
 	return static_cast<QXmlResultItems*>(ptr)->hasError();
 }
 
+void* QXmlResultItems_Next(void* ptr){
+	return new QXmlItem(static_cast<QXmlResultItems*>(ptr)->next());
+}
+
 void QXmlResultItems_DestroyQXmlResultItems(void* ptr){
 	static_cast<QXmlResultItems*>(ptr)->~QXmlResultItems();
 }
@@ -660,8 +696,8 @@ int QXmlSchema_Load2(void* ptr, void* source, void* documentUri){
 	return static_cast<QXmlSchema*>(ptr)->load(static_cast<QIODevice*>(source), *static_cast<QUrl*>(documentUri));
 }
 
-int QXmlSchema_Load3(void* ptr, void* data, void* documentUri){
-	return static_cast<QXmlSchema*>(ptr)->load(*static_cast<QByteArray*>(data), *static_cast<QUrl*>(documentUri));
+int QXmlSchema_Load3(void* ptr, char* data, void* documentUri){
+	return static_cast<QXmlSchema*>(ptr)->load(QByteArray(data), *static_cast<QUrl*>(documentUri));
 }
 
 int QXmlSchema_Load(void* ptr, void* source){
@@ -672,6 +708,10 @@ void* QXmlSchema_MessageHandler(void* ptr){
 	return static_cast<QXmlSchema*>(ptr)->messageHandler();
 }
 
+void* QXmlSchema_NamePool(void* ptr){
+	return new QXmlNamePool(static_cast<QXmlSchema*>(ptr)->namePool());
+}
+
 void* QXmlSchema_NetworkAccessManager(void* ptr){
 	return static_cast<QXmlSchema*>(ptr)->networkAccessManager();
 }
@@ -708,10 +748,18 @@ void* QXmlSchemaValidator_MessageHandler(void* ptr){
 	return static_cast<QXmlSchemaValidator*>(ptr)->messageHandler();
 }
 
+void* QXmlSchemaValidator_NamePool(void* ptr){
+	return new QXmlNamePool(static_cast<QXmlSchemaValidator*>(ptr)->namePool());
+}
+
 void* QXmlSchemaValidator_NetworkAccessManager(void* ptr){
 	return static_cast<QXmlSchemaValidator*>(ptr)->networkAccessManager();
 }
 
+void* QXmlSchemaValidator_Schema(void* ptr){
+	return new QXmlSchema(static_cast<QXmlSchemaValidator*>(ptr)->schema());
+}
+
 void QXmlSchemaValidator_SetMessageHandler(void* ptr, void* handler){
 	static_cast<QXmlSchemaValidator*>(ptr)->setMessageHandler(static_cast<QAbstractMessageHandler*>(handler));
 }
@@ -736,8 +784,8 @@ int QXmlSchemaValidator_Validate2(void* ptr, void* source, void* documentUri){
 	return static_cast<QXmlSchemaValidator*>(ptr)->validate(static_cast<QIODevice*>(source), *static_cast<QUrl*>(documentUri));
 }
 
-int QXmlSchemaValidator_Validate3(void* ptr, void* data, void* documentUri){
-	return static_cast<QXmlSchemaValidator*>(ptr)->validate(*static_cast<QByteArray*>(data), *static_cast<QUrl*>(documentUri));
+int QXmlSchemaValidator_Validate3(void* ptr, char* data, void* documentUri){
+	return static_cast<QXmlSchemaValidator*>(ptr)->validate(QByteArray(data), *static_cast<QUrl*>(documentUri));
 }
 
 int QXmlSchemaValidator_Validate(void* ptr, void* source){

xmlpatterns/xmlpatterns.go

@@ -445,6 +445,15 @@ func (ptr *QAbstractXmlNodeModel) DocumentUri(n QXmlNodeModelIndex_ITF) *core.QU
 	return nil
 }
 
+func (ptr *QAbstractXmlNodeModel) ElementById(id QXmlName_ITF) *QXmlNodeModelIndex {
+	defer qt.Recovering("QAbstractXmlNodeModel::elementById")
+
+	if ptr.Pointer() != nil {
+		return NewQXmlNodeModelIndexFromPointer(C.QAbstractXmlNodeModel_ElementById(ptr.Pointer(), PointerFromQXmlName(id)))
+	}
+	return nil
+}
+
 func (ptr *QAbstractXmlNodeModel) Kind(ni QXmlNodeModelIndex_ITF) QXmlNodeModelIndex__NodeKind {
 	defer qt.Recovering("QAbstractXmlNodeModel::kind")
 
@@ -454,6 +463,24 @@ func (ptr *QAbstractXmlNodeModel) Kind(ni QXmlNodeModelIndex_ITF) QXmlNodeModelI
 	return 0
 }
 
+func (ptr *QAbstractXmlNodeModel) Root(n QXmlNodeModelIndex_ITF) *QXmlNodeModelIndex {
+	defer qt.Recovering("QAbstractXmlNodeModel::root")
+
+	if ptr.Pointer() != nil {
+		return NewQXmlNodeModelIndexFromPointer(C.QAbstractXmlNodeModel_Root(ptr.Pointer(), PointerFromQXmlNodeModelIndex(n)))
+	}
+	return nil
+}
+
+func (ptr *QAbstractXmlNodeModel) SourceLocation(index QXmlNodeModelIndex_ITF) *QSourceLocation {
+	defer qt.Recovering("QAbstractXmlNodeModel::sourceLocation")
+
+	if ptr.Pointer() != nil {
+		return NewQSourceLocationFromPointer(C.QAbstractXmlNodeModel_SourceLocation(ptr.Pointer(), PointerFromQXmlNodeModelIndex(index)))
+	}
+	return nil
+}
+
 func (ptr *QAbstractXmlNodeModel) StringValue(n QXmlNodeModelIndex_ITF) string {
 	defer qt.Recovering("QAbstractXmlNodeModel::stringValue")
 
@@ -694,6 +721,24 @@ func (ptr *QSimpleXmlNodeModel) BaseUri(node QXmlNodeModelIndex_ITF) *core.QUrl
 	return nil
 }
 
+func (ptr *QSimpleXmlNodeModel) ElementById(id QXmlName_ITF) *QXmlNodeModelIndex {
+	defer qt.Recovering("QSimpleXmlNodeModel::elementById")
+
+	if ptr.Pointer() != nil {
+		return NewQXmlNodeModelIndexFromPointer(C.QSimpleXmlNodeModel_ElementById(ptr.Pointer(), PointerFromQXmlName(id)))
+	}
+	return nil
+}
+
+func (ptr *QSimpleXmlNodeModel) NamePool() *QXmlNamePool {
+	defer qt.Recovering("QSimpleXmlNodeModel::namePool")
+
+	if ptr.Pointer() != nil {
+		return NewQXmlNamePoolFromPointer(C.QSimpleXmlNodeModel_NamePool(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QSimpleXmlNodeModel) StringValue(node QXmlNodeModelIndex_ITF) string {
 	defer qt.Recovering("QSimpleXmlNodeModel::stringValue")
 
@@ -1321,6 +1366,15 @@ func (ptr *QXmlItem) IsNull() bool {
 	return false
 }
 
+func (ptr *QXmlItem) ToNodeModelIndex() *QXmlNodeModelIndex {
+	defer qt.Recovering("QXmlItem::toNodeModelIndex")
+
+	if ptr.Pointer() != nil {
+		return NewQXmlNodeModelIndexFromPointer(C.QXmlItem_ToNodeModelIndex(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QXmlItem) DestroyQXmlItem() {
 	defer qt.Recovering("QXmlItem::~QXmlItem")
 
@@ -1744,6 +1798,15 @@ func (ptr *QXmlQuery) MessageHandler() *QAbstractMessageHandler {
 	return nil
 }
 
+func (ptr *QXmlQuery) NamePool() *QXmlNamePool {
+	defer qt.Recovering("QXmlQuery::namePool")
+
+	if ptr.Pointer() != nil {
+		return NewQXmlNamePoolFromPointer(C.QXmlQuery_NamePool(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QXmlQuery) NetworkAccessManager() *network.QNetworkAccessManager {
 	defer qt.Recovering("QXmlQuery::networkAccessManager")
 
@@ -1925,6 +1988,15 @@ func NewQXmlResultItems() *QXmlResultItems {
 	return newQXmlResultItemsFromPointer(C.QXmlResultItems_NewQXmlResultItems())
 }
 
+func (ptr *QXmlResultItems) Current() *QXmlItem {
+	defer qt.Recovering("QXmlResultItems::current")
+
+	if ptr.Pointer() != nil {
+		return NewQXmlItemFromPointer(C.QXmlResultItems_Current(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QXmlResultItems) HasError() bool {
 	defer qt.Recovering("QXmlResultItems::hasError")
 
@@ -1934,6 +2006,15 @@ func (ptr *QXmlResultItems) HasError() bool {
 	return false
 }
 
+func (ptr *QXmlResultItems) Next() *QXmlItem {
+	defer qt.Recovering("QXmlResultItems::next")
+
+	if ptr.Pointer() != nil {
+		return NewQXmlItemFromPointer(C.QXmlResultItems_Next(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QXmlResultItems) DestroyQXmlResultItems() {
 	defer qt.Recovering("QXmlResultItems::~QXmlResultItems")
 
@@ -2036,11 +2117,11 @@ func (ptr *QXmlSchema) Load2(source core.QIODevice_ITF, documentUri core.QUrl_IT
 	return false
 }
 
-func (ptr *QXmlSchema) Load3(data core.QByteArray_ITF, documentUri core.QUrl_ITF) bool {
+func (ptr *QXmlSchema) Load3(data string, documentUri core.QUrl_ITF) bool {
 	defer qt.Recovering("QXmlSchema::load")
 
 	if ptr.Pointer() != nil {
-		return C.QXmlSchema_Load3(ptr.Pointer(), core.PointerFromQByteArray(data), core.PointerFromQUrl(documentUri)) != 0
+		return C.QXmlSchema_Load3(ptr.Pointer(), C.CString(data), core.PointerFromQUrl(documentUri)) != 0
 	}
 	return false
 }
@@ -2063,6 +2144,15 @@ func (ptr *QXmlSchema) MessageHandler() *QAbstractMessageHandler {
 	return nil
 }
 
+func (ptr *QXmlSchema) NamePool() *QXmlNamePool {
+	defer qt.Recovering("QXmlSchema::namePool")
+
+	if ptr.Pointer() != nil {
+		return NewQXmlNamePoolFromPointer(C.QXmlSchema_NamePool(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QXmlSchema) NetworkAccessManager() *network.QNetworkAccessManager {
 	defer qt.Recovering("QXmlSchema::networkAccessManager")
 
@@ -2172,6 +2262,15 @@ func (ptr *QXmlSchemaValidator) MessageHandler() *QAbstractMessageHandler {
 	return nil
 }
 
+func (ptr *QXmlSchemaValidator) NamePool() *QXmlNamePool {
+	defer qt.Recovering("QXmlSchemaValidator::namePool")
+
+	if ptr.Pointer() != nil {
+		return NewQXmlNamePoolFromPointer(C.QXmlSchemaValidator_NamePool(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QXmlSchemaValidator) NetworkAccessManager() *network.QNetworkAccessManager {
 	defer qt.Recovering("QXmlSchemaValidator::networkAccessManager")
 
@@ -2181,6 +2280,15 @@ func (ptr *QXmlSchemaValidator) NetworkAccessManager() *network.QNetworkAccessMa
 	return nil
 }
 
+func (ptr *QXmlSchemaValidator) Schema() *QXmlSchema {
+	defer qt.Recovering("QXmlSchemaValidator::schema")
+
+	if ptr.Pointer() != nil {
+		return NewQXmlSchemaFromPointer(C.QXmlSchemaValidator_Schema(ptr.Pointer()))
+	}
+	return nil
+}
+
 func (ptr *QXmlSchemaValidator) SetMessageHandler(handler QAbstractMessageHandler_ITF) {
 	defer qt.Recovering("QXmlSchemaValidator::setMessageHandler")
 
@@ -2231,11 +2339,11 @@ func (ptr *QXmlSchemaValidator) Validate2(source core.QIODevice_ITF, documentUri
 	return false
 }
 
-func (ptr *QXmlSchemaValidator) Validate3(data core.QByteArray_ITF, documentUri core.QUrl_ITF) bool {
+func (ptr *QXmlSchemaValidator) Validate3(data string, documentUri core.QUrl_ITF) bool {
 	defer qt.Recovering("QXmlSchemaValidator::validate")
 
 	if ptr.Pointer() != nil {
-		return C.QXmlSchemaValidator_Validate3(ptr.Pointer(), core.PointerFromQByteArray(data), core.PointerFromQUrl(documentUri)) != 0
+		return C.QXmlSchemaValidator_Validate3(ptr.Pointer(), C.CString(data), core.PointerFromQUrl(documentUri)) != 0
 	}
 	return false
 }

xmlpatterns/xmlpatterns.h

@@ -25,7 +25,10 @@ void QAbstractUriResolver_CustomEventDefault(void* ptr, void* event);
 void* QAbstractXmlNodeModel_BaseUri(void* ptr, void* n);
 int QAbstractXmlNodeModel_CompareOrder(void* ptr, void* ni1, void* ni2);
 void* QAbstractXmlNodeModel_DocumentUri(void* ptr, void* n);
+void* QAbstractXmlNodeModel_ElementById(void* ptr, void* id);
 int QAbstractXmlNodeModel_Kind(void* ptr, void* ni);
+void* QAbstractXmlNodeModel_Root(void* ptr, void* n);
+void* QAbstractXmlNodeModel_SourceLocation(void* ptr, void* index);
 char* QAbstractXmlNodeModel_StringValue(void* ptr, void* n);
 void* QAbstractXmlNodeModel_TypedValue(void* ptr, void* node);
 void QAbstractXmlNodeModel_DestroyQAbstractXmlNodeModel(void* ptr);
@@ -47,6 +50,9 @@ char* QAbstractXmlReceiver_ObjectNameAbs(void* ptr);
 void QAbstractXmlReceiver_SetObjectNameAbs(void* ptr, char* name);
 void* QSimpleXmlNodeModel_BaseUri(void* ptr, void* node);
 void* QSimpleXmlNodeModel_BaseUriDefault(void* ptr, void* node);
+void* QSimpleXmlNodeModel_ElementById(void* ptr, void* id);
+void* QSimpleXmlNodeModel_ElementByIdDefault(void* ptr, void* id);
+void* QSimpleXmlNodeModel_NamePool(void* ptr);
 char* QSimpleXmlNodeModel_StringValue(void* ptr, void* node);
 char* QSimpleXmlNodeModel_StringValueDefault(void* ptr, void* node);
 void QSimpleXmlNodeModel_DestroyQSimpleXmlNodeModel(void* ptr);
@@ -88,6 +94,7 @@ void* QXmlItem_NewQXmlItem2(void* other);
 void* QXmlItem_NewQXmlItem3(void* node);
 int QXmlItem_IsNode(void* ptr);
 int QXmlItem_IsNull(void* ptr);
+void* QXmlItem_ToNodeModelIndex(void* ptr);
 void QXmlItem_DestroyQXmlItem(void* ptr);
 void* QXmlName_NewQXmlName();
 void* QXmlName_NewQXmlName2(void* namePool, char* localName, char* namespaceURI, char* prefix);
@@ -119,6 +126,7 @@ void QXmlQuery_BindVariable(void* ptr, void* name, void* value);
 void QXmlQuery_BindVariable3(void* ptr, void* name, void* query);
 int QXmlQuery_IsValid(void* ptr);
 void* QXmlQuery_MessageHandler(void* ptr);
+void* QXmlQuery_NamePool(void* ptr);
 void* QXmlQuery_NetworkAccessManager(void* ptr);
 int QXmlQuery_QueryLanguage(void* ptr);
 int QXmlQuery_SetFocus3(void* ptr, void* document);
@@ -136,7 +144,9 @@ void QXmlQuery_SetUriResolver(void* ptr, void* resolver);
 void* QXmlQuery_UriResolver(void* ptr);
 void QXmlQuery_DestroyQXmlQuery(void* ptr);
 void* QXmlResultItems_NewQXmlResultItems();
+void* QXmlResultItems_Current(void* ptr);
 int QXmlResultItems_HasError(void* ptr);
+void* QXmlResultItems_Next(void* ptr);
 void QXmlResultItems_DestroyQXmlResultItems(void* ptr);
 char* QXmlResultItems_ObjectNameAbs(void* ptr);
 void QXmlResultItems_SetObjectNameAbs(void* ptr, char* name);
@@ -145,9 +155,10 @@ void* QXmlSchema_NewQXmlSchema2(void* other);
 void* QXmlSchema_DocumentUri(void* ptr);
 int QXmlSchema_IsValid(void* ptr);
 int QXmlSchema_Load2(void* ptr, void* source, void* documentUri);
-int QXmlSchema_Load3(void* ptr, void* data, void* documentUri);
+int QXmlSchema_Load3(void* ptr, char* data, void* documentUri);
 int QXmlSchema_Load(void* ptr, void* source);
 void* QXmlSchema_MessageHandler(void* ptr);
+void* QXmlSchema_NamePool(void* ptr);
 void* QXmlSchema_NetworkAccessManager(void* ptr);
 void QXmlSchema_SetMessageHandler(void* ptr, void* handler);
 void QXmlSchema_SetNetworkAccessManager(void* ptr, void* manager);
@@ -157,14 +168,16 @@ void QXmlSchema_DestroyQXmlSchema(void* ptr);
 void* QXmlSchemaValidator_NewQXmlSchemaValidator();
 void* QXmlSchemaValidator_NewQXmlSchemaValidator2(void* schema);
 void* QXmlSchemaValidator_MessageHandler(void* ptr);
+void* QXmlSchemaValidator_NamePool(void* ptr);
 void* QXmlSchemaValidator_NetworkAccessManager(void* ptr);
+void* QXmlSchemaValidator_Schema(void* ptr);
 void QXmlSchemaValidator_SetMessageHandler(void* ptr, void* handler);
 void QXmlSchemaValidator_SetNetworkAccessManager(void* ptr, void* manager);
 void QXmlSchemaValidator_SetSchema(void* ptr, void* schema);
 void QXmlSchemaValidator_SetUriResolver(void* ptr, void* resolver);
 void* QXmlSchemaValidator_UriResolver(void* ptr);
 int QXmlSchemaValidator_Validate2(void* ptr, void* source, void* documentUri);
-int QXmlSchemaValidator_Validate3(void* ptr, void* data, void* documentUri);
+int QXmlSchemaValidator_Validate3(void* ptr, char* data, void* documentUri);
 int QXmlSchemaValidator_Validate(void* ptr, void* source);
 void QXmlSchemaValidator_DestroyQXmlSchemaValidator(void* ptr);
 void* QXmlSerializer_NewQXmlSerializer(void* query, void* outputDevice);