diff --git a/crates/cxx-qt-lib-headers/include/qset.h b/crates/cxx-qt-lib-headers/include/qset.h
index 9ff8f6021..37846704e 100644
--- a/crates/cxx-qt-lib-headers/include/qset.h
+++ b/crates/cxx-qt-lib-headers/include/qset.h
@@ -26,6 +26,7 @@ struct rust::IsRelocatable<QSet<T>> : std::true_type
 
 namespace rust {
 namespace cxxqtlib1 {
+namespace qset {
 
 template<typename T>
 ::rust::isize
@@ -58,6 +59,7 @@ qsetLen(const QSet<T>& s) noexcept
   return static_cast<::rust::isize>(s.size());
 }
 
+}
 }
 }
 
diff --git a/crates/cxx-qt-lib/src/types/qset/generate.sh b/crates/cxx-qt-lib/src/types/qset/generate.sh
index 4d2da3786..a40dff444 100755
--- a/crates/cxx-qt-lib/src/types/qset/generate.sh
+++ b/crates/cxx-qt-lib/src/types/qset/generate.sh
@@ -37,12 +37,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_$1"]
+        #[rust_name = "qset_clone_$1"]
         fn construct(_: &QSet_$1) -> QSet_$1;
-        #[rust_name = "default_$1"]
+        #[rust_name = "qset_default_$1"]
         fn construct() -> QSet_$1;
-        #[rust_name = "drop_$1"]
+        #[rust_name = "qset_drop_$1"]
         fn drop(_: &mut QSet_$1);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_$1"]
         #[allow(clippy::needless_lifetimes)]
         unsafe fn qsetGetUnchecked<'a>(set: &'a QSet_$1, pos: isize) -> &'a $1;
