diff --git a/qt/gen_qbitarray.cpp b/qt/gen_qbitarray.cpp
index 4879e91..7c8dc90 100644
--- a/qt/gen_qbitarray.cpp
+++ b/qt/gen_qbitarray.cpp
@@ -144,8 +144,8 @@ const char* QBitArray_Bits(const QBitArray* self) {
 	return (const char*) self->bits();
 }
 
-QBitArray* QBitArray_FromBits(const char* data, size_t lenVal) {
-	return new QBitArray(QBitArray::fromBits(data, static_cast<qsizetype>(lenVal)));
+QBitArray* QBitArray_FromBits(const char* data, ptrdiff_t lenVal) {
+	return new QBitArray(QBitArray::fromBits(data, (qsizetype)(lenVal)));
 }
 
 bool QBitArray_Fill22(QBitArray* self, bool val, int size) {
diff --git a/qt/gen_qbitarray.go b/qt/gen_qbitarray.go
index 2d5b797..742c631 100644
--- a/qt/gen_qbitarray.go
+++ b/qt/gen_qbitarray.go
@@ -193,10 +193,10 @@ func (this *QBitArray) Bits() unsafe.Pointer {
 	return (unsafe.Pointer)(_ret)
 }
 
-func QBitArray_FromBits(data string, lenVal uint64) *QBitArray {
+func QBitArray_FromBits(data string, lenVal int64) *QBitArray {
 	data_Cstring := C.CString(data)
 	defer C.free(unsafe.Pointer(data_Cstring))
-	_ret := C.QBitArray_FromBits(data_Cstring, (C.size_t)(lenVal))
+	_ret := C.QBitArray_FromBits(data_Cstring, (C.ptrdiff_t)(lenVal))
 	_goptr := newQBitArray(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
diff --git a/qt/gen_qbitarray.h b/qt/gen_qbitarray.h
index bf59b3a..c6b79fc 100644
--- a/qt/gen_qbitarray.h
+++ b/qt/gen_qbitarray.h
@@ -56,7 +56,7 @@ bool QBitArray_Fill(QBitArray* self, bool val);
 void QBitArray_Fill2(QBitArray* self, bool val, int first, int last);
 void QBitArray_Truncate(QBitArray* self, int pos);
 const char* QBitArray_Bits(const QBitArray* self);
-QBitArray* QBitArray_FromBits(const char* data, size_t lenVal);
+QBitArray* QBitArray_FromBits(const char* data, ptrdiff_t lenVal);
 bool QBitArray_Fill22(QBitArray* self, bool val, int size);
 void QBitArray_Delete(QBitArray* self);
 
diff --git a/qt/gen_qbytearray.go b/qt/gen_qbytearray.go
index 290eda8..7aa9b7c 100644
--- a/qt/gen_qbytearray.go
+++ b/qt/gen_qbytearray.go
@@ -132,7 +132,7 @@ func NewQByteArray2(param1 string) *QByteArray {
 }
 
 // NewQByteArray3 constructs a new QByteArray object.
-func NewQByteArray3(size int, c byte) *QByteArray {
+func NewQByteArray3(size int, c int8) *QByteArray {
 	ret := C.QByteArray_new3((C.int)(size), (C.char)(c))
 	return newQByteArray(ret)
 }
@@ -189,7 +189,7 @@ func (this *QByteArray) Resize(size int) {
 	C.QByteArray_Resize(this.h, (C.int)(size))
 }
 
-func (this *QByteArray) Fill(c byte) *QByteArray {
+func (this *QByteArray) Fill(c int8) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_Fill(this.h, (C.char)(c))))
 }
 
@@ -236,16 +236,16 @@ func (this *QByteArray) Clear() {
 	C.QByteArray_Clear(this.h)
 }
 
-func (this *QByteArray) At(i int) byte {
-	return (byte)(C.QByteArray_At(this.h, (C.int)(i)))
+func (this *QByteArray) At(i int) int8 {
+	return (int8)(C.QByteArray_At(this.h, (C.int)(i)))
 }
 
-func (this *QByteArray) OperatorSubscript(i int) byte {
-	return (byte)(C.QByteArray_OperatorSubscript(this.h, (C.int)(i)))
+func (this *QByteArray) OperatorSubscript(i int) int8 {
+	return (int8)(C.QByteArray_OperatorSubscript(this.h, (C.int)(i)))
 }
 
-func (this *QByteArray) OperatorSubscriptWithUint(i uint) byte {
-	return (byte)(C.QByteArray_OperatorSubscriptWithUint(this.h, (C.uint)(i)))
+func (this *QByteArray) OperatorSubscriptWithUint(i uint) int8 {
+	return (int8)(C.QByteArray_OperatorSubscriptWithUint(this.h, (C.uint)(i)))
 }
 
 func (this *QByteArray) OperatorSubscriptWithInt(i int) *QByteRef {
@@ -262,8 +262,8 @@ func (this *QByteArray) OperatorSubscript2(i uint) *QByteRef {
 	return _goptr
 }
 
-func (this *QByteArray) Front() byte {
-	return (byte)(C.QByteArray_Front(this.h))
+func (this *QByteArray) Front() int8 {
+	return (int8)(C.QByteArray_Front(this.h))
 }
 
 func (this *QByteArray) Front2() *QByteRef {
@@ -273,8 +273,8 @@ func (this *QByteArray) Front2() *QByteRef {
 	return _goptr
 }
 
-func (this *QByteArray) Back() byte {
-	return (byte)(C.QByteArray_Back(this.h))
+func (this *QByteArray) Back() int8 {
+	return (int8)(C.QByteArray_Back(this.h))
 }
 
 func (this *QByteArray) Back2() *QByteRef {
@@ -284,7 +284,7 @@ func (this *QByteArray) Back2() *QByteRef {
 	return _goptr
 }
 
-func (this *QByteArray) IndexOf(c byte) int {
+func (this *QByteArray) IndexOf(c int8) int {
 	return (int)(C.QByteArray_IndexOf(this.h, (C.char)(c)))
 }
 
@@ -298,7 +298,7 @@ func (this *QByteArray) IndexOfWithQByteArray(a *QByteArray) int {
 	return (int)(C.QByteArray_IndexOfWithQByteArray(this.h, a.cPointer()))
 }
 
-func (this *QByteArray) LastIndexOf(c byte) int {
+func (this *QByteArray) LastIndexOf(c int8) int {
 	return (int)(C.QByteArray_LastIndexOf(this.h, (C.char)(c)))
 }
 
@@ -312,7 +312,7 @@ func (this *QByteArray) LastIndexOfWithQByteArray(a *QByteArray) int {
 	return (int)(C.QByteArray_LastIndexOfWithQByteArray(this.h, a.cPointer()))
 }
 
-func (this *QByteArray) Contains(c byte) bool {
+func (this *QByteArray) Contains(c int8) bool {
 	return (bool)(C.QByteArray_Contains(this.h, (C.char)(c)))
 }
 
@@ -326,7 +326,7 @@ func (this *QByteArray) ContainsWithQByteArray(a *QByteArray) bool {
 	return (bool)(C.QByteArray_ContainsWithQByteArray(this.h, a.cPointer()))
 }
 
-func (this *QByteArray) Count(c byte) int {
+func (this *QByteArray) Count(c int8) int {
 	return (int)(C.QByteArray_Count(this.h, (C.char)(c)))
 }
 
@@ -382,7 +382,7 @@ func (this *QByteArray) StartsWith(a *QByteArray) bool {
 	return (bool)(C.QByteArray_StartsWith(this.h, a.cPointer()))
 }
 
-func (this *QByteArray) StartsWithWithChar(c byte) bool {
+func (this *QByteArray) StartsWithWithChar(c int8) bool {
 	return (bool)(C.QByteArray_StartsWithWithChar(this.h, (C.char)(c)))
 }
 
@@ -396,7 +396,7 @@ func (this *QByteArray) EndsWith(a *QByteArray) bool {
 	return (bool)(C.QByteArray_EndsWith(this.h, a.cPointer()))
 }
 
-func (this *QByteArray) EndsWithWithChar(c byte) bool {
+func (this *QByteArray) EndsWithWithChar(c int8) bool {
 	return (bool)(C.QByteArray_EndsWithWithChar(this.h, (C.char)(c)))
 }
 
@@ -464,11 +464,11 @@ func (this *QByteArray) RightJustified(width int) *QByteArray {
 	return _goptr
 }
 
-func (this *QByteArray) Prepend(c byte) *QByteArray {
+func (this *QByteArray) Prepend(c int8) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_Prepend(this.h, (C.char)(c))))
 }
 
-func (this *QByteArray) Prepend2(count int, c byte) *QByteArray {
+func (this *QByteArray) Prepend2(count int, c int8) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_Prepend2(this.h, (C.int)(count), (C.char)(c))))
 }
 
@@ -488,11 +488,11 @@ func (this *QByteArray) PrependWithQByteArray(a *QByteArray) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_PrependWithQByteArray(this.h, a.cPointer())))
 }
 
-func (this *QByteArray) Append(c byte) *QByteArray {
+func (this *QByteArray) Append(c int8) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_Append(this.h, (C.char)(c))))
 }
 
-func (this *QByteArray) Append2(count int, c byte) *QByteArray {
+func (this *QByteArray) Append2(count int, c int8) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_Append2(this.h, (C.int)(count), (C.char)(c))))
 }
 
@@ -512,11 +512,11 @@ func (this *QByteArray) AppendWithQByteArray(a *QByteArray) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_AppendWithQByteArray(this.h, a.cPointer())))
 }
 
-func (this *QByteArray) Insert(i int, c byte) *QByteArray {
+func (this *QByteArray) Insert(i int, c int8) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_Insert(this.h, (C.int)(i), (C.char)(c))))
 }
 
-func (this *QByteArray) Insert2(i int, count int, c byte) *QByteArray {
+func (this *QByteArray) Insert2(i int, count int, c int8) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_Insert2(this.h, (C.int)(i), (C.int)(count), (C.char)(c))))
 }
 
@@ -556,13 +556,13 @@ func (this *QByteArray) Replace3(index int, lenVal int, s *QByteArray) *QByteArr
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_Replace3(this.h, (C.int)(index), (C.int)(lenVal), s.cPointer())))
 }
 
-func (this *QByteArray) Replace4(before byte, after string) *QByteArray {
+func (this *QByteArray) Replace4(before int8, after string) *QByteArray {
 	after_Cstring := C.CString(after)
 	defer C.free(unsafe.Pointer(after_Cstring))
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_Replace4(this.h, (C.char)(before), after_Cstring)))
 }
 
-func (this *QByteArray) Replace5(before byte, after *QByteArray) *QByteArray {
+func (this *QByteArray) Replace5(before int8, after *QByteArray) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_Replace5(this.h, (C.char)(before), after.cPointer())))
 }
 
@@ -598,11 +598,11 @@ func (this *QByteArray) Replace10(before string, after *QByteArray) *QByteArray
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_Replace10(this.h, before_Cstring, after.cPointer())))
 }
 
-func (this *QByteArray) Replace11(before byte, after byte) *QByteArray {
+func (this *QByteArray) Replace11(before int8, after int8) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_Replace11(this.h, (C.char)(before), (C.char)(after))))
 }
 
-func (this *QByteArray) OperatorPlusAssign(c byte) *QByteArray {
+func (this *QByteArray) OperatorPlusAssign(c int8) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_OperatorPlusAssign(this.h, (C.char)(c))))
 }
 
@@ -616,7 +616,7 @@ func (this *QByteArray) OperatorPlusAssignWithQByteArray(a *QByteArray) *QByteAr
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_OperatorPlusAssignWithQByteArray(this.h, a.cPointer())))
 }
 
-func (this *QByteArray) Split(sep byte) []QByteArray {
+func (this *QByteArray) Split(sep int8) []QByteArray {
 	var _ma *C.struct_miqt_array = C.QByteArray_Split(this.h, (C.char)(sep))
 	_ret := make([]QByteArray, int(_ma.len))
 	_outCast := (*[0xffff]*C.QByteArray)(unsafe.Pointer(_ma.data)) // hey ya
@@ -657,7 +657,7 @@ func (this *QByteArray) Replace12(before string, after string) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_Replace12(this.h, (*C.struct_miqt_string)(before_ms), after_Cstring)))
 }
 
-func (this *QByteArray) Replace13(c byte, after string) *QByteArray {
+func (this *QByteArray) Replace13(c int8, after string) *QByteArray {
 	after_ms := miqt_strdupg(after)
 	defer C.free(after_ms)
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_Replace13(this.h, (C.char)(c), (*C.struct_miqt_string)(after_ms))))
@@ -784,7 +784,7 @@ func (this *QByteArray) ToHex() *QByteArray {
 	return _goptr
 }
 
