diff --git a/cmd/genbindings/config-libraries.go b/cmd/genbindings/config-libraries.go
index 64f0b9fc..a7b66d2e 100644
--- a/cmd/genbindings/config-libraries.go
+++ b/cmd/genbindings/config-libraries.go
@@ -147,7 +147,7 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) {
 	generate(
 		"qt6/cbor",
 		[]string{
-			"/usr/include/x86_64-linux-gnu/qt5/QtCore",
+			"/usr/include/x86_64-linux-gnu/qt6/QtCore",
 		},
 		func(fullpath string) bool {
 			// Only include the same json, xml, cbor files excluded above
@@ -155,7 +155,7 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) {
 			return strings.HasPrefix(fname, "qcbor")
 		},
 		clangBin,
-		pkgConfigCflags("Qt6Core"),
+		"--std=c++20 "+pkgConfigCflags("Qt6Core"),
 		outDir,
 		ClangMatchSameHeaderDefinitionOnly,
 	)
diff --git a/qt6/cbor/gen_qcborarray.cpp b/qt6/cbor/gen_qcborarray.cpp
index 6fdc4350..dd23072e 100644
--- a/qt6/cbor/gen_qcborarray.cpp
+++ b/qt6/cbor/gen_qcborarray.cpp
@@ -2,6 +2,7 @@
 #define WORKAROUND_INNER_CLASS_DEFINITION_QCborArray__ConstIterator
 #define WORKAROUND_INNER_CLASS_DEFINITION_QCborArray__Iterator
 #include <QCborValue>
+#include <QCborValueConstRef>
 #include <QCborValueRef>
 #include <QJsonArray>
 #include <QList>
@@ -260,11 +261,15 @@ QCborValueRef* QCborArray__Iterator_OperatorMultiply(const QCborArray__Iterator*
 	return new QCborValueRef(self->operator*());
 }
 
-QCborValueRef* QCborArray__Iterator_OperatorMinusGreater(const QCborArray__Iterator* self) {
+QCborValueRef* QCborArray__Iterator_OperatorMinusGreater(QCborArray__Iterator* self) {
 	return self->operator->();
 }
 
-QCborValueRef* QCborArray__Iterator_OperatorSubscript(QCborArray__Iterator* self, ptrdiff_t j) {
+QCborValueConstRef* QCborArray__Iterator_OperatorMinusGreater2(const QCborArray__Iterator* self) {
+	return (QCborValueConstRef*) self->operator->();
+}
+
+QCborValueRef* QCborArray__Iterator_OperatorSubscript(const QCborArray__Iterator* self, ptrdiff_t j) {
 	return new QCborValueRef(self->operator[]((qsizetype)(j)));
 }
 
@@ -377,16 +382,16 @@ void QCborArray__ConstIterator_OperatorAssign(QCborArray__ConstIterator* self, Q
 	self->operator=(*other);
 }
 
-QCborValueRef* QCborArray__ConstIterator_OperatorMultiply(const QCborArray__ConstIterator* self) {
-	return new QCborValueRef(self->operator*());
+QCborValueConstRef* QCborArray__ConstIterator_OperatorMultiply(const QCborArray__ConstIterator* self) {
+	return new QCborValueConstRef(self->operator*());
 }
 
-QCborValueRef* QCborArray__ConstIterator_OperatorMinusGreater(const QCborArray__ConstIterator* self) {
-	return (QCborValueRef*) self->operator->();
+QCborValueConstRef* QCborArray__ConstIterator_OperatorMinusGreater(const QCborArray__ConstIterator* self) {
+	return (QCborValueConstRef*) self->operator->();
 }
 
-QCborValueRef* QCborArray__ConstIterator_OperatorSubscript(QCborArray__ConstIterator* self, ptrdiff_t j) {
-	return new QCborValueRef(self->operator[]((qsizetype)(j)));
+QCborValueConstRef* QCborArray__ConstIterator_OperatorSubscript(const QCborArray__ConstIterator* self, ptrdiff_t j) {
+	return new QCborValueConstRef(self->operator[]((qsizetype)(j)));
 }
 
 bool QCborArray__ConstIterator_OperatorEqual(const QCborArray__ConstIterator* self, QCborArray__Iterator* o) {
diff --git a/qt6/cbor/gen_qcborarray.go b/qt6/cbor/gen_qcborarray.go
index de2b74f9..012bff7b 100644
--- a/qt6/cbor/gen_qcborarray.go
+++ b/qt6/cbor/gen_qcborarray.go
@@ -430,6 +430,10 @@ func (this *QCborArray__Iterator) OperatorMinusGreater() *QCborValueRef {
 	return UnsafeNewQCborValueRef(unsafe.Pointer(C.QCborArray__Iterator_OperatorMinusGreater(this.h)))
 }
 
+func (this *QCborArray__Iterator) OperatorMinusGreater2() *QCborValueConstRef {
+	return UnsafeNewQCborValueConstRef(unsafe.Pointer(C.QCborArray__Iterator_OperatorMinusGreater2(this.h)))
+}
+
 func (this *QCborArray__Iterator) OperatorSubscript(j int64) *QCborValueRef {
 	_ret := C.QCborArray__Iterator_OperatorSubscript(this.h, (C.ptrdiff_t)(j))
 	_goptr := newQCborValueRef(_ret)
@@ -592,20 +596,20 @@ func (this *QCborArray__ConstIterator) OperatorAssign(other *QCborArray__ConstIt
 	C.QCborArray__ConstIterator_OperatorAssign(this.h, other.cPointer())
 }
 
-func (this *QCborArray__ConstIterator) OperatorMultiply() *QCborValueRef {
+func (this *QCborArray__ConstIterator) OperatorMultiply() *QCborValueConstRef {
 	_ret := C.QCborArray__ConstIterator_OperatorMultiply(this.h)
-	_goptr := newQCborValueRef(_ret)
+	_goptr := newQCborValueConstRef(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func (this *QCborArray__ConstIterator) OperatorMinusGreater() *QCborValueRef {
-	return UnsafeNewQCborValueRef(unsafe.Pointer(C.QCborArray__ConstIterator_OperatorMinusGreater(this.h)))
+func (this *QCborArray__ConstIterator) OperatorMinusGreater() *QCborValueConstRef {
+	return UnsafeNewQCborValueConstRef(unsafe.Pointer(C.QCborArray__ConstIterator_OperatorMinusGreater(this.h)))
 }
 
-func (this *QCborArray__ConstIterator) OperatorSubscript(j int64) *QCborValueRef {
+func (this *QCborArray__ConstIterator) OperatorSubscript(j int64) *QCborValueConstRef {
 	_ret := C.QCborArray__ConstIterator_OperatorSubscript(this.h, (C.ptrdiff_t)(j))
-	_goptr := newQCborValueRef(_ret)
+	_goptr := newQCborValueConstRef(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
diff --git a/qt6/cbor/gen_qcborarray.h b/qt6/cbor/gen_qcborarray.h
index 69076b66..eff255f0 100644
--- a/qt6/cbor/gen_qcborarray.h
+++ b/qt6/cbor/gen_qcborarray.h
@@ -27,6 +27,7 @@ typedef QCborArray::Iterator QCborArray__Iterator;
 class QCborArray__Iterator;
 #endif
 class QCborValue;
+class QCborValueConstRef;
 class QCborValueRef;
 class QJsonArray;
 #else
@@ -34,6 +35,7 @@ typedef struct QCborArray QCborArray;
 typedef struct QCborArray__ConstIterator QCborArray__ConstIterator;
 typedef struct QCborArray__Iterator QCborArray__Iterator;
 typedef struct QCborValue QCborValue;
+typedef struct QCborValueConstRef QCborValueConstRef;
 typedef struct QCborValueRef QCborValueRef;
 typedef struct QJsonArray QJsonArray;
 #endif
@@ -98,8 +100,9 @@ QCborArray__Iterator* QCborArray__Iterator_new();
 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, ptrdiff_t j);
+QCborValueRef* QCborArray__Iterator_OperatorMinusGreater(QCborArray__Iterator* self);
+QCborValueConstRef* QCborArray__Iterator_OperatorMinusGreater2(const QCborArray__Iterator* self);
+QCborValueRef* QCborArray__Iterator_OperatorSubscript(const 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);
@@ -126,9 +129,9 @@ void QCborArray__Iterator_Delete(QCborArray__Iterator* self);
 QCborArray__ConstIterator* QCborArray__ConstIterator_new();
 QCborArray__ConstIterator* QCborArray__ConstIterator_new2(QCborArray__ConstIterator* param1);
 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, ptrdiff_t j);
+QCborValueConstRef* QCborArray__ConstIterator_OperatorMultiply(const QCborArray__ConstIterator* self);
+QCborValueConstRef* QCborArray__ConstIterator_OperatorMinusGreater(const QCborArray__ConstIterator* self);
+QCborValueConstRef* QCborArray__ConstIterator_OperatorSubscript(const 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);
diff --git a/qt6/cbor/gen_qcbormap.cpp b/qt6/cbor/gen_qcbormap.cpp
index 7ce888bf..d42a42ed 100644
--- a/qt6/cbor/gen_qcbormap.cpp
+++ b/qt6/cbor/gen_qcbormap.cpp
@@ -2,6 +2,7 @@
 #define WORKAROUND_INNER_CLASS_DEFINITION_QCborMap__ConstIterator
 #define WORKAROUND_INNER_CLASS_DEFINITION_QCborMap__Iterator
 #include <QCborValue>
+#include <QCborValueConstRef>
 #include <QCborValueRef>
 #include <QJsonObject>
 #include <QList>
@@ -48,7 +49,7 @@ void QCborMap_Clear(QCborMap* self) {
 }
 
 struct miqt_array /* of QCborValue* */  QCborMap_Keys(const QCborMap* self) {
-	QVector<QCborValue> _ret = self->keys();
+	QList<QCborValue> _ret = self->keys();
 	// Convert QList<> from C++ memory to manually-managed C memory
 	QCborValue** _arr = static_cast<QCborValue**>(malloc(sizeof(QCborValue*) * _ret.length()));
 	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
@@ -364,12 +365,12 @@ void QCborMap__Iterator_OperatorAssign(QCborMap__Iterator* self, QCborMap__Itera
 	self->operator=(*other);
 }
 
-struct miqt_map /* tuple of QCborValueRef* and QCborValueRef* */  QCborMap__Iterator_OperatorMultiply(const QCborMap__Iterator* self) {
+struct miqt_map /* tuple of QCborValueConstRef* and QCborValueRef* */  QCborMap__Iterator_OperatorMultiply(const QCborMap__Iterator* self) {
 	QCborMap::Iterator::value_type _ret = self->operator*();
 	// Convert QPair<> from C++ memory to manually-managed C memory
-	QCborValueRef** _first_arr = static_cast<QCborValueRef**>(malloc(sizeof(QCborValueRef*)));
+	QCborValueConstRef** _first_arr = static_cast<QCborValueConstRef**>(malloc(sizeof(QCborValueConstRef*)));
 	QCborValueRef** _second_arr = static_cast<QCborValueRef**>(malloc(sizeof(QCborValueRef*)));
-	_first_arr[0] = new QCborValueRef(_ret.first);
+	_first_arr[0] = new QCborValueConstRef(_ret.first);
 	_second_arr[0] = new QCborValueRef(_ret.second);
 	struct miqt_map _out;
 	_out.len = 1;
@@ -378,10 +379,28 @@ struct miqt_map /* tuple of QCborValueRef* and QCborValueRef* */  QCborMap__Iter
 	return _out;
 }
 
-QCborValueRef* QCborMap__Iterator_OperatorMinusGreater(const QCborMap__Iterator* self) {
+struct miqt_map /* tuple of QCborValueConstRef* and QCborValueRef* */  QCborMap__Iterator_OperatorSubscript(const QCborMap__Iterator* self, ptrdiff_t j) {
+	QCborMap::Iterator::value_type _ret = self->operator[]((qsizetype)(j));
+	// Convert QPair<> from C++ memory to manually-managed C memory
+	QCborValueConstRef** _first_arr = static_cast<QCborValueConstRef**>(malloc(sizeof(QCborValueConstRef*)));
+	QCborValueRef** _second_arr = static_cast<QCborValueRef**>(malloc(sizeof(QCborValueRef*)));
+	_first_arr[0] = new QCborValueConstRef(_ret.first);
+	_second_arr[0] = new QCborValueRef(_ret.second);
+	struct miqt_map _out;
+	_out.len = 1;
+	_out.keys = static_cast<void*>(_first_arr);
+	_out.values = static_cast<void*>(_second_arr);
+	return _out;
+}
+
+QCborValueRef* QCborMap__Iterator_OperatorMinusGreater(QCborMap__Iterator* self) {
 	return self->operator->();
 }
 
+QCborValueConstRef* QCborMap__Iterator_OperatorMinusGreater2(const QCborMap__Iterator* self) {
+	return (QCborValueConstRef*) self->operator->();
+}
+
 QCborValue* QCborMap__Iterator_Key(const QCborMap__Iterator* self) {
 	return new QCborValue(self->key());
 }
@@ -499,13 +518,13 @@ void QCborMap__ConstIterator_OperatorAssign(QCborMap__ConstIterator* self, QCbor
 	self->operator=(*other);
 }
 
-struct miqt_map /* tuple of QCborValueRef* and QCborValueRef* */  QCborMap__ConstIterator_OperatorMultiply(const QCborMap__ConstIterator* self) {
+struct miqt_map /* tuple of QCborValueConstRef* and QCborValueConstRef* */  QCborMap__ConstIterator_OperatorMultiply(const QCborMap__ConstIterator* self) {
 	QCborMap::ConstIterator::value_type _ret = self->operator*();
 	// Convert QPair<> from C++ memory to manually-managed C memory
-	QCborValueRef** _first_arr = static_cast<QCborValueRef**>(malloc(sizeof(QCborValueRef*)));
-	QCborValueRef** _second_arr = static_cast<QCborValueRef**>(malloc(sizeof(QCborValueRef*)));
-	_first_arr[0] = new QCborValueRef(_ret.first);
-	_second_arr[0] = new QCborValueRef(_ret.second);
+	QCborValueConstRef** _first_arr = static_cast<QCborValueConstRef**>(malloc(sizeof(QCborValueConstRef*)));
+	QCborValueConstRef** _second_arr = static_cast<QCborValueConstRef**>(malloc(sizeof(QCborValueConstRef*)));
+	_first_arr[0] = new QCborValueConstRef(_ret.first);
+	_second_arr[0] = new QCborValueConstRef(_ret.second);
 	struct miqt_map _out;
 	_out.len = 1;
 	_out.keys = static_cast<void*>(_first_arr);
@@ -513,16 +532,30 @@ struct miqt_map /* tuple of QCborValueRef* and QCborValueRef* */  QCborMap__Cons
 	return _out;
 }
 
-QCborValueRef* QCborMap__ConstIterator_OperatorMinusGreater(const QCborMap__ConstIterator* self) {
-	return (QCborValueRef*) self->operator->();
+struct miqt_map /* tuple of QCborValueConstRef* and QCborValueConstRef* */  QCborMap__ConstIterator_OperatorSubscript(const QCborMap__ConstIterator* self, ptrdiff_t j) {
+	QCborMap::ConstIterator::value_type _ret = self->operator[]((qsizetype)(j));
+	// Convert QPair<> from C++ memory to manually-managed C memory
+	QCborValueConstRef** _first_arr = static_cast<QCborValueConstRef**>(malloc(sizeof(QCborValueConstRef*)));
+	QCborValueConstRef** _second_arr = static_cast<QCborValueConstRef**>(malloc(sizeof(QCborValueConstRef*)));
+	_first_arr[0] = new QCborValueConstRef(_ret.first);
+	_second_arr[0] = new QCborValueConstRef(_ret.second);
+	struct miqt_map _out;
+	_out.len = 1;
+	_out.keys = static_cast<void*>(_first_arr);
+	_out.values = static_cast<void*>(_second_arr);
+	return _out;
+}
+
+QCborValueConstRef* QCborMap__ConstIterator_OperatorMinusGreater(const QCborMap__ConstIterator* self) {
+	return (QCborValueConstRef*) self->operator->();
 }
 
 QCborValue* QCborMap__ConstIterator_Key(const QCborMap__ConstIterator* self) {
 	return new QCborValue(self->key());
 }
 
-QCborValueRef* QCborMap__ConstIterator_Value(const QCborMap__ConstIterator* self) {
-	return new QCborValueRef(self->value());
+QCborValueConstRef* QCborMap__ConstIterator_Value(const QCborMap__ConstIterator* self) {
+	return new QCborValueConstRef(self->value());
 }
 
 bool QCborMap__ConstIterator_OperatorEqual(const QCborMap__ConstIterator* self, QCborMap__Iterator* o) {
diff --git a/qt6/cbor/gen_qcbormap.go b/qt6/cbor/gen_qcbormap.go
index e6f1d1f4..c21f4120 100644
--- a/qt6/cbor/gen_qcbormap.go
+++ b/qt6/cbor/gen_qcbormap.go
@@ -87,10 +87,10 @@ func (this *QCborMap) Keys() []QCborValue {
 	_ret := make([]QCborValue, int(_ma.len))
 	_outCast := (*[0xffff]*C.QCborValue)(unsafe.Pointer(_ma.data)) // hey ya
 	for i := 0; i < int(_ma.len); i++ {
-		_vv_ret := _outCast[i]
-		_vv_goptr := newQCborValue(_vv_ret)
-		_vv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
-		_ret[i] = *_vv_goptr
+		_lv_ret := _outCast[i]
+		_lv_goptr := newQCborValue(_lv_ret)
+		_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+		_ret[i] = *_lv_goptr
 	}
 	return _ret
 }
@@ -618,14 +618,14 @@ func (this *QCborMap__Iterator) OperatorAssign(other *QCborMap__Iterator) {
 }
 
 func (this *QCborMap__Iterator) OperatorMultiply() struct {
-	First  QCborValueRef
+	First  QCborValueConstRef
 	Second QCborValueRef
 } {
 	var _mm C.struct_miqt_map = C.QCborMap__Iterator_OperatorMultiply(this.h)
-	_First_CArray := (*[0xffff]*C.QCborValueRef)(unsafe.Pointer(_mm.keys))
+	_First_CArray := (*[0xffff]*C.QCborValueConstRef)(unsafe.Pointer(_mm.keys))
 	_Second_CArray := (*[0xffff]*C.QCborValueRef)(unsafe.Pointer(_mm.values))
 	_first_ret := _First_CArray[0]
-	_first_goptr := newQCborValueRef(_first_ret)
+	_first_goptr := newQCborValueConstRef(_first_ret)
 	_first_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	_entry_First := *_first_goptr
 
@@ -635,7 +635,30 @@ func (this *QCborMap__Iterator) OperatorMultiply() struct {
 	_entry_Second := *_second_goptr
 
 	return struct {
-		First  QCborValueRef
+		First  QCborValueConstRef
+		Second QCborValueRef
+	}{First: _entry_First, Second: _entry_Second}
+}
+
+func (this *QCborMap__Iterator) OperatorSubscript(j int64) struct {
+	First  QCborValueConstRef
+	Second QCborValueRef
+} {
+	var _mm C.struct_miqt_map = C.QCborMap__Iterator_OperatorSubscript(this.h, (C.ptrdiff_t)(j))
+	_First_CArray := (*[0xffff]*C.QCborValueConstRef)(unsafe.Pointer(_mm.keys))
+	_Second_CArray := (*[0xffff]*C.QCborValueRef)(unsafe.Pointer(_mm.values))
+	_first_ret := _First_CArray[0]
+	_first_goptr := newQCborValueConstRef(_first_ret)
+	_first_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	_entry_First := *_first_goptr
+
+	_second_ret := _Second_CArray[0]
+	_second_goptr := newQCborValueRef(_second_ret)
+	_second_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	_entry_Second := *_second_goptr
+
+	return struct {
+		First  QCborValueConstRef
 		Second QCborValueRef
 	}{First: _entry_First, Second: _entry_Second}
 }
@@ -644,6 +667,10 @@ func (this *QCborMap__Iterator) OperatorMinusGreater() *QCborValueRef {
 	return UnsafeNewQCborValueRef(unsafe.Pointer(C.QCborMap__Iterator_OperatorMinusGreater(this.h)))
 }
 
+func (this *QCborMap__Iterator) OperatorMinusGreater2() *QCborValueConstRef {
+	return UnsafeNewQCborValueConstRef(unsafe.Pointer(C.QCborMap__Iterator_OperatorMinusGreater2(this.h)))
+}
+
 func (this *QCborMap__Iterator) Key() *QCborValue {
 	_ret := C.QCborMap__Iterator_Key(this.h)
 	_goptr := newQCborValue(_ret)
@@ -814,30 +841,53 @@ func (this *QCborMap__ConstIterator) OperatorAssign(other *QCborMap__ConstIterat
 }
 
 func (this *QCborMap__ConstIterator) OperatorMultiply() struct {
-	First  QCborValueRef
-	Second QCborValueRef
+	First  QCborValueConstRef
+	Second QCborValueConstRef
 } {
 	var _mm C.struct_miqt_map = C.QCborMap__ConstIterator_OperatorMultiply(this.h)
-	_First_CArray := (*[0xffff]*C.QCborValueRef)(unsafe.Pointer(_mm.keys))
-	_Second_CArray := (*[0xffff]*C.QCborValueRef)(unsafe.Pointer(_mm.values))
+	_First_CArray := (*[0xffff]*C.QCborValueConstRef)(unsafe.Pointer(_mm.keys))
+	_Second_CArray := (*[0xffff]*C.QCborValueConstRef)(unsafe.Pointer(_mm.values))
 	_first_ret := _First_CArray[0]
-	_first_goptr := newQCborValueRef(_first_ret)
+	_first_goptr := newQCborValueConstRef(_first_ret)
 	_first_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	_entry_First := *_first_goptr
 
 	_second_ret := _Second_CArray[0]
-	_second_goptr := newQCborValueRef(_second_ret)
+	_second_goptr := newQCborValueConstRef(_second_ret)
 	_second_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	_entry_Second := *_second_goptr
 
 	return struct {
-		First  QCborValueRef
-		Second QCborValueRef
+		First  QCborValueConstRef
+		Second QCborValueConstRef
 	}{First: _entry_First, Second: _entry_Second}
 }
 
-func (this *QCborMap__ConstIterator) OperatorMinusGreater() *QCborValueRef {
-	return UnsafeNewQCborValueRef(unsafe.Pointer(C.QCborMap__ConstIterator_OperatorMinusGreater(this.h)))
+func (this *QCborMap__ConstIterator) OperatorSubscript(j int64) struct {
+	First  QCborValueConstRef
+	Second QCborValueConstRef
+} {
+	var _mm C.struct_miqt_map = C.QCborMap__ConstIterator_OperatorSubscript(this.h, (C.ptrdiff_t)(j))
+	_First_CArray := (*[0xffff]*C.QCborValueConstRef)(unsafe.Pointer(_mm.keys))
+	_Second_CArray := (*[0xffff]*C.QCborValueConstRef)(unsafe.Pointer(_mm.values))
+	_first_ret := _First_CArray[0]
+	_first_goptr := newQCborValueConstRef(_first_ret)
+	_first_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	_entry_First := *_first_goptr
+
+	_second_ret := _Second_CArray[0]
+	_second_goptr := newQCborValueConstRef(_second_ret)
+	_second_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	_entry_Second := *_second_goptr
+
+	return struct {
+		First  QCborValueConstRef
+		Second QCborValueConstRef
+	}{First: _entry_First, Second: _entry_Second}
+}
+
+func (this *QCborMap__ConstIterator) OperatorMinusGreater() *QCborValueConstRef {
+	return UnsafeNewQCborValueConstRef(unsafe.Pointer(C.QCborMap__ConstIterator_OperatorMinusGreater(this.h)))
 }
 
 func (this *QCborMap__ConstIterator) Key() *QCborValue {
@@ -847,9 +897,9 @@ func (this *QCborMap__ConstIterator) Key() *QCborValue {
 	return _goptr
 }
 
-func (this *QCborMap__ConstIterator) Value() *QCborValueRef {
+func (this *QCborMap__ConstIterator) Value() *QCborValueConstRef {
 	_ret := C.QCborMap__ConstIterator_Value(this.h)
-	_goptr := newQCborValueRef(_ret)
+	_goptr := newQCborValueConstRef(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
diff --git a/qt6/cbor/gen_qcbormap.h b/qt6/cbor/gen_qcbormap.h
index f7fc3749..f3ae3138 100644
--- a/qt6/cbor/gen_qcbormap.h
+++ b/qt6/cbor/gen_qcbormap.h
@@ -27,6 +27,7 @@ typedef QCborMap::Iterator QCborMap__Iterator;
 class QCborMap__Iterator;
 #endif
 class QCborValue;
+class QCborValueConstRef;
 class QCborValueRef;
 class QJsonObject;
 class QVariant;
@@ -35,6 +36,7 @@ typedef struct QCborMap QCborMap;
 typedef struct QCborMap__ConstIterator QCborMap__ConstIterator;
 typedef struct QCborMap__Iterator QCborMap__Iterator;
 typedef struct QCborValue QCborValue;
+typedef struct QCborValueConstRef QCborValueConstRef;
 typedef struct QCborValueRef QCborValueRef;
 typedef struct QJsonObject QJsonObject;
 typedef struct QVariant QVariant;
@@ -108,8 +110,10 @@ void QCborMap_Delete(QCborMap* self);
 QCborMap__Iterator* QCborMap__Iterator_new();
 QCborMap__Iterator* QCborMap__Iterator_new2(QCborMap__Iterator* param1);
 void QCborMap__Iterator_OperatorAssign(QCborMap__Iterator* self, QCborMap__Iterator* other);
-struct miqt_map /* tuple of QCborValueRef* and QCborValueRef* */  QCborMap__Iterator_OperatorMultiply(const QCborMap__Iterator* self);
-QCborValueRef* QCborMap__Iterator_OperatorMinusGreater(const QCborMap__Iterator* self);
+struct miqt_map /* tuple of QCborValueConstRef* and QCborValueRef* */  QCborMap__Iterator_OperatorMultiply(const QCborMap__Iterator* self);
+struct miqt_map /* tuple of QCborValueConstRef* and QCborValueRef* */  QCborMap__Iterator_OperatorSubscript(const QCborMap__Iterator* self, ptrdiff_t j);
+QCborValueRef* QCborMap__Iterator_OperatorMinusGreater(QCborMap__Iterator* self);
+QCborValueConstRef* QCborMap__Iterator_OperatorMinusGreater2(const QCborMap__Iterator* self);
 QCborValue* QCborMap__Iterator_Key(const QCborMap__Iterator* self);
 QCborValueRef* QCborMap__Iterator_Value(const QCborMap__Iterator* self);
 bool QCborMap__Iterator_OperatorEqual(const QCborMap__Iterator* self, QCborMap__Iterator* o);
@@ -138,10 +142,11 @@ void QCborMap__Iterator_Delete(QCborMap__Iterator* self);
 QCborMap__ConstIterator* QCborMap__ConstIterator_new();
 QCborMap__ConstIterator* QCborMap__ConstIterator_new2(QCborMap__ConstIterator* param1);
 void QCborMap__ConstIterator_OperatorAssign(QCborMap__ConstIterator* self, QCborMap__ConstIterator* other);
-struct miqt_map /* tuple of QCborValueRef* and QCborValueRef* */  QCborMap__ConstIterator_OperatorMultiply(const QCborMap__ConstIterator* self);
-QCborValueRef* QCborMap__ConstIterator_OperatorMinusGreater(const QCborMap__ConstIterator* self);
+struct miqt_map /* tuple of QCborValueConstRef* and QCborValueConstRef* */  QCborMap__ConstIterator_OperatorMultiply(const QCborMap__ConstIterator* self);
+struct miqt_map /* tuple of QCborValueConstRef* and QCborValueConstRef* */  QCborMap__ConstIterator_OperatorSubscript(const QCborMap__ConstIterator* self, ptrdiff_t j);
+QCborValueConstRef* QCborMap__ConstIterator_OperatorMinusGreater(const QCborMap__ConstIterator* self);
 QCborValue* QCborMap__ConstIterator_Key(const QCborMap__ConstIterator* self);
-QCborValueRef* QCborMap__ConstIterator_Value(const QCborMap__ConstIterator* self);
+QCborValueConstRef* QCborMap__ConstIterator_Value(const QCborMap__ConstIterator* self);
 bool QCborMap__ConstIterator_OperatorEqual(const QCborMap__ConstIterator* self, QCborMap__Iterator* o);
 bool QCborMap__ConstIterator_OperatorNotEqual(const QCborMap__ConstIterator* self, QCborMap__Iterator* o);
 bool QCborMap__ConstIterator_OperatorLesser(const QCborMap__ConstIterator* self, QCborMap__Iterator* other);
diff --git a/qt6/cbor/gen_qcborvalue.cpp b/qt6/cbor/gen_qcborvalue.cpp
index bf20637b..78ee74d7 100644
--- a/qt6/cbor/gen_qcborvalue.cpp
+++ b/qt6/cbor/gen_qcborvalue.cpp
@@ -5,6 +5,7 @@
 #include <QCborStreamReader>
 #include <QCborStreamWriter>
 #include <QCborValue>
+#include <QCborValueConstRef>
 #include <QCborValueRef>
 #include <QDateTime>
 #include <QJsonValue>
@@ -363,7 +364,7 @@ QCborValue* QCborValue_FromCbor3(const unsigned char* data, ptrdiff_t lenVal) {
 	return new QCborValue(QCborValue::fromCbor(static_cast<const quint8*>(data), (qsizetype)(lenVal)));
 }
 
-struct miqt_string QCborValue_ToCbor(QCborValue* self) {
+struct miqt_string QCborValue_ToCbor(const QCborValue* self) {
 	QByteArray _qb = self->toCbor();
 	struct miqt_string _ms;
 	_ms.len = _qb.length();
@@ -372,7 +373,7 @@ struct miqt_string QCborValue_ToCbor(QCborValue* self) {
 	return _ms;
 }
 
-void QCborValue_ToCborWithWriter(QCborValue* self, QCborStreamWriter* writer) {
+void QCborValue_ToCborWithWriter(const QCborValue* self, QCborStreamWriter* writer) {
 	self->toCbor(*writer);
 }
 
@@ -465,7 +466,7 @@ QCborValue* QCborValue_FromCbor33(const unsigned char* data, ptrdiff_t lenVal, Q
 	return new QCborValue(QCborValue::fromCbor(static_cast<const quint8*>(data), (qsizetype)(lenVal), error));
 }
 
-struct miqt_string QCborValue_ToCbor1(QCborValue* self, int opt) {
+struct miqt_string QCborValue_ToCbor1(const QCborValue* self, int opt) {
 	QByteArray _qb = self->toCbor(static_cast<QCborValue::EncodingOptions>(opt));
 	struct miqt_string _ms;
 	_ms.len = _qb.length();
@@ -474,7 +475,7 @@ struct miqt_string QCborValue_ToCbor1(QCborValue* self, int opt) {
 	return _ms;
 }
 
-void QCborValue_ToCbor2(QCborValue* self, QCborStreamWriter* writer, int opt) {
+void QCborValue_ToCbor2(const QCborValue* self, QCborStreamWriter* writer, int opt) {
 	self->toCbor(*writer, static_cast<QCborValue::EncodingOptions>(opt));
 }
 
@@ -493,6 +494,324 @@ void QCborValue_Delete(QCborValue* self) {
 	delete self;
 }
 
+QCborValueConstRef* QCborValueConstRef_new(QCborValueConstRef* param1) {
+	return new QCborValueConstRef(*param1);
+}
+
+int QCborValueConstRef_Type(const QCborValueConstRef* self) {
+	QCborValue::Type _ret = self->type();
+	return static_cast<int>(_ret);
+}
+
+bool QCborValueConstRef_IsInteger(const QCborValueConstRef* self) {
+	return self->isInteger();
+}
+
+bool QCborValueConstRef_IsByteArray(const QCborValueConstRef* self) {
+	return self->isByteArray();
+}
+
+bool QCborValueConstRef_IsString(const QCborValueConstRef* self) {
+	return self->isString();
+}
+
+bool QCborValueConstRef_IsArray(const QCborValueConstRef* self) {
+	return self->isArray();
+}
+
+bool QCborValueConstRef_IsMap(const QCborValueConstRef* self) {
+	return self->isMap();
+}
+
+bool QCborValueConstRef_IsTag(const QCborValueConstRef* self) {
+	return self->isTag();
+}
+
+bool QCborValueConstRef_IsFalse(const QCborValueConstRef* self) {
+	return self->isFalse();
+}
+
+bool QCborValueConstRef_IsTrue(const QCborValueConstRef* self) {
+	return self->isTrue();
+}
+
+bool QCborValueConstRef_IsBool(const QCborValueConstRef* self) {
+	return self->isBool();
+}
+
+bool QCborValueConstRef_IsNull(const QCborValueConstRef* self) {
+	return self->isNull();
+}
+
+bool QCborValueConstRef_IsUndefined(const QCborValueConstRef* self) {
+	return self->isUndefined();
+}
+
+bool QCborValueConstRef_IsDouble(const QCborValueConstRef* self) {
+	return self->isDouble();
+}
+
+bool QCborValueConstRef_IsDateTime(const QCborValueConstRef* self) {
+	return self->isDateTime();
+}
+
+bool QCborValueConstRef_IsUrl(const QCborValueConstRef* self) {
+	return self->isUrl();
+}
+
+bool QCborValueConstRef_IsRegularExpression(const QCborValueConstRef* self) {
+	return self->isRegularExpression();
+}
+
+bool QCborValueConstRef_IsUuid(const QCborValueConstRef* self) {
+	return self->isUuid();
+}
+
+bool QCborValueConstRef_IsInvalid(const QCborValueConstRef* self) {
+	return self->isInvalid();
+}
+
+bool QCborValueConstRef_IsContainer(const QCborValueConstRef* self) {
+	return self->isContainer();
+}
+
+bool QCborValueConstRef_IsSimpleType(const QCborValueConstRef* self) {
+	return self->isSimpleType();
+}
+
+bool QCborValueConstRef_IsSimpleTypeWithSt(const QCborValueConstRef* self, uint8_t st) {
+	return self->isSimpleType(static_cast<QCborSimpleType>(st));
+}
+
+uint8_t QCborValueConstRef_ToSimpleType(const QCborValueConstRef* self) {
+	QCborSimpleType _ret = self->toSimpleType();
+	return static_cast<uint8_t>(_ret);
+}
+
+uint64_t QCborValueConstRef_Tag(const QCborValueConstRef* self) {
+	QCborTag _ret = self->tag();
+	return static_cast<uint64_t>(_ret);
+}
+
+QCborValue* QCborValueConstRef_TaggedValue(const QCborValueConstRef* self) {
+	return new QCborValue(self->taggedValue());
+}
+
+long long QCborValueConstRef_ToInteger(const QCborValueConstRef* self) {
+	qint64 _ret = self->toInteger();
+	return static_cast<long long>(_ret);
+}
+
+bool QCborValueConstRef_ToBool(const QCborValueConstRef* self) {
+	return self->toBool();
+}
+
+double QCborValueConstRef_ToDouble(const QCborValueConstRef* self) {
+	return self->toDouble();
+}
+
+struct miqt_string QCborValueConstRef_ToByteArray(const QCborValueConstRef* self) {
+	QByteArray _qb = self->toByteArray();
+	struct miqt_string _ms;
+	_ms.len = _qb.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _qb.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QCborValueConstRef_ToString(const QCborValueConstRef* self) {
+	QString _ret = self->toString();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+QDateTime* QCborValueConstRef_ToDateTime(const QCborValueConstRef* self) {
+	return new QDateTime(self->toDateTime());
+}
+
+QUrl* QCborValueConstRef_ToUrl(const QCborValueConstRef* self) {
+	return new QUrl(self->toUrl());
+}
+
+QRegularExpression* QCborValueConstRef_ToRegularExpression(const QCborValueConstRef* self) {
+	return new QRegularExpression(self->toRegularExpression());
+}
+
+QUuid* QCborValueConstRef_ToUuid(const QCborValueConstRef* self) {
+	return new QUuid(self->toUuid());
+}
+
+QCborArray* QCborValueConstRef_ToArray(const QCborValueConstRef* self) {
+	return new QCborArray(self->toArray());
+}
+
+QCborArray* QCborValueConstRef_ToArrayWithQCborArray(const QCborValueConstRef* self, QCborArray* a) {
+	return new QCborArray(self->toArray(*a));
+}
+
+QCborMap* QCborValueConstRef_ToMap(const QCborValueConstRef* self) {
+	return new QCborMap(self->toMap());
+}
+
+QCborMap* QCborValueConstRef_ToMapWithQCborMap(const QCborValueConstRef* self, QCborMap* m) {
+	return new QCborMap(self->toMap(*m));
+}
+
+QCborValue* QCborValueConstRef_OperatorSubscript(const QCborValueConstRef* self, struct miqt_string key) {
+	QString key_QString = QString::fromUtf8(key.data, key.len);
+	return new QCborValue(self->operator[](key_QString));
+}
+
+QCborValue* QCborValueConstRef_OperatorSubscript2(const QCborValueConstRef* self, long long key) {
+	return new QCborValue(self->operator[](static_cast<qint64>(key)));
+}
+
+int QCborValueConstRef_Compare(const QCborValueConstRef* self, QCborValue* other) {
+	return self->compare(*other);
+}
+
+bool QCborValueConstRef_OperatorEqual(const QCborValueConstRef* self, QCborValue* other) {
+	return self->operator==(*other);
+}
+
+bool QCborValueConstRef_OperatorNotEqual(const QCborValueConstRef* self, QCborValue* other) {
+	return self->operator!=(*other);
+}
+
+bool QCborValueConstRef_OperatorLesser(const QCborValueConstRef* self, QCborValue* other) {
+	return self->operator<(*other);
+}
+
+QVariant* QCborValueConstRef_ToVariant(const QCborValueConstRef* self) {
+	return new QVariant(self->toVariant());
+}
+
+QJsonValue* QCborValueConstRef_ToJsonValue(const QCborValueConstRef* self) {
+	return new QJsonValue(self->toJsonValue());
+}
+
+struct miqt_string QCborValueConstRef_ToCbor(const QCborValueConstRef* self) {
+	QByteArray _qb = self->toCbor();
+	struct miqt_string _ms;
+	_ms.len = _qb.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _qb.data(), _ms.len);
+	return _ms;
+}
+
+void QCborValueConstRef_ToCborWithWriter(const QCborValueConstRef* self, QCborStreamWriter* writer) {
+	self->toCbor(*writer);
+}
+
+struct miqt_string QCborValueConstRef_ToDiagnosticNotation(const QCborValueConstRef* self) {
+	QString _ret = self->toDiagnosticNotation();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+uint8_t QCborValueConstRef_ToSimpleType1(const QCborValueConstRef* self, uint8_t defaultValue) {
+	QCborSimpleType _ret = self->toSimpleType(static_cast<QCborSimpleType>(defaultValue));
+	return static_cast<uint8_t>(_ret);
+}
+
+uint64_t QCborValueConstRef_Tag1(const QCborValueConstRef* self, uint64_t defaultValue) {
+	QCborTag _ret = self->tag(static_cast<QCborTag>(defaultValue));
+	return static_cast<uint64_t>(_ret);
+}
+
+QCborValue* QCborValueConstRef_TaggedValue1(const QCborValueConstRef* self, QCborValue* defaultValue) {
+	return new QCborValue(self->taggedValue(*defaultValue));
+}
+
+long long QCborValueConstRef_ToInteger1(const QCborValueConstRef* self, long long defaultValue) {
+	qint64 _ret = self->toInteger(static_cast<qint64>(defaultValue));
+	return static_cast<long long>(_ret);
+}
+
+bool QCborValueConstRef_ToBool1(const QCborValueConstRef* self, bool defaultValue) {
+	return self->toBool(defaultValue);
+}
+
+double QCborValueConstRef_ToDouble1(const QCborValueConstRef* self, double defaultValue) {
+	return self->toDouble(static_cast<double>(defaultValue));
+}
+
+struct miqt_string QCborValueConstRef_ToByteArray1(const QCborValueConstRef* self, struct miqt_string defaultValue) {
+	QByteArray defaultValue_QByteArray(defaultValue.data, defaultValue.len);
+	QByteArray _qb = self->toByteArray(defaultValue_QByteArray);
+	struct miqt_string _ms;
+	_ms.len = _qb.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _qb.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QCborValueConstRef_ToString1(const QCborValueConstRef* self, struct miqt_string defaultValue) {
+	QString defaultValue_QString = QString::fromUtf8(defaultValue.data, defaultValue.len);
+	QString _ret = self->toString(defaultValue_QString);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+QDateTime* QCborValueConstRef_ToDateTime1(const QCborValueConstRef* self, QDateTime* defaultValue) {
+	return new QDateTime(self->toDateTime(*defaultValue));
+}
+
+QUrl* QCborValueConstRef_ToUrl1(const QCborValueConstRef* self, QUrl* defaultValue) {
+	return new QUrl(self->toUrl(*defaultValue));
+}
+
+QRegularExpression* QCborValueConstRef_ToRegularExpression1(const QCborValueConstRef* self, QRegularExpression* defaultValue) {
+	return new QRegularExpression(self->toRegularExpression(*defaultValue));
+}
+
+QUuid* QCborValueConstRef_ToUuid1(const QCborValueConstRef* self, QUuid* defaultValue) {
+	return new QUuid(self->toUuid(*defaultValue));
+}
+
+struct miqt_string QCborValueConstRef_ToCbor1(const QCborValueConstRef* self, int opt) {
+	QByteArray _qb = self->toCbor(static_cast<QCborValue::EncodingOptions>(opt));
+	struct miqt_string _ms;
+	_ms.len = _qb.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _qb.data(), _ms.len);
+	return _ms;
+}
+
+void QCborValueConstRef_ToCbor2(const QCborValueConstRef* self, QCborStreamWriter* writer, int opt) {
+	self->toCbor(*writer, static_cast<QCborValue::EncodingOptions>(opt));
+}
+
+struct miqt_string QCborValueConstRef_ToDiagnosticNotation1(const QCborValueConstRef* self, int opt) {
+	QString _ret = self->toDiagnosticNotation(static_cast<QCborValue::DiagnosticNotationOptions>(opt));
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QCborValueConstRef_Delete(QCborValueConstRef* self) {
+	delete self;
+}
+
 QCborValueRef* QCborValueRef_new(QCborValueRef* param1) {
 	return new QCborValueRef(*param1);
 }
@@ -505,6 +824,15 @@ void QCborValueRef_OperatorAssignWithOther(QCborValueRef* self, QCborValueRef* o
 	self->operator=(*other);
 }
 
+QCborValueRef* QCborValueRef_OperatorSubscript(QCborValueRef* self, long long key) {
+	return new QCborValueRef(self->operator[](static_cast<qint64>(key)));
+}
+
+QCborValueRef* QCborValueRef_OperatorSubscript2(QCborValueRef* self, struct miqt_string key) {
+	QString key_QString = QString::fromUtf8(key.data, key.len);
+	return new QCborValueRef(self->operator[](key_QString));
+}
+
 int QCborValueRef_Type(const QCborValueRef* self) {
 	QCborValue::Type _ret = self->type();
 	return static_cast<int>(_ret);
@@ -590,6 +918,11 @@ bool QCborValueRef_IsSimpleTypeWithSt(const QCborValueRef* self, uint8_t st) {
 	return self->isSimpleType(static_cast<QCborSimpleType>(st));
 }
 
+uint8_t QCborValueRef_ToSimpleType(const QCborValueRef* self) {
+	QCborSimpleType _ret = self->toSimpleType();
+	return static_cast<uint8_t>(_ret);
+}
+
 uint64_t QCborValueRef_Tag(const QCborValueRef* self) {
 	QCborTag _ret = self->tag();
 	return static_cast<uint64_t>(_ret);
@@ -664,24 +997,15 @@ QCborMap* QCborValueRef_ToMapWithQCborMap(const QCborValueRef* self, QCborMap* m
 	return new QCborMap(self->toMap(*m));
 }
 
-QCborValue* QCborValueRef_OperatorSubscript(const QCborValueRef* self, struct miqt_string key) {
+QCborValue* QCborValueRef_OperatorSubscript3(const QCborValueRef* self, struct miqt_string key) {
 	QString key_QString = QString::fromUtf8(key.data, key.len);
 	return new QCborValue(self->operator[](key_QString));
 }
 
-QCborValue* QCborValueRef_OperatorSubscript2(const QCborValueRef* self, long long key) {
+QCborValue* QCborValueRef_OperatorSubscript5(const QCborValueRef* self, long long key) {
 	return new QCborValue(self->operator[](static_cast<qint64>(key)));
 }
 
-QCborValueRef* QCborValueRef_OperatorSubscript3(QCborValueRef* self, long long key) {
-	return new QCborValueRef(self->operator[](static_cast<qint64>(key)));
-}
-
-QCborValueRef* QCborValueRef_OperatorSubscript5(QCborValueRef* self, struct miqt_string key) {
-	QString key_QString = QString::fromUtf8(key.data, key.len);
-	return new QCborValueRef(self->operator[](key_QString));
-}
-
 int QCborValueRef_Compare(const QCborValueRef* self, QCborValue* other) {
 	return self->compare(*other);
 }
@@ -730,6 +1054,11 @@ struct miqt_string QCborValueRef_ToDiagnosticNotation(QCborValueRef* self) {
 	return _ms;
 }
 
+uint8_t QCborValueRef_ToSimpleType1(const QCborValueRef* self, uint8_t defaultValue) {
+	QCborSimpleType _ret = self->toSimpleType(static_cast<QCborSimpleType>(defaultValue));
+	return static_cast<uint8_t>(_ret);
+}
+
 uint64_t QCborValueRef_Tag1(const QCborValueRef* self, uint64_t defaultValue) {
 	QCborTag _ret = self->tag(static_cast<QCborTag>(defaultValue));
 	return static_cast<uint64_t>(_ret);
diff --git a/qt6/cbor/gen_qcborvalue.go b/qt6/cbor/gen_qcborvalue.go
index 29e57f60..4891d483 100644
--- a/qt6/cbor/gen_qcborvalue.go
+++ b/qt6/cbor/gen_qcborvalue.go
@@ -728,8 +728,399 @@ func (this *QCborValue) GoGC() {
 	})
 }
 
+type QCborValueConstRef struct {
+	h *C.QCborValueConstRef
+}
+
+func (this *QCborValueConstRef) cPointer() *C.QCborValueConstRef {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QCborValueConstRef) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+func newQCborValueConstRef(h *C.QCborValueConstRef) *QCborValueConstRef {
+	if h == nil {
+		return nil
+	}
+	return &QCborValueConstRef{h: h}
+}
+
+func UnsafeNewQCborValueConstRef(h unsafe.Pointer) *QCborValueConstRef {
+	return newQCborValueConstRef((*C.QCborValueConstRef)(h))
+}
+
+// NewQCborValueConstRef constructs a new QCborValueConstRef object.
+func NewQCborValueConstRef(param1 *QCborValueConstRef) *QCborValueConstRef {
+	ret := C.QCborValueConstRef_new(param1.cPointer())
+	return newQCborValueConstRef(ret)
+}
+
+func (this *QCborValueConstRef) Type() QCborValue__Type {
+	return (QCborValue__Type)(C.QCborValueConstRef_Type(this.h))
+}
+
+func (this *QCborValueConstRef) IsInteger() bool {
+	return (bool)(C.QCborValueConstRef_IsInteger(this.h))
+}
+
+func (this *QCborValueConstRef) IsByteArray() bool {
+	return (bool)(C.QCborValueConstRef_IsByteArray(this.h))
+}
+
+func (this *QCborValueConstRef) IsString() bool {
+	return (bool)(C.QCborValueConstRef_IsString(this.h))
+}
+
+func (this *QCborValueConstRef) IsArray() bool {
+	return (bool)(C.QCborValueConstRef_IsArray(this.h))
+}
+
+func (this *QCborValueConstRef) IsMap() bool {
+	return (bool)(C.QCborValueConstRef_IsMap(this.h))
+}
+
+func (this *QCborValueConstRef) IsTag() bool {
+	return (bool)(C.QCborValueConstRef_IsTag(this.h))
+}
+
+func (this *QCborValueConstRef) IsFalse() bool {
+	return (bool)(C.QCborValueConstRef_IsFalse(this.h))
+}
+
+func (this *QCborValueConstRef) IsTrue() bool {
+	return (bool)(C.QCborValueConstRef_IsTrue(this.h))
+}
+
+func (this *QCborValueConstRef) IsBool() bool {
+	return (bool)(C.QCborValueConstRef_IsBool(this.h))
+}
+
+func (this *QCborValueConstRef) IsNull() bool {
+	return (bool)(C.QCborValueConstRef_IsNull(this.h))
+}
+
+func (this *QCborValueConstRef) IsUndefined() bool {
+	return (bool)(C.QCborValueConstRef_IsUndefined(this.h))
+}
+
+func (this *QCborValueConstRef) IsDouble() bool {
+	return (bool)(C.QCborValueConstRef_IsDouble(this.h))
+}
+
+func (this *QCborValueConstRef) IsDateTime() bool {
+	return (bool)(C.QCborValueConstRef_IsDateTime(this.h))
+}
+
+func (this *QCborValueConstRef) IsUrl() bool {
+	return (bool)(C.QCborValueConstRef_IsUrl(this.h))
+}
+
+func (this *QCborValueConstRef) IsRegularExpression() bool {
+	return (bool)(C.QCborValueConstRef_IsRegularExpression(this.h))
+}
+
+func (this *QCborValueConstRef) IsUuid() bool {
+	return (bool)(C.QCborValueConstRef_IsUuid(this.h))
+}
+
+func (this *QCborValueConstRef) IsInvalid() bool {
+	return (bool)(C.QCborValueConstRef_IsInvalid(this.h))
+}
+
+func (this *QCborValueConstRef) IsContainer() bool {
+	return (bool)(C.QCborValueConstRef_IsContainer(this.h))
+}
+
+func (this *QCborValueConstRef) IsSimpleType() bool {
+	return (bool)(C.QCborValueConstRef_IsSimpleType(this.h))
+}
+
+func (this *QCborValueConstRef) IsSimpleTypeWithSt(st QCborSimpleType) bool {
+	return (bool)(C.QCborValueConstRef_IsSimpleTypeWithSt(this.h, (C.uint8_t)(st)))
+}
+
+func (this *QCborValueConstRef) ToSimpleType() QCborSimpleType {
+	return (QCborSimpleType)(C.QCborValueConstRef_ToSimpleType(this.h))
+}
+
+func (this *QCborValueConstRef) Tag() QCborTag {
+	return (QCborTag)(C.QCborValueConstRef_Tag(this.h))
+}
+
+func (this *QCborValueConstRef) TaggedValue() *QCborValue {
+	_ret := C.QCborValueConstRef_TaggedValue(this.h)
+	_goptr := newQCborValue(_ret)
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) ToInteger() int64 {
+	return (int64)(C.QCborValueConstRef_ToInteger(this.h))
+}
+
+func (this *QCborValueConstRef) ToBool() bool {
+	return (bool)(C.QCborValueConstRef_ToBool(this.h))
+}
+
+func (this *QCborValueConstRef) ToDouble() float64 {
+	return (float64)(C.QCborValueConstRef_ToDouble(this.h))
+}
+
+func (this *QCborValueConstRef) ToByteArray() []byte {
+	var _bytearray C.struct_miqt_string = C.QCborValueConstRef_ToByteArray(this.h)
+	_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
+	C.free(unsafe.Pointer(_bytearray.data))
+	return _ret
+}
+
+func (this *QCborValueConstRef) ToString() string {
+	var _ms C.struct_miqt_string = C.QCborValueConstRef_ToString(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QCborValueConstRef) ToDateTime() *qt6.QDateTime {
+	_ret := C.QCborValueConstRef_ToDateTime(this.h)
+	_goptr := qt6.UnsafeNewQDateTime(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) ToUrl() *qt6.QUrl {
+	_ret := C.QCborValueConstRef_ToUrl(this.h)
+	_goptr := qt6.UnsafeNewQUrl(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) ToRegularExpression() *qt6.QRegularExpression {
+	_ret := C.QCborValueConstRef_ToRegularExpression(this.h)
+	_goptr := qt6.UnsafeNewQRegularExpression(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) ToUuid() *qt6.QUuid {
+	_ret := C.QCborValueConstRef_ToUuid(this.h)
+	_goptr := qt6.UnsafeNewQUuid(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) ToArray() *QCborArray {
+	_ret := C.QCborValueConstRef_ToArray(this.h)
+	_goptr := newQCborArray(_ret)
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) ToArrayWithQCborArray(a *QCborArray) *QCborArray {
+	_ret := C.QCborValueConstRef_ToArrayWithQCborArray(this.h, a.cPointer())
+	_goptr := newQCborArray(_ret)
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) ToMap() *QCborMap {
+	_ret := C.QCborValueConstRef_ToMap(this.h)
+	_goptr := newQCborMap(_ret)
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) ToMapWithQCborMap(m *QCborMap) *QCborMap {
+	_ret := C.QCborValueConstRef_ToMapWithQCborMap(this.h, m.cPointer())
+	_goptr := newQCborMap(_ret)
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) OperatorSubscript(key string) *QCborValue {
+	key_ms := C.struct_miqt_string{}
+	key_ms.data = C.CString(key)
+	key_ms.len = C.size_t(len(key))
+	defer C.free(unsafe.Pointer(key_ms.data))
+	_ret := C.QCborValueConstRef_OperatorSubscript(this.h, key_ms)
+	_goptr := newQCborValue(_ret)
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) OperatorSubscript2(key int64) *QCborValue {
+	_ret := C.QCborValueConstRef_OperatorSubscript2(this.h, (C.longlong)(key))
+	_goptr := newQCborValue(_ret)
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) Compare(other *QCborValue) int {
+	return (int)(C.QCborValueConstRef_Compare(this.h, other.cPointer()))
+}
+
+func (this *QCborValueConstRef) OperatorEqual(other *QCborValue) bool {
+	return (bool)(C.QCborValueConstRef_OperatorEqual(this.h, other.cPointer()))
+}
+
+func (this *QCborValueConstRef) OperatorNotEqual(other *QCborValue) bool {
+	return (bool)(C.QCborValueConstRef_OperatorNotEqual(this.h, other.cPointer()))
+}
+
+func (this *QCborValueConstRef) OperatorLesser(other *QCborValue) bool {
+	return (bool)(C.QCborValueConstRef_OperatorLesser(this.h, other.cPointer()))
+}
+
+func (this *QCborValueConstRef) ToVariant() *qt6.QVariant {
+	_ret := C.QCborValueConstRef_ToVariant(this.h)
+	_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) ToJsonValue() *qt6.QJsonValue {
+	_ret := C.QCborValueConstRef_ToJsonValue(this.h)
+	_goptr := qt6.UnsafeNewQJsonValue(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) ToCbor() []byte {
+	var _bytearray C.struct_miqt_string = C.QCborValueConstRef_ToCbor(this.h)
+	_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
+	C.free(unsafe.Pointer(_bytearray.data))
+	return _ret
+}
+
+func (this *QCborValueConstRef) ToCborWithWriter(writer *QCborStreamWriter) {
+	C.QCborValueConstRef_ToCborWithWriter(this.h, writer.cPointer())
+}
+
+func (this *QCborValueConstRef) ToDiagnosticNotation() string {
+	var _ms C.struct_miqt_string = C.QCborValueConstRef_ToDiagnosticNotation(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QCborValueConstRef) ToSimpleType1(defaultValue QCborSimpleType) QCborSimpleType {
+	return (QCborSimpleType)(C.QCborValueConstRef_ToSimpleType1(this.h, (C.uint8_t)(defaultValue)))
+}
+
+func (this *QCborValueConstRef) Tag1(defaultValue QCborTag) QCborTag {
+	return (QCborTag)(C.QCborValueConstRef_Tag1(this.h, (C.uint64_t)(defaultValue)))
+}
+
+func (this *QCborValueConstRef) TaggedValue1(defaultValue *QCborValue) *QCborValue {
+	_ret := C.QCborValueConstRef_TaggedValue1(this.h, defaultValue.cPointer())
+	_goptr := newQCborValue(_ret)
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) ToInteger1(defaultValue int64) int64 {
+	return (int64)(C.QCborValueConstRef_ToInteger1(this.h, (C.longlong)(defaultValue)))
+}
+
+func (this *QCborValueConstRef) ToBool1(defaultValue bool) bool {
+	return (bool)(C.QCborValueConstRef_ToBool1(this.h, (C.bool)(defaultValue)))
+}
+
+func (this *QCborValueConstRef) ToDouble1(defaultValue float64) float64 {
+	return (float64)(C.QCborValueConstRef_ToDouble1(this.h, (C.double)(defaultValue)))
+}
+
+func (this *QCborValueConstRef) ToByteArray1(defaultValue []byte) []byte {
+	defaultValue_alias := C.struct_miqt_string{}
+	defaultValue_alias.data = (*C.char)(unsafe.Pointer(&defaultValue[0]))
+	defaultValue_alias.len = C.size_t(len(defaultValue))
+	var _bytearray C.struct_miqt_string = C.QCborValueConstRef_ToByteArray1(this.h, defaultValue_alias)
+	_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
+	C.free(unsafe.Pointer(_bytearray.data))
+	return _ret
+}
+
+func (this *QCborValueConstRef) ToString1(defaultValue string) string {
+	defaultValue_ms := C.struct_miqt_string{}
+	defaultValue_ms.data = C.CString(defaultValue)
+	defaultValue_ms.len = C.size_t(len(defaultValue))
+	defer C.free(unsafe.Pointer(defaultValue_ms.data))
+	var _ms C.struct_miqt_string = C.QCborValueConstRef_ToString1(this.h, defaultValue_ms)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QCborValueConstRef) ToDateTime1(defaultValue *qt6.QDateTime) *qt6.QDateTime {
+	_ret := C.QCborValueConstRef_ToDateTime1(this.h, (*C.QDateTime)(defaultValue.UnsafePointer()))
+	_goptr := qt6.UnsafeNewQDateTime(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) ToUrl1(defaultValue *qt6.QUrl) *qt6.QUrl {
+	_ret := C.QCborValueConstRef_ToUrl1(this.h, (*C.QUrl)(defaultValue.UnsafePointer()))
+	_goptr := qt6.UnsafeNewQUrl(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) ToRegularExpression1(defaultValue *qt6.QRegularExpression) *qt6.QRegularExpression {
+	_ret := C.QCborValueConstRef_ToRegularExpression1(this.h, (*C.QRegularExpression)(defaultValue.UnsafePointer()))
+	_goptr := qt6.UnsafeNewQRegularExpression(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) ToUuid1(defaultValue *qt6.QUuid) *qt6.QUuid {
+	_ret := C.QCborValueConstRef_ToUuid1(this.h, (*C.QUuid)(defaultValue.UnsafePointer()))
+	_goptr := qt6.UnsafeNewQUuid(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueConstRef) ToCbor1(opt QCborValue__EncodingOption) []byte {
+	var _bytearray C.struct_miqt_string = C.QCborValueConstRef_ToCbor1(this.h, (C.int)(opt))
+	_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
+	C.free(unsafe.Pointer(_bytearray.data))
+	return _ret
+}
+
+func (this *QCborValueConstRef) ToCbor2(writer *QCborStreamWriter, opt QCborValue__EncodingOption) {
+	C.QCborValueConstRef_ToCbor2(this.h, writer.cPointer(), (C.int)(opt))
+}
+
+func (this *QCborValueConstRef) ToDiagnosticNotation1(opt QCborValue__DiagnosticNotationOption) string {
+	var _ms C.struct_miqt_string = C.QCborValueConstRef_ToDiagnosticNotation1(this.h, (C.int)(opt))
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+// Delete this object from C++ memory.
+func (this *QCborValueConstRef) Delete() {
+	C.QCborValueConstRef_Delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QCborValueConstRef) GoGC() {
+	runtime.SetFinalizer(this, func(this *QCborValueConstRef) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}
+
 type QCborValueRef struct {
 	h *C.QCborValueRef
+	*QCborValueConstRef
 }
 
 func (this *QCborValueRef) cPointer() *C.QCborValueRef {
@@ -750,7 +1141,7 @@ func newQCborValueRef(h *C.QCborValueRef) *QCborValueRef {
 	if h == nil {
 		return nil
 	}
-	return &QCborValueRef{h: h}
+	return &QCborValueRef{h: h, QCborValueConstRef: UnsafeNewQCborValueConstRef(unsafe.Pointer(h))}
 }
 
 func UnsafeNewQCborValueRef(h unsafe.Pointer) *QCborValueRef {
@@ -771,6 +1162,24 @@ func (this *QCborValueRef) OperatorAssignWithOther(other *QCborValueRef) {
 	C.QCborValueRef_OperatorAssignWithOther(this.h, other.cPointer())
 }
 
+func (this *QCborValueRef) OperatorSubscript(key int64) *QCborValueRef {
+	_ret := C.QCborValueRef_OperatorSubscript(this.h, (C.longlong)(key))
+	_goptr := newQCborValueRef(_ret)
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QCborValueRef) OperatorSubscript2(key string) *QCborValueRef {
+	key_ms := C.struct_miqt_string{}
+	key_ms.data = C.CString(key)
+	key_ms.len = C.size_t(len(key))
+	defer C.free(unsafe.Pointer(key_ms.data))
+	_ret := C.QCborValueRef_OperatorSubscript2(this.h, key_ms)
+	_goptr := newQCborValueRef(_ret)
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
 func (this *QCborValueRef) Type() QCborValue__Type {
 	return (QCborValue__Type)(C.QCborValueRef_Type(this.h))
 }
@@ -855,6 +1264,10 @@ func (this *QCborValueRef) IsSimpleTypeWithSt(st QCborSimpleType) bool {
 	return (bool)(C.QCborValueRef_IsSimpleTypeWithSt(this.h, (C.uint8_t)(st)))
 }
 
+func (this *QCborValueRef) ToSimpleType() QCborSimpleType {
+	return (QCborSimpleType)(C.QCborValueRef_ToSimpleType(this.h))
+}
+
 func (this *QCborValueRef) Tag() QCborTag {
 	return (QCborTag)(C.QCborValueRef_Tag(this.h))
 }
@@ -948,42 +1361,24 @@ func (this *QCborValueRef) ToMapWithQCborMap(m *QCborMap) *QCborMap {
 	return _goptr
 }
 
-func (this *QCborValueRef) OperatorSubscript(key string) *QCborValue {
+func (this *QCborValueRef) OperatorSubscript3(key string) *QCborValue {
 	key_ms := C.struct_miqt_string{}
 	key_ms.data = C.CString(key)
 	key_ms.len = C.size_t(len(key))
 	defer C.free(unsafe.Pointer(key_ms.data))
-	_ret := C.QCborValueRef_OperatorSubscript(this.h, key_ms)
+	_ret := C.QCborValueRef_OperatorSubscript3(this.h, key_ms)
 	_goptr := newQCborValue(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func (this *QCborValueRef) OperatorSubscript2(key int64) *QCborValue {
-	_ret := C.QCborValueRef_OperatorSubscript2(this.h, (C.longlong)(key))
+func (this *QCborValueRef) OperatorSubscript5(key int64) *QCborValue {
+	_ret := C.QCborValueRef_OperatorSubscript5(this.h, (C.longlong)(key))
 	_goptr := newQCborValue(_ret)
 	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
 	return _goptr
 }
 
-func (this *QCborValueRef) OperatorSubscript3(key int64) *QCborValueRef {
-	_ret := C.QCborValueRef_OperatorSubscript3(this.h, (C.longlong)(key))
-	_goptr := newQCborValueRef(_ret)
-	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
-	return _goptr
-}
-
-func (this *QCborValueRef) OperatorSubscript5(key string) *QCborValueRef {
-	key_ms := C.struct_miqt_string{}
-	key_ms.data = C.CString(key)
-	key_ms.len = C.size_t(len(key))
-	defer C.free(unsafe.Pointer(key_ms.data))
-	_ret := C.QCborValueRef_OperatorSubscript5(this.h, key_ms)
-	_goptr := newQCborValueRef(_ret)
-	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
-	return _goptr
-}
-
 func (this *QCborValueRef) Compare(other *QCborValue) int {
 	return (int)(C.QCborValueRef_Compare(this.h, other.cPointer()))
 }
@@ -1032,6 +1427,10 @@ func (this *QCborValueRef) ToDiagnosticNotation() string {
 	return _ret
 }
 
+func (this *QCborValueRef) ToSimpleType1(defaultValue QCborSimpleType) QCborSimpleType {
+	return (QCborSimpleType)(C.QCborValueRef_ToSimpleType1(this.h, (C.uint8_t)(defaultValue)))
+}
+
 func (this *QCborValueRef) Tag1(defaultValue QCborTag) QCborTag {
 	return (QCborTag)(C.QCborValueRef_Tag1(this.h, (C.uint64_t)(defaultValue)))
 }
diff --git a/qt6/cbor/gen_qcborvalue.h b/qt6/cbor/gen_qcborvalue.h
index d43d635b..fe811b46 100644
--- a/qt6/cbor/gen_qcborvalue.h
+++ b/qt6/cbor/gen_qcborvalue.h
@@ -22,6 +22,7 @@ class QCborParserError;
 class QCborStreamReader;
 class QCborStreamWriter;
 class QCborValue;
+class QCborValueConstRef;
 class QCborValueRef;
 class QDateTime;
 class QJsonValue;
@@ -37,6 +38,7 @@ typedef struct QCborParserError QCborParserError;
 typedef struct QCborStreamReader QCborStreamReader;
 typedef struct QCborStreamWriter QCborStreamWriter;
 typedef struct QCborValue QCborValue;
+typedef struct QCborValueConstRef QCborValueConstRef;
 typedef struct QCborValueRef QCborValueRef;
 typedef struct QDateTime QDateTime;
 typedef struct QJsonValue QJsonValue;
@@ -126,8 +128,8 @@ QCborValue* QCborValue_FromCbor(QCborStreamReader* reader);
 QCborValue* QCborValue_FromCborWithBa(struct miqt_string ba);
 QCborValue* QCborValue_FromCbor2(const char* data, ptrdiff_t lenVal);
 QCborValue* QCborValue_FromCbor3(const unsigned char* data, ptrdiff_t lenVal);
-struct miqt_string QCborValue_ToCbor(QCborValue* self);
-void QCborValue_ToCborWithWriter(QCborValue* self, QCborStreamWriter* writer);
+struct miqt_string QCborValue_ToCbor(const QCborValue* self);
+void QCborValue_ToCborWithWriter(const QCborValue* self, QCborStreamWriter* writer);
 struct miqt_string QCborValue_ToDiagnosticNotation(const QCborValue* self);
 uint8_t QCborValue_ToSimpleType1(const QCborValue* self, uint8_t defaultValue);
 long long QCborValue_ToInteger1(const QCborValue* self, long long defaultValue);
@@ -144,14 +146,82 @@ QUuid* QCborValue_ToUuid1(const QCborValue* self, QUuid* defaultValue);
 QCborValue* QCborValue_FromCbor22(struct miqt_string ba, 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);
-struct miqt_string QCborValue_ToCbor1(QCborValue* self, int opt);
-void QCborValue_ToCbor2(QCborValue* self, QCborStreamWriter* writer, int opt);
+struct miqt_string QCborValue_ToCbor1(const QCborValue* self, int opt);
+void QCborValue_ToCbor2(const QCborValue* self, QCborStreamWriter* writer, int opt);
 struct miqt_string QCborValue_ToDiagnosticNotation1(const QCborValue* self, int opts);
 void QCborValue_Delete(QCborValue* self);
 
+QCborValueConstRef* QCborValueConstRef_new(QCborValueConstRef* param1);
+int QCborValueConstRef_Type(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsInteger(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsByteArray(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsString(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsArray(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsMap(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsTag(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsFalse(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsTrue(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsBool(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsNull(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsUndefined(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsDouble(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsDateTime(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsUrl(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsRegularExpression(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsUuid(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsInvalid(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsContainer(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsSimpleType(const QCborValueConstRef* self);
+bool QCborValueConstRef_IsSimpleTypeWithSt(const QCborValueConstRef* self, uint8_t st);
+uint8_t QCborValueConstRef_ToSimpleType(const QCborValueConstRef* self);
+uint64_t QCborValueConstRef_Tag(const QCborValueConstRef* self);
+QCborValue* QCborValueConstRef_TaggedValue(const QCborValueConstRef* self);
+long long QCborValueConstRef_ToInteger(const QCborValueConstRef* self);
+bool QCborValueConstRef_ToBool(const QCborValueConstRef* self);
+double QCborValueConstRef_ToDouble(const QCborValueConstRef* self);
+struct miqt_string QCborValueConstRef_ToByteArray(const QCborValueConstRef* self);
+struct miqt_string QCborValueConstRef_ToString(const QCborValueConstRef* self);
+QDateTime* QCborValueConstRef_ToDateTime(const QCborValueConstRef* self);
+QUrl* QCborValueConstRef_ToUrl(const QCborValueConstRef* self);
+QRegularExpression* QCborValueConstRef_ToRegularExpression(const QCborValueConstRef* self);
+QUuid* QCborValueConstRef_ToUuid(const QCborValueConstRef* self);
+QCborArray* QCborValueConstRef_ToArray(const QCborValueConstRef* self);
+QCborArray* QCborValueConstRef_ToArrayWithQCborArray(const QCborValueConstRef* self, QCborArray* a);
+QCborMap* QCborValueConstRef_ToMap(const QCborValueConstRef* self);
+QCborMap* QCborValueConstRef_ToMapWithQCborMap(const QCborValueConstRef* self, QCborMap* m);
+QCborValue* QCborValueConstRef_OperatorSubscript(const QCborValueConstRef* self, struct miqt_string key);
+QCborValue* QCborValueConstRef_OperatorSubscript2(const QCborValueConstRef* self, long long key);
+int QCborValueConstRef_Compare(const QCborValueConstRef* self, QCborValue* other);
+bool QCborValueConstRef_OperatorEqual(const QCborValueConstRef* self, QCborValue* other);
+bool QCborValueConstRef_OperatorNotEqual(const QCborValueConstRef* self, QCborValue* other);
+bool QCborValueConstRef_OperatorLesser(const QCborValueConstRef* self, QCborValue* other);
+QVariant* QCborValueConstRef_ToVariant(const QCborValueConstRef* self);
+QJsonValue* QCborValueConstRef_ToJsonValue(const QCborValueConstRef* self);
+struct miqt_string QCborValueConstRef_ToCbor(const QCborValueConstRef* self);
+void QCborValueConstRef_ToCborWithWriter(const QCborValueConstRef* self, QCborStreamWriter* writer);
+struct miqt_string QCborValueConstRef_ToDiagnosticNotation(const QCborValueConstRef* self);
+uint8_t QCborValueConstRef_ToSimpleType1(const QCborValueConstRef* self, uint8_t defaultValue);
+uint64_t QCborValueConstRef_Tag1(const QCborValueConstRef* self, uint64_t defaultValue);
+QCborValue* QCborValueConstRef_TaggedValue1(const QCborValueConstRef* self, QCborValue* defaultValue);
+long long QCborValueConstRef_ToInteger1(const QCborValueConstRef* self, long long defaultValue);
+bool QCborValueConstRef_ToBool1(const QCborValueConstRef* self, bool defaultValue);
+double QCborValueConstRef_ToDouble1(const QCborValueConstRef* self, double defaultValue);
+struct miqt_string QCborValueConstRef_ToByteArray1(const QCborValueConstRef* self, struct miqt_string defaultValue);
+struct miqt_string QCborValueConstRef_ToString1(const QCborValueConstRef* self, struct miqt_string defaultValue);
+QDateTime* QCborValueConstRef_ToDateTime1(const QCborValueConstRef* self, QDateTime* defaultValue);
+QUrl* QCborValueConstRef_ToUrl1(const QCborValueConstRef* self, QUrl* defaultValue);
+QRegularExpression* QCborValueConstRef_ToRegularExpression1(const QCborValueConstRef* self, QRegularExpression* defaultValue);
+QUuid* QCborValueConstRef_ToUuid1(const QCborValueConstRef* self, QUuid* defaultValue);
+struct miqt_string QCborValueConstRef_ToCbor1(const QCborValueConstRef* self, int opt);
+void QCborValueConstRef_ToCbor2(const QCborValueConstRef* self, QCborStreamWriter* writer, int opt);
+struct miqt_string QCborValueConstRef_ToDiagnosticNotation1(const QCborValueConstRef* self, int opt);
+void QCborValueConstRef_Delete(QCborValueConstRef* self);
+
 QCborValueRef* QCborValueRef_new(QCborValueRef* param1);
 void QCborValueRef_OperatorAssign(QCborValueRef* self, QCborValue* other);
 void QCborValueRef_OperatorAssignWithOther(QCborValueRef* self, QCborValueRef* other);
+QCborValueRef* QCborValueRef_OperatorSubscript(QCborValueRef* self, long long key);
+QCborValueRef* QCborValueRef_OperatorSubscript2(QCborValueRef* self, struct miqt_string key);
 int QCborValueRef_Type(const QCborValueRef* self);
 bool QCborValueRef_IsInteger(const QCborValueRef* self);
 bool QCborValueRef_IsByteArray(const QCborValueRef* self);
@@ -173,6 +243,7 @@ bool QCborValueRef_IsInvalid(const QCborValueRef* self);
 bool QCborValueRef_IsContainer(const QCborValueRef* self);
 bool QCborValueRef_IsSimpleType(const QCborValueRef* self);
 bool QCborValueRef_IsSimpleTypeWithSt(const QCborValueRef* self, uint8_t st);
+uint8_t QCborValueRef_ToSimpleType(const QCborValueRef* self);
 uint64_t QCborValueRef_Tag(const QCborValueRef* self);
 QCborValue* QCborValueRef_TaggedValue(const QCborValueRef* self);
 long long QCborValueRef_ToInteger(const QCborValueRef* self);
@@ -188,10 +259,8 @@ QCborArray* QCborValueRef_ToArray(const QCborValueRef* self);
 QCborArray* QCborValueRef_ToArrayWithQCborArray(const QCborValueRef* self, QCborArray* a);
 QCborMap* QCborValueRef_ToMap(const QCborValueRef* self);
 QCborMap* QCborValueRef_ToMapWithQCborMap(const QCborValueRef* self, QCborMap* m);
-QCborValue* QCborValueRef_OperatorSubscript(const QCborValueRef* self, struct miqt_string key);
-QCborValue* QCborValueRef_OperatorSubscript2(const QCborValueRef* self, long long key);
-QCborValueRef* QCborValueRef_OperatorSubscript3(QCborValueRef* self, long long key);
-QCborValueRef* QCborValueRef_OperatorSubscript5(QCborValueRef* self, struct miqt_string key);
+QCborValue* QCborValueRef_OperatorSubscript3(const QCborValueRef* self, struct miqt_string key);
+QCborValue* QCborValueRef_OperatorSubscript5(const QCborValueRef* self, long long key);
 int QCborValueRef_Compare(const QCborValueRef* self, QCborValue* other);
 bool QCborValueRef_OperatorEqual(const QCborValueRef* self, QCborValue* other);
 bool QCborValueRef_OperatorNotEqual(const QCborValueRef* self, QCborValue* other);
@@ -201,6 +270,7 @@ QJsonValue* QCborValueRef_ToJsonValue(const QCborValueRef* self);
 struct miqt_string QCborValueRef_ToCbor(QCborValueRef* self);
 void QCborValueRef_ToCborWithWriter(QCborValueRef* self, QCborStreamWriter* writer);
 struct miqt_string QCborValueRef_ToDiagnosticNotation(QCborValueRef* self);
+uint8_t QCborValueRef_ToSimpleType1(const QCborValueRef* self, uint8_t defaultValue);
 uint64_t QCborValueRef_Tag1(const QCborValueRef* self, uint64_t defaultValue);
 QCborValue* QCborValueRef_TaggedValue1(const QCborValueRef* self, QCborValue* defaultValue);
 long long QCborValueRef_ToInteger1(const QCborValueRef* self, long long defaultValue);