@@ -54,15 +58,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_$1) -> ffi::QSet_$1 {
-    ffi::clone_$1(s)
+    ffi::qset_clone_$1(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_$1 {
-    ffi::default_$1()
+    ffi::qset_default_$1()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_$1) {
-    ffi::drop_$1(s);
+    ffi::qset_drop_$1(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_$1, pos: isize) -> &$1 {
@@ -110,12 +114,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_$1"]
+        #[rust_name = "qset_clone_$1"]
         fn construct(_: &QSet_$1) -> QSet_$1;
-        #[rust_name = "default_$1"]
+        #[rust_name = "qset_default_$1"]
         fn construct() -> QSet_$1;
-        #[rust_name = "drop_$1"]
+        #[rust_name = "qset_drop_$1"]
         fn drop(_: &mut QSet_$1);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_$1"]
         unsafe fn qsetGetUnchecked(set: &QSet_$1, pos: isize) -> &$1;
         #[rust_name = "insert_$1"]
@@ -126,15 +134,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_$1) -> ffi::QSet_$1 {
-    ffi::clone_$1(s)
+    ffi::qset_clone_$1(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_$1 {
-    ffi::default_$1()
+    ffi::qset_default_$1()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_$1) {
-    ffi::drop_$1(s);
+    ffi::qset_drop_$1(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_$1, pos: isize) -> &ffi::$1 {
diff --git a/crates/cxx-qt-lib/src/types/qset/qset_bool.rs b/crates/cxx-qt-lib/src/types/qset/qset_bool.rs
index c977ca697..94483cd84 100644
--- a/crates/cxx-qt-lib/src/types/qset/qset_bool.rs
+++ b/crates/cxx-qt-lib/src/types/qset/qset_bool.rs
@@ -23,12 +23,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_bool"]
+        #[rust_name = "qset_clone_bool"]
         fn construct(_: &QSet_bool) -> QSet_bool;
-        #[rust_name = "default_bool"]
+        #[rust_name = "qset_default_bool"]
         fn construct() -> QSet_bool;
-        #[rust_name = "drop_bool"]
+        #[rust_name = "qset_drop_bool"]
         fn drop(_: &mut QSet_bool);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_bool"]
         #[allow(clippy::needless_lifetimes)]
         unsafe fn qsetGetUnchecked<'a>(set: &'a QSet_bool, pos: isize) -> &'a bool;
@@ -40,15 +44,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_bool) -> ffi::QSet_bool {
-    ffi::clone_bool(s)
+    ffi::qset_clone_bool(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_bool {
-    ffi::default_bool()
+    ffi::qset_default_bool()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_bool) {
-    ffi::drop_bool(s);
+    ffi::qset_drop_bool(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_bool, pos: isize) -> &bool {
diff --git a/crates/cxx-qt-lib/src/types/qset/qset_f32.rs b/crates/cxx-qt-lib/src/types/qset/qset_f32.rs
index 9bab5d72a..c6db5744b 100644
--- a/crates/cxx-qt-lib/src/types/qset/qset_f32.rs
+++ b/crates/cxx-qt-lib/src/types/qset/qset_f32.rs
@@ -23,12 +23,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_f32"]
+        #[rust_name = "qset_clone_f32"]
         fn construct(_: &QSet_f32) -> QSet_f32;
-        #[rust_name = "default_f32"]
+        #[rust_name = "qset_default_f32"]
         fn construct() -> QSet_f32;
-        #[rust_name = "drop_f32"]
+        #[rust_name = "qset_drop_f32"]
         fn drop(_: &mut QSet_f32);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_f32"]
         #[allow(clippy::needless_lifetimes)]
         unsafe fn qsetGetUnchecked<'a>(set: &'a QSet_f32, pos: isize) -> &'a f32;
@@ -40,15 +44,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_f32) -> ffi::QSet_f32 {
-    ffi::clone_f32(s)
+    ffi::qset_clone_f32(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_f32 {
-    ffi::default_f32()
+    ffi::qset_default_f32()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_f32) {
-    ffi::drop_f32(s);
+    ffi::qset_drop_f32(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_f32, pos: isize) -> &f32 {
diff --git a/crates/cxx-qt-lib/src/types/qset/qset_f64.rs b/crates/cxx-qt-lib/src/types/qset/qset_f64.rs
index 7bbd8de4e..a4f689810 100644
--- a/crates/cxx-qt-lib/src/types/qset/qset_f64.rs
+++ b/crates/cxx-qt-lib/src/types/qset/qset_f64.rs
@@ -23,12 +23,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_f64"]
+        #[rust_name = "qset_clone_f64"]
         fn construct(_: &QSet_f64) -> QSet_f64;
-        #[rust_name = "default_f64"]
+        #[rust_name = "qset_default_f64"]
         fn construct() -> QSet_f64;
-        #[rust_name = "drop_f64"]
+        #[rust_name = "qset_drop_f64"]
         fn drop(_: &mut QSet_f64);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_f64"]
         #[allow(clippy::needless_lifetimes)]
         unsafe fn qsetGetUnchecked<'a>(set: &'a QSet_f64, pos: isize) -> &'a f64;
@@ -40,15 +44,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_f64) -> ffi::QSet_f64 {
-    ffi::clone_f64(s)
+    ffi::qset_clone_f64(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_f64 {
-    ffi::default_f64()
+    ffi::qset_default_f64()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_f64) {
-    ffi::drop_f64(s);
+    ffi::qset_drop_f64(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_f64, pos: isize) -> &f64 {
diff --git a/crates/cxx-qt-lib/src/types/qset/qset_i16.rs b/crates/cxx-qt-lib/src/types/qset/qset_i16.rs
index f7f24b520..4adba837b 100644
--- a/crates/cxx-qt-lib/src/types/qset/qset_i16.rs
+++ b/crates/cxx-qt-lib/src/types/qset/qset_i16.rs
@@ -23,12 +23,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_i16"]
+        #[rust_name = "qset_clone_i16"]
         fn construct(_: &QSet_i16) -> QSet_i16;
-        #[rust_name = "default_i16"]
+        #[rust_name = "qset_default_i16"]
         fn construct() -> QSet_i16;
-        #[rust_name = "drop_i16"]
+        #[rust_name = "qset_drop_i16"]
         fn drop(_: &mut QSet_i16);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_i16"]
         #[allow(clippy::needless_lifetimes)]
         unsafe fn qsetGetUnchecked<'a>(set: &'a QSet_i16, pos: isize) -> &'a i16;
@@ -40,15 +44,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_i16) -> ffi::QSet_i16 {
-    ffi::clone_i16(s)
+    ffi::qset_clone_i16(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_i16 {
-    ffi::default_i16()
+    ffi::qset_default_i16()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_i16) {
-    ffi::drop_i16(s);
+    ffi::qset_drop_i16(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_i16, pos: isize) -> &i16 {
diff --git a/crates/cxx-qt-lib/src/types/qset/qset_i32.rs b/crates/cxx-qt-lib/src/types/qset/qset_i32.rs
index ee0a2cb76..6178be20e 100644
--- a/crates/cxx-qt-lib/src/types/qset/qset_i32.rs
+++ b/crates/cxx-qt-lib/src/types/qset/qset_i32.rs
@@ -23,12 +23,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_i32"]
+        #[rust_name = "qset_clone_i32"]
         fn construct(_: &QSet_i32) -> QSet_i32;
-        #[rust_name = "default_i32"]
+        #[rust_name = "qset_default_i32"]
         fn construct() -> QSet_i32;
-        #[rust_name = "drop_i32"]
+        #[rust_name = "qset_drop_i32"]
         fn drop(_: &mut QSet_i32);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_i32"]
         #[allow(clippy::needless_lifetimes)]
         unsafe fn qsetGetUnchecked<'a>(set: &'a QSet_i32, pos: isize) -> &'a i32;
@@ -40,15 +44,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_i32) -> ffi::QSet_i32 {
-    ffi::clone_i32(s)
+    ffi::qset_clone_i32(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_i32 {
-    ffi::default_i32()
+    ffi::qset_default_i32()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_i32) {
-    ffi::drop_i32(s);
+    ffi::qset_drop_i32(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_i32, pos: isize) -> &i32 {
diff --git a/crates/cxx-qt-lib/src/types/qset/qset_i64.rs b/crates/cxx-qt-lib/src/types/qset/qset_i64.rs
index e251971cf..16c5a464d 100644
--- a/crates/cxx-qt-lib/src/types/qset/qset_i64.rs
+++ b/crates/cxx-qt-lib/src/types/qset/qset_i64.rs
@@ -23,12 +23,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_i64"]
+        #[rust_name = "qset_clone_i64"]
         fn construct(_: &QSet_i64) -> QSet_i64;
-        #[rust_name = "default_i64"]
+        #[rust_name = "qset_default_i64"]
         fn construct() -> QSet_i64;
-        #[rust_name = "drop_i64"]
+        #[rust_name = "qset_drop_i64"]
         fn drop(_: &mut QSet_i64);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_i64"]
         #[allow(clippy::needless_lifetimes)]
         unsafe fn qsetGetUnchecked<'a>(set: &'a QSet_i64, pos: isize) -> &'a i64;
@@ -40,15 +44,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_i64) -> ffi::QSet_i64 {
-    ffi::clone_i64(s)
+    ffi::qset_clone_i64(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_i64 {
-    ffi::default_i64()
+    ffi::qset_default_i64()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_i64) {
-    ffi::drop_i64(s);
+    ffi::qset_drop_i64(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_i64, pos: isize) -> &i64 {
diff --git a/crates/cxx-qt-lib/src/types/qset/qset_i8.rs b/crates/cxx-qt-lib/src/types/qset/qset_i8.rs
index 41b0deb3f..c84d62f99 100644
--- a/crates/cxx-qt-lib/src/types/qset/qset_i8.rs
+++ b/crates/cxx-qt-lib/src/types/qset/qset_i8.rs
@@ -23,12 +23,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_i8"]
+        #[rust_name = "qset_clone_i8"]
         fn construct(_: &QSet_i8) -> QSet_i8;
-        #[rust_name = "default_i8"]
+        #[rust_name = "qset_default_i8"]
         fn construct() -> QSet_i8;
-        #[rust_name = "drop_i8"]
+        #[rust_name = "qset_drop_i8"]
         fn drop(_: &mut QSet_i8);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_i8"]
         #[allow(clippy::needless_lifetimes)]
         unsafe fn qsetGetUnchecked<'a>(set: &'a QSet_i8, pos: isize) -> &'a i8;
@@ -40,15 +44,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_i8) -> ffi::QSet_i8 {
-    ffi::clone_i8(s)
+    ffi::qset_clone_i8(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_i8 {
-    ffi::default_i8()
+    ffi::qset_default_i8()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_i8) {
-    ffi::drop_i8(s);
+    ffi::qset_drop_i8(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_i8, pos: isize) -> &i8 {
diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qdate.rs b/crates/cxx-qt-lib/src/types/qset/qset_qdate.rs
index a9ae676c8..c2cdfa137 100644
--- a/crates/cxx-qt-lib/src/types/qset/qset_qdate.rs
+++ b/crates/cxx-qt-lib/src/types/qset/qset_qdate.rs
@@ -26,12 +26,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_QDate"]
+        #[rust_name = "qset_clone_QDate"]
         fn construct(_: &QSet_QDate) -> QSet_QDate;
-        #[rust_name = "default_QDate"]
+        #[rust_name = "qset_default_QDate"]
         fn construct() -> QSet_QDate;
-        #[rust_name = "drop_QDate"]
+        #[rust_name = "qset_drop_QDate"]
         fn drop(_: &mut QSet_QDate);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_QDate"]
         unsafe fn qsetGetUnchecked(set: &QSet_QDate, pos: isize) -> &QDate;
         #[rust_name = "insert_QDate"]
@@ -42,15 +46,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_QDate) -> ffi::QSet_QDate {
-    ffi::clone_QDate(s)
+    ffi::qset_clone_QDate(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_QDate {
-    ffi::default_QDate()
+    ffi::qset_default_QDate()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_QDate) {
-    ffi::drop_QDate(s);
+    ffi::qset_drop_QDate(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_QDate, pos: isize) -> &ffi::QDate {
diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qdatetime.rs b/crates/cxx-qt-lib/src/types/qset/qset_qdatetime.rs
index b4bc883c4..4141e141f 100644
--- a/crates/cxx-qt-lib/src/types/qset/qset_qdatetime.rs
+++ b/crates/cxx-qt-lib/src/types/qset/qset_qdatetime.rs
@@ -26,12 +26,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_QDateTime"]
+        #[rust_name = "qset_clone_QDateTime"]
         fn construct(_: &QSet_QDateTime) -> QSet_QDateTime;
-        #[rust_name = "default_QDateTime"]
+        #[rust_name = "qset_default_QDateTime"]
         fn construct() -> QSet_QDateTime;
-        #[rust_name = "drop_QDateTime"]
+        #[rust_name = "qset_drop_QDateTime"]
         fn drop(_: &mut QSet_QDateTime);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_QDateTime"]
         unsafe fn qsetGetUnchecked(set: &QSet_QDateTime, pos: isize) -> &QDateTime;
         #[rust_name = "insert_QDateTime"]
@@ -42,15 +46,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_QDateTime) -> ffi::QSet_QDateTime {
-    ffi::clone_QDateTime(s)
+    ffi::qset_clone_QDateTime(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_QDateTime {
-    ffi::default_QDateTime()
+    ffi::qset_default_QDateTime()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_QDateTime) {
-    ffi::drop_QDateTime(s);
+    ffi::qset_drop_QDateTime(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_QDateTime, pos: isize) -> &ffi::QDateTime {
diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qstring.rs b/crates/cxx-qt-lib/src/types/qset/qset_qstring.rs
index c581b6c00..89c77e611 100644
--- a/crates/cxx-qt-lib/src/types/qset/qset_qstring.rs
+++ b/crates/cxx-qt-lib/src/types/qset/qset_qstring.rs
@@ -26,12 +26,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_QString"]
+        #[rust_name = "qset_clone_QString"]
         fn construct(_: &QSet_QString) -> QSet_QString;
-        #[rust_name = "default_QString"]
+        #[rust_name = "qset_default_QString"]
         fn construct() -> QSet_QString;
-        #[rust_name = "drop_QString"]
+        #[rust_name = "qset_drop_QString"]
         fn drop(_: &mut QSet_QString);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_QString"]
         unsafe fn qsetGetUnchecked(set: &QSet_QString, pos: isize) -> &QString;
         #[rust_name = "insert_QString"]
@@ -42,15 +46,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_QString) -> ffi::QSet_QString {
-    ffi::clone_QString(s)
+    ffi::qset_clone_QString(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_QString {
-    ffi::default_QString()
+    ffi::qset_default_QString()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_QString) {
-    ffi::drop_QString(s);
+    ffi::qset_drop_QString(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_QString, pos: isize) -> &ffi::QString {
diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qtime.rs b/crates/cxx-qt-lib/src/types/qset/qset_qtime.rs
index b3ea116fc..0e627c990 100644
--- a/crates/cxx-qt-lib/src/types/qset/qset_qtime.rs
+++ b/crates/cxx-qt-lib/src/types/qset/qset_qtime.rs
@@ -26,12 +26,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_QTime"]
+        #[rust_name = "qset_clone_QTime"]
         fn construct(_: &QSet_QTime) -> QSet_QTime;
-        #[rust_name = "default_QTime"]
+        #[rust_name = "qset_default_QTime"]
         fn construct() -> QSet_QTime;
-        #[rust_name = "drop_QTime"]
+        #[rust_name = "qset_drop_QTime"]
         fn drop(_: &mut QSet_QTime);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_QTime"]
         unsafe fn qsetGetUnchecked(set: &QSet_QTime, pos: isize) -> &QTime;
         #[rust_name = "insert_QTime"]
@@ -42,15 +46,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_QTime) -> ffi::QSet_QTime {
-    ffi::clone_QTime(s)
+    ffi::qset_clone_QTime(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_QTime {
-    ffi::default_QTime()
+    ffi::qset_default_QTime()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_QTime) {
-    ffi::drop_QTime(s);
+    ffi::qset_drop_QTime(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_QTime, pos: isize) -> &ffi::QTime {
diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qurl.rs b/crates/cxx-qt-lib/src/types/qset/qset_qurl.rs
index 679f0a8a5..97e152ca5 100644
--- a/crates/cxx-qt-lib/src/types/qset/qset_qurl.rs
+++ b/crates/cxx-qt-lib/src/types/qset/qset_qurl.rs
@@ -26,12 +26,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_QUrl"]
+        #[rust_name = "qset_clone_QUrl"]
         fn construct(_: &QSet_QUrl) -> QSet_QUrl;
-        #[rust_name = "default_QUrl"]
+        #[rust_name = "qset_default_QUrl"]
         fn construct() -> QSet_QUrl;
-        #[rust_name = "drop_QUrl"]
+        #[rust_name = "qset_drop_QUrl"]
         fn drop(_: &mut QSet_QUrl);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_QUrl"]
         unsafe fn qsetGetUnchecked(set: &QSet_QUrl, pos: isize) -> &QUrl;
         #[rust_name = "insert_QUrl"]
@@ -42,15 +46,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_QUrl) -> ffi::QSet_QUrl {
-    ffi::clone_QUrl(s)
+    ffi::qset_clone_QUrl(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_QUrl {
-    ffi::default_QUrl()
+    ffi::qset_default_QUrl()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_QUrl) {
-    ffi::drop_QUrl(s);
+    ffi::qset_drop_QUrl(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_QUrl, pos: isize) -> &ffi::QUrl {
diff --git a/crates/cxx-qt-lib/src/types/qset/qset_u16.rs b/crates/cxx-qt-lib/src/types/qset/qset_u16.rs
index 75f1fde9e..200eaa349 100644
--- a/crates/cxx-qt-lib/src/types/qset/qset_u16.rs
+++ b/crates/cxx-qt-lib/src/types/qset/qset_u16.rs
@@ -23,12 +23,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_u16"]
+        #[rust_name = "qset_clone_u16"]
         fn construct(_: &QSet_u16) -> QSet_u16;
-        #[rust_name = "default_u16"]
+        #[rust_name = "qset_default_u16"]
         fn construct() -> QSet_u16;
-        #[rust_name = "drop_u16"]
+        #[rust_name = "qset_drop_u16"]
         fn drop(_: &mut QSet_u16);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_u16"]
         #[allow(clippy::needless_lifetimes)]
         unsafe fn qsetGetUnchecked<'a>(set: &'a QSet_u16, pos: isize) -> &'a u16;
@@ -40,15 +44,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_u16) -> ffi::QSet_u16 {
-    ffi::clone_u16(s)
+    ffi::qset_clone_u16(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_u16 {
-    ffi::default_u16()
+    ffi::qset_default_u16()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_u16) {
-    ffi::drop_u16(s);
+    ffi::qset_drop_u16(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_u16, pos: isize) -> &u16 {
diff --git a/crates/cxx-qt-lib/src/types/qset/qset_u32.rs b/crates/cxx-qt-lib/src/types/qset/qset_u32.rs
index e85141797..567e938ed 100644
--- a/crates/cxx-qt-lib/src/types/qset/qset_u32.rs
+++ b/crates/cxx-qt-lib/src/types/qset/qset_u32.rs
@@ -23,12 +23,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_u32"]
+        #[rust_name = "qset_clone_u32"]
         fn construct(_: &QSet_u32) -> QSet_u32;
-        #[rust_name = "default_u32"]
+        #[rust_name = "qset_default_u32"]
         fn construct() -> QSet_u32;
-        #[rust_name = "drop_u32"]
+        #[rust_name = "qset_drop_u32"]
         fn drop(_: &mut QSet_u32);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_u32"]
         #[allow(clippy::needless_lifetimes)]
         unsafe fn qsetGetUnchecked<'a>(set: &'a QSet_u32, pos: isize) -> &'a u32;
@@ -40,15 +44,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_u32) -> ffi::QSet_u32 {
-    ffi::clone_u32(s)
+    ffi::qset_clone_u32(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_u32 {
-    ffi::default_u32()
+    ffi::qset_default_u32()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_u32) {
-    ffi::drop_u32(s);
+    ffi::qset_drop_u32(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_u32, pos: isize) -> &u32 {
diff --git a/crates/cxx-qt-lib/src/types/qset/qset_u64.rs b/crates/cxx-qt-lib/src/types/qset/qset_u64.rs
index 1d019e67e..6326369a6 100644
--- a/crates/cxx-qt-lib/src/types/qset/qset_u64.rs
+++ b/crates/cxx-qt-lib/src/types/qset/qset_u64.rs
@@ -23,12 +23,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_u64"]
+        #[rust_name = "qset_clone_u64"]
         fn construct(_: &QSet_u64) -> QSet_u64;
-        #[rust_name = "default_u64"]
+        #[rust_name = "qset_default_u64"]
         fn construct() -> QSet_u64;
-        #[rust_name = "drop_u64"]
+        #[rust_name = "qset_drop_u64"]
         fn drop(_: &mut QSet_u64);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_u64"]
         #[allow(clippy::needless_lifetimes)]
         unsafe fn qsetGetUnchecked<'a>(set: &'a QSet_u64, pos: isize) -> &'a u64;
@@ -40,15 +44,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_u64) -> ffi::QSet_u64 {
-    ffi::clone_u64(s)
+    ffi::qset_clone_u64(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_u64 {
-    ffi::default_u64()
+    ffi::qset_default_u64()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_u64) {
-    ffi::drop_u64(s);
+    ffi::qset_drop_u64(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_u64, pos: isize) -> &u64 {
diff --git a/crates/cxx-qt-lib/src/types/qset/qset_u8.rs b/crates/cxx-qt-lib/src/types/qset/qset_u8.rs
index ed64591d2..101b92ea8 100644
--- a/crates/cxx-qt-lib/src/types/qset/qset_u8.rs
+++ b/crates/cxx-qt-lib/src/types/qset/qset_u8.rs
@@ -23,12 +23,16 @@ pub mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
-        #[rust_name = "clone_u8"]
+        #[rust_name = "qset_clone_u8"]
         fn construct(_: &QSet_u8) -> QSet_u8;
-        #[rust_name = "default_u8"]
+        #[rust_name = "qset_default_u8"]
         fn construct() -> QSet_u8;
-        #[rust_name = "drop_u8"]
+        #[rust_name = "qset_drop_u8"]
         fn drop(_: &mut QSet_u8);
+    }
+
+    #[namespace = "rust::cxxqtlib1::qset"]
+    unsafe extern "C++" {
         #[rust_name = "get_unchecked_u8"]
         #[allow(clippy::needless_lifetimes)]
         unsafe fn qsetGetUnchecked<'a>(set: &'a QSet_u8, pos: isize) -> &'a u8;
@@ -40,15 +44,15 @@ pub mod ffi {
 }
 
 pub(crate) fn clone(s: &ffi::QSet_u8) -> ffi::QSet_u8 {
-    ffi::clone_u8(s)
+    ffi::qset_clone_u8(s)
 }
 
 pub(crate) fn default() -> ffi::QSet_u8 {
-    ffi::default_u8()
+    ffi::qset_default_u8()
 }
 
 pub(crate) fn drop(s: &mut ffi::QSet_u8) {
-    ffi::drop_u8(s);
+    ffi::qset_drop_u8(s);
 }
 
 pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_u8, pos: isize) -> &u8 {