-func (this *QByteArray) ToHexWithSeparator(separator byte) *QByteArray {
+func (this *QByteArray) ToHexWithSeparator(separator int8) *QByteArray {
 	_ret := C.QByteArray_ToHexWithSeparator(this.h, (C.char)(separator))
 	_goptr := newQByteArray(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
@@ -955,7 +955,7 @@ func (this *QByteArray) ConstEnd() unsafe.Pointer {
 	return (unsafe.Pointer)(_ret)
 }
 
-func (this *QByteArray) PushBack(c byte) {
+func (this *QByteArray) PushBack(c int8) {
 	C.QByteArray_PushBack(this.h, (C.char)(c))
 }
 
@@ -969,7 +969,7 @@ func (this *QByteArray) PushBackWithQByteArray(a *QByteArray) {
 	C.QByteArray_PushBackWithQByteArray(this.h, a.cPointer())
 }
 
-func (this *QByteArray) PushFront(c byte) {
+func (this *QByteArray) PushFront(c int8) {
 	C.QByteArray_PushFront(this.h, (C.char)(c))
 }
 
@@ -999,11 +999,11 @@ func (this *QByteArray) IsNull() bool {
 	return (bool)(C.QByteArray_IsNull(this.h))
 }
 
-func (this *QByteArray) Fill2(c byte, size int) *QByteArray {
+func (this *QByteArray) Fill2(c int8, size int) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_Fill2(this.h, (C.char)(c), (C.int)(size))))
 }
 
-func (this *QByteArray) IndexOf2(c byte, from int) int {
+func (this *QByteArray) IndexOf2(c int8, from int) int {
 	return (int)(C.QByteArray_IndexOf2(this.h, (C.char)(c), (C.int)(from)))
 }
 
@@ -1017,7 +1017,7 @@ func (this *QByteArray) IndexOf23(a *QByteArray, from int) int {
 	return (int)(C.QByteArray_IndexOf23(this.h, a.cPointer(), (C.int)(from)))
 }
 
-func (this *QByteArray) LastIndexOf2(c byte, from int) int {
+func (this *QByteArray) LastIndexOf2(c int8, from int) int {
 	return (int)(C.QByteArray_LastIndexOf2(this.h, (C.char)(c), (C.int)(from)))
 }
 
@@ -1048,28 +1048,28 @@ func (this *QByteArray) Mid2(index int, lenVal int) *QByteArray {
 	return _goptr
 }
 
-func (this *QByteArray) LeftJustified2(width int, fill byte) *QByteArray {
+func (this *QByteArray) LeftJustified2(width int, fill int8) *QByteArray {
 	_ret := C.QByteArray_LeftJustified2(this.h, (C.int)(width), (C.char)(fill))
 	_goptr := newQByteArray(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func (this *QByteArray) LeftJustified3(width int, fill byte, truncate bool) *QByteArray {
+func (this *QByteArray) LeftJustified3(width int, fill int8, truncate bool) *QByteArray {
 	_ret := C.QByteArray_LeftJustified3(this.h, (C.int)(width), (C.char)(fill), (C.bool)(truncate))
 	_goptr := newQByteArray(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func (this *QByteArray) RightJustified2(width int, fill byte) *QByteArray {
+func (this *QByteArray) RightJustified2(width int, fill int8) *QByteArray {
 	_ret := C.QByteArray_RightJustified2(this.h, (C.int)(width), (C.char)(fill))
 	_goptr := newQByteArray(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func (this *QByteArray) RightJustified3(width int, fill byte, truncate bool) *QByteArray {
+func (this *QByteArray) RightJustified3(width int, fill int8, truncate bool) *QByteArray {
 	_ret := C.QByteArray_RightJustified3(this.h, (C.int)(width), (C.char)(fill), (C.bool)(truncate))
 	_goptr := newQByteArray(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
@@ -1174,7 +1174,7 @@ func (this *QByteArray) ToPercentEncoding2(exclude *QByteArray, include *QByteAr
 	return _goptr
 }
 
-func (this *QByteArray) ToPercentEncoding3(exclude *QByteArray, include *QByteArray, percent byte) *QByteArray {
+func (this *QByteArray) ToPercentEncoding3(exclude *QByteArray, include *QByteArray, percent int8) *QByteArray {
 	_ret := C.QByteArray_ToPercentEncoding3(this.h, exclude.cPointer(), include.cPointer(), (C.char)(percent))
 	_goptr := newQByteArray(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
@@ -1205,19 +1205,19 @@ func (this *QByteArray) SetNum26(param1 uint64, base int) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_SetNum26(this.h, (C.ulonglong)(param1), (C.int)(base))))
 }
 
-func (this *QByteArray) SetNum27(param1 float32, f byte) *QByteArray {
+func (this *QByteArray) SetNum27(param1 float32, f int8) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_SetNum27(this.h, (C.float)(param1), (C.char)(f))))
 }
 
-func (this *QByteArray) SetNum3(param1 float32, f byte, prec int) *QByteArray {
+func (this *QByteArray) SetNum3(param1 float32, f int8, prec int) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_SetNum3(this.h, (C.float)(param1), (C.char)(f), (C.int)(prec))))
 }
 
-func (this *QByteArray) SetNum28(param1 float64, f byte) *QByteArray {
+func (this *QByteArray) SetNum28(param1 float64, f int8) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_SetNum28(this.h, (C.double)(param1), (C.char)(f))))
 }
 
-func (this *QByteArray) SetNum32(param1 float64, f byte, prec int) *QByteArray {
+func (this *QByteArray) SetNum32(param1 float64, f int8, prec int) *QByteArray {
 	return newQByteArray_U(unsafe.Pointer(C.QByteArray_SetNum32(this.h, (C.double)(param1), (C.char)(f), (C.int)(prec))))
 }
 
@@ -1249,14 +1249,14 @@ func QByteArray_Number24(param1 uint64, base int) *QByteArray {
 	return _goptr
 }
 
-func QByteArray_Number25(param1 float64, f byte) *QByteArray {
+func QByteArray_Number25(param1 float64, f int8) *QByteArray {
 	_ret := C.QByteArray_Number25((C.double)(param1), (C.char)(f))
 	_goptr := newQByteArray(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func QByteArray_Number3(param1 float64, f byte, prec int) *QByteArray {
+func QByteArray_Number3(param1 float64, f int8, prec int) *QByteArray {
 	_ret := C.QByteArray_Number3((C.double)(param1), (C.char)(f), (C.int)(prec))
 	_goptr := newQByteArray(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
@@ -1270,7 +1270,7 @@ func QByteArray_FromBase64Encoding2(base64 *QByteArray, options QByteArray__Base
 	return _goptr
 }
 
-func QByteArray_FromPercentEncoding2(pctEncoded *QByteArray, percent byte) *QByteArray {
+func QByteArray_FromPercentEncoding2(pctEncoded *QByteArray, percent int8) *QByteArray {
 	_ret := C.QByteArray_FromPercentEncoding2(pctEncoded.cPointer(), (C.char)(percent))
 	_goptr := newQByteArray(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
@@ -1319,7 +1319,7 @@ func NewQByteRef(param1 *QByteRef) *QByteRef {
 	return newQByteRef(ret)
 }
 
-func (this *QByteRef) OperatorAssign(c byte) {
+func (this *QByteRef) OperatorAssign(c int8) {
 	C.QByteRef_OperatorAssign(this.h, (C.char)(c))
 }
 
@@ -1327,27 +1327,27 @@ func (this *QByteRef) OperatorAssignWithQByteRef(c *QByteRef) {
 	C.QByteRef_OperatorAssignWithQByteRef(this.h, c.cPointer())
 }
 
-func (this *QByteRef) OperatorEqual(c byte) bool {
+func (this *QByteRef) OperatorEqual(c int8) bool {
 	return (bool)(C.QByteRef_OperatorEqual(this.h, (C.char)(c)))
 }
 
-func (this *QByteRef) OperatorNotEqual(c byte) bool {
+func (this *QByteRef) OperatorNotEqual(c int8) bool {
 	return (bool)(C.QByteRef_OperatorNotEqual(this.h, (C.char)(c)))
 }
 
-func (this *QByteRef) OperatorGreater(c byte) bool {
+func (this *QByteRef) OperatorGreater(c int8) bool {
 	return (bool)(C.QByteRef_OperatorGreater(this.h, (C.char)(c)))
 }
 
-func (this *QByteRef) OperatorGreaterOrEqual(c byte) bool {
+func (this *QByteRef) OperatorGreaterOrEqual(c int8) bool {
 	return (bool)(C.QByteRef_OperatorGreaterOrEqual(this.h, (C.char)(c)))
 }
 
-func (this *QByteRef) OperatorLesser(c byte) bool {
+func (this *QByteRef) OperatorLesser(c int8) bool {
 	return (bool)(C.QByteRef_OperatorLesser(this.h, (C.char)(c)))
 }
 
-func (this *QByteRef) OperatorLesserOrEqual(c byte) bool {
+func (this *QByteRef) OperatorLesserOrEqual(c int8) bool {
 	return (bool)(C.QByteRef_OperatorLesserOrEqual(this.h, (C.char)(c)))
 }
 
diff --git a/qt/gen_qcborarray.cpp b/qt/gen_qcborarray.cpp
index 2ea74b0..2a5de07 100644
--- a/qt/gen_qcborarray.cpp
+++ b/qt/gen_qcborarray.cpp
@@ -32,8 +32,9 @@ QCborValue* QCborArray_ToCborValue(const QCborArray* self) {
 	return new QCborValue(self->toCborValue());
 }
 
-size_t QCborArray_Size(const QCborArray* self) {
-	return self->size();
+ptrdiff_t QCborArray_Size(const QCborArray* self) {
+	qsizetype _ret = self->size();
+	return static_cast<ptrdiff_t>(_ret);
 }
 
 bool QCborArray_IsEmpty(const QCborArray* self) {
@@ -44,8 +45,8 @@ void QCborArray_Clear(QCborArray* self) {
 	self->clear();
 }
 
-QCborValue* QCborArray_At(const QCborArray* self, size_t i) {
-	return new QCborValue(self->at(static_cast<qsizetype>(i)));
+QCborValue* QCborArray_At(const QCborArray* self, ptrdiff_t i) {
+	return new QCborValue(self->at((qsizetype)(i)));
 }
 
 QCborValue* QCborArray_First(const QCborArray* self) {
@@ -56,8 +57,8 @@ QCborValue* QCborArray_Last(const QCborArray* self) {
 	return new QCborValue(self->last());
 }
 
-QCborValue* QCborArray_OperatorSubscript(const QCborArray* self, size_t i) {
-	return new QCborValue(self->operator[](static_cast<qsizetype>(i)));
+QCborValue* QCborArray_OperatorSubscript(const QCborArray* self, ptrdiff_t i) {
+	return new QCborValue(self->operator[]((qsizetype)(i)));
 }
 
 QCborValueRef* QCborArray_First2(QCborArray* self) {
@@ -68,12 +69,12 @@ QCborValueRef* QCborArray_Last2(QCborArray* self) {
 	return new QCborValueRef(self->last());
 }
 
-QCborValueRef* QCborArray_OperatorSubscriptWithQsizetype(QCborArray* self, size_t i) {
-	return new QCborValueRef(self->operator[](static_cast<qsizetype>(i)));
+QCborValueRef* QCborArray_OperatorSubscriptWithQsizetype(QCborArray* self, ptrdiff_t i) {
+	return new QCborValueRef(self->operator[]((qsizetype)(i)));
 }
 
-void QCborArray_Insert(QCborArray* self, size_t i, QCborValue* value) {
-	self->insert(static_cast<qsizetype>(i), *value);
+void QCborArray_Insert(QCborArray* self, ptrdiff_t i, QCborValue* value) {
+	self->insert((qsizetype)(i), *value);
 }
 
 void QCborArray_Prepend(QCborArray* self, QCborValue* value) {
@@ -92,12 +93,12 @@ QCborValue* QCborArray_ExtractWithIt(QCborArray* self, QCborArray__Iterator* it)
 	return new QCborValue(self->extract(*it));
 }
 
-void QCborArray_RemoveAt(QCborArray* self, size_t i) {
-	self->removeAt(static_cast<qsizetype>(i));
+void QCborArray_RemoveAt(QCborArray* self, ptrdiff_t i) {
+	self->removeAt((qsizetype)(i));
 }
 
-QCborValue* QCborArray_TakeAt(QCborArray* self, size_t i) {
-	return new QCborValue(self->takeAt(static_cast<qsizetype>(i)));
+QCborValue* QCborArray_TakeAt(QCborArray* self, ptrdiff_t i) {
+	return new QCborValue(self->takeAt((qsizetype)(i)));
 }
 
 void QCborArray_RemoveFirst(QCborArray* self) {
@@ -263,8 +264,8 @@ QCborValueRef* QCborArray__Iterator_OperatorMinusGreater(const QCborArray__Itera
 	return self->operator->();
 }
 
-QCborValueRef* QCborArray__Iterator_OperatorSubscript(QCborArray__Iterator* self, size_t j) {
-	return new QCborValueRef(self->operator[](static_cast<qsizetype>(j)));
+QCborValueRef* QCborArray__Iterator_OperatorSubscript(QCborArray__Iterator* self, ptrdiff_t j) {
+	return new QCborValueRef(self->operator[]((qsizetype)(j)));
 }
 
 bool QCborArray__Iterator_OperatorEqual(const QCborArray__Iterator* self, QCborArray__Iterator* o) {
@@ -335,28 +336,29 @@ QCborArray__Iterator* QCborArray__Iterator_OperatorMinusMinusWithInt(QCborArray_
 	return new QCborArray::Iterator(self->operator--(static_cast<int>(param1)));
 }
 
-QCborArray__Iterator* QCborArray__Iterator_OperatorPlusAssign(QCborArray__Iterator* self, size_t j) {
-	QCborArray::Iterator& _ret = self->operator+=(static_cast<qsizetype>(j));
+QCborArray__Iterator* QCborArray__Iterator_OperatorPlusAssign(QCborArray__Iterator* self, ptrdiff_t j) {
+	QCborArray::Iterator& _ret = self->operator+=((qsizetype)(j));
 	// Cast returned reference into pointer
 	return &_ret;
 }
 
-QCborArray__Iterator* QCborArray__Iterator_OperatorMinusAssign(QCborArray__Iterator* self, size_t j) {
-	QCborArray::Iterator& _ret = self->operator-=(static_cast<qsizetype>(j));
+QCborArray__Iterator* QCborArray__Iterator_OperatorMinusAssign(QCborArray__Iterator* self, ptrdiff_t j) {
+	QCborArray::Iterator& _ret = self->operator-=((qsizetype)(j));
 	// Cast returned reference into pointer
 	return &_ret;
 }
 
-QCborArray__Iterator* QCborArray__Iterator_OperatorPlus(const QCborArray__Iterator* self, size_t j) {
-	return new QCborArray::Iterator(self->operator+(static_cast<qsizetype>(j)));
+QCborArray__Iterator* QCborArray__Iterator_OperatorPlus(const QCborArray__Iterator* self, ptrdiff_t j) {
+	return new QCborArray::Iterator(self->operator+((qsizetype)(j)));
 }
 
-QCborArray__Iterator* QCborArray__Iterator_OperatorMinus(const QCborArray__Iterator* self, size_t j) {
-	return new QCborArray::Iterator(self->operator-(static_cast<qsizetype>(j)));
+QCborArray__Iterator* QCborArray__Iterator_OperatorMinus(const QCborArray__Iterator* self, ptrdiff_t j) {
+	return new QCborArray::Iterator(self->operator-((qsizetype)(j)));
 }
 
-size_t QCborArray__Iterator_OperatorMinusWithQCborArrayIterator(const QCborArray__Iterator* self, QCborArray__Iterator* j) {
-	return self->operator-(*j);
+ptrdiff_t QCborArray__Iterator_OperatorMinusWithQCborArrayIterator(const QCborArray__Iterator* self, QCborArray__Iterator* j) {
+	qsizetype _ret = self->operator-(*j);
+	return static_cast<ptrdiff_t>(_ret);
 }
 
 void QCborArray__Iterator_Delete(QCborArray__Iterator* self) {
@@ -383,8 +385,8 @@ QCborValueRef* QCborArray__ConstIterator_OperatorMinusGreater(const QCborArray__
 	return (QCborValueRef*) self->operator->();
 }
 
-QCborValueRef* QCborArray__ConstIterator_OperatorSubscript(QCborArray__ConstIterator* self, size_t j) {
-	return new QCborValueRef(self->operator[](static_cast<qsizetype>(j)));
+QCborValueRef* QCborArray__ConstIterator_OperatorSubscript(QCborArray__ConstIterator* self, ptrdiff_t j) {
+	return new QCborValueRef(self->operator[]((qsizetype)(j)));
 }
 
 bool QCborArray__ConstIterator_OperatorEqual(const QCborArray__ConstIterator* self, QCborArray__Iterator* o) {
@@ -455,28 +457,29 @@ QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinusMinusWithInt(Q
 	return new QCborArray::ConstIterator(self->operator--(static_cast<int>(param1)));
 }
 
-QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlusAssign(QCborArray__ConstIterator* self, size_t j) {
-	QCborArray::ConstIterator& _ret = self->operator+=(static_cast<qsizetype>(j));
+QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlusAssign(QCborArray__ConstIterator* self, ptrdiff_t j) {
+	QCborArray::ConstIterator& _ret = self->operator+=((qsizetype)(j));
 	// Cast returned reference into pointer
 	return &_ret;
 }
 
-QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinusAssign(QCborArray__ConstIterator* self, size_t j) {
-	QCborArray::ConstIterator& _ret = self->operator-=(static_cast<qsizetype>(j));
+QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinusAssign(QCborArray__ConstIterator* self, ptrdiff_t j) {
+	QCborArray::ConstIterator& _ret = self->operator-=((qsizetype)(j));
 	// Cast returned reference into pointer
 	return &_ret;
 }
 
-QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlus(const QCborArray__ConstIterator* self, size_t j) {
-	return new QCborArray::ConstIterator(self->operator+(static_cast<qsizetype>(j)));
+QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlus(const QCborArray__ConstIterator* self, ptrdiff_t j) {
+	return new QCborArray::ConstIterator(self->operator+((qsizetype)(j)));
 }
 
-QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinus(const QCborArray__ConstIterator* self, size_t j) {
-	return new QCborArray::ConstIterator(self->operator-(static_cast<qsizetype>(j)));
+QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinus(const QCborArray__ConstIterator* self, ptrdiff_t j) {
+	return new QCborArray::ConstIterator(self->operator-((qsizetype)(j)));
 }
 
-size_t QCborArray__ConstIterator_OperatorMinusWithQCborArrayConstIterator(const QCborArray__ConstIterator* self, QCborArray__ConstIterator* j) {
-	return self->operator-(*j);
+ptrdiff_t QCborArray__ConstIterator_OperatorMinusWithQCborArrayConstIterator(const QCborArray__ConstIterator* self, QCborArray__ConstIterator* j) {
+	qsizetype _ret = self->operator-(*j);
+	return static_cast<ptrdiff_t>(_ret);
 }
 
 void QCborArray__ConstIterator_Delete(QCborArray__ConstIterator* self) {
diff --git a/qt/gen_qcborarray.go b/qt/gen_qcborarray.go
index 76002c0..7da8702 100644
--- a/qt/gen_qcborarray.go
+++ b/qt/gen_qcborarray.go
@@ -62,8 +62,8 @@ func (this *QCborArray) ToCborValue() *QCborValue {
 	return _goptr
 }
 
-func (this *QCborArray) Size() uint64 {
-	return (uint64)(C.QCborArray_Size(this.h))
+func (this *QCborArray) Size() int64 {
+	return (int64)(C.QCborArray_Size(this.h))
 }
 
 func (this *QCborArray) IsEmpty() bool {
@@ -74,8 +74,8 @@ func (this *QCborArray) Clear() {
 	C.QCborArray_Clear(this.h)
 }
 
-func (this *QCborArray) At(i uint64) *QCborValue {
-	_ret := C.QCborArray_At(this.h, (C.size_t)(i))
+func (this *QCborArray) At(i int64) *QCborValue {
+	_ret := C.QCborArray_At(this.h, (C.ptrdiff_t)(i))
 	_goptr := newQCborValue(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
@@ -95,8 +95,8 @@ func (this *QCborArray) Last() *QCborValue {
 	return _goptr
 }
 
-func (this *QCborArray) OperatorSubscript(i uint64) *QCborValue {
-	_ret := C.QCborArray_OperatorSubscript(this.h, (C.size_t)(i))
+func (this *QCborArray) OperatorSubscript(i int64) *QCborValue {
+	_ret := C.QCborArray_OperatorSubscript(this.h, (C.ptrdiff_t)(i))
 	_goptr := newQCborValue(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
@@ -116,15 +116,15 @@ func (this *QCborArray) Last2() *QCborValueRef {
 	return _goptr
 }
 
-func (this *QCborArray) OperatorSubscriptWithQsizetype(i uint64) *QCborValueRef {
-	_ret := C.QCborArray_OperatorSubscriptWithQsizetype(this.h, (C.size_t)(i))
+func (this *QCborArray) OperatorSubscriptWithQsizetype(i int64) *QCborValueRef {
+	_ret := C.QCborArray_OperatorSubscriptWithQsizetype(this.h, (C.ptrdiff_t)(i))
 	_goptr := newQCborValueRef(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func (this *QCborArray) Insert(i uint64, value *QCborValue) {
-	C.QCborArray_Insert(this.h, (C.size_t)(i), value.cPointer())
+func (this *QCborArray) Insert(i int64, value *QCborValue) {
+	C.QCborArray_Insert(this.h, (C.ptrdiff_t)(i), value.cPointer())
 }
 
 func (this *QCborArray) Prepend(value *QCborValue) {
@@ -149,12 +149,12 @@ func (this *QCborArray) ExtractWithIt(it QCborArray__Iterator) *QCborValue {
 	return _goptr
 }
 
-func (this *QCborArray) RemoveAt(i uint64) {
-	C.QCborArray_RemoveAt(this.h, (C.size_t)(i))
+func (this *QCborArray) RemoveAt(i int64) {
+	C.QCborArray_RemoveAt(this.h, (C.ptrdiff_t)(i))
 }
 
-func (this *QCborArray) TakeAt(i uint64) *QCborValue {
-	_ret := C.QCborArray_TakeAt(this.h, (C.size_t)(i))
+func (this *QCborArray) TakeAt(i int64) *QCborValue {
+	_ret := C.QCborArray_TakeAt(this.h, (C.ptrdiff_t)(i))
 	_goptr := newQCborValue(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
@@ -415,8 +415,8 @@ func (this *QCborArray__Iterator) OperatorMinusGreater() *QCborValueRef {
 	return newQCborValueRef_U(unsafe.Pointer(C.QCborArray__Iterator_OperatorMinusGreater(this.h)))
 }
 
-func (this *QCborArray__Iterator) OperatorSubscript(j uint64) *QCborValueRef {
-	_ret := C.QCborArray__Iterator_OperatorSubscript(this.h, (C.size_t)(j))
+func (this *QCborArray__Iterator) OperatorSubscript(j int64) *QCborValueRef {
+	_ret := C.QCborArray__Iterator_OperatorSubscript(this.h, (C.ptrdiff_t)(j))
 	_goptr := newQCborValueRef(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
@@ -492,30 +492,30 @@ func (this *QCborArray__Iterator) OperatorMinusMinusWithInt(param1 int) *QCborAr
 	return _goptr
 }
 
-func (this *QCborArray__Iterator) OperatorPlusAssign(j uint64) *QCborArray__Iterator {
-	return newQCborArray__Iterator_U(unsafe.Pointer(C.QCborArray__Iterator_OperatorPlusAssign(this.h, (C.size_t)(j))))
+func (this *QCborArray__Iterator) OperatorPlusAssign(j int64) *QCborArray__Iterator {
+	return newQCborArray__Iterator_U(unsafe.Pointer(C.QCborArray__Iterator_OperatorPlusAssign(this.h, (C.ptrdiff_t)(j))))
 }
 
-func (this *QCborArray__Iterator) OperatorMinusAssign(j uint64) *QCborArray__Iterator {
-	return newQCborArray__Iterator_U(unsafe.Pointer(C.QCborArray__Iterator_OperatorMinusAssign(this.h, (C.size_t)(j))))
+func (this *QCborArray__Iterator) OperatorMinusAssign(j int64) *QCborArray__Iterator {
+	return newQCborArray__Iterator_U(unsafe.Pointer(C.QCborArray__Iterator_OperatorMinusAssign(this.h, (C.ptrdiff_t)(j))))
 }
 
-func (this *QCborArray__Iterator) OperatorPlus(j uint64) *QCborArray__Iterator {
-	_ret := C.QCborArray__Iterator_OperatorPlus(this.h, (C.size_t)(j))
+func (this *QCborArray__Iterator) OperatorPlus(j int64) *QCborArray__Iterator {
+	_ret := C.QCborArray__Iterator_OperatorPlus(this.h, (C.ptrdiff_t)(j))
 	_goptr := newQCborArray__Iterator(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func (this *QCborArray__Iterator) OperatorMinus(j uint64) *QCborArray__Iterator {
-	_ret := C.QCborArray__Iterator_OperatorMinus(this.h, (C.size_t)(j))
+func (this *QCborArray__Iterator) OperatorMinus(j int64) *QCborArray__Iterator {
+	_ret := C.QCborArray__Iterator_OperatorMinus(this.h, (C.ptrdiff_t)(j))
 	_goptr := newQCborArray__Iterator(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func (this *QCborArray__Iterator) OperatorMinusWithQCborArrayIterator(j QCborArray__Iterator) uint64 {
-	return (uint64)(C.QCborArray__Iterator_OperatorMinusWithQCborArrayIterator(this.h, j.cPointer()))
+func (this *QCborArray__Iterator) OperatorMinusWithQCborArrayIterator(j QCborArray__Iterator) int64 {
+	return (int64)(C.QCborArray__Iterator_OperatorMinusWithQCborArrayIterator(this.h, j.cPointer()))
 }
 
 // Delete this object from C++ memory.
@@ -581,8 +581,8 @@ func (this *QCborArray__ConstIterator) OperatorMinusGreater() *QCborValueRef {
 	return newQCborValueRef_U(unsafe.Pointer(C.QCborArray__ConstIterator_OperatorMinusGreater(this.h)))
 }
 
-func (this *QCborArray__ConstIterator) OperatorSubscript(j uint64) *QCborValueRef {
-	_ret := C.QCborArray__ConstIterator_OperatorSubscript(this.h, (C.size_t)(j))
+func (this *QCborArray__ConstIterator) OperatorSubscript(j int64) *QCborValueRef {
+	_ret := C.QCborArray__ConstIterator_OperatorSubscript(this.h, (C.ptrdiff_t)(j))
 	_goptr := newQCborValueRef(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
@@ -658,30 +658,30 @@ func (this *QCborArray__ConstIterator) OperatorMinusMinusWithInt(param1 int) *QC
 	return _goptr
 }
 
-func (this *QCborArray__ConstIterator) OperatorPlusAssign(j uint64) *QCborArray__ConstIterator {
-	return newQCborArray__ConstIterator_U(unsafe.Pointer(C.QCborArray__ConstIterator_OperatorPlusAssign(this.h, (C.size_t)(j))))
+func (this *QCborArray__ConstIterator) OperatorPlusAssign(j int64) *QCborArray__ConstIterator {
+	return newQCborArray__ConstIterator_U(unsafe.Pointer(C.QCborArray__ConstIterator_OperatorPlusAssign(this.h, (C.ptrdiff_t)(j))))
 }
 
-func (this *QCborArray__ConstIterator) OperatorMinusAssign(j uint64) *QCborArray__ConstIterator {
-	return newQCborArray__ConstIterator_U(unsafe.Pointer(C.QCborArray__ConstIterator_OperatorMinusAssign(this.h, (C.size_t)(j))))
+func (this *QCborArray__ConstIterator) OperatorMinusAssign(j int64) *QCborArray__ConstIterator {
+	return newQCborArray__ConstIterator_U(unsafe.Pointer(C.QCborArray__ConstIterator_OperatorMinusAssign(this.h, (C.ptrdiff_t)(j))))
 }
 
-func (this *QCborArray__ConstIterator) OperatorPlus(j uint64) *QCborArray__ConstIterator {
-	_ret := C.QCborArray__ConstIterator_OperatorPlus(this.h, (C.size_t)(j))
+func (this *QCborArray__ConstIterator) OperatorPlus(j int64) *QCborArray__ConstIterator {
+	_ret := C.QCborArray__ConstIterator_OperatorPlus(this.h, (C.ptrdiff_t)(j))
 	_goptr := newQCborArray__ConstIterator(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func (this *QCborArray__ConstIterator) OperatorMinus(j uint64) *QCborArray__ConstIterator {
-	_ret := C.QCborArray__ConstIterator_OperatorMinus(this.h, (C.size_t)(j))
+func (this *QCborArray__ConstIterator) OperatorMinus(j int64) *QCborArray__ConstIterator {
+	_ret := C.QCborArray__ConstIterator_OperatorMinus(this.h, (C.ptrdiff_t)(j))
 	_goptr := newQCborArray__ConstIterator(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func (this *QCborArray__ConstIterator) OperatorMinusWithQCborArrayConstIterator(j QCborArray__ConstIterator) uint64 {
-	return (uint64)(C.QCborArray__ConstIterator_OperatorMinusWithQCborArrayConstIterator(this.h, j.cPointer()))
+func (this *QCborArray__ConstIterator) OperatorMinusWithQCborArrayConstIterator(j QCborArray__ConstIterator) int64 {
+	return (int64)(C.QCborArray__ConstIterator_OperatorMinusWithQCborArrayConstIterator(this.h, j.cPointer()))
 }
 
 // Delete this object from C++ memory.
diff --git a/qt/gen_qcborarray.h b/qt/gen_qcborarray.h
index 37b6a17..a05b5c5 100644
--- a/qt/gen_qcborarray.h
+++ b/qt/gen_qcborarray.h
@@ -42,23 +42,23 @@ QCborArray* QCborArray_new2(QCborArray* other);
 void QCborArray_OperatorAssign(QCborArray* self, QCborArray* other);
 void QCborArray_Swap(QCborArray* self, QCborArray* other);
 QCborValue* QCborArray_ToCborValue(const QCborArray* self);
-size_t QCborArray_Size(const QCborArray* self);
+ptrdiff_t QCborArray_Size(const QCborArray* self);
 bool QCborArray_IsEmpty(const QCborArray* self);
 void QCborArray_Clear(QCborArray* self);
-QCborValue* QCborArray_At(const QCborArray* self, size_t i);
+QCborValue* QCborArray_At(const QCborArray* self, ptrdiff_t i);
 QCborValue* QCborArray_First(const QCborArray* self);
 QCborValue* QCborArray_Last(const QCborArray* self);
-QCborValue* QCborArray_OperatorSubscript(const QCborArray* self, size_t i);
+QCborValue* QCborArray_OperatorSubscript(const QCborArray* self, ptrdiff_t i);
 QCborValueRef* QCborArray_First2(QCborArray* self);
 QCborValueRef* QCborArray_Last2(QCborArray* self);
-QCborValueRef* QCborArray_OperatorSubscriptWithQsizetype(QCborArray* self, size_t i);
-void QCborArray_Insert(QCborArray* self, size_t i, QCborValue* value);
+QCborValueRef* QCborArray_OperatorSubscriptWithQsizetype(QCborArray* self, ptrdiff_t i);
+void QCborArray_Insert(QCborArray* self, ptrdiff_t i, QCborValue* value);
 void QCborArray_Prepend(QCborArray* self, QCborValue* value);
 void QCborArray_Append(QCborArray* self, QCborValue* value);
 QCborValue* QCborArray_Extract(QCborArray* self, QCborArray__ConstIterator* it);
 QCborValue* QCborArray_ExtractWithIt(QCborArray* self, QCborArray__Iterator* it);
-void QCborArray_RemoveAt(QCborArray* self, size_t i);
-QCborValue* QCborArray_TakeAt(QCborArray* self, size_t i);
+void QCborArray_RemoveAt(QCborArray* self, ptrdiff_t i);
+QCborValue* QCborArray_TakeAt(QCborArray* self, ptrdiff_t i);
 void QCborArray_RemoveFirst(QCborArray* self);
 void QCborArray_RemoveLast(QCborArray* self);
 QCborValue* QCborArray_TakeFirst(QCborArray* self);
@@ -98,7 +98,7 @@ QCborArray__Iterator* QCborArray__Iterator_new2(QCborArray__Iterator* param1);
 void QCborArray__Iterator_OperatorAssign(QCborArray__Iterator* self, QCborArray__Iterator* other);
 QCborValueRef* QCborArray__Iterator_OperatorMultiply(const QCborArray__Iterator* self);
 QCborValueRef* QCborArray__Iterator_OperatorMinusGreater(const QCborArray__Iterator* self);
-QCborValueRef* QCborArray__Iterator_OperatorSubscript(QCborArray__Iterator* self, size_t j);
+QCborValueRef* QCborArray__Iterator_OperatorSubscript(QCborArray__Iterator* self, ptrdiff_t j);
 bool QCborArray__Iterator_OperatorEqual(const QCborArray__Iterator* self, QCborArray__Iterator* o);
 bool QCborArray__Iterator_OperatorNotEqual(const QCborArray__Iterator* self, QCborArray__Iterator* o);
 bool QCborArray__Iterator_OperatorLesser(const QCborArray__Iterator* self, QCborArray__Iterator* other);
@@ -115,11 +115,11 @@ QCborArray__Iterator* QCborArray__Iterator_OperatorPlusPlus(QCborArray__Iterator
 QCborArray__Iterator* QCborArray__Iterator_OperatorPlusPlusWithInt(QCborArray__Iterator* self, int param1);
 QCborArray__Iterator* QCborArray__Iterator_OperatorMinusMinus(QCborArray__Iterator* self);
 QCborArray__Iterator* QCborArray__Iterator_OperatorMinusMinusWithInt(QCborArray__Iterator* self, int param1);
-QCborArray__Iterator* QCborArray__Iterator_OperatorPlusAssign(QCborArray__Iterator* self, size_t j);
-QCborArray__Iterator* QCborArray__Iterator_OperatorMinusAssign(QCborArray__Iterator* self, size_t j);
-QCborArray__Iterator* QCborArray__Iterator_OperatorPlus(const QCborArray__Iterator* self, size_t j);
-QCborArray__Iterator* QCborArray__Iterator_OperatorMinus(const QCborArray__Iterator* self, size_t j);
-size_t QCborArray__Iterator_OperatorMinusWithQCborArrayIterator(const QCborArray__Iterator* self, QCborArray__Iterator* j);
+QCborArray__Iterator* QCborArray__Iterator_OperatorPlusAssign(QCborArray__Iterator* self, ptrdiff_t j);
+QCborArray__Iterator* QCborArray__Iterator_OperatorMinusAssign(QCborArray__Iterator* self, ptrdiff_t j);
+QCborArray__Iterator* QCborArray__Iterator_OperatorPlus(const QCborArray__Iterator* self, ptrdiff_t j);
+QCborArray__Iterator* QCborArray__Iterator_OperatorMinus(const QCborArray__Iterator* self, ptrdiff_t j);
+ptrdiff_t QCborArray__Iterator_OperatorMinusWithQCborArrayIterator(const QCborArray__Iterator* self, QCborArray__Iterator* j);
 void QCborArray__Iterator_Delete(QCborArray__Iterator* self);
 
 QCborArray__ConstIterator* QCborArray__ConstIterator_new();
@@ -127,7 +127,7 @@ QCborArray__ConstIterator* QCborArray__ConstIterator_new2(QCborArray__ConstItera
 void QCborArray__ConstIterator_OperatorAssign(QCborArray__ConstIterator* self, QCborArray__ConstIterator* other);
 QCborValueRef* QCborArray__ConstIterator_OperatorMultiply(const QCborArray__ConstIterator* self);
 QCborValueRef* QCborArray__ConstIterator_OperatorMinusGreater(const QCborArray__ConstIterator* self);
-QCborValueRef* QCborArray__ConstIterator_OperatorSubscript(QCborArray__ConstIterator* self, size_t j);
+QCborValueRef* QCborArray__ConstIterator_OperatorSubscript(QCborArray__ConstIterator* self, ptrdiff_t j);
 bool QCborArray__ConstIterator_OperatorEqual(const QCborArray__ConstIterator* self, QCborArray__Iterator* o);
 bool QCborArray__ConstIterator_OperatorNotEqual(const QCborArray__ConstIterator* self, QCborArray__Iterator* o);
 bool QCborArray__ConstIterator_OperatorLesser(const QCborArray__ConstIterator* self, QCborArray__Iterator* other);
@@ -144,11 +144,11 @@ QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlusPlus(QCborArray
 QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlusPlusWithInt(QCborArray__ConstIterator* self, int param1);
 QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinusMinus(QCborArray__ConstIterator* self);
 QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinusMinusWithInt(QCborArray__ConstIterator* self, int param1);
-QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlusAssign(QCborArray__ConstIterator* self, size_t j);
-QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinusAssign(QCborArray__ConstIterator* self, size_t j);
-QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlus(const QCborArray__ConstIterator* self, size_t j);
-QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinus(const QCborArray__ConstIterator* self, size_t j);
-size_t QCborArray__ConstIterator_OperatorMinusWithQCborArrayConstIterator(const QCborArray__ConstIterator* self, QCborArray__ConstIterator* j);
+QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlusAssign(QCborArray__ConstIterator* self, ptrdiff_t j);
+QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinusAssign(QCborArray__ConstIterator* self, ptrdiff_t j);
+QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlus(const QCborArray__ConstIterator* self, ptrdiff_t j);
+QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinus(const QCborArray__ConstIterator* self, ptrdiff_t j);
+ptrdiff_t QCborArray__ConstIterator_OperatorMinusWithQCborArrayConstIterator(const QCborArray__ConstIterator* self, QCborArray__ConstIterator* j);
 void QCborArray__ConstIterator_Delete(QCborArray__ConstIterator* self);
 
 #ifdef __cplusplus
diff --git a/qt/gen_qcbormap.cpp b/qt/gen_qcbormap.cpp
index 06d842f..4e7557c 100644
--- a/qt/gen_qcbormap.cpp
+++ b/qt/gen_qcbormap.cpp
@@ -32,8 +32,9 @@ QCborValue* QCborMap_ToCborValue(const QCborMap* self) {
 	return new QCborValue(self->toCborValue());
 }
 
-size_t QCborMap_Size(const QCborMap* self) {
-	return self->size();
+ptrdiff_t QCborMap_Size(const QCborMap* self) {
+	qsizetype _ret = self->size();
+	return static_cast<ptrdiff_t>(_ret);
 }
 
 bool QCborMap_IsEmpty(const QCborMap* self) {
@@ -359,28 +360,29 @@ QCborMap__Iterator* QCborMap__Iterator_OperatorMinusMinusWithInt(QCborMap__Itera
 	return new QCborMap::Iterator(self->operator--(static_cast<int>(param1)));
 }
 
-QCborMap__Iterator* QCborMap__Iterator_OperatorPlusAssign(QCborMap__Iterator* self, size_t j) {
-	QCborMap::Iterator& _ret = self->operator+=(static_cast<qsizetype>(j));
+QCborMap__Iterator* QCborMap__Iterator_OperatorPlusAssign(QCborMap__Iterator* self, ptrdiff_t j) {
+	QCborMap::Iterator& _ret = self->operator+=((qsizetype)(j));
 	// Cast returned reference into pointer
 	return &_ret;
 }
 
-QCborMap__Iterator* QCborMap__Iterator_OperatorMinusAssign(QCborMap__Iterator* self, size_t j) {
-	QCborMap::Iterator& _ret = self->operator-=(static_cast<qsizetype>(j));
+QCborMap__Iterator* QCborMap__Iterator_OperatorMinusAssign(QCborMap__Iterator* self, ptrdiff_t j) {
+	QCborMap::Iterator& _ret = self->operator-=((qsizetype)(j));
 	// Cast returned reference into pointer
 	return &_ret;
 }
 
-QCborMap__Iterator* QCborMap__Iterator_OperatorPlus(const QCborMap__Iterator* self, size_t j) {
-	return new QCborMap::Iterator(self->operator+(static_cast<qsizetype>(j)));
+QCborMap__Iterator* QCborMap__Iterator_OperatorPlus(const QCborMap__Iterator* self, ptrdiff_t j) {
+	return new QCborMap::Iterator(self->operator+((qsizetype)(j)));
 }
 
-QCborMap__Iterator* QCborMap__Iterator_OperatorMinus(const QCborMap__Iterator* self, size_t j) {
-	return new QCborMap::Iterator(self->operator-(static_cast<qsizetype>(j)));
+QCborMap__Iterator* QCborMap__Iterator_OperatorMinus(const QCborMap__Iterator* self, ptrdiff_t j) {
+	return new QCborMap::Iterator(self->operator-((qsizetype)(j)));
 }
 
-size_t QCborMap__Iterator_OperatorMinusWithQCborMapIterator(const QCborMap__Iterator* self, QCborMap__Iterator* j) {
-	return self->operator-(*j);
+ptrdiff_t QCborMap__Iterator_OperatorMinusWithQCborMapIterator(const QCborMap__Iterator* self, QCborMap__Iterator* j) {
+	qsizetype _ret = self->operator-(*j);
+	return static_cast<ptrdiff_t>(_ret);
 }
 
 void QCborMap__Iterator_Delete(QCborMap__Iterator* self) {
@@ -479,28 +481,29 @@ QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinusMinusWithInt(QCbor
 	return new QCborMap::ConstIterator(self->operator--(static_cast<int>(param1)));
 }
 
-QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlusAssign(QCborMap__ConstIterator* self, size_t j) {
-	QCborMap::ConstIterator& _ret = self->operator+=(static_cast<qsizetype>(j));
+QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlusAssign(QCborMap__ConstIterator* self, ptrdiff_t j) {
+	QCborMap::ConstIterator& _ret = self->operator+=((qsizetype)(j));
 	// Cast returned reference into pointer
 	return &_ret;
 }
 
-QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinusAssign(QCborMap__ConstIterator* self, size_t j) {
-	QCborMap::ConstIterator& _ret = self->operator-=(static_cast<qsizetype>(j));
+QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinusAssign(QCborMap__ConstIterator* self, ptrdiff_t j) {
+	QCborMap::ConstIterator& _ret = self->operator-=((qsizetype)(j));
 	// Cast returned reference into pointer
 	return &_ret;
 }
 
-QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlus(const QCborMap__ConstIterator* self, size_t j) {
-	return new QCborMap::ConstIterator(self->operator+(static_cast<qsizetype>(j)));
+QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlus(const QCborMap__ConstIterator* self, ptrdiff_t j) {
+	return new QCborMap::ConstIterator(self->operator+((qsizetype)(j)));
 }
 
-QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinus(const QCborMap__ConstIterator* self, size_t j) {
-	return new QCborMap::ConstIterator(self->operator-(static_cast<qsizetype>(j)));
+QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinus(const QCborMap__ConstIterator* self, ptrdiff_t j) {
+	return new QCborMap::ConstIterator(self->operator-((qsizetype)(j)));
 }
 
-size_t QCborMap__ConstIterator_OperatorMinusWithQCborMapConstIterator(const QCborMap__ConstIterator* self, QCborMap__ConstIterator* j) {
-	return self->operator-(*j);
+ptrdiff_t QCborMap__ConstIterator_OperatorMinusWithQCborMapConstIterator(const QCborMap__ConstIterator* self, QCborMap__ConstIterator* j) {
+	qsizetype _ret = self->operator-(*j);
+	return static_cast<ptrdiff_t>(_ret);
 }
 
 void QCborMap__ConstIterator_Delete(QCborMap__ConstIterator* self) {
diff --git a/qt/gen_qcbormap.go b/qt/gen_qcbormap.go
index 650acfe..70c1ffb 100644
--- a/qt/gen_qcbormap.go
+++ b/qt/gen_qcbormap.go
@@ -62,8 +62,8 @@ func (this *QCborMap) ToCborValue() *QCborValue {
 	return _goptr
 }
 
-func (this *QCborMap) Size() uint64 {
-	return (uint64)(C.QCborMap_Size(this.h))
+func (this *QCborMap) Size() int64 {
+	return (int64)(C.QCborMap_Size(this.h))
 }
 
 func (this *QCborMap) IsEmpty() bool {
@@ -558,30 +558,30 @@ func (this *QCborMap__Iterator) OperatorMinusMinusWithInt(param1 int) *QCborMap_
 	return _goptr
 }
 
-func (this *QCborMap__Iterator) OperatorPlusAssign(j uint64) *QCborMap__Iterator {
-	return newQCborMap__Iterator_U(unsafe.Pointer(C.QCborMap__Iterator_OperatorPlusAssign(this.h, (C.size_t)(j))))
+func (this *QCborMap__Iterator) OperatorPlusAssign(j int64) *QCborMap__Iterator {
+	return newQCborMap__Iterator_U(unsafe.Pointer(C.QCborMap__Iterator_OperatorPlusAssign(this.h, (C.ptrdiff_t)(j))))
 }
 
-func (this *QCborMap__Iterator) OperatorMinusAssign(j uint64) *QCborMap__Iterator {
-	return newQCborMap__Iterator_U(unsafe.Pointer(C.QCborMap__Iterator_OperatorMinusAssign(this.h, (C.size_t)(j))))
+func (this *QCborMap__Iterator) OperatorMinusAssign(j int64) *QCborMap__Iterator {
+	return newQCborMap__Iterator_U(unsafe.Pointer(C.QCborMap__Iterator_OperatorMinusAssign(this.h, (C.ptrdiff_t)(j))))
 }
 
-func (this *QCborMap__Iterator) OperatorPlus(j uint64) *QCborMap__Iterator {
-	_ret := C.QCborMap__Iterator_OperatorPlus(this.h, (C.size_t)(j))
+func (this *QCborMap__Iterator) OperatorPlus(j int64) *QCborMap__Iterator {
+	_ret := C.QCborMap__Iterator_OperatorPlus(this.h, (C.ptrdiff_t)(j))
 	_goptr := newQCborMap__Iterator(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func (this *QCborMap__Iterator) OperatorMinus(j uint64) *QCborMap__Iterator {
-	_ret := C.QCborMap__Iterator_OperatorMinus(this.h, (C.size_t)(j))
+func (this *QCborMap__Iterator) OperatorMinus(j int64) *QCborMap__Iterator {
+	_ret := C.QCborMap__Iterator_OperatorMinus(this.h, (C.ptrdiff_t)(j))
 	_goptr := newQCborMap__Iterator(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func (this *QCborMap__Iterator) OperatorMinusWithQCborMapIterator(j QCborMap__Iterator) uint64 {
-	return (uint64)(C.QCborMap__Iterator_OperatorMinusWithQCborMapIterator(this.h, j.cPointer()))
+func (this *QCborMap__Iterator) OperatorMinusWithQCborMapIterator(j QCborMap__Iterator) int64 {
+	return (int64)(C.QCborMap__Iterator_OperatorMinusWithQCborMapIterator(this.h, j.cPointer()))
 }
 
 // Delete this object from C++ memory.
@@ -724,30 +724,30 @@ func (this *QCborMap__ConstIterator) OperatorMinusMinusWithInt(param1 int) *QCbo
 	return _goptr
 }
 
-func (this *QCborMap__ConstIterator) OperatorPlusAssign(j uint64) *QCborMap__ConstIterator {
-	return newQCborMap__ConstIterator_U(unsafe.Pointer(C.QCborMap__ConstIterator_OperatorPlusAssign(this.h, (C.size_t)(j))))
+func (this *QCborMap__ConstIterator) OperatorPlusAssign(j int64) *QCborMap__ConstIterator {
+	return newQCborMap__ConstIterator_U(unsafe.Pointer(C.QCborMap__ConstIterator_OperatorPlusAssign(this.h, (C.ptrdiff_t)(j))))
 }
 
-func (this *QCborMap__ConstIterator) OperatorMinusAssign(j uint64) *QCborMap__ConstIterator {
-	return newQCborMap__ConstIterator_U(unsafe.Pointer(C.QCborMap__ConstIterator_OperatorMinusAssign(this.h, (C.size_t)(j))))
+func (this *QCborMap__ConstIterator) OperatorMinusAssign(j int64) *QCborMap__ConstIterator {
+	return newQCborMap__ConstIterator_U(unsafe.Pointer(C.QCborMap__ConstIterator_OperatorMinusAssign(this.h, (C.ptrdiff_t)(j))))
 }
 
-func (this *QCborMap__ConstIterator) OperatorPlus(j uint64) *QCborMap__ConstIterator {
-	_ret := C.QCborMap__ConstIterator_OperatorPlus(this.h, (C.size_t)(j))
+func (this *QCborMap__ConstIterator) OperatorPlus(j int64) *QCborMap__ConstIterator {
+	_ret := C.QCborMap__ConstIterator_OperatorPlus(this.h, (C.ptrdiff_t)(j))
 	_goptr := newQCborMap__ConstIterator(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func (this *QCborMap__ConstIterator) OperatorMinus(j uint64) *QCborMap__ConstIterator {
-	_ret := C.QCborMap__ConstIterator_OperatorMinus(this.h, (C.size_t)(j))
+func (this *QCborMap__ConstIterator) OperatorMinus(j int64) *QCborMap__ConstIterator {
+	_ret := C.QCborMap__ConstIterator_OperatorMinus(this.h, (C.ptrdiff_t)(j))
 	_goptr := newQCborMap__ConstIterator(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func (this *QCborMap__ConstIterator) OperatorMinusWithQCborMapConstIterator(j QCborMap__ConstIterator) uint64 {
-	return (uint64)(C.QCborMap__ConstIterator_OperatorMinusWithQCborMapConstIterator(this.h, j.cPointer()))
+func (this *QCborMap__ConstIterator) OperatorMinusWithQCborMapConstIterator(j QCborMap__ConstIterator) int64 {
+	return (int64)(C.QCborMap__ConstIterator_OperatorMinusWithQCborMapConstIterator(this.h, j.cPointer()))
 }
 
 // Delete this object from C++ memory.
diff --git a/qt/gen_qcbormap.h b/qt/gen_qcbormap.h
index ab929c4..c990cf6 100644
--- a/qt/gen_qcbormap.h
+++ b/qt/gen_qcbormap.h
@@ -42,7 +42,7 @@ QCborMap* QCborMap_new2(QCborMap* other);
 void QCborMap_OperatorAssign(QCborMap* self, QCborMap* other);
 void QCborMap_Swap(QCborMap* self, QCborMap* other);
 QCborValue* QCborMap_ToCborValue(const QCborMap* self);
-size_t QCborMap_Size(const QCborMap* self);
+ptrdiff_t QCborMap_Size(const QCborMap* self);
 bool QCborMap_IsEmpty(const QCborMap* self);
 void QCborMap_Clear(QCborMap* self);
 struct miqt_array* QCborMap_Keys(const QCborMap* self);
@@ -119,11 +119,11 @@ QCborMap__Iterator* QCborMap__Iterator_OperatorPlusPlus(QCborMap__Iterator* self
 QCborMap__Iterator* QCborMap__Iterator_OperatorPlusPlusWithInt(QCborMap__Iterator* self, int param1);
 QCborMap__Iterator* QCborMap__Iterator_OperatorMinusMinus(QCborMap__Iterator* self);
 QCborMap__Iterator* QCborMap__Iterator_OperatorMinusMinusWithInt(QCborMap__Iterator* self, int param1);
-QCborMap__Iterator* QCborMap__Iterator_OperatorPlusAssign(QCborMap__Iterator* self, size_t j);
-QCborMap__Iterator* QCborMap__Iterator_OperatorMinusAssign(QCborMap__Iterator* self, size_t j);
-QCborMap__Iterator* QCborMap__Iterator_OperatorPlus(const QCborMap__Iterator* self, size_t j);
-QCborMap__Iterator* QCborMap__Iterator_OperatorMinus(const QCborMap__Iterator* self, size_t j);
-size_t QCborMap__Iterator_OperatorMinusWithQCborMapIterator(const QCborMap__Iterator* self, QCborMap__Iterator* j);
+QCborMap__Iterator* QCborMap__Iterator_OperatorPlusAssign(QCborMap__Iterator* self, ptrdiff_t j);
+QCborMap__Iterator* QCborMap__Iterator_OperatorMinusAssign(QCborMap__Iterator* self, ptrdiff_t j);
+QCborMap__Iterator* QCborMap__Iterator_OperatorPlus(const QCborMap__Iterator* self, ptrdiff_t j);
+QCborMap__Iterator* QCborMap__Iterator_OperatorMinus(const QCborMap__Iterator* self, ptrdiff_t j);
+ptrdiff_t QCborMap__Iterator_OperatorMinusWithQCborMapIterator(const QCborMap__Iterator* self, QCborMap__Iterator* j);
 void QCborMap__Iterator_Delete(QCborMap__Iterator* self);
 
 QCborMap__ConstIterator* QCborMap__ConstIterator_new();
@@ -148,11 +148,11 @@ QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlusPlus(QCborMap__Cons
 QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlusPlusWithInt(QCborMap__ConstIterator* self, int param1);
 QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinusMinus(QCborMap__ConstIterator* self);
 QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinusMinusWithInt(QCborMap__ConstIterator* self, int param1);
-QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlusAssign(QCborMap__ConstIterator* self, size_t j);
-QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinusAssign(QCborMap__ConstIterator* self, size_t j);
-QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlus(const QCborMap__ConstIterator* self, size_t j);
-QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinus(const QCborMap__ConstIterator* self, size_t j);
-size_t QCborMap__ConstIterator_OperatorMinusWithQCborMapConstIterator(const QCborMap__ConstIterator* self, QCborMap__ConstIterator* j);
+QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlusAssign(QCborMap__ConstIterator* self, ptrdiff_t j);
+QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinusAssign(QCborMap__ConstIterator* self, ptrdiff_t j);
+QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlus(const QCborMap__ConstIterator* self, ptrdiff_t j);
+QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinus(const QCborMap__ConstIterator* self, ptrdiff_t j);
+ptrdiff_t QCborMap__ConstIterator_OperatorMinusWithQCborMapConstIterator(const QCborMap__ConstIterator* self, QCborMap__ConstIterator* j);
 void QCborMap__ConstIterator_Delete(QCborMap__ConstIterator* self);
 
 #ifdef __cplusplus
diff --git a/qt/gen_qcborstreamreader.cpp b/qt/gen_qcborstreamreader.cpp
index 7b56f9c..64bafac 100644
--- a/qt/gen_qcborstreamreader.cpp
+++ b/qt/gen_qcborstreamreader.cpp
@@ -10,12 +10,12 @@ QCborStreamReader* QCborStreamReader_new() {
 	return new QCborStreamReader();
 }
 
-QCborStreamReader* QCborStreamReader_new2(const char* data, size_t lenVal) {
-	return new QCborStreamReader(data, static_cast<qsizetype>(lenVal));
+QCborStreamReader* QCborStreamReader_new2(const char* data, ptrdiff_t lenVal) {
+	return new QCborStreamReader(data, (qsizetype)(lenVal));
 }
 
-QCborStreamReader* QCborStreamReader_new3(const unsigned char* data, size_t lenVal) {
-	return new QCborStreamReader(static_cast<const quint8*>(data), static_cast<qsizetype>(lenVal));
+QCborStreamReader* QCborStreamReader_new3(const unsigned char* data, ptrdiff_t lenVal) {
+	return new QCborStreamReader(static_cast<const quint8*>(data), (qsizetype)(lenVal));
 }
 
 QCborStreamReader* QCborStreamReader_new4(QByteArray* data) {
@@ -38,12 +38,12 @@ void QCborStreamReader_AddData(QCborStreamReader* self, QByteArray* data) {
 	self->addData(*data);
 }
 
-void QCborStreamReader_AddData2(QCborStreamReader* self, const char* data, size_t lenVal) {
-	self->addData(data, static_cast<qsizetype>(lenVal));
+void QCborStreamReader_AddData2(QCborStreamReader* self, const char* data, ptrdiff_t lenVal) {
+	self->addData(data, (qsizetype)(lenVal));
 }
 
-void QCborStreamReader_AddData3(QCborStreamReader* self, const unsigned char* data, size_t lenVal) {
-	self->addData(static_cast<const quint8*>(data), static_cast<qsizetype>(lenVal));
+void QCborStreamReader_AddData3(QCborStreamReader* self, const unsigned char* data, ptrdiff_t lenVal) {
+	self->addData(static_cast<const quint8*>(data), (qsizetype)(lenVal));
 }
 
 void QCborStreamReader_Reparse(QCborStreamReader* self) {
@@ -190,8 +190,9 @@ bool QCborStreamReader_LeaveContainer(QCborStreamReader* self) {
 	return self->leaveContainer();
 }
 
-size_t QCborStreamReader_CurrentStringChunkSize(const QCborStreamReader* self) {
-	return self->currentStringChunkSize();
+ptrdiff_t QCborStreamReader_CurrentStringChunkSize(const QCborStreamReader* self) {
+	qsizetype _ret = self->currentStringChunkSize();
+	return static_cast<ptrdiff_t>(_ret);
 }
 
 bool QCborStreamReader_ToBool(const QCborStreamReader* self) {
diff --git a/qt/gen_qcborstreamreader.go b/qt/gen_qcborstreamreader.go
index f0f40ef..8d8b983 100644
--- a/qt/gen_qcborstreamreader.go
+++ b/qt/gen_qcborstreamreader.go
@@ -70,16 +70,16 @@ func NewQCborStreamReader() *QCborStreamReader {
 }
 
 // NewQCborStreamReader2 constructs a new QCborStreamReader object.
-func NewQCborStreamReader2(data string, lenVal uint64) *QCborStreamReader {
+func NewQCborStreamReader2(data string, lenVal int64) *QCborStreamReader {
 	data_Cstring := C.CString(data)
 	defer C.free(unsafe.Pointer(data_Cstring))
-	ret := C.QCborStreamReader_new2(data_Cstring, (C.size_t)(lenVal))
+	ret := C.QCborStreamReader_new2(data_Cstring, (C.ptrdiff_t)(lenVal))
 	return newQCborStreamReader(ret)
 }
 
 // NewQCborStreamReader3 constructs a new QCborStreamReader object.
-func NewQCborStreamReader3(data *byte, lenVal uint64) *QCborStreamReader {
-	ret := C.QCborStreamReader_new3((*C.uchar)(unsafe.Pointer(data)), (C.size_t)(lenVal))
+func NewQCborStreamReader3(data *byte, lenVal int64) *QCborStreamReader {
+	ret := C.QCborStreamReader_new3((*C.uchar)(unsafe.Pointer(data)), (C.ptrdiff_t)(lenVal))
 	return newQCborStreamReader(ret)
 }
 
@@ -107,14 +107,14 @@ func (this *QCborStreamReader) AddData(data *QByteArray) {
 	C.QCborStreamReader_AddData(this.h, data.cPointer())
 }
 
-func (this *QCborStreamReader) AddData2(data string, lenVal uint64) {
+func (this *QCborStreamReader) AddData2(data string, lenVal int64) {
 	data_Cstring := C.CString(data)
 	defer C.free(unsafe.Pointer(data_Cstring))
-	C.QCborStreamReader_AddData2(this.h, data_Cstring, (C.size_t)(lenVal))
+	C.QCborStreamReader_AddData2(this.h, data_Cstring, (C.ptrdiff_t)(lenVal))
 }
 
-func (this *QCborStreamReader) AddData3(data *byte, lenVal uint64) {
-	C.QCborStreamReader_AddData3(this.h, (*C.uchar)(unsafe.Pointer(data)), (C.size_t)(lenVal))
+func (this *QCborStreamReader) AddData3(data *byte, lenVal int64) {
+	C.QCborStreamReader_AddData3(this.h, (*C.uchar)(unsafe.Pointer(data)), (C.ptrdiff_t)(lenVal))
 }
 
 func (this *QCborStreamReader) Reparse() {
@@ -260,8 +260,8 @@ func (this *QCborStreamReader) LeaveContainer() bool {
 	return (bool)(C.QCborStreamReader_LeaveContainer(this.h))
 }
 
-func (this *QCborStreamReader) CurrentStringChunkSize() uint64 {
-	return (uint64)(C.QCborStreamReader_CurrentStringChunkSize(this.h))
+func (this *QCborStreamReader) CurrentStringChunkSize() int64 {
+	return (int64)(C.QCborStreamReader_CurrentStringChunkSize(this.h))
 }
 
 func (this *QCborStreamReader) ToBool() bool {
diff --git a/qt/gen_qcborstreamreader.h b/qt/gen_qcborstreamreader.h
index 66a2b74..566ead4 100644
--- a/qt/gen_qcborstreamreader.h
+++ b/qt/gen_qcborstreamreader.h
@@ -26,15 +26,15 @@ typedef struct QIODevice QIODevice;
 #endif
 
 QCborStreamReader* QCborStreamReader_new();
-QCborStreamReader* QCborStreamReader_new2(const char* data, size_t lenVal);
-QCborStreamReader* QCborStreamReader_new3(const unsigned char* data, size_t lenVal);
+QCborStreamReader* QCborStreamReader_new2(const char* data, ptrdiff_t lenVal);
+QCborStreamReader* QCborStreamReader_new3(const unsigned char* data, ptrdiff_t lenVal);
 QCborStreamReader* QCborStreamReader_new4(QByteArray* data);
 QCborStreamReader* QCborStreamReader_new5(QIODevice* device);
 void QCborStreamReader_SetDevice(QCborStreamReader* self, QIODevice* device);
 QIODevice* QCborStreamReader_Device(const QCborStreamReader* self);
 void QCborStreamReader_AddData(QCborStreamReader* self, QByteArray* data);
-void QCborStreamReader_AddData2(QCborStreamReader* self, const char* data, size_t lenVal);
-void QCborStreamReader_AddData3(QCborStreamReader* self, const unsigned char* data, size_t lenVal);
+void QCborStreamReader_AddData2(QCborStreamReader* self, const char* data, ptrdiff_t lenVal);
+void QCborStreamReader_AddData3(QCborStreamReader* self, const unsigned char* data, ptrdiff_t lenVal);
 void QCborStreamReader_Reparse(QCborStreamReader* self);
 void QCborStreamReader_Clear(QCborStreamReader* self);
 void QCborStreamReader_Reset(QCborStreamReader* self);
@@ -70,7 +70,7 @@ unsigned long long QCborStreamReader_Length(const QCborStreamReader* self);
 bool QCborStreamReader_IsContainer(const QCborStreamReader* self);
 bool QCborStreamReader_EnterContainer(QCborStreamReader* self);
 bool QCborStreamReader_LeaveContainer(QCborStreamReader* self);
-size_t QCborStreamReader_CurrentStringChunkSize(const QCborStreamReader* self);
+ptrdiff_t QCborStreamReader_CurrentStringChunkSize(const QCborStreamReader* self);
 bool QCborStreamReader_ToBool(const QCborStreamReader* self);
 uint64_t QCborStreamReader_ToTag(const QCborStreamReader* self);
 unsigned long long QCborStreamReader_ToUnsignedInteger(const QCborStreamReader* self);
diff --git a/qt/gen_qcborstreamwriter.cpp b/qt/gen_qcborstreamwriter.cpp
index ba460ab..50b36f6 100644
--- a/qt/gen_qcborstreamwriter.cpp
+++ b/qt/gen_qcborstreamwriter.cpp
@@ -57,12 +57,12 @@ void QCborStreamWriter_AppendWithDouble(QCborStreamWriter* self, double d) {
 	self->append(static_cast<double>(d));
 }
 
-void QCborStreamWriter_AppendByteString(QCborStreamWriter* self, const char* data, size_t lenVal) {
-	self->appendByteString(data, static_cast<qsizetype>(lenVal));
+void QCborStreamWriter_AppendByteString(QCborStreamWriter* self, const char* data, ptrdiff_t lenVal) {
+	self->appendByteString(data, (qsizetype)(lenVal));
 }
 
-void QCborStreamWriter_AppendTextString(QCborStreamWriter* self, const char* utf8, size_t lenVal) {
-	self->appendTextString(utf8, static_cast<qsizetype>(lenVal));
+void QCborStreamWriter_AppendTextString(QCborStreamWriter* self, const char* utf8, ptrdiff_t lenVal) {
+	self->appendTextString(utf8, (qsizetype)(lenVal));
 }
 
 void QCborStreamWriter_AppendWithBool(QCborStreamWriter* self, bool b) {
@@ -113,8 +113,8 @@ bool QCborStreamWriter_EndMap(QCborStreamWriter* self) {
 	return self->endMap();
 }
 
-void QCborStreamWriter_Append22(QCborStreamWriter* self, const char* str, size_t size) {
-	self->append(str, static_cast<qsizetype>(size));
+void QCborStreamWriter_Append22(QCborStreamWriter* self, const char* str, ptrdiff_t size) {
+	self->append(str, (qsizetype)(size));
 }
 
 void QCborStreamWriter_Delete(QCborStreamWriter* self) {
diff --git a/qt/gen_qcborstreamwriter.go b/qt/gen_qcborstreamwriter.go
index 3adfc4d..b96c68b 100644
--- a/qt/gen_qcborstreamwriter.go
+++ b/qt/gen_qcborstreamwriter.go
@@ -91,16 +91,16 @@ func (this *QCborStreamWriter) AppendWithDouble(d float64) {
 	C.QCborStreamWriter_AppendWithDouble(this.h, (C.double)(d))
 }
 
-func (this *QCborStreamWriter) AppendByteString(data string, lenVal uint64) {
+func (this *QCborStreamWriter) AppendByteString(data string, lenVal int64) {
 	data_Cstring := C.CString(data)
 	defer C.free(unsafe.Pointer(data_Cstring))
-	C.QCborStreamWriter_AppendByteString(this.h, data_Cstring, (C.size_t)(lenVal))
+	C.QCborStreamWriter_AppendByteString(this.h, data_Cstring, (C.ptrdiff_t)(lenVal))
 }
 
-func (this *QCborStreamWriter) AppendTextString(utf8 string, lenVal uint64) {
+func (this *QCborStreamWriter) AppendTextString(utf8 string, lenVal int64) {
 	utf8_Cstring := C.CString(utf8)
 	defer C.free(unsafe.Pointer(utf8_Cstring))
-	C.QCborStreamWriter_AppendTextString(this.h, utf8_Cstring, (C.size_t)(lenVal))
+	C.QCborStreamWriter_AppendTextString(this.h, utf8_Cstring, (C.ptrdiff_t)(lenVal))
 }
 
 func (this *QCborStreamWriter) AppendWithBool(b bool) {
@@ -153,10 +153,10 @@ func (this *QCborStreamWriter) EndMap() bool {
 	return (bool)(C.QCborStreamWriter_EndMap(this.h))
 }
 
-func (this *QCborStreamWriter) Append22(str string, size uint64) {
+func (this *QCborStreamWriter) Append22(str string, size int64) {
 	str_Cstring := C.CString(str)
 	defer C.free(unsafe.Pointer(str_Cstring))
-	C.QCborStreamWriter_Append22(this.h, str_Cstring, (C.size_t)(size))
+	C.QCborStreamWriter_Append22(this.h, str_Cstring, (C.ptrdiff_t)(size))
 }
 
 // Delete this object from C++ memory.
diff --git a/qt/gen_qcborstreamwriter.h b/qt/gen_qcborstreamwriter.h
index 0e8bb2f..1857f41 100644
--- a/qt/gen_qcborstreamwriter.h
+++ b/qt/gen_qcborstreamwriter.h
@@ -36,8 +36,8 @@ void QCborStreamWriter_Append3(QCborStreamWriter* self, int tag);
 void QCborStreamWriter_AppendWithSt(QCborStreamWriter* self, uint8_t st);
 void QCborStreamWriter_AppendWithFloat(QCborStreamWriter* self, float f);
 void QCborStreamWriter_AppendWithDouble(QCborStreamWriter* self, double d);
-void QCborStreamWriter_AppendByteString(QCborStreamWriter* self, const char* data, size_t lenVal);
-void QCborStreamWriter_AppendTextString(QCborStreamWriter* self, const char* utf8, size_t lenVal);
+void QCborStreamWriter_AppendByteString(QCborStreamWriter* self, const char* data, ptrdiff_t lenVal);
+void QCborStreamWriter_AppendTextString(QCborStreamWriter* self, const char* utf8, ptrdiff_t lenVal);
 void QCborStreamWriter_AppendWithBool(QCborStreamWriter* self, bool b);
 void QCborStreamWriter_AppendNull(QCborStreamWriter* self);
 void QCborStreamWriter_AppendUndefined(QCborStreamWriter* self);
@@ -50,7 +50,7 @@ bool QCborStreamWriter_EndArray(QCborStreamWriter* self);
 void QCborStreamWriter_StartMap(QCborStreamWriter* self);
 void QCborStreamWriter_StartMapWithCount(QCborStreamWriter* self, unsigned long long count);
 bool QCborStreamWriter_EndMap(QCborStreamWriter* self);
-void QCborStreamWriter_Append22(QCborStreamWriter* self, const char* str, size_t size);
+void QCborStreamWriter_Append22(QCborStreamWriter* self, const char* str, ptrdiff_t size);
 void QCborStreamWriter_Delete(QCborStreamWriter* self);
 
 #ifdef __cplusplus
diff --git a/qt/gen_qcborvalue.cpp b/qt/gen_qcborvalue.cpp
index 59c4d23..62eee0c 100644
--- a/qt/gen_qcborvalue.cpp
+++ b/qt/gen_qcborvalue.cpp
@@ -340,12 +340,12 @@ QCborValue* QCborValue_FromCborWithBa(QByteArray* ba) {
 	return new QCborValue(QCborValue::fromCbor(*ba));
 }
 
-QCborValue* QCborValue_FromCbor2(const char* data, size_t lenVal) {
-	return new QCborValue(QCborValue::fromCbor(data, static_cast<qsizetype>(lenVal)));
+QCborValue* QCborValue_FromCbor2(const char* data, ptrdiff_t lenVal) {
+	return new QCborValue(QCborValue::fromCbor(data, (qsizetype)(lenVal)));
 }
 
-QCborValue* QCborValue_FromCbor3(const unsigned char* data, size_t lenVal) {
-	return new QCborValue(QCborValue::fromCbor(static_cast<const quint8*>(data), static_cast<qsizetype>(lenVal)));
+QCborValue* QCborValue_FromCbor3(const unsigned char* data, ptrdiff_t lenVal) {
+	return new QCborValue(QCborValue::fromCbor(static_cast<const quint8*>(data), (qsizetype)(lenVal)));
 }
 
 QByteArray* QCborValue_ToCbor(QCborValue* self) {
@@ -422,12 +422,12 @@ QCborValue* QCborValue_FromCbor22(QByteArray* ba, QCborParserError* error) {
 	return new QCborValue(QCborValue::fromCbor(*ba, error));
 }
 
-QCborValue* QCborValue_FromCbor32(const char* data, size_t lenVal, QCborParserError* error) {
-	return new QCborValue(QCborValue::fromCbor(data, static_cast<qsizetype>(lenVal), error));
+QCborValue* QCborValue_FromCbor32(const char* data, ptrdiff_t lenVal, QCborParserError* error) {
+	return new QCborValue(QCborValue::fromCbor(data, (qsizetype)(lenVal), error));
 }
 
-QCborValue* QCborValue_FromCbor33(const unsigned char* data, size_t lenVal, QCborParserError* error) {
-	return new QCborValue(QCborValue::fromCbor(static_cast<const quint8*>(data), static_cast<qsizetype>(lenVal), error));
+QCborValue* QCborValue_FromCbor33(const unsigned char* data, ptrdiff_t lenVal, QCborParserError* error) {
+	return new QCborValue(QCborValue::fromCbor(static_cast<const quint8*>(data), (qsizetype)(lenVal), error));
 }
 
 QByteArray* QCborValue_ToCbor1(QCborValue* self, int opt) {
diff --git a/qt/gen_qcborvalue.go b/qt/gen_qcborvalue.go
index f9121f2..03d8b93 100644
--- a/qt/gen_qcborvalue.go
+++ b/qt/gen_qcborvalue.go
@@ -533,17 +533,17 @@ func QCborValue_FromCborWithBa(ba *QByteArray) *QCborValue {
 	return _goptr
 }
 
-func QCborValue_FromCbor2(data string, lenVal uint64) *QCborValue {
+func QCborValue_FromCbor2(data string, lenVal int64) *QCborValue {
 	data_Cstring := C.CString(data)
 	defer C.free(unsafe.Pointer(data_Cstring))
-	_ret := C.QCborValue_FromCbor2(data_Cstring, (C.size_t)(lenVal))
+	_ret := C.QCborValue_FromCbor2(data_Cstring, (C.ptrdiff_t)(lenVal))
 	_goptr := newQCborValue(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func QCborValue_FromCbor3(data *byte, lenVal uint64) *QCborValue {
-	_ret := C.QCborValue_FromCbor3((*C.uchar)(unsafe.Pointer(data)), (C.size_t)(lenVal))
+func QCborValue_FromCbor3(data *byte, lenVal int64) *QCborValue {
+	_ret := C.QCborValue_FromCbor3((*C.uchar)(unsafe.Pointer(data)), (C.ptrdiff_t)(lenVal))
 	_goptr := newQCborValue(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
@@ -645,17 +645,17 @@ func QCborValue_FromCbor22(ba *QByteArray, error *QCborParserError) *QCborValue
 	return _goptr
 }
 
-func QCborValue_FromCbor32(data string, lenVal uint64, error *QCborParserError) *QCborValue {
+func QCborValue_FromCbor32(data string, lenVal int64, error *QCborParserError) *QCborValue {
 	data_Cstring := C.CString(data)
 	defer C.free(unsafe.Pointer(data_Cstring))
-	_ret := C.QCborValue_FromCbor32(data_Cstring, (C.size_t)(lenVal), error.cPointer())
+	_ret := C.QCborValue_FromCbor32(data_Cstring, (C.ptrdiff_t)(lenVal), error.cPointer())
 	_goptr := newQCborValue(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func QCborValue_FromCbor33(data *byte, lenVal uint64, error *QCborParserError) *QCborValue {
-	_ret := C.QCborValue_FromCbor33((*C.uchar)(unsafe.Pointer(data)), (C.size_t)(lenVal), error.cPointer())
+func QCborValue_FromCbor33(data *byte, lenVal int64, error *QCborParserError) *QCborValue {
+	_ret := C.QCborValue_FromCbor33((*C.uchar)(unsafe.Pointer(data)), (C.ptrdiff_t)(lenVal), error.cPointer())
 	_goptr := newQCborValue(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
diff --git a/qt/gen_qcborvalue.h b/qt/gen_qcborvalue.h
index 323b2e7..411f763 100644
--- a/qt/gen_qcborvalue.h
+++ b/qt/gen_qcborvalue.h
@@ -123,8 +123,8 @@ QCborValue* QCborValue_FromJsonValue(QJsonValue* v);
 QJsonValue* QCborValue_ToJsonValue(const QCborValue* self);
 QCborValue* QCborValue_FromCbor(QCborStreamReader* reader);
 QCborValue* QCborValue_FromCborWithBa(QByteArray* ba);
-QCborValue* QCborValue_FromCbor2(const char* data, size_t lenVal);
-QCborValue* QCborValue_FromCbor3(const unsigned char* data, size_t lenVal);
+QCborValue* QCborValue_FromCbor2(const char* data, ptrdiff_t lenVal);
+QCborValue* QCborValue_FromCbor3(const unsigned char* data, ptrdiff_t lenVal);
 QByteArray* QCborValue_ToCbor(QCborValue* self);
 void QCborValue_ToCborWithWriter(QCborValue* self, QCborStreamWriter* writer);
 struct miqt_string* QCborValue_ToDiagnosticNotation(const QCborValue* self);
@@ -141,8 +141,8 @@ QUrl* QCborValue_ToUrl1(const QCborValue* self, QUrl* defaultValue);
 QRegularExpression* QCborValue_ToRegularExpression1(const QCborValue* self, QRegularExpression* defaultValue);
 QUuid* QCborValue_ToUuid1(const QCborValue* self, QUuid* defaultValue);
 QCborValue* QCborValue_FromCbor22(QByteArray* ba, QCborParserError* error);
-QCborValue* QCborValue_FromCbor32(const char* data, size_t lenVal, QCborParserError* error);
-QCborValue* QCborValue_FromCbor33(const unsigned char* data, size_t lenVal, QCborParserError* error);
+QCborValue* QCborValue_FromCbor32(const char* data, ptrdiff_t lenVal, QCborParserError* error);
+QCborValue* QCborValue_FromCbor33(const unsigned char* data, ptrdiff_t lenVal, QCborParserError* error);
 QByteArray* QCborValue_ToCbor1(QCborValue* self, int opt);
 void QCborValue_ToCbor2(QCborValue* self, QCborStreamWriter* writer, int opt);
 struct miqt_string* QCborValue_ToDiagnosticNotation1(const QCborValue* self, int opts);
diff --git a/qt/gen_qchar.go b/qt/gen_qchar.go
index 82aedb9..859821a 100644
--- a/qt/gen_qchar.go
+++ b/qt/gen_qchar.go
@@ -378,7 +378,7 @@ func newQLatin1Char_U(h unsafe.Pointer) *QLatin1Char {
 }
 
 // NewQLatin1Char constructs a new QLatin1Char object.
-func NewQLatin1Char(c byte) *QLatin1Char {
+func NewQLatin1Char(c int8) *QLatin1Char {
 	ret := C.QLatin1Char_new((C.char)(c))
 	return newQLatin1Char(ret)
 }
@@ -389,8 +389,8 @@ func NewQLatin1Char2(param1 *QLatin1Char) *QLatin1Char {
 	return newQLatin1Char(ret)
 }
 
-func (this *QLatin1Char) ToLatin1() byte {
-	return (byte)(C.QLatin1Char_ToLatin1(this.h))
+func (this *QLatin1Char) ToLatin1() int8 {
+	return (int8)(C.QLatin1Char_ToLatin1(this.h))
 }
 
 func (this *QLatin1Char) Unicode() uint16 {
@@ -482,7 +482,7 @@ func NewQChar8(ch QLatin1Char) *QChar {
 }
 
 // NewQChar9 constructs a new QChar object.
-func NewQChar9(c byte) *QChar {
+func NewQChar9(c int8) *QChar {
 	ret := C.QChar_new9((C.char)(c))
 	return newQChar(ret)
 }
@@ -581,15 +581,15 @@ func (this *QChar) UnicodeVersion() QChar__UnicodeVersion {
 	return (QChar__UnicodeVersion)(C.QChar_UnicodeVersion(this.h))
 }
 
-func (this *QChar) ToLatin1() byte {
-	return (byte)(C.QChar_ToLatin1(this.h))
+func (this *QChar) ToLatin1() int8 {
+	return (int8)(C.QChar_ToLatin1(this.h))
 }
 
 func (this *QChar) Unicode() uint16 {
 	return (uint16)(C.QChar_Unicode(this.h))
 }
 
-func QChar_FromLatin1(c byte) *QChar {
+func QChar_FromLatin1(c int8) *QChar {
 	_ret := C.QChar_FromLatin1((C.char)(c))
 	_goptr := newQChar(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
diff --git a/qt/gen_qcontainerfwd.cpp b/qt/gen_qcontainerfwd.cpp
new file mode 100644
index 0000000..8f19bf9
--- /dev/null
+++ b/qt/gen_qcontainerfwd.cpp
@@ -0,0 +1,4 @@
+#include "qcontainerfwd.h"
+#include "gen_qcontainerfwd.h"
+#include "_cgo_export.h"
+
diff --git a/qt/gen_qcontainerfwd.go b/qt/gen_qcontainerfwd.go
new file mode 100644
index 0000000..b3d915a
--- /dev/null
+++ b/qt/gen_qcontainerfwd.go
@@ -0,0 +1,9 @@
+package qt
+
+/*
+
+#include "gen_qcontainerfwd.h"
+#include <stdlib.h>
+
+*/
+import "C"
diff --git a/qt/gen_qcontainerfwd.h b/qt/gen_qcontainerfwd.h
new file mode 100644
index 0000000..c796f30
--- /dev/null
+++ b/qt/gen_qcontainerfwd.h
@@ -0,0 +1,24 @@
+#ifndef GEN_QCONTAINERFWD_H
+#define GEN_QCONTAINERFWD_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "binding.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+#else
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif 
+
+#endif
diff --git a/qt/gen_qdatastream.go b/qt/gen_qdatastream.go
index edd4696..f27e2fb 100644
--- a/qt/gen_qdatastream.go
+++ b/qt/gen_qdatastream.go
@@ -172,7 +172,7 @@ func (this *QDataStream) SetVersion(version int) {
 	C.QDataStream_SetVersion(this.h, (C.int)(version))
 }
 
-func (this *QDataStream) OperatorShiftRight(i *byte) {
+func (this *QDataStream) OperatorShiftRight(i *int8) {
 	C.QDataStream_OperatorShiftRight(this.h, (*C.schar)(unsafe.Pointer(i)))
 }
 
@@ -222,7 +222,7 @@ func (this *QDataStream) OperatorShiftRightWithStr(str string) {
 	C.QDataStream_OperatorShiftRightWithStr(this.h, str_Cstring)
 }
 
-func (this *QDataStream) OperatorShiftLeft(i byte) {
+func (this *QDataStream) OperatorShiftLeft(i int8) {
 	C.QDataStream_OperatorShiftLeft(this.h, (C.schar)(i))
 }
 
diff --git a/qt/gen_qdebug.go b/qt/gen_qdebug.go
index 84ce011..cefe1a2 100644
--- a/qt/gen_qdebug.go
+++ b/qt/gen_qdebug.go
@@ -119,7 +119,7 @@ func (this *QDebug) OperatorShiftLeftWithBool(t bool) *QDebug {
 	return newQDebug_U(unsafe.Pointer(C.QDebug_OperatorShiftLeftWithBool(this.h, (C.bool)(t))))
 }
 
-func (this *QDebug) OperatorShiftLeftWithChar(t byte) *QDebug {
+func (this *QDebug) OperatorShiftLeftWithChar(t int8) *QDebug {
 	return newQDebug_U(unsafe.Pointer(C.QDebug_OperatorShiftLeftWithChar(this.h, (C.char)(t))))
 }
 
@@ -183,7 +183,7 @@ func (this *QDebug) OperatorShiftLeftWithVoid(t unsafe.Pointer) *QDebug {
 	return newQDebug_U(unsafe.Pointer(C.QDebug_OperatorShiftLeftWithVoid(this.h, t)))
 }
 
-func (this *QDebug) MaybeQuote1(c byte) *QDebug {
+func (this *QDebug) MaybeQuote1(c int8) *QDebug {
 	return newQDebug_U(unsafe.Pointer(C.QDebug_MaybeQuote1(this.h, (C.char)(c))))
 }
 
@@ -293,7 +293,7 @@ func (this *QNoDebug) Verbosity(param1 int) *QNoDebug {
 	return newQNoDebug_U(unsafe.Pointer(C.QNoDebug_Verbosity(this.h, (C.int)(param1))))
 }
 
-func (this *QNoDebug) MaybeQuote1(param1 byte) *QNoDebug {
+func (this *QNoDebug) MaybeQuote1(param1 int8) *QNoDebug {
 	return newQNoDebug_U(unsafe.Pointer(C.QNoDebug_MaybeQuote1(this.h, (C.char)(param1))))
 }
 
diff --git a/qt/gen_qimage.cpp b/qt/gen_qimage.cpp
index 1fbbf12..6f00e67 100644
--- a/qt/gen_qimage.cpp
+++ b/qt/gen_qimage.cpp
@@ -196,8 +196,9 @@ int QImage_ByteCount(const QImage* self) {
 	return self->byteCount();
 }
 
-size_t QImage_SizeInBytes(const QImage* self) {
-	return self->sizeInBytes();
+ptrdiff_t QImage_SizeInBytes(const QImage* self) {
+	qsizetype _ret = self->sizeInBytes();
+	return static_cast<ptrdiff_t>(_ret);
 }
 
 unsigned char* QImage_ScanLine(QImage* self, int param1) {
diff --git a/qt/gen_qimage.go b/qt/gen_qimage.go
index 5265c0b..c02243c 100644
--- a/qt/gen_qimage.go
+++ b/qt/gen_qimage.go
@@ -295,8 +295,8 @@ func (this *QImage) ByteCount() int {
 	return (int)(C.QImage_ByteCount(this.h))
 }
 
-func (this *QImage) SizeInBytes() uint64 {
-	return (uint64)(C.QImage_SizeInBytes(this.h))
+func (this *QImage) SizeInBytes() int64 {
+	return (int64)(C.QImage_SizeInBytes(this.h))
 }
 
 func (this *QImage) ScanLine(param1 int) *byte {
diff --git a/qt/gen_qimage.h b/qt/gen_qimage.h
index c092d8d..4ad9844 100644
--- a/qt/gen_qimage.h
+++ b/qt/gen_qimage.h
@@ -84,7 +84,7 @@ unsigned char* QImage_Bits(QImage* self);
 const unsigned char* QImage_Bits2(const QImage* self);
 const unsigned char* QImage_ConstBits(const QImage* self);
 int QImage_ByteCount(const QImage* self);
-size_t QImage_SizeInBytes(const QImage* self);
+ptrdiff_t QImage_SizeInBytes(const QImage* self);
 unsigned char* QImage_ScanLine(QImage* self, int param1);
 const unsigned char* QImage_ScanLineWithInt(const QImage* self, int param1);
 const unsigned char* QImage_ConstScanLine(const QImage* self, int param1);
diff --git a/qt/gen_qiodevice.go b/qt/gen_qiodevice.go
index 22564ce..7df1c56 100644
--- a/qt/gen_qiodevice.go
+++ b/qt/gen_qiodevice.go
@@ -262,11 +262,11 @@ func (this *QIODevice) WaitForBytesWritten(msecs int) bool {
 	return (bool)(C.QIODevice_WaitForBytesWritten(this.h, (C.int)(msecs)))
 }
 
-func (this *QIODevice) UngetChar(c byte) {
+func (this *QIODevice) UngetChar(c int8) {
 	C.QIODevice_UngetChar(this.h, (C.char)(c))
 }
 
-func (this *QIODevice) PutChar(c byte) bool {
+func (this *QIODevice) PutChar(c int8) bool {
 	return (bool)(C.QIODevice_PutChar(this.h, (C.char)(c)))
 }
 
diff --git a/qt/gen_qlocale.go b/qt/gen_qlocale.go
index ef38e10..a0e940b 100644
--- a/qt/gen_qlocale.go
+++ b/qt/gen_qlocale.go
@@ -1746,28 +1746,28 @@ func (this *QLocale) ToDouble2(s string, ok *bool) float64 {
 	return (float64)(C.QLocale_ToDouble2(this.h, (*C.struct_miqt_string)(s_ms), (*C.bool)(unsafe.Pointer(ok))))
 }
 
-func (this *QLocale) ToString22(i float64, f byte) string {
+func (this *QLocale) ToString22(i float64, f int8) string {
 	var _ms *C.struct_miqt_string = C.QLocale_ToString22(this.h, (C.double)(i), (C.char)(f))
 	_ret := C.GoStringN(&_ms.data, C.int(int64(_ms.len)))
 	C.free(unsafe.Pointer(_ms))
 	return _ret
 }
 
-func (this *QLocale) ToString32(i float64, f byte, prec int) string {
+func (this *QLocale) ToString32(i float64, f int8, prec int) string {
 	var _ms *C.struct_miqt_string = C.QLocale_ToString32(this.h, (C.double)(i), (C.char)(f), (C.int)(prec))
 	_ret := C.GoStringN(&_ms.data, C.int(int64(_ms.len)))
 	C.free(unsafe.Pointer(_ms))
 	return _ret
 }
 
-func (this *QLocale) ToString23(i float32, f byte) string {
+func (this *QLocale) ToString23(i float32, f int8) string {
 	var _ms *C.struct_miqt_string = C.QLocale_ToString23(this.h, (C.float)(i), (C.char)(f))
 	_ret := C.GoStringN(&_ms.data, C.int(int64(_ms.len)))
 	C.free(unsafe.Pointer(_ms))
 	return _ret
 }
 
-func (this *QLocale) ToString33(i float32, f byte, prec int) string {
+func (this *QLocale) ToString33(i float32, f int8, prec int) string {
 	var _ms *C.struct_miqt_string = C.QLocale_ToString33(this.h, (C.float)(i), (C.char)(f), (C.int)(prec))
 	_ret := C.GoStringN(&_ms.data, C.int(int64(_ms.len)))
 	C.free(unsafe.Pointer(_ms))
diff --git a/qt/gen_qrandom.cpp b/qt/gen_qrandom.cpp
index 9ee9a22..e17fa12 100644
--- a/qt/gen_qrandom.cpp
+++ b/qt/gen_qrandom.cpp
@@ -8,8 +8,8 @@ QRandomGenerator* QRandomGenerator_new() {
 	return new QRandomGenerator();
 }
 
-QRandomGenerator* QRandomGenerator_new2(const unsigned int* seedBuffer, size_t lenVal) {
-	return new QRandomGenerator(static_cast<const quint32*>(seedBuffer), static_cast<qsizetype>(lenVal));
+QRandomGenerator* QRandomGenerator_new2(const unsigned int* seedBuffer, ptrdiff_t lenVal) {
+	return new QRandomGenerator(static_cast<const quint32*>(seedBuffer), (qsizetype)(lenVal));
 }
 
 QRandomGenerator* QRandomGenerator_new3(const unsigned int* begin, const unsigned int* end) {
@@ -115,8 +115,8 @@ QRandomGenerator64* QRandomGenerator64_new() {
 	return new QRandomGenerator64();
 }
 
-QRandomGenerator64* QRandomGenerator64_new2(const unsigned int* seedBuffer, size_t lenVal) {
-	return new QRandomGenerator64(static_cast<const quint32*>(seedBuffer), static_cast<qsizetype>(lenVal));
+QRandomGenerator64* QRandomGenerator64_new2(const unsigned int* seedBuffer, ptrdiff_t lenVal) {
+	return new QRandomGenerator64(static_cast<const quint32*>(seedBuffer), (qsizetype)(lenVal));
 }
 
 QRandomGenerator64* QRandomGenerator64_new3(const unsigned int* begin, const unsigned int* end) {
diff --git a/qt/gen_qrandom.go b/qt/gen_qrandom.go
index f88017f..bf3524f 100644
--- a/qt/gen_qrandom.go
+++ b/qt/gen_qrandom.go
@@ -42,8 +42,8 @@ func NewQRandomGenerator() *QRandomGenerator {
 }
 
 // NewQRandomGenerator2 constructs a new QRandomGenerator object.
-func NewQRandomGenerator2(seedBuffer *uint, lenVal uint64) *QRandomGenerator {
-	ret := C.QRandomGenerator_new2((*C.uint)(unsafe.Pointer(seedBuffer)), (C.size_t)(lenVal))
+func NewQRandomGenerator2(seedBuffer *uint, lenVal int64) *QRandomGenerator {
+	ret := C.QRandomGenerator_new2((*C.uint)(unsafe.Pointer(seedBuffer)), (C.ptrdiff_t)(lenVal))
 	return newQRandomGenerator(ret)
 }
 
@@ -188,8 +188,8 @@ func NewQRandomGenerator64() *QRandomGenerator64 {
 }
 
 // NewQRandomGenerator642 constructs a new QRandomGenerator64 object.
-func NewQRandomGenerator642(seedBuffer *uint, lenVal uint64) *QRandomGenerator64 {
-	ret := C.QRandomGenerator64_new2((*C.uint)(unsafe.Pointer(seedBuffer)), (C.size_t)(lenVal))
+func NewQRandomGenerator642(seedBuffer *uint, lenVal int64) *QRandomGenerator64 {
+	ret := C.QRandomGenerator64_new2((*C.uint)(unsafe.Pointer(seedBuffer)), (C.ptrdiff_t)(lenVal))
 	return newQRandomGenerator64(ret)
 }
 
diff --git a/qt/gen_qrandom.h b/qt/gen_qrandom.h
index 3410c67..9928844 100644
--- a/qt/gen_qrandom.h
+++ b/qt/gen_qrandom.h
@@ -22,7 +22,7 @@ typedef struct QRandomGenerator64 QRandomGenerator64;
 #endif
 
 QRandomGenerator* QRandomGenerator_new();
-QRandomGenerator* QRandomGenerator_new2(const unsigned int* seedBuffer, size_t lenVal);
+QRandomGenerator* QRandomGenerator_new2(const unsigned int* seedBuffer, ptrdiff_t lenVal);
 QRandomGenerator* QRandomGenerator_new3(const unsigned int* begin, const unsigned int* end);
 QRandomGenerator* QRandomGenerator_new4(QRandomGenerator* other);
 QRandomGenerator* QRandomGenerator_new5(unsigned int seedValue);
@@ -48,7 +48,7 @@ void QRandomGenerator_Seed1(QRandomGenerator* self, unsigned int s);
 void QRandomGenerator_Delete(QRandomGenerator* self);
 
 QRandomGenerator64* QRandomGenerator64_new();
-QRandomGenerator64* QRandomGenerator64_new2(const unsigned int* seedBuffer, size_t lenVal);
+QRandomGenerator64* QRandomGenerator64_new2(const unsigned int* seedBuffer, ptrdiff_t lenVal);
 QRandomGenerator64* QRandomGenerator64_new3(const unsigned int* begin, const unsigned int* end);
 QRandomGenerator64* QRandomGenerator64_new4(QRandomGenerator* other);
 QRandomGenerator64* QRandomGenerator64_new5(QRandomGenerator64* param1);
diff --git a/qt/gen_qsocketnotifier.cpp b/qt/gen_qsocketnotifier.cpp
index d4479c1..58add22 100644
--- a/qt/gen_qsocketnotifier.cpp
+++ b/qt/gen_qsocketnotifier.cpp
@@ -10,11 +10,11 @@
 #include "_cgo_export.h"
 
 QSocketNotifier* QSocketNotifier_new(intptr_t socket, int param2) {
-	return new QSocketNotifier(static_cast<qintptr>(socket), static_cast<QSocketNotifier::Type>(param2));
+	return new QSocketNotifier((qintptr)(socket), static_cast<QSocketNotifier::Type>(param2));
 }
 
 QSocketNotifier* QSocketNotifier_new2(intptr_t socket, int param2, QObject* parent) {
-	return new QSocketNotifier(static_cast<qintptr>(socket), static_cast<QSocketNotifier::Type>(param2), parent);
+	return new QSocketNotifier((qintptr)(socket), static_cast<QSocketNotifier::Type>(param2), parent);
 }
 
 QMetaObject* QSocketNotifier_MetaObject(const QSocketNotifier* self) {
diff --git a/qt/gen_qsocketnotifier.go b/qt/gen_qsocketnotifier.go
index dae15f9..0479a5e 100644
--- a/qt/gen_qsocketnotifier.go
+++ b/qt/gen_qsocketnotifier.go
@@ -193,7 +193,7 @@ func NewQSocketDescriptor2(param1 *QSocketDescriptor) *QSocketDescriptor {
 }
 
 // NewQSocketDescriptor3 constructs a new QSocketDescriptor object.
-func NewQSocketDescriptor3(descriptor QSocketNotifier__Type) *QSocketDescriptor {
+func NewQSocketDescriptor3(descriptor int) *QSocketDescriptor {
 	if runtime.GOOS == "linux" {
 		ret := C.QSocketDescriptor_new3((C.int)(descriptor))
 		return newQSocketDescriptor(ret)
diff --git a/qt/gen_qstringview.cpp b/qt/gen_qstringview.cpp
index 64e6e84..e101cbc 100644
--- a/qt/gen_qstringview.cpp
+++ b/qt/gen_qstringview.cpp
@@ -20,8 +20,9 @@ struct miqt_string* QStringView_ToString(const QStringView* self) {
 	return miqt_strdup(_b.data(), _b.length());
 }
 
-size_t QStringView_Size(const QStringView* self) {
-	return self->size();
+ptrdiff_t QStringView_Size(const QStringView* self) {
+	qsizetype _ret = self->size();
+	return static_cast<ptrdiff_t>(_ret);
 }
 
 QChar* QStringView_Data(const QStringView* self) {
@@ -29,8 +30,8 @@ QChar* QStringView_Data(const QStringView* self) {
 	return const_cast<QChar*>(static_cast<const QChar*>(_ret));
 }
 
-QChar* QStringView_OperatorSubscript(const QStringView* self, size_t n) {
-	return new QChar(self->operator[](static_cast<qsizetype>(n)));
+QChar* QStringView_OperatorSubscript(const QStringView* self, ptrdiff_t n) {
+	return new QChar(self->operator[]((qsizetype)(n)));
 }
 
 QByteArray* QStringView_ToLatin1(const QStringView* self) {
@@ -58,16 +59,16 @@ struct miqt_array* QStringView_ToUcs4(const QStringView* self) {
 	return _out;
 }
 
-QChar* QStringView_At(const QStringView* self, size_t n) {
-	return new QChar(self->at(static_cast<qsizetype>(n)));
+QChar* QStringView_At(const QStringView* self, ptrdiff_t n) {
+	return new QChar(self->at((qsizetype)(n)));
 }
 
-void QStringView_Truncate(QStringView* self, size_t n) {
-	self->truncate(static_cast<qsizetype>(n));
+void QStringView_Truncate(QStringView* self, ptrdiff_t n) {
+	self->truncate((qsizetype)(n));
 }
 
-void QStringView_Chop(QStringView* self, size_t n) {
-	self->chop(static_cast<qsizetype>(n));
+void QStringView_Chop(QStringView* self, ptrdiff_t n) {
+	self->chop((qsizetype)(n));
 }
 
 int QStringView_CompareWithQChar(const QStringView* self, QChar* c) {
@@ -94,20 +95,23 @@ bool QStringView_EndsWith2(const QStringView* self, QChar* c, int cs) {
 	return self->endsWith(*c, static_cast<Qt::CaseSensitivity>(cs));
 }
 
-size_t QStringView_IndexOf(const QStringView* self, QChar* c) {
-	return self->indexOf(*c);
+ptrdiff_t QStringView_IndexOf(const QStringView* self, QChar* c) {
+	qsizetype _ret = self->indexOf(*c);
+	return static_cast<ptrdiff_t>(_ret);
 }
 
 bool QStringView_Contains(const QStringView* self, QChar* c) {
 	return self->contains(*c);
 }
 
-size_t QStringView_Count(const QStringView* self, QChar* c) {
-	return self->count(*c);
+ptrdiff_t QStringView_Count(const QStringView* self, QChar* c) {
+	qsizetype _ret = self->count(*c);
+	return static_cast<ptrdiff_t>(_ret);
 }
 
-size_t QStringView_LastIndexOf(const QStringView* self, QChar* c) {
-	return self->lastIndexOf(*c);
+ptrdiff_t QStringView_LastIndexOf(const QStringView* self, QChar* c) {
+	qsizetype _ret = self->lastIndexOf(*c);
+	return static_cast<ptrdiff_t>(_ret);
 }
 
 bool QStringView_IsRightToLeft(const QStringView* self) {
@@ -215,28 +219,33 @@ QChar* QStringView_Last(const QStringView* self) {
 	return new QChar(self->last());
 }
 
-size_t QStringView_IndexOf2(const QStringView* self, QChar* c, size_t from) {
-	return self->indexOf(*c, static_cast<qsizetype>(from));
+ptrdiff_t QStringView_IndexOf2(const QStringView* self, QChar* c, ptrdiff_t from) {
+	qsizetype _ret = self->indexOf(*c, (qsizetype)(from));
+	return static_cast<ptrdiff_t>(_ret);
 }
 
-size_t QStringView_IndexOf3(const QStringView* self, QChar* c, size_t from, int cs) {
-	return self->indexOf(*c, static_cast<qsizetype>(from), static_cast<Qt::CaseSensitivity>(cs));
+ptrdiff_t QStringView_IndexOf3(const QStringView* self, QChar* c, ptrdiff_t from, int cs) {
+	qsizetype _ret = self->indexOf(*c, (qsizetype)(from), static_cast<Qt::CaseSensitivity>(cs));
+	return static_cast<ptrdiff_t>(_ret);
 }
 
 bool QStringView_Contains2(const QStringView* self, QChar* c, int cs) {
 	return self->contains(*c, static_cast<Qt::CaseSensitivity>(cs));
 }
 
-size_t QStringView_Count2(const QStringView* self, QChar* c, int cs) {
-	return self->count(*c, static_cast<Qt::CaseSensitivity>(cs));
+ptrdiff_t QStringView_Count2(const QStringView* self, QChar* c, int cs) {
+	qsizetype _ret = self->count(*c, static_cast<Qt::CaseSensitivity>(cs));
+	return static_cast<ptrdiff_t>(_ret);
 }
 
-size_t QStringView_LastIndexOf2(const QStringView* self, QChar* c, size_t from) {
-	return self->lastIndexOf(*c, static_cast<qsizetype>(from));
+ptrdiff_t QStringView_LastIndexOf2(const QStringView* self, QChar* c, ptrdiff_t from) {
+	qsizetype _ret = self->lastIndexOf(*c, (qsizetype)(from));
+	return static_cast<ptrdiff_t>(_ret);
 }
 
-size_t QStringView_LastIndexOf3(const QStringView* self, QChar* c, size_t from, int cs) {
-	return self->lastIndexOf(*c, static_cast<qsizetype>(from), static_cast<Qt::CaseSensitivity>(cs));
+ptrdiff_t QStringView_LastIndexOf3(const QStringView* self, QChar* c, ptrdiff_t from, int cs) {
+	qsizetype _ret = self->lastIndexOf(*c, (qsizetype)(from), static_cast<Qt::CaseSensitivity>(cs));
+	return static_cast<ptrdiff_t>(_ret);
 }
 
 int16_t QStringView_ToShort1(const QStringView* self, bool* ok) {
diff --git a/qt/gen_qstringview.go b/qt/gen_qstringview.go
index e60ea1d..07a8f9e 100644
--- a/qt/gen_qstringview.go
+++ b/qt/gen_qstringview.go
@@ -48,16 +48,16 @@ func (this *QStringView) ToString() string {
 	return _ret
 }
 
-func (this *QStringView) Size() uint64 {
-	return (uint64)(C.QStringView_Size(this.h))
+func (this *QStringView) Size() int64 {
+	return (int64)(C.QStringView_Size(this.h))
 }
 
 func (this *QStringView) Data() *QChar {
 	return newQChar_U(unsafe.Pointer(C.QStringView_Data(this.h)))
 }
 
-func (this *QStringView) OperatorSubscript(n uint64) *QChar {
-	_ret := C.QStringView_OperatorSubscript(this.h, (C.size_t)(n))
+func (this *QStringView) OperatorSubscript(n int64) *QChar {
+	_ret := C.QStringView_OperatorSubscript(this.h, (C.ptrdiff_t)(n))
 	_goptr := newQChar(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
@@ -95,19 +95,19 @@ func (this *QStringView) ToUcs4() []uint {
 	return _ret
 }
 
-func (this *QStringView) At(n uint64) *QChar {
-	_ret := C.QStringView_At(this.h, (C.size_t)(n))
+func (this *QStringView) At(n int64) *QChar {
+	_ret := C.QStringView_At(this.h, (C.ptrdiff_t)(n))
 	_goptr := newQChar(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func (this *QStringView) Truncate(n uint64) {
-	C.QStringView_Truncate(this.h, (C.size_t)(n))
+func (this *QStringView) Truncate(n int64) {
+	C.QStringView_Truncate(this.h, (C.ptrdiff_t)(n))
 }
 
-func (this *QStringView) Chop(n uint64) {
-	C.QStringView_Chop(this.h, (C.size_t)(n))
+func (this *QStringView) Chop(n int64) {
+	C.QStringView_Chop(this.h, (C.ptrdiff_t)(n))
 }
 
 func (this *QStringView) CompareWithQChar(c QChar) int {
@@ -134,20 +134,20 @@ func (this *QStringView) EndsWith2(c QChar, cs CaseSensitivity) bool {
 	return (bool)(C.QStringView_EndsWith2(this.h, c.cPointer(), (C.int)(cs)))
 }
 
-func (this *QStringView) IndexOf(c QChar) uint64 {
-	return (uint64)(C.QStringView_IndexOf(this.h, c.cPointer()))
+func (this *QStringView) IndexOf(c QChar) int64 {
+	return (int64)(C.QStringView_IndexOf(this.h, c.cPointer()))
 }
 
 func (this *QStringView) Contains(c QChar) bool {
 	return (bool)(C.QStringView_Contains(this.h, c.cPointer()))
 }
 
-func (this *QStringView) Count(c QChar) uint64 {
-	return (uint64)(C.QStringView_Count(this.h, c.cPointer()))
+func (this *QStringView) Count(c QChar) int64 {
+	return (int64)(C.QStringView_Count(this.h, c.cPointer()))
 }
 
-func (this *QStringView) LastIndexOf(c QChar) uint64 {
-	return (uint64)(C.QStringView_LastIndexOf(this.h, c.cPointer()))
+func (this *QStringView) LastIndexOf(c QChar) int64 {
+	return (int64)(C.QStringView_LastIndexOf(this.h, c.cPointer()))
 }
 
 func (this *QStringView) IsRightToLeft() bool {
@@ -258,28 +258,28 @@ func (this *QStringView) Last() *QChar {
 	return _goptr
 }
 
-func (this *QStringView) IndexOf2(c QChar, from uint64) uint64 {
-	return (uint64)(C.QStringView_IndexOf2(this.h, c.cPointer(), (C.size_t)(from)))
+func (this *QStringView) IndexOf2(c QChar, from int64) int64 {
+	return (int64)(C.QStringView_IndexOf2(this.h, c.cPointer(), (C.ptrdiff_t)(from)))
 }
 
-func (this *QStringView) IndexOf3(c QChar, from uint64, cs CaseSensitivity) uint64 {
-	return (uint64)(C.QStringView_IndexOf3(this.h, c.cPointer(), (C.size_t)(from), (C.int)(cs)))
+func (this *QStringView) IndexOf3(c QChar, from int64, cs CaseSensitivity) int64 {
+	return (int64)(C.QStringView_IndexOf3(this.h, c.cPointer(), (C.ptrdiff_t)(from), (C.int)(cs)))
 }
 
 func (this *QStringView) Contains2(c QChar, cs CaseSensitivity) bool {
 	return (bool)(C.QStringView_Contains2(this.h, c.cPointer(), (C.int)(cs)))
 }
 
-func (this *QStringView) Count2(c QChar, cs CaseSensitivity) uint64 {
-	return (uint64)(C.QStringView_Count2(this.h, c.cPointer(), (C.int)(cs)))
+func (this *QStringView) Count2(c QChar, cs CaseSensitivity) int64 {
+	return (int64)(C.QStringView_Count2(this.h, c.cPointer(), (C.int)(cs)))
 }
 
-func (this *QStringView) LastIndexOf2(c QChar, from uint64) uint64 {
-	return (uint64)(C.QStringView_LastIndexOf2(this.h, c.cPointer(), (C.size_t)(from)))
+func (this *QStringView) LastIndexOf2(c QChar, from int64) int64 {
+	return (int64)(C.QStringView_LastIndexOf2(this.h, c.cPointer(), (C.ptrdiff_t)(from)))
 }
 
-func (this *QStringView) LastIndexOf3(c QChar, from uint64, cs CaseSensitivity) uint64 {
-	return (uint64)(C.QStringView_LastIndexOf3(this.h, c.cPointer(), (C.size_t)(from), (C.int)(cs)))
+func (this *QStringView) LastIndexOf3(c QChar, from int64, cs CaseSensitivity) int64 {
+	return (int64)(C.QStringView_LastIndexOf3(this.h, c.cPointer(), (C.ptrdiff_t)(from), (C.int)(cs)))
 }
 
 func (this *QStringView) ToShort1(ok *bool) int16 {
diff --git a/qt/gen_qstringview.h b/qt/gen_qstringview.h
index 0afb452..e9cf14d 100644
--- a/qt/gen_qstringview.h
+++ b/qt/gen_qstringview.h
@@ -25,26 +25,26 @@ typedef struct QStringView QStringView;
 
 QStringView* QStringView_new();
 struct miqt_string* QStringView_ToString(const QStringView* self);
-size_t QStringView_Size(const QStringView* self);
+ptrdiff_t QStringView_Size(const QStringView* self);
 QChar* QStringView_Data(const QStringView* self);
-QChar* QStringView_OperatorSubscript(const QStringView* self, size_t n);
+QChar* QStringView_OperatorSubscript(const QStringView* self, ptrdiff_t n);
 QByteArray* QStringView_ToLatin1(const QStringView* self);
 QByteArray* QStringView_ToUtf8(const QStringView* self);
 QByteArray* QStringView_ToLocal8Bit(const QStringView* self);
 struct miqt_array* QStringView_ToUcs4(const QStringView* self);
-QChar* QStringView_At(const QStringView* self, size_t n);
-void QStringView_Truncate(QStringView* self, size_t n);
-void QStringView_Chop(QStringView* self, size_t n);
+QChar* QStringView_At(const QStringView* self, ptrdiff_t n);
+void QStringView_Truncate(QStringView* self, ptrdiff_t n);
+void QStringView_Chop(QStringView* self, ptrdiff_t n);
 int QStringView_CompareWithQChar(const QStringView* self, QChar* c);
 int QStringView_Compare2(const QStringView* self, QChar* c, int cs);
 bool QStringView_StartsWithWithQChar(const QStringView* self, QChar* c);
 bool QStringView_StartsWith2(const QStringView* self, QChar* c, int cs);
 bool QStringView_EndsWithWithQChar(const QStringView* self, QChar* c);
 bool QStringView_EndsWith2(const QStringView* self, QChar* c, int cs);
-size_t QStringView_IndexOf(const QStringView* self, QChar* c);
+ptrdiff_t QStringView_IndexOf(const QStringView* self, QChar* c);
 bool QStringView_Contains(const QStringView* self, QChar* c);
-size_t QStringView_Count(const QStringView* self, QChar* c);
-size_t QStringView_LastIndexOf(const QStringView* self, QChar* c);
+ptrdiff_t QStringView_Count(const QStringView* self, QChar* c);
+ptrdiff_t QStringView_LastIndexOf(const QStringView* self, QChar* c);
 bool QStringView_IsRightToLeft(const QStringView* self);
 bool QStringView_IsValidUtf16(const QStringView* self);
 int16_t QStringView_ToShort(const QStringView* self);
@@ -69,12 +69,12 @@ bool QStringView_IsEmpty(const QStringView* self);
 int QStringView_Length(const QStringView* self);
 QChar* QStringView_First(const QStringView* self);
 QChar* QStringView_Last(const QStringView* self);
-size_t QStringView_IndexOf2(const QStringView* self, QChar* c, size_t from);
-size_t QStringView_IndexOf3(const QStringView* self, QChar* c, size_t from, int cs);
+ptrdiff_t QStringView_IndexOf2(const QStringView* self, QChar* c, ptrdiff_t from);
+ptrdiff_t QStringView_IndexOf3(const QStringView* self, QChar* c, ptrdiff_t from, int cs);
 bool QStringView_Contains2(const QStringView* self, QChar* c, int cs);
-size_t QStringView_Count2(const QStringView* self, QChar* c, int cs);
-size_t QStringView_LastIndexOf2(const QStringView* self, QChar* c, size_t from);
-size_t QStringView_LastIndexOf3(const QStringView* self, QChar* c, size_t from, int cs);
+ptrdiff_t QStringView_Count2(const QStringView* self, QChar* c, int cs);
+ptrdiff_t QStringView_LastIndexOf2(const QStringView* self, QChar* c, ptrdiff_t from);
+ptrdiff_t QStringView_LastIndexOf3(const QStringView* self, QChar* c, ptrdiff_t from, int cs);
 int16_t QStringView_ToShort1(const QStringView* self, bool* ok);
 int16_t QStringView_ToShort2(const QStringView* self, bool* ok, int base);
 uint16_t QStringView_ToUShort1(const QStringView* self, bool* ok);
diff --git a/qt/gen_qtextstream.go b/qt/gen_qtextstream.go
index 32c0188..0d746c6 100644
--- a/qt/gen_qtextstream.go
+++ b/qt/gen_qtextstream.go
@@ -283,7 +283,7 @@ func (this *QTextStream) OperatorShiftRight(ch *QChar) *QTextStream {
 	return newQTextStream_U(unsafe.Pointer(C.QTextStream_OperatorShiftRight(this.h, ch.cPointer())))
 }
 
-func (this *QTextStream) OperatorShiftRightWithCh(ch *byte) *QTextStream {
+func (this *QTextStream) OperatorShiftRightWithCh(ch *int8) *QTextStream {
 	return newQTextStream_U(unsafe.Pointer(C.QTextStream_OperatorShiftRightWithCh(this.h, (*C.char)(unsafe.Pointer(ch)))))
 }
 
@@ -347,7 +347,7 @@ func (this *QTextStream) OperatorShiftLeft(ch QChar) *QTextStream {
 	return newQTextStream_U(unsafe.Pointer(C.QTextStream_OperatorShiftLeft(this.h, ch.cPointer())))
 }
 
-func (this *QTextStream) OperatorShiftLeftWithCh(ch byte) *QTextStream {
+func (this *QTextStream) OperatorShiftLeftWithCh(ch int8) *QTextStream {
 	return newQTextStream_U(unsafe.Pointer(C.QTextStream_OperatorShiftLeftWithCh(this.h, (C.char)(ch))))
 }