diff --git a/gdk-pixbuf/src/subclass/pixbuf_animation.rs b/gdk-pixbuf/src/subclass/pixbuf_animation.rs
index 4a014d8be908..ee5ff297496d 100644
--- a/gdk-pixbuf/src/subclass/pixbuf_animation.rs
+++ b/gdk-pixbuf/src/subclass/pixbuf_animation.rs
@@ -13,7 +13,10 @@ use glib::{prelude::*, subclass::prelude::*, translate::*};
 
 use crate::{ffi, Pixbuf, PixbufAnimation, PixbufAnimationIter};
 
-pub trait PixbufAnimationImpl: ObjectImpl {
+pub trait PixbufAnimationImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<PixbufAnimation>,
+{
     fn is_static_image(&self) -> bool {
         self.parent_is_static_image()
     }
@@ -31,12 +34,10 @@ pub trait PixbufAnimationImpl: ObjectImpl {
     }
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::PixbufAnimationImplExt> Sealed for T {}
-}
-
-pub trait PixbufAnimationImplExt: sealed::Sealed + ObjectSubclass {
+pub trait PixbufAnimationImplExt: ObjectSubclass + PixbufAnimationImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<PixbufAnimation>,
+{
     fn parent_is_static_image(&self) -> bool {
         unsafe {
             let data = Self::type_data();
@@ -116,9 +117,15 @@ pub trait PixbufAnimationImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: PixbufAnimationImpl> PixbufAnimationImplExt for T {}
+impl<T: PixbufAnimationImpl> PixbufAnimationImplExt for T where
+    <Self as ObjectSubclass>::Type: IsA<PixbufAnimation>
+{
+}
 
-unsafe impl<T: PixbufAnimationImpl> IsSubclassable<T> for PixbufAnimation {
+unsafe impl<T: PixbufAnimationImpl> IsSubclassable<T> for PixbufAnimation
+where
+    <T as ObjectSubclass>::Type: IsA<PixbufAnimation>,
+{
     fn class_init(class: &mut ::glib::Class<Self>) {
         Self::parent_class_init::<T>(class);
 
@@ -132,7 +139,10 @@ unsafe impl<T: PixbufAnimationImpl> IsSubclassable<T> for PixbufAnimation {
 
 unsafe extern "C" fn animation_is_static_image<T: PixbufAnimationImpl>(
     ptr: *mut ffi::GdkPixbufAnimation,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<PixbufAnimation>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -143,7 +153,9 @@ unsafe extern "C" fn animation_get_size<T: PixbufAnimationImpl>(
     ptr: *mut ffi::GdkPixbufAnimation,
     width_ptr: *mut libc::c_int,
     height_ptr: *mut libc::c_int,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<PixbufAnimation>,
+{
     if width_ptr.is_null() && height_ptr.is_null() {
         return;
     }
@@ -162,7 +174,10 @@ unsafe extern "C" fn animation_get_size<T: PixbufAnimationImpl>(
 
 unsafe extern "C" fn animation_get_static_image<T: PixbufAnimationImpl>(
     ptr: *mut ffi::GdkPixbufAnimation,
-) -> *mut ffi::GdkPixbuf {
+) -> *mut ffi::GdkPixbuf
+where
+    <T as ObjectSubclass>::Type: IsA<PixbufAnimation>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -192,7 +207,10 @@ unsafe extern "C" fn animation_get_static_image<T: PixbufAnimationImpl>(
 unsafe extern "C" fn animation_get_iter<T: PixbufAnimationImpl>(
     ptr: *mut ffi::GdkPixbufAnimation,
     start_time_ptr: *const glib::ffi::GTimeVal,
-) -> *mut ffi::GdkPixbufAnimationIter {
+) -> *mut ffi::GdkPixbufAnimationIter
+where
+    <T as ObjectSubclass>::Type: IsA<PixbufAnimation>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
diff --git a/gdk-pixbuf/src/subclass/pixbuf_animation_iter.rs b/gdk-pixbuf/src/subclass/pixbuf_animation_iter.rs
index 99d05ccae3ae..03e16a1db22c 100644
--- a/gdk-pixbuf/src/subclass/pixbuf_animation_iter.rs
+++ b/gdk-pixbuf/src/subclass/pixbuf_animation_iter.rs
@@ -12,7 +12,10 @@ use glib::{prelude::*, subclass::prelude::*, translate::*};
 
 use crate::{ffi, Pixbuf, PixbufAnimationIter};
 
-pub trait PixbufAnimationIterImpl: ObjectImpl {
+pub trait PixbufAnimationIterImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<PixbufAnimationIter>,
+{
     // rustdoc-stripper-ignore-next
     /// Time in milliseconds, returning `None` implies showing the same pixbuf forever.
     fn delay_time(&self) -> Option<Duration> {
@@ -32,12 +35,10 @@ pub trait PixbufAnimationIterImpl: ObjectImpl {
     }
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::PixbufAnimationIterImplExt> Sealed for T {}
-}
-
-pub trait PixbufAnimationIterImplExt: sealed::Sealed + ObjectSubclass {
+pub trait PixbufAnimationIterImplExt: ObjectSubclass + PixbufAnimationIterImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<PixbufAnimationIter>,
+{
     fn parent_delay_time(&self) -> Option<Duration> {
         unsafe {
             let data = Self::type_data();
@@ -121,9 +122,15 @@ pub trait PixbufAnimationIterImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: PixbufAnimationIterImpl> PixbufAnimationIterImplExt for T {}
+impl<T: PixbufAnimationIterImpl> PixbufAnimationIterImplExt for T where
+    <T as ObjectSubclass>::Type: IsA<PixbufAnimationIter>
+{
+}
 
-unsafe impl<T: PixbufAnimationIterImpl> IsSubclassable<T> for PixbufAnimationIter {
+unsafe impl<T: PixbufAnimationIterImpl> IsSubclassable<T> for PixbufAnimationIter
+where
+    <T as ObjectSubclass>::Type: IsA<PixbufAnimationIter>,
+{
     fn class_init(class: &mut ::glib::Class<Self>) {
         Self::parent_class_init::<T>(class);
 
@@ -137,7 +144,10 @@ unsafe impl<T: PixbufAnimationIterImpl> IsSubclassable<T> for PixbufAnimationIte
 
 unsafe extern "C" fn animation_iter_get_delay_time<T: PixbufAnimationIterImpl>(
     ptr: *mut ffi::GdkPixbufAnimationIter,
-) -> i32 {
+) -> i32
+where
+    <T as ObjectSubclass>::Type: IsA<PixbufAnimationIter>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -146,7 +156,10 @@ unsafe extern "C" fn animation_iter_get_delay_time<T: PixbufAnimationIterImpl>(
 
 unsafe extern "C" fn animation_iter_get_pixbuf<T: PixbufAnimationIterImpl>(
     ptr: *mut ffi::GdkPixbufAnimationIter,
-) -> *mut ffi::GdkPixbuf {
+) -> *mut ffi::GdkPixbuf
+where
+    <T as ObjectSubclass>::Type: IsA<PixbufAnimationIter>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -162,7 +175,10 @@ unsafe extern "C" fn animation_iter_get_pixbuf<T: PixbufAnimationIterImpl>(
 
 unsafe extern "C" fn animation_iter_on_currently_loading_frame<T: PixbufAnimationIterImpl>(
     ptr: *mut ffi::GdkPixbufAnimationIter,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<PixbufAnimationIter>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -172,7 +188,10 @@ unsafe extern "C" fn animation_iter_on_currently_loading_frame<T: PixbufAnimatio
 unsafe extern "C" fn animation_iter_advance<T: PixbufAnimationIterImpl>(
     ptr: *mut ffi::GdkPixbufAnimationIter,
     current_time_ptr: *const glib::ffi::GTimeVal,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<PixbufAnimationIter>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
diff --git a/gdk-pixbuf/src/subclass/pixbuf_loader.rs b/gdk-pixbuf/src/subclass/pixbuf_loader.rs
index c2d53a7132f5..e99388644043 100644
--- a/gdk-pixbuf/src/subclass/pixbuf_loader.rs
+++ b/gdk-pixbuf/src/subclass/pixbuf_loader.rs
@@ -7,7 +7,10 @@ use glib::{prelude::*, subclass::prelude::*, translate::*};
 
 use crate::{ffi, PixbufLoader};
 
-pub trait PixbufLoaderImpl: ObjectImpl {
+pub trait PixbufLoaderImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<PixbufLoader>,
+{
     fn size_prepared(&self, width: i32, height: i32) {
         self.parent_size_prepared(width, height)
     }
@@ -25,12 +28,10 @@ pub trait PixbufLoaderImpl: ObjectImpl {
     }
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::PixbufLoaderImplExt> Sealed for T {}
-}
-
-pub trait PixbufLoaderImplExt: sealed::Sealed + ObjectSubclass {
+pub trait PixbufLoaderImplExt: ObjectSubclass + PixbufLoaderImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<PixbufLoader>,
+{
     fn parent_size_prepared(&self, width: i32, height: i32) {
         unsafe {
             let data = Self::type_data();
@@ -96,9 +97,15 @@ pub trait PixbufLoaderImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: PixbufLoaderImpl> PixbufLoaderImplExt for T {}
+impl<T: PixbufLoaderImpl> PixbufLoaderImplExt for T where
+    <T as ObjectSubclass>::Type: IsA<PixbufLoader>
+{
+}
 
-unsafe impl<T: PixbufLoaderImpl> IsSubclassable<T> for PixbufLoader {
+unsafe impl<T: PixbufLoaderImpl> IsSubclassable<T> for PixbufLoader
+where
+    <T as ObjectSubclass>::Type: IsA<PixbufLoader>,
+{
     fn class_init(class: &mut ::glib::Class<Self>) {
         Self::parent_class_init::<T>(class);
 
@@ -114,14 +121,19 @@ unsafe extern "C" fn loader_size_prepared<T: PixbufLoaderImpl>(
     ptr: *mut ffi::GdkPixbufLoader,
     width: i32,
     height: i32,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<PixbufLoader>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
     imp.size_prepared(width, height)
 }
 
-unsafe extern "C" fn loader_area_prepared<T: PixbufLoaderImpl>(ptr: *mut ffi::GdkPixbufLoader) {
+unsafe extern "C" fn loader_area_prepared<T: PixbufLoaderImpl>(ptr: *mut ffi::GdkPixbufLoader)
+where
+    <T as ObjectSubclass>::Type: IsA<PixbufLoader>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -134,14 +146,19 @@ unsafe extern "C" fn loader_area_updated<T: PixbufLoaderImpl>(
     y: i32,
     width: i32,
     height: i32,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<PixbufLoader>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
     imp.area_updated(x, y, width, height)
 }
 
-unsafe extern "C" fn loader_closed<T: PixbufLoaderImpl>(ptr: *mut ffi::GdkPixbufLoader) {
+unsafe extern "C" fn loader_closed<T: PixbufLoaderImpl>(ptr: *mut ffi::GdkPixbufLoader)
+where
+    <T as ObjectSubclass>::Type: IsA<PixbufLoader>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
diff --git a/gio/src/subclass/action_group.rs b/gio/src/subclass/action_group.rs
index 948fb2d318c8..ca895077889a 100644
--- a/gio/src/subclass/action_group.rs
+++ b/gio/src/subclass/action_group.rs
@@ -6,7 +6,10 @@ use glib::{prelude::*, subclass::prelude::*, translate::*, GString, Quark, Varia
 
 use crate::{ffi, ActionGroup};
 
-pub trait ActionGroupImpl: ObjectImpl {
+pub trait ActionGroupImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     fn action_added(&self, action_name: &str) {
         self.parent_action_added(action_name);
     }
@@ -73,12 +76,10 @@ pub trait ActionGroupImpl: ObjectImpl {
     )>;
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::ActionGroupImplExt> Sealed for T {}
-}
-
-pub trait ActionGroupImplExt: sealed::Sealed + ObjectSubclass {
+pub trait ActionGroupImplExt: ObjectSubclass + ActionGroupImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     fn parent_action_added(&self, action_name: &str) {
         unsafe {
             let type_data = Self::type_data();
@@ -341,9 +342,13 @@ pub trait ActionGroupImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: ActionGroupImpl> ActionGroupImplExt for T {}
+impl<T: ActionGroupImpl> ActionGroupImplExt for T where <T as ObjectSubclass>::Type: IsA<ActionGroup>
+{}
 
-unsafe impl<T: ActionGroupImpl> IsImplementable<T> for ActionGroup {
+unsafe impl<T: ActionGroupImpl> IsImplementable<T> for ActionGroup
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     fn interface_init(iface: &mut glib::Interface<Self>) {
         let iface = iface.as_mut();
 
@@ -367,7 +372,10 @@ unsafe impl<T: ActionGroupImpl> IsImplementable<T> for ActionGroup {
 unsafe extern "C" fn action_group_has_action<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let action_name = GString::from_glib_borrow(action_nameptr);
     let imp = instance.imp();
@@ -378,7 +386,10 @@ unsafe extern "C" fn action_group_has_action<T: ActionGroupImpl>(
 unsafe extern "C" fn action_group_get_action_enabled<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -399,7 +410,10 @@ impl<T, F: Fn(*mut T) + 'static> Drop for PtrHolder<T, F> {
 unsafe extern "C" fn action_group_get_action_parameter_type<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
-) -> *const glib::ffi::GVariantType {
+) -> *const glib::ffi::GVariantType
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -428,7 +442,10 @@ unsafe extern "C" fn action_group_get_action_parameter_type<T: ActionGroupImpl>(
 unsafe extern "C" fn action_group_get_action_state_type<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
-) -> *const glib::ffi::GVariantType {
+) -> *const glib::ffi::GVariantType
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -457,7 +474,10 @@ unsafe extern "C" fn action_group_get_action_state_type<T: ActionGroupImpl>(
 unsafe extern "C" fn action_group_get_action_state_hint<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
-) -> *mut glib::ffi::GVariant {
+) -> *mut glib::ffi::GVariant
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -485,7 +505,10 @@ unsafe extern "C" fn action_group_get_action_state_hint<T: ActionGroupImpl>(
 unsafe extern "C" fn action_group_get_action_state<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
-) -> *mut glib::ffi::GVariant {
+) -> *mut glib::ffi::GVariant
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -512,7 +535,9 @@ unsafe extern "C" fn action_group_change_action_state<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
     stateptr: *mut glib::ffi::GVariant,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -525,7 +550,9 @@ unsafe extern "C" fn action_group_activate_action<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
     parameterptr: *mut glib::ffi::GVariant,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -537,7 +564,9 @@ unsafe extern "C" fn action_group_activate_action<T: ActionGroupImpl>(
 unsafe extern "C" fn action_group_action_added<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -548,7 +577,9 @@ unsafe extern "C" fn action_group_action_added<T: ActionGroupImpl>(
 unsafe extern "C" fn action_group_action_removed<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -560,7 +591,9 @@ unsafe extern "C" fn action_group_action_enabled_changed<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
     enabled: glib::ffi::gboolean,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -572,7 +605,9 @@ unsafe extern "C" fn action_group_action_state_changed<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
     action_nameptr: *const libc::c_char,
     stateptr: *mut glib::ffi::GVariant,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
@@ -583,7 +618,10 @@ unsafe extern "C" fn action_group_action_state_changed<T: ActionGroupImpl>(
 
 unsafe extern "C" fn action_group_list_actions<T: ActionGroupImpl>(
     action_group: *mut ffi::GActionGroup,
-) -> *mut *mut libc::c_char {
+) -> *mut *mut libc::c_char
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
 
@@ -609,7 +647,10 @@ unsafe extern "C" fn action_group_query_action<T: ActionGroupImpl>(
     state_type: *mut *const glib::ffi::GVariantType,
     state_hint: *mut *mut glib::ffi::GVariant,
     state: *mut *mut glib::ffi::GVariant,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<ActionGroup>,
+{
     let instance = &*(action_group as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
diff --git a/gio/src/subclass/action_map.rs b/gio/src/subclass/action_map.rs
index d7a668ee33e7..13b21ca01afc 100644
--- a/gio/src/subclass/action_map.rs
+++ b/gio/src/subclass/action_map.rs
@@ -6,18 +6,19 @@ use glib::{prelude::*, subclass::prelude::*, translate::*, GString, Quark};
 
 use crate::{ffi, Action, ActionMap};
 
-pub trait ActionMapImpl: ObjectImpl {
+pub trait ActionMapImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<ActionMap>,
+{
     fn lookup_action(&self, action_name: &str) -> Option<Action>;
     fn add_action(&self, action: &Action);
     fn remove_action(&self, action_name: &str);
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::ActionMapImplExt> Sealed for T {}
-}
-
-pub trait ActionMapImplExt: sealed::Sealed + ObjectSubclass {
+pub trait ActionMapImplExt: ObjectSubclass + ActionMapImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<ActionMap>,
+{
     fn parent_lookup_action(&self, name: &str) -> Option<Action> {
         unsafe {
             let type_data = Self::type_data();
@@ -68,11 +69,11 @@ pub trait ActionMapImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: ActionMapImpl> ActionMapImplExt for T {}
+impl<T: ActionMapImpl> ActionMapImplExt for T where <T as ObjectSubclass>::Type: IsA<ActionMap> {}
 
 unsafe impl<T: ActionMapImpl> IsImplementable<T> for ActionMap
 where
-    <T as ObjectSubclass>::Type: IsA<glib::Object>,
+    <T as ObjectSubclass>::Type: IsA<ActionMap>,
 {
     fn interface_init(iface: &mut glib::Interface<Self>) {
         let iface = iface.as_mut();
@@ -86,7 +87,10 @@ where
 unsafe extern "C" fn action_map_lookup_action<T: ActionMapImpl>(
     action_map: *mut ffi::GActionMap,
     action_nameptr: *const libc::c_char,
-) -> *mut ffi::GAction {
+) -> *mut ffi::GAction
+where
+    <T as ObjectSubclass>::Type: IsA<ActionMap>,
+{
     let instance = &*(action_map as *mut T::Instance);
     let action_name = GString::from_glib_borrow(action_nameptr);
     let imp = instance.imp();
@@ -116,7 +120,9 @@ unsafe extern "C" fn action_map_lookup_action<T: ActionMapImpl>(
 unsafe extern "C" fn action_map_add_action<T: ActionMapImpl>(
     action_map: *mut ffi::GActionMap,
     actionptr: *mut ffi::GAction,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<ActionMap>,
+{
     let instance = &*(action_map as *mut T::Instance);
     let imp = instance.imp();
     let action: Borrowed<Action> = from_glib_borrow(actionptr);
@@ -127,7 +133,9 @@ unsafe extern "C" fn action_map_add_action<T: ActionMapImpl>(
 unsafe extern "C" fn action_map_remove_action<T: ActionMapImpl>(
     action_map: *mut ffi::GActionMap,
     action_nameptr: *const libc::c_char,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<ActionMap>,
+{
     let instance = &*(action_map as *mut T::Instance);
     let imp = instance.imp();
     let action_name = GString::from_glib_borrow(action_nameptr);
diff --git a/gio/src/subclass/application.rs b/gio/src/subclass/application.rs
index 5a863c388d17..b9962f15078d 100644
--- a/gio/src/subclass/application.rs
+++ b/gio/src/subclass/application.rs
@@ -64,7 +64,10 @@ impl From<ArgumentList> for Vec<OsString> {
     }
 }
 
-pub trait ApplicationImpl: ObjectImpl + ApplicationImplExt {
+pub trait ApplicationImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<Application>,
+{
     fn activate(&self) {
         self.parent_activate()
     }
@@ -110,12 +113,10 @@ pub trait ApplicationImpl: ObjectImpl + ApplicationImplExt {
     }
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::ApplicationImplExt> Sealed for T {}
-}
-
-pub trait ApplicationImplExt: sealed::Sealed + ObjectSubclass {
+pub trait ApplicationImplExt: ObjectSubclass + ApplicationImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<Application>,
+{
     fn parent_activate(&self) {
         unsafe {
             let data = Self::type_data();
@@ -271,9 +272,13 @@ pub trait ApplicationImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: ApplicationImpl> ApplicationImplExt for T {}
+impl<T: ApplicationImpl> ApplicationImplExt for T where <T as ObjectSubclass>::Type: IsA<Application>
+{}
 
-unsafe impl<T: ApplicationImpl> IsSubclassable<T> for Application {
+unsafe impl<T: ApplicationImpl> IsSubclassable<T> for Application
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     fn class_init(class: &mut ::glib::Class<Self>) {
         Self::parent_class_init::<T>(class);
 
@@ -292,7 +297,10 @@ unsafe impl<T: ApplicationImpl> IsSubclassable<T> for Application {
     }
 }
 
-unsafe extern "C" fn application_activate<T: ApplicationImpl>(ptr: *mut ffi::GApplication) {
+unsafe extern "C" fn application_activate<T: ApplicationImpl>(ptr: *mut ffi::GApplication)
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -302,7 +310,9 @@ unsafe extern "C" fn application_activate<T: ApplicationImpl>(ptr: *mut ffi::GAp
 unsafe extern "C" fn application_after_emit<T: ApplicationImpl>(
     ptr: *mut ffi::GApplication,
     platform_data: *mut glib::ffi::GVariant,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -311,7 +321,9 @@ unsafe extern "C" fn application_after_emit<T: ApplicationImpl>(
 unsafe extern "C" fn application_before_emit<T: ApplicationImpl>(
     ptr: *mut ffi::GApplication,
     platform_data: *mut glib::ffi::GVariant,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -320,7 +332,10 @@ unsafe extern "C" fn application_before_emit<T: ApplicationImpl>(
 unsafe extern "C" fn application_command_line<T: ApplicationImpl>(
     ptr: *mut ffi::GApplication,
     command_line: *mut ffi::GApplicationCommandLine,
-) -> i32 {
+) -> i32
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -330,7 +345,10 @@ unsafe extern "C" fn application_local_command_line<T: ApplicationImpl>(
     ptr: *mut ffi::GApplication,
     arguments: *mut *mut *mut c_char,
     exit_status: *mut i32,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -351,32 +369,46 @@ unsafe extern "C" fn application_open<T: ApplicationImpl>(
     files: *mut *mut ffi::GFile,
     num_files: i32,
     hint: *const c_char,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
     let files: Vec<crate::File> = FromGlibContainer::from_glib_none_num(files, num_files as usize);
     imp.open(files.as_slice(), &glib::GString::from_glib_borrow(hint))
 }
-unsafe extern "C" fn application_quit_mainloop<T: ApplicationImpl>(ptr: *mut ffi::GApplication) {
+unsafe extern "C" fn application_quit_mainloop<T: ApplicationImpl>(ptr: *mut ffi::GApplication)
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
     imp.quit_mainloop()
 }
-unsafe extern "C" fn application_run_mainloop<T: ApplicationImpl>(ptr: *mut ffi::GApplication) {
+unsafe extern "C" fn application_run_mainloop<T: ApplicationImpl>(ptr: *mut ffi::GApplication)
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
     imp.run_mainloop()
 }
-unsafe extern "C" fn application_shutdown<T: ApplicationImpl>(ptr: *mut ffi::GApplication) {
+unsafe extern "C" fn application_shutdown<T: ApplicationImpl>(ptr: *mut ffi::GApplication)
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
     imp.shutdown()
 }
-unsafe extern "C" fn application_startup<T: ApplicationImpl>(ptr: *mut ffi::GApplication) {
+unsafe extern "C" fn application_startup<T: ApplicationImpl>(ptr: *mut ffi::GApplication)
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -386,7 +418,10 @@ unsafe extern "C" fn application_startup<T: ApplicationImpl>(ptr: *mut ffi::GApp
 unsafe extern "C" fn application_handle_local_options<T: ApplicationImpl>(
     ptr: *mut ffi::GApplication,
     options: *mut glib::ffi::GVariantDict,
-) -> c_int {
+) -> c_int
+where
+    <T as ObjectSubclass>::Type: IsA<Application>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
diff --git a/gio/src/subclass/async_initable.rs b/gio/src/subclass/async_initable.rs
index 1c2171bcfa55..433ae27ac68d 100644
--- a/gio/src/subclass/async_initable.rs
+++ b/gio/src/subclass/async_initable.rs
@@ -8,7 +8,10 @@ use crate::{
     ffi, AsyncInitable, AsyncResult, Cancellable, CancellableFuture, GioFutureResult, LocalTask,
 };
 
-pub trait AsyncInitableImpl: ObjectImpl {
+pub trait AsyncInitableImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<AsyncInitable>,
+{
     fn init_future(
         &self,
         io_priority: glib::Priority,
@@ -17,12 +20,10 @@ pub trait AsyncInitableImpl: ObjectImpl {
     }
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::AsyncInitableImplExt> Sealed for T {}
-}
-
-pub trait AsyncInitableImplExt: sealed::Sealed + AsyncInitableImpl + ObjectSubclass {
+pub trait AsyncInitableImplExt: ObjectSubclass + AsyncInitableImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<AsyncInitable>,
+{
     fn parent_init_future(
         &self,
         io_priority: glib::Priority,
@@ -42,6 +43,7 @@ pub trait AsyncInitableImplExt: sealed::Sealed + AsyncInitableImpl + ObjectSubcl
                 user_data: glib::ffi::gpointer,
             ) where
                 T: AsyncInitableImpl,
+                <T as ObjectSubclass>::Type: IsA<AsyncInitable>,
             {
                 let type_data = T::type_data();
                 let parent_iface = type_data.as_ref().parent_interface::<AsyncInitable>()
@@ -83,9 +85,15 @@ pub trait AsyncInitableImplExt: sealed::Sealed + AsyncInitableImpl + ObjectSubcl
     }
 }
 
-impl<T: AsyncInitableImpl> AsyncInitableImplExt for T {}
+impl<T: AsyncInitableImpl> AsyncInitableImplExt for T where
+    <T as ObjectSubclass>::Type: IsA<AsyncInitable>
+{
+}
 
-unsafe impl<T: AsyncInitableImpl> IsImplementable<T> for AsyncInitable {
+unsafe impl<T: AsyncInitableImpl> IsImplementable<T> for AsyncInitable
+where
+    <T as ObjectSubclass>::Type: IsA<AsyncInitable>,
+{
     fn interface_init(iface: &mut glib::Interface<Self>) {
         let iface = iface.as_mut();
         iface.init_async = Some(async_initable_init_async::<T>);
@@ -99,7 +107,9 @@ unsafe extern "C" fn async_initable_init_async<T: AsyncInitableImpl>(
     cancellable: *mut ffi::GCancellable,
     callback: ffi::GAsyncReadyCallback,
     user_data: glib::ffi::gpointer,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<AsyncInitable>,
+{
     let instance = &*(initable as *mut T::Instance);
     let imp = instance.imp();
     let cancellable = Option::<Cancellable>::from_glib_none(cancellable);
diff --git a/gio/src/subclass/initable.rs b/gio/src/subclass/initable.rs
index 23b4beb7fc8e..9ad33d9bd364 100644
--- a/gio/src/subclass/initable.rs
+++ b/gio/src/subclass/initable.rs
@@ -6,18 +6,19 @@ use glib::{prelude::*, subclass::prelude::*, translate::*, Error};
 
 use crate::{ffi, Cancellable, Initable};
 
-pub trait InitableImpl: ObjectImpl {
+pub trait InitableImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<Initable>,
+{
     fn init(&self, cancellable: Option<&Cancellable>) -> Result<(), Error> {
         self.parent_init(cancellable)
     }
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::InitableImplExt> Sealed for T {}
-}
-
-pub trait InitableImplExt: sealed::Sealed + ObjectSubclass {
+pub trait InitableImplExt: ObjectSubclass + InitableImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<Initable>,
+{
     fn parent_init(&self, cancellable: Option<&Cancellable>) -> Result<(), Error> {
         unsafe {
             let type_data = Self::type_data();
@@ -44,9 +45,12 @@ pub trait InitableImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: InitableImpl> InitableImplExt for T {}
+impl<T: InitableImpl> InitableImplExt for T where <Self as ObjectSubclass>::Type: IsA<Initable> {}
 
-unsafe impl<T: InitableImpl> IsImplementable<T> for Initable {
+unsafe impl<T: InitableImpl> IsImplementable<T> for Initable
+where
+    <T as ObjectSubclass>::Type: IsA<Initable>,
+{
     fn interface_init(iface: &mut glib::Interface<Self>) {
         let iface = iface.as_mut();
         iface.init = Some(initable_init::<T>);
@@ -57,7 +61,10 @@ unsafe extern "C" fn initable_init<T: InitableImpl>(
     initable: *mut ffi::GInitable,
     cancellable: *mut ffi::GCancellable,
     error: *mut *mut glib::ffi::GError,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<Initable>,
+{
     let instance = &*(initable as *mut T::Instance);
     let imp = instance.imp();
 
diff --git a/gio/src/subclass/input_stream.rs b/gio/src/subclass/input_stream.rs
index e65e27678791..7d8f97c48722 100644
--- a/gio/src/subclass/input_stream.rs
+++ b/gio/src/subclass/input_stream.rs
@@ -6,7 +6,10 @@ use glib::{prelude::*, subclass::prelude::*, translate::*, Error};
 
 use crate::{ffi, Cancellable, InputStream};
 
-pub trait InputStreamImpl: ObjectImpl + InputStreamImplExt + Send {
+pub trait InputStreamImpl: ObjectImpl + Send
+where
+    <Self as ObjectSubclass>::Type: IsA<InputStream>,
+{
     fn read(&self, buffer: &mut [u8], cancellable: Option<&Cancellable>) -> Result<usize, Error> {
         self.parent_read(buffer, cancellable)
     }
@@ -20,12 +23,10 @@ pub trait InputStreamImpl: ObjectImpl + InputStreamImplExt + Send {
     }
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::InputStreamImplExt> Sealed for T {}
-}
-
-pub trait InputStreamImplExt: sealed::Sealed + ObjectSubclass {
+pub trait InputStreamImplExt: ObjectSubclass + InputStreamImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<InputStream>,
+{
     fn parent_read(
         &self,
         buffer: &mut [u8],
@@ -103,9 +104,13 @@ pub trait InputStreamImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: InputStreamImpl> InputStreamImplExt for T {}
+impl<T: InputStreamImpl> InputStreamImplExt for T where <T as ObjectSubclass>::Type: IsA<InputStream>
+{}
 
-unsafe impl<T: InputStreamImpl> IsSubclassable<T> for InputStream {
+unsafe impl<T: InputStreamImpl> IsSubclassable<T> for InputStream
+where
+    <T as ObjectSubclass>::Type: IsA<InputStream>,
+{
     fn class_init(class: &mut ::glib::Class<Self>) {
         Self::parent_class_init::<T>(class);
 
@@ -122,7 +127,10 @@ unsafe extern "C" fn stream_read<T: InputStreamImpl>(
     count: usize,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> isize {
+) -> isize
+where
+    <T as ObjectSubclass>::Type: IsA<InputStream>,
+{
     debug_assert!(count <= isize::MAX as usize);
 
     let instance = &*(ptr as *mut T::Instance);
@@ -156,7 +164,10 @@ unsafe extern "C" fn stream_close<T: InputStreamImpl>(
     ptr: *mut ffi::GInputStream,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<InputStream>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -180,7 +191,10 @@ unsafe extern "C" fn stream_skip<T: InputStreamImpl>(
     count: usize,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> isize {
+) -> isize
+where
+    <T as ObjectSubclass>::Type: IsA<InputStream>,
+{
     debug_assert!(count <= isize::MAX as usize);
 
     let instance = &*(ptr as *mut T::Instance);
@@ -299,7 +313,8 @@ mod tests {
 
     glib::wrapper! {
         pub struct SimpleInputStream(ObjectSubclass<imp::SimpleInputStream>)
-            @extends InputStream;
+            @extends InputStream,
+            @implements crate::Seekable;
     }
 
     #[test]
diff --git a/gio/src/subclass/io_stream.rs b/gio/src/subclass/io_stream.rs
index 6a3b290c7049..fed6b9aeb6ca 100644
--- a/gio/src/subclass/io_stream.rs
+++ b/gio/src/subclass/io_stream.rs
@@ -6,7 +6,10 @@ use glib::{prelude::*, subclass::prelude::*, translate::*, Error};
 
 use crate::{ffi, Cancellable, IOStream, InputStream, OutputStream};
 
-pub trait IOStreamImpl: ObjectImpl + IOStreamImplExt + Send {
+pub trait IOStreamImpl: ObjectImpl + Send
+where
+    <Self as ObjectSubclass>::Type: IsA<IOStream>,
+{
     fn input_stream(&self) -> InputStream {
         self.parent_input_stream()
     }
@@ -20,12 +23,10 @@ pub trait IOStreamImpl: ObjectImpl + IOStreamImplExt + Send {
     }
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::IOStreamImplExt> Sealed for T {}
-}
-
-pub trait IOStreamImplExt: sealed::Sealed + ObjectSubclass {
+pub trait IOStreamImplExt: ObjectSubclass + IOStreamImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<IOStream>,
+{
     fn parent_input_stream(&self) -> InputStream {
         unsafe {
             let data = Self::type_data();
@@ -70,9 +71,12 @@ pub trait IOStreamImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: IOStreamImpl> IOStreamImplExt for T {}
+impl<T: IOStreamImpl> IOStreamImplExt for T where <T as ObjectSubclass>::Type: IsA<IOStream> {}
 
-unsafe impl<T: IOStreamImpl> IsSubclassable<T> for IOStream {
+unsafe impl<T: IOStreamImpl> IsSubclassable<T> for IOStream
+where
+    <T as ObjectSubclass>::Type: IsA<IOStream>,
+{
     fn class_init(class: &mut ::glib::Class<Self>) {
         Self::parent_class_init::<T>(class);
 
@@ -85,7 +89,10 @@ unsafe impl<T: IOStreamImpl> IsSubclassable<T> for IOStream {
 
 unsafe extern "C" fn stream_get_input_stream<T: IOStreamImpl>(
     ptr: *mut ffi::GIOStream,
-) -> *mut ffi::GInputStream {
+) -> *mut ffi::GInputStream
+where
+    <T as ObjectSubclass>::Type: IsA<IOStream>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -112,7 +119,10 @@ unsafe extern "C" fn stream_get_input_stream<T: IOStreamImpl>(
 
 unsafe extern "C" fn stream_get_output_stream<T: IOStreamImpl>(
     ptr: *mut ffi::GIOStream,
-) -> *mut ffi::GOutputStream {
+) -> *mut ffi::GOutputStream
+where
+    <T as ObjectSubclass>::Type: IsA<IOStream>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -141,7 +151,10 @@ unsafe extern "C" fn stream_close<T: IOStreamImpl>(
     ptr: *mut ffi::GIOStream,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<IOStream>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
diff --git a/gio/src/subclass/list_model.rs b/gio/src/subclass/list_model.rs
index 96a411f3595b..8223739d7a6e 100644
--- a/gio/src/subclass/list_model.rs
+++ b/gio/src/subclass/list_model.rs
@@ -6,7 +6,10 @@ use glib::{prelude::*, subclass::prelude::*, translate::*};
 
 use crate::{ffi, ListModel};
 
-pub trait ListModelImpl: ObjectImpl {
+pub trait ListModelImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<ListModel>,
+{
     #[doc(alias = "get_item_type")]
     fn item_type(&self) -> glib::Type;
     #[doc(alias = "get_n_items")]
@@ -15,12 +18,10 @@ pub trait ListModelImpl: ObjectImpl {
     fn item(&self, position: u32) -> Option<glib::Object>;
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::ListModelImplExt> Sealed for T {}
-}
-
-pub trait ListModelImplExt: sealed::Sealed + ObjectSubclass {
+pub trait ListModelImplExt: ObjectSubclass + ListModelImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<ListModel>,
+{
     fn parent_item_type(&self) -> glib::Type {
         unsafe {
             let type_data = Self::type_data();
@@ -66,11 +67,11 @@ pub trait ListModelImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: ListModelImpl> ListModelImplExt for T {}
+impl<T: ListModelImpl> ListModelImplExt for T where <T as ObjectSubclass>::Type: IsA<ListModel> {}
 
 unsafe impl<T: ListModelImpl> IsImplementable<T> for ListModel
 where
-    <T as ObjectSubclass>::Type: IsA<glib::Object>,
+    <T as ObjectSubclass>::Type: IsA<ListModel>,
 {
     fn interface_init(iface: &mut glib::Interface<Self>) {
         let iface = iface.as_mut();
@@ -85,7 +86,7 @@ unsafe extern "C" fn list_model_get_item_type<T: ListModelImpl>(
     list_model: *mut ffi::GListModel,
 ) -> glib::ffi::GType
 where
-    <T as ObjectSubclass>::Type: IsA<glib::Object>,
+    <T as ObjectSubclass>::Type: IsA<ListModel>,
 {
     let instance = &*(list_model as *mut T::Instance);
     let imp = instance.imp();
@@ -117,7 +118,7 @@ unsafe extern "C" fn list_model_get_n_items<T: ListModelImpl>(
     list_model: *mut ffi::GListModel,
 ) -> u32
 where
-    <T as ObjectSubclass>::Type: IsA<glib::Object>,
+    <T as ObjectSubclass>::Type: IsA<ListModel>,
 {
     let instance = &*(list_model as *mut T::Instance);
     let imp = instance.imp();
@@ -130,7 +131,7 @@ unsafe extern "C" fn list_model_get_item<T: ListModelImpl>(
     position: u32,
 ) -> *mut glib::gobject_ffi::GObject
 where
-    <T as ObjectSubclass>::Type: IsA<glib::Object>,
+    <T as ObjectSubclass>::Type: IsA<ListModel>,
 {
     let instance = &*(list_model as *mut T::Instance);
     let imp = instance.imp();
diff --git a/gio/src/subclass/output_stream.rs b/gio/src/subclass/output_stream.rs
index 6f9d8ec86c6c..e3836fad748d 100644
--- a/gio/src/subclass/output_stream.rs
+++ b/gio/src/subclass/output_stream.rs
@@ -6,7 +6,10 @@ use glib::{prelude::*, subclass::prelude::*, translate::*, Error};
 
 use crate::{ffi, Cancellable, InputStream, OutputStream, OutputStreamSpliceFlags};
 
-pub trait OutputStreamImpl: ObjectImpl + OutputStreamImplExt + Send {
+pub trait OutputStreamImpl: ObjectImpl + Send
+where
+    <Self as ObjectSubclass>::Type: IsA<OutputStream>,
+{
     fn write(&self, buffer: &[u8], cancellable: Option<&Cancellable>) -> Result<usize, Error> {
         self.parent_write(buffer, cancellable)
     }
@@ -29,12 +32,10 @@ pub trait OutputStreamImpl: ObjectImpl + OutputStreamImplExt + Send {
     }
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::OutputStreamImplExt> Sealed for T {}
-}
-
-pub trait OutputStreamImplExt: sealed::Sealed + ObjectSubclass {
+pub trait OutputStreamImplExt: ObjectSubclass + OutputStreamImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<OutputStream>,
+{
     fn parent_write(
         &self,
         buffer: &[u8],
@@ -150,9 +151,15 @@ pub trait OutputStreamImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: OutputStreamImpl> OutputStreamImplExt for T {}
+impl<T: OutputStreamImpl> OutputStreamImplExt for T where
+    <T as ObjectSubclass>::Type: IsA<OutputStream>
+{
+}
 
-unsafe impl<T: OutputStreamImpl> IsSubclassable<T> for OutputStream {
+unsafe impl<T: OutputStreamImpl> IsSubclassable<T> for OutputStream
+where
+    <T as ObjectSubclass>::Type: IsA<OutputStream>,
+{
     fn class_init(class: &mut ::glib::Class<Self>) {
         Self::parent_class_init::<T>(class);
 
@@ -170,7 +177,10 @@ unsafe extern "C" fn stream_write<T: OutputStreamImpl>(
     count: usize,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> isize {
+) -> isize
+where
+    <T as ObjectSubclass>::Type: IsA<OutputStream>,
+{
     debug_assert!(count <= isize::MAX as usize);
 
     let instance = &*(ptr as *mut T::Instance);
@@ -204,7 +214,10 @@ unsafe extern "C" fn stream_close<T: OutputStreamImpl>(
     ptr: *mut ffi::GOutputStream,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<OutputStream>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -227,7 +240,10 @@ unsafe extern "C" fn stream_flush<T: OutputStreamImpl>(
     ptr: *mut ffi::GOutputStream,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<OutputStream>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -252,7 +268,10 @@ unsafe extern "C" fn stream_splice<T: OutputStreamImpl>(
     flags: ffi::GOutputStreamSpliceFlags,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> isize {
+) -> isize
+where
+    <T as ObjectSubclass>::Type: IsA<OutputStream>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
diff --git a/gio/src/subclass/seekable.rs b/gio/src/subclass/seekable.rs
index 3d23db1e5a23..dd8a70f2ddeb 100644
--- a/gio/src/subclass/seekable.rs
+++ b/gio/src/subclass/seekable.rs
@@ -6,7 +6,10 @@ use glib::{prelude::*, subclass::prelude::*, translate::*, Error, SeekType};
 
 use crate::{ffi, Cancellable, Seekable};
 
-pub trait SeekableImpl: ObjectImpl + Send {
+pub trait SeekableImpl: ObjectImpl + Send
+where
+    <Self as ObjectSubclass>::Type: IsA<Seekable>,
+{
     fn tell(&self) -> i64;
     fn can_seek(&self) -> bool;
     fn seek(
@@ -19,12 +22,10 @@ pub trait SeekableImpl: ObjectImpl + Send {
     fn truncate(&self, offset: i64, cancellable: Option<&Cancellable>) -> Result<(), Error>;
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::SeekableImplExt> Sealed for T {}
-}
-
-pub trait SeekableImplExt: sealed::Sealed + ObjectSubclass {
+pub trait SeekableImplExt: ObjectSubclass + SeekableImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<Seekable>,
+{
     fn parent_tell(&self) -> i64 {
         unsafe {
             let type_data = Self::type_data();
@@ -125,9 +126,12 @@ pub trait SeekableImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: SeekableImpl> SeekableImplExt for T {}
+impl<T: SeekableImpl> SeekableImplExt for T where <T as ObjectSubclass>::Type: IsA<Seekable> {}
 
-unsafe impl<T: SeekableImpl> IsImplementable<T> for Seekable {
+unsafe impl<T: SeekableImpl> IsImplementable<T> for Seekable
+where
+    <T as ObjectSubclass>::Type: IsA<Seekable>,
+{
     fn interface_init(iface: &mut glib::Interface<Self>) {
         let iface = iface.as_mut();
 
@@ -139,7 +143,10 @@ unsafe impl<T: SeekableImpl> IsImplementable<T> for Seekable {
     }
 }
 
-unsafe extern "C" fn seekable_tell<T: SeekableImpl>(seekable: *mut ffi::GSeekable) -> i64 {
+unsafe extern "C" fn seekable_tell<T: SeekableImpl>(seekable: *mut ffi::GSeekable) -> i64
+where
+    <T as ObjectSubclass>::Type: IsA<Seekable>,
+{
     let instance = &*(seekable as *mut T::Instance);
     let imp = instance.imp();
 
@@ -148,7 +155,10 @@ unsafe extern "C" fn seekable_tell<T: SeekableImpl>(seekable: *mut ffi::GSeekabl
 
 unsafe extern "C" fn seekable_can_seek<T: SeekableImpl>(
     seekable: *mut ffi::GSeekable,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<Seekable>,
+{
     let instance = &*(seekable as *mut T::Instance);
     let imp = instance.imp();
 
@@ -161,7 +171,10 @@ unsafe extern "C" fn seekable_seek<T: SeekableImpl>(
     type_: glib::ffi::GSeekType,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<Seekable>,
+{
     let instance = &*(seekable as *mut T::Instance);
     let imp = instance.imp();
 
@@ -184,7 +197,10 @@ unsafe extern "C" fn seekable_seek<T: SeekableImpl>(
 
 unsafe extern "C" fn seekable_can_truncate<T: SeekableImpl>(
     seekable: *mut ffi::GSeekable,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<Seekable>,
+{
     let instance = &*(seekable as *mut T::Instance);
     let imp = instance.imp();
 
@@ -196,7 +212,10 @@ unsafe extern "C" fn seekable_truncate<T: SeekableImpl>(
     offset: i64,
     cancellable: *mut ffi::GCancellable,
     err: *mut *mut glib::ffi::GError,
-) -> glib::ffi::gboolean {
+) -> glib::ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<Seekable>,
+{
     let instance = &*(seekable as *mut T::Instance);
     let imp = instance.imp();
 
diff --git a/gio/src/subclass/socket_control_message.rs b/gio/src/subclass/socket_control_message.rs
index 3f43ac1608e1..6eed7637fb7a 100644
--- a/gio/src/subclass/socket_control_message.rs
+++ b/gio/src/subclass/socket_control_message.rs
@@ -4,7 +4,10 @@ use glib::{prelude::*, subclass::prelude::*, translate::*};
 
 use crate::{ffi, SocketControlMessage};
 
-pub trait SocketControlMessageImpl: ObjectImpl + SocketControlMessageImplExt {
+pub trait SocketControlMessageImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<SocketControlMessage>,
+{
     fn level(&self) -> i32 {
         self.parent_level()
     }
@@ -26,12 +29,10 @@ pub trait SocketControlMessageImpl: ObjectImpl + SocketControlMessageImplExt {
     }
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::SocketControlMessageImplExt> Sealed for T {}
-}
-
-pub trait SocketControlMessageImplExt: sealed::Sealed + ObjectSubclass {
+pub trait SocketControlMessageImplExt: ObjectSubclass + SocketControlMessageImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<SocketControlMessage>,
+{
     fn parent_level(&self) -> i32 {
         unsafe {
             let data = Self::type_data();
@@ -113,9 +114,15 @@ pub trait SocketControlMessageImplExt: sealed::Sealed + ObjectSubclass {
     }
 }
 
-impl<T: SocketControlMessageImpl> SocketControlMessageImplExt for T {}
+impl<T: SocketControlMessageImpl> SocketControlMessageImplExt for T where
+    <T as ObjectSubclass>::Type: IsA<SocketControlMessage>
+{
+}
 
-unsafe impl<T: SocketControlMessageImpl> IsSubclassable<T> for SocketControlMessage {
+unsafe impl<T: SocketControlMessageImpl> IsSubclassable<T> for SocketControlMessage
+where
+    <T as ObjectSubclass>::Type: IsA<SocketControlMessage>,
+{
     fn class_init(class: &mut ::glib::Class<Self>) {
         Self::parent_class_init::<T>(class);
 
@@ -130,7 +137,10 @@ unsafe impl<T: SocketControlMessageImpl> IsSubclassable<T> for SocketControlMess
 
 unsafe extern "C" fn socket_control_message_get_level<T: SocketControlMessageImpl>(
     ptr: *mut ffi::GSocketControlMessage,
-) -> i32 {
+) -> i32
+where
+    <T as ObjectSubclass>::Type: IsA<SocketControlMessage>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -139,7 +149,10 @@ unsafe extern "C" fn socket_control_message_get_level<T: SocketControlMessageImp
 
 unsafe extern "C" fn socket_control_message_get_type<T: SocketControlMessageImpl>(
     ptr: *mut ffi::GSocketControlMessage,
-) -> i32 {
+) -> i32
+where
+    <T as ObjectSubclass>::Type: IsA<SocketControlMessage>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -148,7 +161,10 @@ unsafe extern "C" fn socket_control_message_get_type<T: SocketControlMessageImpl
 
 unsafe extern "C" fn socket_control_message_get_size<T: SocketControlMessageImpl>(
     ptr: *mut ffi::GSocketControlMessage,
-) -> usize {
+) -> usize
+where
+    <T as ObjectSubclass>::Type: IsA<SocketControlMessage>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -158,7 +174,9 @@ unsafe extern "C" fn socket_control_message_get_size<T: SocketControlMessageImpl
 unsafe extern "C" fn socket_control_message_serialize<T: SocketControlMessageImpl>(
     ptr: *mut ffi::GSocketControlMessage,
     data: glib::ffi::gpointer,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<SocketControlMessage>,
+{
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
@@ -172,7 +190,10 @@ unsafe extern "C" fn socket_control_message_deserialize<T: SocketControlMessageI
     type_: i32,
     size: usize,
     data: glib::ffi::gpointer,
-) -> *mut ffi::GSocketControlMessage {
+) -> *mut ffi::GSocketControlMessage
+where
+    <T as ObjectSubclass>::Type: IsA<SocketControlMessage>,
+{
     let data = std::slice::from_raw_parts(data as *mut u8, size);
 
     T::deserialize(level, type_, data).into_glib_ptr()
diff --git a/glib/src/gobject/dynamic_object.rs b/glib/src/gobject/dynamic_object.rs
index f6e7648046fb..8736aa8ec580 100644
--- a/glib/src/gobject/dynamic_object.rs
+++ b/glib/src/gobject/dynamic_object.rs
@@ -44,6 +44,7 @@ pub trait DynamicObjectRegisterExt: AsRef<TypePlugin> + sealed::Sealed + 'static
 impl<O: IsA<TypePlugin> + ObjectSubclassIsExt> DynamicObjectRegisterExt for O
 where
     O::Subclass: TypePluginRegisterImpl,
+    <O::Subclass as ObjectSubclass>::Type: IsA<TypePlugin>,
 {
     fn add_dynamic_interface(
         &self,
diff --git a/glib/src/subclass/object.rs b/glib/src/subclass/object.rs
index ae84380a48f7..fc4b42b6cff7 100644
--- a/glib/src/subclass/object.rs
+++ b/glib/src/subclass/object.rs
@@ -19,7 +19,7 @@ use crate::{
 ///
 /// This allows overriding the virtual methods of `glib::Object`. Except for
 /// `finalize` as implementing `Drop` would allow the same behavior.
-pub trait ObjectImpl: ObjectSubclass + ObjectImplExt {
+pub trait ObjectImpl: ObjectSubclass {
     // rustdoc-stripper-ignore-next
     /// Properties installed for this type.
     fn properties() -> &'static [ParamSpec] {
@@ -253,12 +253,7 @@ unsafe impl<T: ObjectImpl> IsSubclassable<T> for Object {
     fn instance_init(_instance: &mut super::InitializingObject<T>) {}
 }
 
-mod sealed {
-    pub trait Sealed {}
-    impl<T: super::ObjectImplExt> Sealed for T {}
-}
-
-pub trait ObjectImplExt: sealed::Sealed + ObjectSubclass {
+pub trait ObjectImplExt: ObjectSubclass + ObjectImpl {
     // rustdoc-stripper-ignore-next
     /// Chain up to the parent class' implementation of `glib::Object::constructed()`.
     #[inline]
diff --git a/glib/src/subclass/type_module.rs b/glib/src/subclass/type_module.rs
index bb0fe6f78ce8..cd78adade1ab 100644
--- a/glib/src/subclass/type_module.rs
+++ b/glib/src/subclass/type_module.rs
@@ -2,7 +2,10 @@
 
 use crate::{ffi, gobject_ffi, prelude::*, subclass::prelude::*, translate::*, TypeModule};
 
-pub trait TypeModuleImpl: ObjectImpl + TypeModuleImplExt {
+pub trait TypeModuleImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<TypeModule>,
+{
     // rustdoc-stripper-ignore-next
     /// Loads the module, registers one or more object subclasses using
     /// [`register_dynamic_type`] and registers one or more object interfaces
@@ -21,12 +24,18 @@ pub trait TypeModuleImpl: ObjectImpl + TypeModuleImplExt {
     fn unload(&self);
 }
 
-pub trait TypeModuleImplExt: ObjectSubclass {
+pub trait TypeModuleImplExt: ObjectSubclass + TypeModuleImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<TypeModule>,
+{
     fn parent_load(&self) -> bool;
     fn parent_unload(&self);
 }
 
-impl<T: TypeModuleImpl> TypeModuleImplExt for T {
+impl<T: TypeModuleImpl> TypeModuleImplExt for T
+where
+    <Self as ObjectSubclass>::Type: IsA<TypeModule>,
+{
     fn parent_load(&self) -> bool {
         unsafe {
             let data = T::type_data();
@@ -58,7 +67,10 @@ impl<T: TypeModuleImpl> TypeModuleImplExt for T {
     }
 }
 
-unsafe impl<T: TypeModuleImpl> IsSubclassable<T> for TypeModule {
+unsafe impl<T: TypeModuleImpl> IsSubclassable<T> for TypeModule
+where
+    <T as ObjectSubclass>::Type: IsA<TypeModule>,
+{
     fn class_init(class: &mut crate::Class<Self>) {
         Self::parent_class_init::<T>(class);
 
@@ -70,7 +82,10 @@ unsafe impl<T: TypeModuleImpl> IsSubclassable<T> for TypeModule {
 
 unsafe extern "C" fn load<T: TypeModuleImpl>(
     type_module: *mut gobject_ffi::GTypeModule,
-) -> ffi::gboolean {
+) -> ffi::gboolean
+where
+    <T as ObjectSubclass>::Type: IsA<TypeModule>,
+{
     let instance = &*(type_module as *mut T::Instance);
     let imp = instance.imp();
 
@@ -90,7 +105,10 @@ unsafe extern "C" fn load<T: TypeModuleImpl>(
     res.into_glib()
 }
 
-unsafe extern "C" fn unload<T: TypeModuleImpl>(type_module: *mut gobject_ffi::GTypeModule) {
+unsafe extern "C" fn unload<T: TypeModuleImpl>(type_module: *mut gobject_ffi::GTypeModule)
+where
+    <T as ObjectSubclass>::Type: IsA<TypeModule>,
+{
     let instance = &*(type_module as *mut T::Instance);
     let imp = instance.imp();
 
diff --git a/glib/src/subclass/type_plugin.rs b/glib/src/subclass/type_plugin.rs
index bb4d755f8a88..9e8ab6908b0a 100644
--- a/glib/src/subclass/type_plugin.rs
+++ b/glib/src/subclass/type_plugin.rs
@@ -6,7 +6,10 @@ use crate::{
     Type, TypeFlags, TypeInfo, TypePlugin, TypeValueTable,
 };
 
-pub trait TypePluginImpl: ObjectImpl + TypePluginImplExt {
+pub trait TypePluginImpl: ObjectImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<TypePlugin>,
+{
     fn use_plugin(&self) {
         self.parent_use_plugin();
     }
@@ -24,7 +27,10 @@ pub trait TypePluginImpl: ObjectImpl + TypePluginImplExt {
     }
 }
 
-pub trait TypePluginImplExt: ObjectSubclass {
+pub trait TypePluginImplExt: ObjectSubclass + TypePluginImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<TypePlugin>,
+{
     fn parent_use_plugin(&self);
     fn parent_unuse_plugin(&self);
     fn parent_complete_type_info(&self, type_: Type) -> (TypeInfo, TypeValueTable);
@@ -35,7 +41,10 @@ pub trait TypePluginImplExt: ObjectSubclass {
     ) -> InterfaceInfo;
 }
 
-impl<T: TypePluginImpl> TypePluginImplExt for T {
+impl<T: TypePluginImpl> TypePluginImplExt for T
+where
+    <Self as ObjectSubclass>::Type: IsA<TypePlugin>,
+{
     fn parent_use_plugin(&self) {
         unsafe {
             let type_data = Self::type_data();
@@ -113,7 +122,10 @@ impl<T: TypePluginImpl> TypePluginImplExt for T {
     }
 }
 
-unsafe impl<T: TypePluginImpl> IsImplementable<T> for TypePlugin {
+unsafe impl<T: TypePluginImpl> IsImplementable<T> for TypePlugin
+where
+    <T as ObjectSubclass>::Type: IsA<TypePlugin>,
+{
     fn interface_init(iface: &mut Interface<Self>) {
         let iface = iface.as_mut();
 
@@ -124,14 +136,20 @@ unsafe impl<T: TypePluginImpl> IsImplementable<T> for TypePlugin {
     }
 }
 
-unsafe extern "C" fn use_plugin<T: TypePluginImpl>(type_plugin: *mut gobject_ffi::GTypePlugin) {
+unsafe extern "C" fn use_plugin<T: TypePluginImpl>(type_plugin: *mut gobject_ffi::GTypePlugin)
+where
+    <T as ObjectSubclass>::Type: IsA<TypePlugin>,
+{
     let instance = &*(type_plugin as *mut T::Instance);
     let imp = instance.imp();
 
     imp.use_plugin();
 }
 
-unsafe extern "C" fn unuse_plugin<T: TypePluginImpl>(type_plugin: *mut gobject_ffi::GTypePlugin) {
+unsafe extern "C" fn unuse_plugin<T: TypePluginImpl>(type_plugin: *mut gobject_ffi::GTypePlugin)
+where
+    <T as ObjectSubclass>::Type: IsA<TypePlugin>,
+{
     let instance = &*(type_plugin as *mut T::Instance);
     let imp = instance.imp();
 
@@ -143,7 +161,9 @@ unsafe extern "C" fn complete_type_info<T: TypePluginImpl>(
     gtype: ffi::GType,
     info_ptr: *mut gobject_ffi::GTypeInfo,
     value_table_ptr: *mut gobject_ffi::GTypeValueTable,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<TypePlugin>,
+{
     assert!(!info_ptr.is_null());
     assert!(!value_table_ptr.is_null());
     let instance = &*(type_plugin as *mut T::Instance);
@@ -163,7 +183,9 @@ unsafe extern "C" fn complete_interface_info<T: TypePluginImpl>(
     instance_gtype: ffi::GType,
     interface_gtype: ffi::GType,
     info_ptr: *mut gobject_ffi::GInterfaceInfo,
-) {
+) where
+    <T as ObjectSubclass>::Type: IsA<TypePlugin>,
+{
     assert!(!info_ptr.is_null());
     let instance = &*(type_plugin as *mut T::Instance);
     let imp = instance.imp();
@@ -175,7 +197,10 @@ unsafe extern "C" fn complete_interface_info<T: TypePluginImpl>(
     *info = info_;
 }
 
-pub trait TypePluginRegisterImpl: ObjectImpl + TypePluginImpl {
+pub trait TypePluginRegisterImpl: ObjectImpl + TypePluginImpl
+where
+    <Self as ObjectSubclass>::Type: IsA<TypePlugin>,
+{
     fn add_dynamic_interface(
         &self,
         _instance_type: Type,