diff --git a/gdk-pixbuf/src/auto/pixbuf.rs b/gdk-pixbuf/src/auto/pixbuf.rs
index 4aede39d1ed6..478a0c0a04db 100644
--- a/gdk-pixbuf/src/auto/pixbuf.rs
+++ b/gdk-pixbuf/src/auto/pixbuf.rs
@@ -60,7 +60,7 @@ impl Pixbuf {
 
     //#[doc(alias = "gdk_pixbuf_new_from_data")]
     //#[doc(alias = "new_from_data")]
-    //pub fn from_data(data: &[u8], colorspace: Colorspace, has_alpha: bool, bits_per_sample: i32, width: i32, height: i32, rowstride: i32, destroy_fn: Option<Box_<dyn FnOnce(&Vec<u8>) + 'static>>) -> Pixbuf {
+    //pub fn from_data(data: &[u8], colorspace: Colorspace, has_alpha: bool, bits_per_sample: i32, width: i32, height: i32, rowstride: i32, destroy_fn: Option<Box_<dyn FnOnce(&[u8]) + 'static>>) -> Pixbuf {
     //    unsafe { TODO: call ffi:gdk_pixbuf_new_from_data() }
     //}
 
@@ -167,15 +167,20 @@ impl Pixbuf {
 
     #[doc(alias = "gdk_pixbuf_new_from_stream")]
     #[doc(alias = "new_from_stream")]
-    pub fn from_stream(
+    pub fn from_stream<'a, P: IsA<gio::Cancellable>>(
         stream: &impl IsA<gio::InputStream>,
-        cancellable: Option<&impl IsA<gio::Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<Pixbuf, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::gdk_pixbuf_new_from_stream(
                 stream.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -188,12 +193,12 @@ impl Pixbuf {
 
     #[doc(alias = "gdk_pixbuf_new_from_stream_at_scale")]
     #[doc(alias = "new_from_stream_at_scale")]
-    pub fn from_stream_at_scale(
+    pub fn from_stream_at_scale<'a, P: IsA<gio::Cancellable>>(
         stream: &impl IsA<gio::InputStream>,
         width: i32,
         height: i32,
         preserve_aspect_ratio: bool,
-        cancellable: Option<&impl IsA<gio::Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<Pixbuf, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -202,7 +207,12 @@ impl Pixbuf {
                 width,
                 height,
                 preserve_aspect_ratio.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -465,7 +475,7 @@ impl Pixbuf {
 
     //#[doc(alias = "gdk_pixbuf_get_options")]
     //#[doc(alias = "get_options")]
-    //pub fn options(&self) -> /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 0, id: 28 } {
+    //pub fn options(&self) -> /*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 0, id: 28 } {
     //    unsafe { TODO: call ffi:gdk_pixbuf_get_options() }
     //}
 
@@ -534,37 +544,37 @@ impl Pixbuf {
     }
 
     //#[doc(alias = "gdk_pixbuf_save")]
-    //pub fn save(&self, filename: impl AsRef<std::path::Path>, type_: &str, error: Option<&mut glib::Error>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> bool {
+    //pub fn save<'a>(&self, filename: impl AsRef<std::path::Path>, type_: &str, error: impl Into<Option<&'a mut  glib::Error>>, : /*Unimplemented*/Basic: VarArgs) -> bool {
     //    unsafe { TODO: call ffi:gdk_pixbuf_save() }
     //}
 
     //#[doc(alias = "gdk_pixbuf_save_to_buffer")]
-    //pub fn save_to_buffer(&self, type_: &str, error: Option<&mut glib::Error>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Option<Vec<u8>> {
+    //pub fn save_to_buffer<'a>(&self, type_: &str, error: impl Into<Option<&'a mut  glib::Error>>, : /*Unimplemented*/Basic: VarArgs) -> Option<Vec<u8>> {
     //    unsafe { TODO: call ffi:gdk_pixbuf_save_to_buffer() }
     //}
 
     //#[doc(alias = "gdk_pixbuf_save_to_callback")]
-    //pub fn save_to_callback<P: FnMut(&Vec<u8>, usize, &glib::Error) -> bool>(&self, save_func: P, type_: &str, error: Option<&mut glib::Error>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> bool {
+    //pub fn save_to_callback<'a, P: FnMut(&[u8], usize, &glib::Error) -> bool>(&self, save_func: P, type_: &str, error: impl Into<Option<&'a mut  glib::Error>>, : /*Unimplemented*/Basic: VarArgs) -> bool {
     //    unsafe { TODO: call ffi:gdk_pixbuf_save_to_callback() }
     //}
 
     //#[doc(alias = "gdk_pixbuf_save_to_callbackv")]
-    //pub fn save_to_callbackv<P: FnMut(&Vec<u8>, usize, &glib::Error) -> bool>(&self, save_func: P, type_: &str, option_keys: &[&str], option_values: &[&str]) -> Result<(), glib::Error> {
+    //pub fn save_to_callbackv<P: FnMut(&[u8], usize, &glib::Error) -> bool>(&self, save_func: P, type_: &str, option_keys: &[&str], option_values: &[&str]) -> Result<(), glib::Error> {
     //    unsafe { TODO: call ffi:gdk_pixbuf_save_to_callbackv() }
     //}
 
     //#[doc(alias = "gdk_pixbuf_save_to_stream")]
-    //pub fn save_to_stream(&self, stream: &impl IsA<gio::OutputStream>, type_: &str, cancellable: Option<&impl IsA<gio::Cancellable>>, error: Option<&mut glib::Error>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> bool {
+    //pub fn save_to_stream<'a, P: IsA<gio::Cancellable>>(&self, stream: &impl IsA<gio::OutputStream>, type_: &str, cancellable: impl Into<Option<&'a P>>, error: impl Into<Option<&'a mut  glib::Error>>, : /*Unimplemented*/Basic: VarArgs) -> bool {
     //    unsafe { TODO: call ffi:gdk_pixbuf_save_to_stream() }
     //}
 
     //#[doc(alias = "gdk_pixbuf_save_to_stream_async")]
-    //pub fn save_to_stream_async<P: FnOnce(Result<(), glib::Error>) + 'static>(&self, stream: &impl IsA<gio::OutputStream>, type_: &str, cancellable: Option<&impl IsA<gio::Cancellable>>, callback: P, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
+    //pub fn save_to_stream_async<'a, P: IsA<gio::Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(&self, stream: &impl IsA<gio::OutputStream>, type_: &str, cancellable: impl Into<Option<&'a P>>, callback: Q, : /*Unimplemented*/Basic: VarArgs) {
     //    unsafe { TODO: call ffi:gdk_pixbuf_save_to_stream_async() }
     //}
 
     //
-    //pub fn save_to_stream_future(&self, stream: &(impl IsA<gio::OutputStream> + Clone + 'static), type_: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
+    //pub fn save_to_stream_future(&self, stream: &(impl IsA<gio::OutputStream> + Clone + 'static), type_: &str, : /*Unimplemented*/Basic: VarArgs) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
 
     //let stream = stream.clone();
     //let type_ = String::from(type_);
diff --git a/gdk-pixbuf/src/auto/pixbuf_animation.rs b/gdk-pixbuf/src/auto/pixbuf_animation.rs
index 94f14d99f738..ecc1299e5af0 100644
--- a/gdk-pixbuf/src/auto/pixbuf_animation.rs
+++ b/gdk-pixbuf/src/auto/pixbuf_animation.rs
@@ -56,15 +56,20 @@ impl PixbufAnimation {
 
     #[doc(alias = "gdk_pixbuf_animation_new_from_stream")]
     #[doc(alias = "new_from_stream")]
-    pub fn from_stream(
+    pub fn from_stream<'a, P: IsA<gio::Cancellable>>(
         stream: &impl IsA<gio::InputStream>,
-        cancellable: Option<&impl IsA<gio::Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<PixbufAnimation, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::gdk_pixbuf_animation_new_from_stream(
                 stream.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -77,10 +82,14 @@ impl PixbufAnimation {
 
     #[doc(alias = "gdk_pixbuf_animation_new_from_stream_async")]
     #[doc(alias = "new_from_stream_async")]
-    pub fn from_stream_async<P: FnOnce(Result<PixbufAnimation, glib::Error>) + 'static>(
+    pub fn from_stream_async<
+        'a,
+        P: IsA<gio::Cancellable>,
+        Q: FnOnce(Result<PixbufAnimation, glib::Error>) + 'static,
+    >(
         stream: &impl IsA<gio::InputStream>,
-        cancellable: Option<&impl IsA<gio::Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -92,10 +101,10 @@ impl PixbufAnimation {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn from_stream_async_trampoline<
-            P: FnOnce(Result<PixbufAnimation, glib::Error>) + 'static,
+            Q: FnOnce(Result<PixbufAnimation, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut gio::ffi::GAsyncResult,
@@ -108,16 +117,21 @@ impl PixbufAnimation {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = from_stream_async_trampoline::<P>;
+        let callback = from_stream_async_trampoline::<Q>;
         unsafe {
             ffi::gdk_pixbuf_animation_new_from_stream_async(
                 stream.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gdk-pixbuf/src/auto/versions.txt b/gdk-pixbuf/src/auto/versions.txt
index 558f7e6574ab..b73621765b9b 100644
--- a/gdk-pixbuf/src/auto/versions.txt
+++ b/gdk-pixbuf/src/auto/versions.txt
@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ 1b34ebba86cb)
+Generated by gir (https://github.com/gtk-rs/gir @ 24f0d6639caa)
 from gir-files (https://github.com/gtk-rs/gir-files @ dfdf5ed146d5)
diff --git a/gdk-pixbuf/sys/versions.txt b/gdk-pixbuf/sys/versions.txt
index 558f7e6574ab..b73621765b9b 100644
--- a/gdk-pixbuf/sys/versions.txt
+++ b/gdk-pixbuf/sys/versions.txt
@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ 1b34ebba86cb)
+Generated by gir (https://github.com/gtk-rs/gir @ 24f0d6639caa)
 from gir-files (https://github.com/gtk-rs/gir-files @ dfdf5ed146d5)
diff --git a/gio/src/auto/action.rs b/gio/src/auto/action.rs
index fc7c7265e2a9..d2da386825bb 100644
--- a/gio/src/auto/action.rs
+++ b/gio/src/auto/action.rs
@@ -51,14 +51,14 @@ impl Action {
     }
 
     #[doc(alias = "g_action_print_detailed_name")]
-    pub fn print_detailed_name(
+    pub fn print_detailed_name<'a>(
         action_name: &str,
-        target_value: Option<&glib::Variant>,
+        target_value: impl Into<Option<&'a glib::Variant>>,
     ) -> glib::GString {
         unsafe {
             from_glib_full(ffi::g_action_print_detailed_name(
                 action_name.to_glib_none().0,
-                target_value.to_glib_none().0,
+                target_value.into().to_glib_none().0,
             ))
         }
     }
@@ -66,9 +66,12 @@ impl Action {
 
 pub trait ActionExt: IsA<Action> + 'static {
     #[doc(alias = "g_action_activate")]
-    fn activate(&self, parameter: Option<&glib::Variant>) {
+    fn activate<'a>(&self, parameter: impl Into<Option<&'a glib::Variant>>) {
         unsafe {
-            ffi::g_action_activate(self.as_ref().to_glib_none().0, parameter.to_glib_none().0);
+            ffi::g_action_activate(
+                self.as_ref().to_glib_none().0,
+                parameter.into().to_glib_none().0,
+            );
         }
     }
 
diff --git a/gio/src/auto/action_group.rs b/gio/src/auto/action_group.rs
index de2602772c82..8502d92a3fd1 100644
--- a/gio/src/auto/action_group.rs
+++ b/gio/src/auto/action_group.rs
@@ -67,12 +67,16 @@ pub trait ActionGroupExt: IsA<ActionGroup> + 'static {
     }
 
     #[doc(alias = "g_action_group_activate_action")]
-    fn activate_action(&self, action_name: &str, parameter: Option<&glib::Variant>) {
+    fn activate_action<'a>(
+        &self,
+        action_name: &str,
+        parameter: impl Into<Option<&'a glib::Variant>>,
+    ) {
         unsafe {
             ffi::g_action_group_activate_action(
                 self.as_ref().to_glib_none().0,
                 action_name.to_glib_none().0,
-                parameter.to_glib_none().0,
+                parameter.into().to_glib_none().0,
             );
         }
     }
diff --git a/gio/src/auto/app_info.rs b/gio/src/auto/app_info.rs
index e9253c9beb4d..b5aebecff10e 100644
--- a/gio/src/auto/app_info.rs
+++ b/gio/src/auto/app_info.rs
@@ -19,16 +19,16 @@ impl AppInfo {
     pub const NONE: Option<&'static AppInfo> = None;
 
     #[doc(alias = "g_app_info_create_from_commandline")]
-    pub fn create_from_commandline(
+    pub fn create_from_commandline<'a>(
         commandline: impl AsRef<std::ffi::OsStr>,
-        application_name: Option<&str>,
+        application_name: impl Into<Option<&'a str>>,
         flags: AppInfoCreateFlags,
     ) -> Result<AppInfo, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_app_info_create_from_commandline(
                 commandline.as_ref().to_glib_none().0,
-                application_name.to_glib_none().0,
+                application_name.into().to_glib_none().0,
                 flags.into_glib(),
                 &mut error,
             );
@@ -71,11 +71,15 @@ impl AppInfo {
     #[cfg_attr(docsrs, doc(cfg(feature = "v2_74")))]
     #[doc(alias = "g_app_info_get_default_for_type_async")]
     #[doc(alias = "get_default_for_type_async")]
-    pub fn default_for_type_async<P: FnOnce(Result<AppInfo, glib::Error>) + 'static>(
+    pub fn default_for_type_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<AppInfo, glib::Error>) + 'static,
+    >(
         content_type: &str,
         must_support_uris: bool,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -87,10 +91,10 @@ impl AppInfo {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn default_for_type_async_trampoline<
-            P: FnOnce(Result<AppInfo, glib::Error>) + 'static,
+            Q: FnOnce(Result<AppInfo, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -103,17 +107,22 @@ impl AppInfo {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = default_for_type_async_trampoline::<P>;
+        let callback = default_for_type_async_trampoline::<Q>;
         unsafe {
             ffi::g_app_info_get_default_for_type_async(
                 content_type.to_glib_none().0,
                 must_support_uris.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -156,10 +165,14 @@ impl AppInfo {
     #[cfg_attr(docsrs, doc(cfg(feature = "v2_74")))]
     #[doc(alias = "g_app_info_get_default_for_uri_scheme_async")]
     #[doc(alias = "get_default_for_uri_scheme_async")]
-    pub fn default_for_uri_scheme_async<P: FnOnce(Result<AppInfo, glib::Error>) + 'static>(
+    pub fn default_for_uri_scheme_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<AppInfo, glib::Error>) + 'static,
+    >(
         uri_scheme: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -171,10 +184,10 @@ impl AppInfo {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn default_for_uri_scheme_async_trampoline<
-            P: FnOnce(Result<AppInfo, glib::Error>) + 'static,
+            Q: FnOnce(Result<AppInfo, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -187,16 +200,21 @@ impl AppInfo {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = default_for_uri_scheme_async_trampoline::<P>;
+        let callback = default_for_uri_scheme_async_trampoline::<Q>;
         unsafe {
             ffi::g_app_info_get_default_for_uri_scheme_async(
                 uri_scheme.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -240,15 +258,15 @@ impl AppInfo {
     }
 
     #[doc(alias = "g_app_info_launch_default_for_uri")]
-    pub fn launch_default_for_uri(
+    pub fn launch_default_for_uri<'a, P: IsA<AppLaunchContext>>(
         uri: &str,
-        context: Option<&impl IsA<AppLaunchContext>>,
+        context: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_app_info_launch_default_for_uri(
                 uri.to_glib_none().0,
-                context.map(|p| p.as_ref()).to_glib_none().0,
+                context.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -261,11 +279,16 @@ impl AppInfo {
     }
 
     #[doc(alias = "g_app_info_launch_default_for_uri_async")]
-    pub fn launch_default_for_uri_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    pub fn launch_default_for_uri_async<
+        'a,
+        P: IsA<AppLaunchContext>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<(), glib::Error>) + 'static,
+    >(
         uri: &str,
-        context: Option<&impl IsA<AppLaunchContext>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        context: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -277,10 +300,10 @@ impl AppInfo {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn launch_default_for_uri_async_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            R: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -293,29 +316,34 @@ impl AppInfo {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = launch_default_for_uri_async_trampoline::<P>;
+        let callback = launch_default_for_uri_async_trampoline::<R>;
         unsafe {
             ffi::g_app_info_launch_default_for_uri_async(
                 uri.to_glib_none().0,
-                context.map(|p| p.as_ref()).to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                context.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    pub fn launch_default_for_uri_future(
+    pub fn launch_default_for_uri_future<'a, P: IsA<AppLaunchContext> + Clone + 'static>(
         uri: &str,
-        context: Option<&(impl IsA<AppLaunchContext> + Clone + 'static)>,
+        context: impl Into<Option<&'a P>>,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
         let uri = String::from(uri);
-        let context = context.map(ToOwned::to_owned);
+        let context = context.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             &(),
             move |_obj, cancellable, send| {
@@ -462,17 +490,17 @@ pub trait AppInfoExt: IsA<AppInfo> + 'static {
     }
 
     #[doc(alias = "g_app_info_launch")]
-    fn launch(
+    fn launch<'a, P: IsA<AppLaunchContext>>(
         &self,
         files: &[File],
-        context: Option<&impl IsA<AppLaunchContext>>,
+        context: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_app_info_launch(
                 self.as_ref().to_glib_none().0,
                 files.to_glib_none().0,
-                context.map(|p| p.as_ref()).to_glib_none().0,
+                context.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -485,17 +513,17 @@ pub trait AppInfoExt: IsA<AppInfo> + 'static {
     }
 
     #[doc(alias = "g_app_info_launch_uris")]
-    fn launch_uris(
+    fn launch_uris<'a, P: IsA<AppLaunchContext>>(
         &self,
         uris: &[&str],
-        context: Option<&impl IsA<AppLaunchContext>>,
+        context: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_app_info_launch_uris(
                 self.as_ref().to_glib_none().0,
                 uris.to_glib_none().0,
-                context.map(|p| p.as_ref()).to_glib_none().0,
+                context.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
diff --git a/gio/src/auto/app_launch_context.rs b/gio/src/auto/app_launch_context.rs
index d2f8653c3cec..27c8f9153a20 100644
--- a/gio/src/auto/app_launch_context.rs
+++ b/gio/src/auto/app_launch_context.rs
@@ -59,15 +59,15 @@ pub trait AppLaunchContextExt: IsA<AppLaunchContext> + 'static {
 
     #[doc(alias = "g_app_launch_context_get_startup_notify_id")]
     #[doc(alias = "get_startup_notify_id")]
-    fn startup_notify_id(
+    fn startup_notify_id<'a, P: IsA<AppInfo>>(
         &self,
-        info: Option<&impl IsA<AppInfo>>,
+        info: impl Into<Option<&'a P>>,
         files: &[File],
     ) -> Option<glib::GString> {
         unsafe {
             from_glib_full(ffi::g_app_launch_context_get_startup_notify_id(
                 self.as_ref().to_glib_none().0,
-                info.map(|p| p.as_ref()).to_glib_none().0,
+                info.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
                 files.to_glib_none().0,
             ))
         }
diff --git a/gio/src/auto/application.rs b/gio/src/auto/application.rs
index 1f0be0c90db3..aa6599ae90ea 100644
--- a/gio/src/auto/application.rs
+++ b/gio/src/auto/application.rs
@@ -26,10 +26,13 @@ impl Application {
     pub const NONE: Option<&'static Application> = None;
 
     #[doc(alias = "g_application_new")]
-    pub fn new(application_id: Option<&str>, flags: ApplicationFlags) -> Application {
+    pub fn new<'a>(
+        application_id: impl Into<Option<&'a str>>,
+        flags: ApplicationFlags,
+    ) -> Application {
         unsafe {
             from_glib_full(ffi::g_application_new(
-                application_id.to_glib_none().0,
+                application_id.into().to_glib_none().0,
                 flags.into_glib(),
             ))
         }
@@ -82,7 +85,7 @@ impl ApplicationBuilder {
         }
     }
 
-    pub fn application_id(self, application_id: impl Into<glib::GString>) -> Self {
+    pub fn application_id<'a>(self, application_id: impl Into<Option<&'a str>>) -> Self {
         Self {
             builder: self
                 .builder
@@ -104,7 +107,7 @@ impl ApplicationBuilder {
         }
     }
 
-    pub fn resource_base_path(self, resource_base_path: impl Into<glib::GString>) -> Self {
+    pub fn resource_base_path<'a>(self, resource_base_path: impl Into<Option<&'a str>>) -> Self {
         Self {
             builder: self
                 .builder
@@ -114,7 +117,7 @@ impl ApplicationBuilder {
 
     #[cfg(feature = "v2_80")]
     #[cfg_attr(docsrs, doc(cfg(feature = "v2_80")))]
-    pub fn version(self, version: impl Into<glib::GString>) -> Self {
+    pub fn version<'a>(self, version: impl Into<Option<&'a str>>) -> Self {
         Self {
             builder: self.builder.property("version", version.into()),
         }
@@ -137,14 +140,14 @@ pub trait ApplicationExt: IsA<Application> + 'static {
     }
 
     #[doc(alias = "g_application_add_main_option")]
-    fn add_main_option(
+    fn add_main_option<'a>(
         &self,
         long_name: &str,
         short_name: glib::Char,
         flags: glib::OptionFlags,
         arg: glib::OptionArg,
         description: &str,
-        arg_description: Option<&str>,
+        arg_description: impl Into<Option<&'a str>>,
     ) {
         unsafe {
             ffi::g_application_add_main_option(
@@ -154,7 +157,7 @@ pub trait ApplicationExt: IsA<Application> + 'static {
                 flags.into_glib(),
                 arg.into_glib(),
                 description.to_glib_none().0,
-                arg_description.to_glib_none().0,
+                arg_description.into().to_glib_none().0,
             );
         }
     }
@@ -301,12 +304,20 @@ pub trait ApplicationExt: IsA<Application> + 'static {
     }
 
     #[doc(alias = "g_application_register")]
-    fn register(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
+    fn register<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_application_register(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -319,11 +330,11 @@ pub trait ApplicationExt: IsA<Application> + 'static {
     }
 
     #[doc(alias = "g_application_send_notification")]
-    fn send_notification(&self, id: Option<&str>, notification: &Notification) {
+    fn send_notification<'a>(&self, id: impl Into<Option<&'a str>>, notification: &Notification) {
         unsafe {
             ffi::g_application_send_notification(
                 self.as_ref().to_glib_none().0,
-                id.to_glib_none().0,
+                id.into().to_glib_none().0,
                 notification.to_glib_none().0,
             );
         }
@@ -331,11 +342,11 @@ pub trait ApplicationExt: IsA<Application> + 'static {
 
     #[doc(alias = "g_application_set_application_id")]
     #[doc(alias = "application-id")]
-    fn set_application_id(&self, application_id: Option<&str>) {
+    fn set_application_id<'a>(&self, application_id: impl Into<Option<&'a str>>) {
         unsafe {
             ffi::g_application_set_application_id(
                 self.as_ref().to_glib_none().0,
-                application_id.to_glib_none().0,
+                application_id.into().to_glib_none().0,
             );
         }
     }
@@ -367,42 +378,45 @@ pub trait ApplicationExt: IsA<Application> + 'static {
     }
 
     #[doc(alias = "g_application_set_option_context_description")]
-    fn set_option_context_description(&self, description: Option<&str>) {
+    fn set_option_context_description<'a>(&self, description: impl Into<Option<&'a str>>) {
         unsafe {
             ffi::g_application_set_option_context_description(
                 self.as_ref().to_glib_none().0,
-                description.to_glib_none().0,
+                description.into().to_glib_none().0,
             );
         }
     }
 
     #[doc(alias = "g_application_set_option_context_parameter_string")]
-    fn set_option_context_parameter_string(&self, parameter_string: Option<&str>) {
+    fn set_option_context_parameter_string<'a>(
+        &self,
+        parameter_string: impl Into<Option<&'a str>>,
+    ) {
         unsafe {
             ffi::g_application_set_option_context_parameter_string(
                 self.as_ref().to_glib_none().0,
-                parameter_string.to_glib_none().0,
+                parameter_string.into().to_glib_none().0,
             );
         }
     }
 
     #[doc(alias = "g_application_set_option_context_summary")]
-    fn set_option_context_summary(&self, summary: Option<&str>) {
+    fn set_option_context_summary<'a>(&self, summary: impl Into<Option<&'a str>>) {
         unsafe {
             ffi::g_application_set_option_context_summary(
                 self.as_ref().to_glib_none().0,
-                summary.to_glib_none().0,
+                summary.into().to_glib_none().0,
             );
         }
     }
 
     #[doc(alias = "g_application_set_resource_base_path")]
     #[doc(alias = "resource-base-path")]
-    fn set_resource_base_path(&self, resource_path: Option<&str>) {
+    fn set_resource_base_path<'a>(&self, resource_path: impl Into<Option<&'a str>>) {
         unsafe {
             ffi::g_application_set_resource_base_path(
                 self.as_ref().to_glib_none().0,
-                resource_path.to_glib_none().0,
+                resource_path.into().to_glib_none().0,
             );
         }
     }
diff --git a/gio/src/auto/application_command_line.rs b/gio/src/auto/application_command_line.rs
index 51ccbb676a9c..55c34759cff0 100644
--- a/gio/src/auto/application_command_line.rs
+++ b/gio/src/auto/application_command_line.rs
@@ -137,7 +137,7 @@ pub trait ApplicationCommandLineExt: IsA<ApplicationCommandLine> + 'static {
     }
 
     //#[doc(alias = "g_application_command_line_print")]
-    //fn print(&self, format: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
+    //fn print(&self, format: &str, : /*Unimplemented*/Basic: VarArgs) {
     //    unsafe { TODO: call ffi:g_application_command_line_print() }
     //}
 
@@ -154,7 +154,7 @@ pub trait ApplicationCommandLineExt: IsA<ApplicationCommandLine> + 'static {
     }
 
     //#[doc(alias = "g_application_command_line_printerr")]
-    //fn printerr(&self, format: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
+    //fn printerr(&self, format: &str, : /*Unimplemented*/Basic: VarArgs) {
     //    unsafe { TODO: call ffi:g_application_command_line_printerr() }
     //}
 
diff --git a/gio/src/auto/async_initable.rs b/gio/src/auto/async_initable.rs
index 1bca5e03cd1f..86c150f510d6 100644
--- a/gio/src/auto/async_initable.rs
+++ b/gio/src/auto/async_initable.rs
@@ -21,11 +21,11 @@ impl AsyncInitable {
 
 pub trait AsyncInitableExt: IsA<AsyncInitable> + 'static {
     #[doc(alias = "g_async_initable_init_async")]
-    unsafe fn init_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    unsafe fn init_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -37,9 +37,9 @@ pub trait AsyncInitableExt: IsA<AsyncInitable> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
-        unsafe extern "C" fn init_async_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
+        unsafe extern "C" fn init_async_trampoline<Q: FnOnce(Result<(), glib::Error>) + 'static>(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
             user_data: glib::ffi::gpointer,
@@ -51,16 +51,21 @@ pub trait AsyncInitableExt: IsA<AsyncInitable> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = init_async_trampoline::<P>;
+        let callback = init_async_trampoline::<Q>;
         ffi::g_async_initable_init_async(
             self.as_ref().to_glib_none().0,
             io_priority.into_glib(),
-            cancellable.map(|p| p.as_ref()).to_glib_none().0,
+            cancellable
+                .into()
+                .as_ref()
+                .map(|p| p.as_ref())
+                .to_glib_none()
+                .0,
             Some(callback),
             Box_::into_raw(user_data) as *mut _,
         );
diff --git a/gio/src/auto/buffered_input_stream.rs b/gio/src/auto/buffered_input_stream.rs
index 9d67441ffb31..26233e63ecac 100644
--- a/gio/src/auto/buffered_input_stream.rs
+++ b/gio/src/auto/buffered_input_stream.rs
@@ -80,11 +80,15 @@ impl BufferedInputStreamBuilder {
         }
     }
 
-    pub fn base_stream(self, base_stream: &impl IsA<InputStream>) -> Self {
+    pub fn base_stream<'a, P: IsA<InputStream>>(
+        self,
+        base_stream: impl Into<Option<&'a P>>,
+    ) -> Self {
         Self {
-            builder: self
-                .builder
-                .property("base-stream", base_stream.clone().upcast()),
+            builder: self.builder.property(
+                "base-stream",
+                base_stream.into().as_ref().map(|p| p.as_ref()),
+            ),
         }
     }
 
@@ -106,17 +110,22 @@ impl BufferedInputStreamBuilder {
 
 pub trait BufferedInputStreamExt: IsA<BufferedInputStream> + 'static {
     #[doc(alias = "g_buffered_input_stream_fill")]
-    fn fill(
+    fn fill<'a, P: IsA<Cancellable>>(
         &self,
         count: isize,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<isize, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_buffered_input_stream_fill(
                 self.as_ref().to_glib_none().0,
                 count,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -128,12 +137,12 @@ pub trait BufferedInputStreamExt: IsA<BufferedInputStream> + 'static {
     }
 
     #[doc(alias = "g_buffered_input_stream_fill_async")]
-    fn fill_async<P: FnOnce(Result<isize, glib::Error>) + 'static>(
+    fn fill_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<isize, glib::Error>) + 'static>(
         &self,
         count: isize,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -145,10 +154,10 @@ pub trait BufferedInputStreamExt: IsA<BufferedInputStream> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn fill_async_trampoline<
-            P: FnOnce(Result<isize, glib::Error>) + 'static,
+            Q: FnOnce(Result<isize, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -162,18 +171,23 @@ pub trait BufferedInputStreamExt: IsA<BufferedInputStream> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = fill_async_trampoline::<P>;
+        let callback = fill_async_trampoline::<Q>;
         unsafe {
             ffi::g_buffered_input_stream_fill_async(
                 self.as_ref().to_glib_none().0,
                 count,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -224,12 +238,20 @@ pub trait BufferedInputStreamExt: IsA<BufferedInputStream> + 'static {
     }
 
     #[doc(alias = "g_buffered_input_stream_read_byte")]
-    fn read_byte(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<i32, glib::Error> {
+    fn read_byte<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<i32, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_buffered_input_stream_read_byte(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
diff --git a/gio/src/auto/buffered_output_stream.rs b/gio/src/auto/buffered_output_stream.rs
index cbd42e5d6d81..8ec6fbe83834 100644
--- a/gio/src/auto/buffered_output_stream.rs
+++ b/gio/src/auto/buffered_output_stream.rs
@@ -86,11 +86,15 @@ impl BufferedOutputStreamBuilder {
         }
     }
 
-    pub fn base_stream(self, base_stream: &impl IsA<OutputStream>) -> Self {
+    pub fn base_stream<'a, P: IsA<OutputStream>>(
+        self,
+        base_stream: impl Into<Option<&'a P>>,
+    ) -> Self {
         Self {
-            builder: self
-                .builder
-                .property("base-stream", base_stream.clone().upcast()),
+            builder: self.builder.property(
+                "base-stream",
+                base_stream.into().as_ref().map(|p| p.as_ref()),
+            ),
         }
     }
 
diff --git a/gio/src/auto/charset_converter.rs b/gio/src/auto/charset_converter.rs
index a1e345f937c5..2b9eaa4f399a 100644
--- a/gio/src/auto/charset_converter.rs
+++ b/gio/src/auto/charset_converter.rs
@@ -129,13 +129,13 @@ impl CharsetConverterBuilder {
         }
     }
 
-    pub fn from_charset(self, from_charset: impl Into<glib::GString>) -> Self {
+    pub fn from_charset<'a>(self, from_charset: impl Into<Option<&'a str>>) -> Self {
         Self {
             builder: self.builder.property("from-charset", from_charset.into()),
         }
     }
 
-    pub fn to_charset(self, to_charset: impl Into<glib::GString>) -> Self {
+    pub fn to_charset<'a>(self, to_charset: impl Into<Option<&'a str>>) -> Self {
         Self {
             builder: self.builder.property("to-charset", to_charset.into()),
         }
diff --git a/gio/src/auto/converter_input_stream.rs b/gio/src/auto/converter_input_stream.rs
index 2226da532eb1..f39a473f97fd 100644
--- a/gio/src/auto/converter_input_stream.rs
+++ b/gio/src/auto/converter_input_stream.rs
@@ -62,19 +62,23 @@ impl ConverterInputStreamBuilder {
         }
     }
 
-    pub fn converter(self, converter: &impl IsA<Converter>) -> Self {
+    pub fn converter<'a, P: IsA<Converter>>(self, converter: impl Into<Option<&'a P>>) -> Self {
         Self {
             builder: self
                 .builder
-                .property("converter", converter.clone().upcast()),
+                .property("converter", converter.into().as_ref().map(|p| p.as_ref())),
         }
     }
 
-    pub fn base_stream(self, base_stream: &impl IsA<InputStream>) -> Self {
+    pub fn base_stream<'a, P: IsA<InputStream>>(
+        self,
+        base_stream: impl Into<Option<&'a P>>,
+    ) -> Self {
         Self {
-            builder: self
-                .builder
-                .property("base-stream", base_stream.clone().upcast()),
+            builder: self.builder.property(
+                "base-stream",
+                base_stream.into().as_ref().map(|p| p.as_ref()),
+            ),
         }
     }
 
diff --git a/gio/src/auto/converter_output_stream.rs b/gio/src/auto/converter_output_stream.rs
index c4d4c4482eb9..692e21afa744 100644
--- a/gio/src/auto/converter_output_stream.rs
+++ b/gio/src/auto/converter_output_stream.rs
@@ -62,19 +62,23 @@ impl ConverterOutputStreamBuilder {
         }
     }
 
-    pub fn converter(self, converter: &impl IsA<Converter>) -> Self {
+    pub fn converter<'a, P: IsA<Converter>>(self, converter: impl Into<Option<&'a P>>) -> Self {
         Self {
             builder: self
                 .builder
-                .property("converter", converter.clone().upcast()),
+                .property("converter", converter.into().as_ref().map(|p| p.as_ref())),
         }
     }
 
-    pub fn base_stream(self, base_stream: &impl IsA<OutputStream>) -> Self {
+    pub fn base_stream<'a, P: IsA<OutputStream>>(
+        self,
+        base_stream: impl Into<Option<&'a P>>,
+    ) -> Self {
         Self {
-            builder: self
-                .builder
-                .property("base-stream", base_stream.clone().upcast()),
+            builder: self.builder.property(
+                "base-stream",
+                base_stream.into().as_ref().map(|p| p.as_ref()),
+            ),
         }
     }
 
diff --git a/gio/src/auto/data_input_stream.rs b/gio/src/auto/data_input_stream.rs
index 301f8903d8ef..d0129b722cce 100644
--- a/gio/src/auto/data_input_stream.rs
+++ b/gio/src/auto/data_input_stream.rs
@@ -83,11 +83,15 @@ impl DataInputStreamBuilder {
         }
     }
 
-    pub fn base_stream(self, base_stream: &impl IsA<InputStream>) -> Self {
+    pub fn base_stream<'a, P: IsA<InputStream>>(
+        self,
+        base_stream: impl Into<Option<&'a P>>,
+    ) -> Self {
         Self {
-            builder: self
-                .builder
-                .property("base-stream", base_stream.clone().upcast()),
+            builder: self.builder.property(
+                "base-stream",
+                base_stream.into().as_ref().map(|p| p.as_ref()),
+            ),
         }
     }
 
@@ -131,12 +135,20 @@ pub trait DataInputStreamExt: IsA<DataInputStream> + 'static {
     }
 
     #[doc(alias = "g_data_input_stream_read_byte")]
-    fn read_byte(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<u8, glib::Error> {
+    fn read_byte<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<u8, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_data_input_stream_read_byte(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -148,12 +160,20 @@ pub trait DataInputStreamExt: IsA<DataInputStream> + 'static {
     }
 
     #[doc(alias = "g_data_input_stream_read_int16")]
-    fn read_int16(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<i16, glib::Error> {
+    fn read_int16<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<i16, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_data_input_stream_read_int16(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -165,12 +185,20 @@ pub trait DataInputStreamExt: IsA<DataInputStream> + 'static {
     }
 
     #[doc(alias = "g_data_input_stream_read_int32")]
-    fn read_int32(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<i32, glib::Error> {
+    fn read_int32<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<i32, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_data_input_stream_read_int32(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -182,12 +210,20 @@ pub trait DataInputStreamExt: IsA<DataInputStream> + 'static {
     }
 
     #[doc(alias = "g_data_input_stream_read_int64")]
-    fn read_int64(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<i64, glib::Error> {
+    fn read_int64<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<i64, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_data_input_stream_read_int64(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -199,12 +235,20 @@ pub trait DataInputStreamExt: IsA<DataInputStream> + 'static {
     }
 
     #[doc(alias = "g_data_input_stream_read_uint16")]
-    fn read_uint16(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<u16, glib::Error> {
+    fn read_uint16<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<u16, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_data_input_stream_read_uint16(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -216,12 +260,20 @@ pub trait DataInputStreamExt: IsA<DataInputStream> + 'static {
     }
 
     #[doc(alias = "g_data_input_stream_read_uint32")]
-    fn read_uint32(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<u32, glib::Error> {
+    fn read_uint32<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<u32, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_data_input_stream_read_uint32(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -233,12 +285,20 @@ pub trait DataInputStreamExt: IsA<DataInputStream> + 'static {
     }
 
     #[doc(alias = "g_data_input_stream_read_uint64")]
-    fn read_uint64(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<u64, glib::Error> {
+    fn read_uint64<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<u64, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_data_input_stream_read_uint64(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
diff --git a/gio/src/auto/data_output_stream.rs b/gio/src/auto/data_output_stream.rs
index 392beaf34f8f..7c17a583314a 100644
--- a/gio/src/auto/data_output_stream.rs
+++ b/gio/src/auto/data_output_stream.rs
@@ -68,11 +68,15 @@ impl DataOutputStreamBuilder {
         }
     }
 
-    pub fn base_stream(self, base_stream: &impl IsA<OutputStream>) -> Self {
+    pub fn base_stream<'a, P: IsA<OutputStream>>(
+        self,
+        base_stream: impl Into<Option<&'a P>>,
+    ) -> Self {
         Self {
-            builder: self
-                .builder
-                .property("base-stream", base_stream.clone().upcast()),
+            builder: self.builder.property(
+                "base-stream",
+                base_stream.into().as_ref().map(|p| p.as_ref()),
+            ),
         }
     }
 
@@ -105,17 +109,22 @@ pub trait DataOutputStreamExt: IsA<DataOutputStream> + 'static {
     }
 
     #[doc(alias = "g_data_output_stream_put_byte")]
-    fn put_byte(
+    fn put_byte<'a, P: IsA<Cancellable>>(
         &self,
         data: u8,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_data_output_stream_put_byte(
                 self.as_ref().to_glib_none().0,
                 data,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -128,17 +137,22 @@ pub trait DataOutputStreamExt: IsA<DataOutputStream> + 'static {
     }
 
     #[doc(alias = "g_data_output_stream_put_int16")]
-    fn put_int16(
+    fn put_int16<'a, P: IsA<Cancellable>>(
         &self,
         data: i16,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_data_output_stream_put_int16(
                 self.as_ref().to_glib_none().0,
                 data,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -151,17 +165,22 @@ pub trait DataOutputStreamExt: IsA<DataOutputStream> + 'static {
     }
 
     #[doc(alias = "g_data_output_stream_put_int32")]
-    fn put_int32(
+    fn put_int32<'a, P: IsA<Cancellable>>(
         &self,
         data: i32,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_data_output_stream_put_int32(
                 self.as_ref().to_glib_none().0,
                 data,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -174,17 +193,22 @@ pub trait DataOutputStreamExt: IsA<DataOutputStream> + 'static {
     }
 
     #[doc(alias = "g_data_output_stream_put_int64")]
-    fn put_int64(
+    fn put_int64<'a, P: IsA<Cancellable>>(
         &self,
         data: i64,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_data_output_stream_put_int64(
                 self.as_ref().to_glib_none().0,
                 data,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -197,17 +221,22 @@ pub trait DataOutputStreamExt: IsA<DataOutputStream> + 'static {
     }
 
     #[doc(alias = "g_data_output_stream_put_string")]
-    fn put_string(
+    fn put_string<'a, P: IsA<Cancellable>>(
         &self,
         str: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_data_output_stream_put_string(
                 self.as_ref().to_glib_none().0,
                 str.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -220,17 +249,22 @@ pub trait DataOutputStreamExt: IsA<DataOutputStream> + 'static {
     }
 
     #[doc(alias = "g_data_output_stream_put_uint16")]
-    fn put_uint16(
+    fn put_uint16<'a, P: IsA<Cancellable>>(
         &self,
         data: u16,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_data_output_stream_put_uint16(
                 self.as_ref().to_glib_none().0,
                 data,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -243,17 +277,22 @@ pub trait DataOutputStreamExt: IsA<DataOutputStream> + 'static {
     }
 
     #[doc(alias = "g_data_output_stream_put_uint32")]
-    fn put_uint32(
+    fn put_uint32<'a, P: IsA<Cancellable>>(
         &self,
         data: u32,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_data_output_stream_put_uint32(
                 self.as_ref().to_glib_none().0,
                 data,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -266,17 +305,22 @@ pub trait DataOutputStreamExt: IsA<DataOutputStream> + 'static {
     }
 
     #[doc(alias = "g_data_output_stream_put_uint64")]
-    fn put_uint64(
+    fn put_uint64<'a, P: IsA<Cancellable>>(
         &self,
         data: u64,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_data_output_stream_put_uint64(
                 self.as_ref().to_glib_none().0,
                 data,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
diff --git a/gio/src/auto/dbus_action_group.rs b/gio/src/auto/dbus_action_group.rs
index 002006aaa0f2..e9d4d8019f76 100644
--- a/gio/src/auto/dbus_action_group.rs
+++ b/gio/src/auto/dbus_action_group.rs
@@ -16,15 +16,15 @@ glib::wrapper! {
 
 impl DBusActionGroup {
     #[doc(alias = "g_dbus_action_group_get")]
-    pub fn get(
+    pub fn get<'a>(
         connection: &DBusConnection,
-        bus_name: Option<&str>,
+        bus_name: impl Into<Option<&'a str>>,
         object_path: &str,
     ) -> DBusActionGroup {
         unsafe {
             from_glib_full(ffi::g_dbus_action_group_get(
                 connection.to_glib_none().0,
-                bus_name.to_glib_none().0,
+                bus_name.into().to_glib_none().0,
                 object_path.to_glib_none().0,
             ))
         }
diff --git a/gio/src/auto/dbus_auth_observer.rs b/gio/src/auto/dbus_auth_observer.rs
index 56a26c07ba6a..5e03833470ff 100644
--- a/gio/src/auto/dbus_auth_observer.rs
+++ b/gio/src/auto/dbus_auth_observer.rs
@@ -36,16 +36,16 @@ impl DBusAuthObserver {
     }
 
     #[doc(alias = "g_dbus_auth_observer_authorize_authenticated_peer")]
-    pub fn authorize_authenticated_peer(
+    pub fn authorize_authenticated_peer<'a>(
         &self,
         stream: &impl IsA<IOStream>,
-        credentials: Option<&Credentials>,
+        credentials: impl Into<Option<&'a Credentials>>,
     ) -> bool {
         unsafe {
             from_glib(ffi::g_dbus_auth_observer_authorize_authenticated_peer(
                 self.to_glib_none().0,
                 stream.as_ref().to_glib_none().0,
-                credentials.to_glib_none().0,
+                credentials.into().to_glib_none().0,
             ))
         }
     }
diff --git a/gio/src/auto/dbus_connection.rs b/gio/src/auto/dbus_connection.rs
index 9867d4834418..a84858001ea7 100644
--- a/gio/src/auto/dbus_connection.rs
+++ b/gio/src/auto/dbus_connection.rs
@@ -29,19 +29,24 @@ glib::wrapper! {
 impl DBusConnection {
     #[doc(alias = "g_dbus_connection_new_for_address_sync")]
     #[doc(alias = "new_for_address_sync")]
-    pub fn for_address_sync(
+    pub fn for_address_sync<'a, P: IsA<Cancellable>>(
         address: &str,
         flags: DBusConnectionFlags,
-        observer: Option<&DBusAuthObserver>,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        observer: impl Into<Option<&'a DBusAuthObserver>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<DBusConnection, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_dbus_connection_new_for_address_sync(
                 address.to_glib_none().0,
                 flags.into_glib(),
-                observer.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                observer.into().to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -53,21 +58,26 @@ impl DBusConnection {
     }
 
     #[doc(alias = "g_dbus_connection_new_sync")]
-    pub fn new_sync(
+    pub fn new_sync<'a, P: IsA<Cancellable>>(
         stream: &impl IsA<IOStream>,
-        guid: Option<&str>,
+        guid: impl Into<Option<&'a str>>,
         flags: DBusConnectionFlags,
-        observer: Option<&DBusAuthObserver>,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        observer: impl Into<Option<&'a DBusAuthObserver>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<DBusConnection, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_dbus_connection_new_sync(
                 stream.as_ref().to_glib_none().0,
-                guid.to_glib_none().0,
+                guid.into().to_glib_none().0,
                 flags.into_glib(),
-                observer.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                observer.into().to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -79,18 +89,22 @@ impl DBusConnection {
     }
 
     #[doc(alias = "g_dbus_connection_call")]
-    pub fn call<P: FnOnce(Result<glib::Variant, glib::Error>) + 'static>(
+    pub fn call<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<glib::Variant, glib::Error>) + 'static,
+    >(
         &self,
-        bus_name: Option<&str>,
+        bus_name: impl Into<Option<&'a str>>,
         object_path: &str,
         interface_name: &str,
         method_name: &str,
-        parameters: Option<&glib::Variant>,
-        reply_type: Option<&glib::VariantTy>,
+        parameters: impl Into<Option<&'a glib::Variant>>,
+        reply_type: impl Into<Option<&'a glib::VariantTy>>,
         flags: DBusCallFlags,
         timeout_msec: i32,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -102,10 +116,10 @@ impl DBusConnection {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn call_trampoline<
-            P: FnOnce(Result<glib::Variant, glib::Error>) + 'static,
+            Q: FnOnce(Result<glib::Variant, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -118,48 +132,53 @@ impl DBusConnection {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = call_trampoline::<P>;
+        let callback = call_trampoline::<Q>;
         unsafe {
             ffi::g_dbus_connection_call(
                 self.to_glib_none().0,
-                bus_name.to_glib_none().0,
+                bus_name.into().to_glib_none().0,
                 object_path.to_glib_none().0,
                 interface_name.to_glib_none().0,
                 method_name.to_glib_none().0,
-                parameters.to_glib_none().0,
-                reply_type.to_glib_none().0,
+                parameters.into().to_glib_none().0,
+                reply_type.into().to_glib_none().0,
                 flags.into_glib(),
                 timeout_msec,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    pub fn call_future(
+    pub fn call_future<'a>(
         &self,
-        bus_name: Option<&str>,
+        bus_name: impl Into<Option<&'a str>>,
         object_path: &str,
         interface_name: &str,
         method_name: &str,
-        parameters: Option<&glib::Variant>,
-        reply_type: Option<&glib::VariantTy>,
+        parameters: impl Into<Option<&'a glib::Variant>>,
+        reply_type: impl Into<Option<&'a glib::VariantTy>>,
         flags: DBusCallFlags,
         timeout_msec: i32,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::Variant, glib::Error>> + 'static>>
     {
-        let bus_name = bus_name.map(ToOwned::to_owned);
+        let bus_name = bus_name.into().map(ToOwned::to_owned);
         let object_path = String::from(object_path);
         let interface_name = String::from(interface_name);
         let method_name = String::from(method_name);
-        let parameters = parameters.map(ToOwned::to_owned);
-        let reply_type = reply_type.map(ToOwned::to_owned);
+        let parameters = parameters.into().map(ToOwned::to_owned);
+        let reply_type = reply_type.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -182,31 +201,36 @@ impl DBusConnection {
     }
 
     #[doc(alias = "g_dbus_connection_call_sync")]
-    pub fn call_sync(
+    pub fn call_sync<'a, P: IsA<Cancellable>>(
         &self,
-        bus_name: Option<&str>,
+        bus_name: impl Into<Option<&'a str>>,
         object_path: &str,
         interface_name: &str,
         method_name: &str,
-        parameters: Option<&glib::Variant>,
-        reply_type: Option<&glib::VariantTy>,
+        parameters: impl Into<Option<&'a glib::Variant>>,
+        reply_type: impl Into<Option<&'a glib::VariantTy>>,
         flags: DBusCallFlags,
         timeout_msec: i32,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<glib::Variant, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_dbus_connection_call_sync(
                 self.to_glib_none().0,
-                bus_name.to_glib_none().0,
+                bus_name.into().to_glib_none().0,
                 object_path.to_glib_none().0,
                 interface_name.to_glib_none().0,
                 method_name.to_glib_none().0,
-                parameters.to_glib_none().0,
-                reply_type.to_glib_none().0,
+                parameters.into().to_glib_none().0,
+                reply_type.into().to_glib_none().0,
                 flags.into_glib(),
                 timeout_msec,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -221,20 +245,23 @@ impl DBusConnection {
     #[cfg_attr(docsrs, doc(cfg(unix)))]
     #[doc(alias = "g_dbus_connection_call_with_unix_fd_list")]
     pub fn call_with_unix_fd_list<
-        P: FnOnce(Result<(glib::Variant, UnixFDList), glib::Error>) + 'static,
+        'a,
+        P: IsA<UnixFDList>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<(glib::Variant, UnixFDList), glib::Error>) + 'static,
     >(
         &self,
-        bus_name: Option<&str>,
+        bus_name: impl Into<Option<&'a str>>,
         object_path: &str,
         interface_name: &str,
         method_name: &str,
-        parameters: Option<&glib::Variant>,
-        reply_type: Option<&glib::VariantTy>,
+        parameters: impl Into<Option<&'a glib::Variant>>,
+        reply_type: impl Into<Option<&'a glib::VariantTy>>,
         flags: DBusCallFlags,
         timeout_msec: i32,
-        fd_list: Option<&impl IsA<UnixFDList>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        fd_list: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -246,10 +273,10 @@ impl DBusConnection {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn call_with_unix_fd_list_trampoline<
-            P: FnOnce(Result<(glib::Variant, UnixFDList), glib::Error>) + 'static,
+            R: FnOnce(Result<(glib::Variant, UnixFDList), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -268,25 +295,30 @@ impl DBusConnection {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = call_with_unix_fd_list_trampoline::<P>;
+        let callback = call_with_unix_fd_list_trampoline::<R>;
         unsafe {
             ffi::g_dbus_connection_call_with_unix_fd_list(
                 self.to_glib_none().0,
-                bus_name.to_glib_none().0,
+                bus_name.into().to_glib_none().0,
                 object_path.to_glib_none().0,
                 interface_name.to_glib_none().0,
                 method_name.to_glib_none().0,
-                parameters.to_glib_none().0,
-                reply_type.to_glib_none().0,
+                parameters.into().to_glib_none().0,
+                reply_type.into().to_glib_none().0,
                 flags.into_glib(),
                 timeout_msec,
-                fd_list.map(|p| p.as_ref()).to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                fd_list.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -295,30 +327,30 @@ impl DBusConnection {
 
     #[cfg(unix)]
     #[cfg_attr(docsrs, doc(cfg(unix)))]
-    pub fn call_with_unix_fd_list_future(
+    pub fn call_with_unix_fd_list_future<'a, P: IsA<UnixFDList> + Clone + 'static>(
         &self,
-        bus_name: Option<&str>,
+        bus_name: impl Into<Option<&'a str>>,
         object_path: &str,
         interface_name: &str,
         method_name: &str,
-        parameters: Option<&glib::Variant>,
-        reply_type: Option<&glib::VariantTy>,
+        parameters: impl Into<Option<&'a glib::Variant>>,
+        reply_type: impl Into<Option<&'a glib::VariantTy>>,
         flags: DBusCallFlags,
         timeout_msec: i32,
-        fd_list: Option<&(impl IsA<UnixFDList> + Clone + 'static)>,
+        fd_list: impl Into<Option<&'a P>>,
     ) -> Pin<
         Box_<
             dyn std::future::Future<Output = Result<(glib::Variant, UnixFDList), glib::Error>>
                 + 'static,
         >,
     > {
-        let bus_name = bus_name.map(ToOwned::to_owned);
+        let bus_name = bus_name.into().map(ToOwned::to_owned);
         let object_path = String::from(object_path);
         let interface_name = String::from(interface_name);
         let method_name = String::from(method_name);
-        let parameters = parameters.map(ToOwned::to_owned);
-        let reply_type = reply_type.map(ToOwned::to_owned);
-        let fd_list = fd_list.map(ToOwned::to_owned);
+        let parameters = parameters.into().map(ToOwned::to_owned);
+        let reply_type = reply_type.into().map(ToOwned::to_owned);
+        let fd_list = fd_list.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -344,35 +376,40 @@ impl DBusConnection {
     #[cfg(unix)]
     #[cfg_attr(docsrs, doc(cfg(unix)))]
     #[doc(alias = "g_dbus_connection_call_with_unix_fd_list_sync")]
-    pub fn call_with_unix_fd_list_sync(
+    pub fn call_with_unix_fd_list_sync<'a, P: IsA<UnixFDList>, Q: IsA<Cancellable>>(
         &self,
-        bus_name: Option<&str>,
+        bus_name: impl Into<Option<&'a str>>,
         object_path: &str,
         interface_name: &str,
         method_name: &str,
-        parameters: Option<&glib::Variant>,
-        reply_type: Option<&glib::VariantTy>,
+        parameters: impl Into<Option<&'a glib::Variant>>,
+        reply_type: impl Into<Option<&'a glib::VariantTy>>,
         flags: DBusCallFlags,
         timeout_msec: i32,
-        fd_list: Option<&impl IsA<UnixFDList>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        fd_list: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
     ) -> Result<(glib::Variant, UnixFDList), glib::Error> {
         unsafe {
             let mut out_fd_list = std::ptr::null_mut();
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_dbus_connection_call_with_unix_fd_list_sync(
                 self.to_glib_none().0,
-                bus_name.to_glib_none().0,
+                bus_name.into().to_glib_none().0,
                 object_path.to_glib_none().0,
                 interface_name.to_glib_none().0,
                 method_name.to_glib_none().0,
-                parameters.to_glib_none().0,
-                reply_type.to_glib_none().0,
+                parameters.into().to_glib_none().0,
+                reply_type.into().to_glib_none().0,
                 flags.into_glib(),
                 timeout_msec,
-                fd_list.map(|p| p.as_ref()).to_glib_none().0,
+                fd_list.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
                 &mut out_fd_list,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -384,10 +421,10 @@ impl DBusConnection {
     }
 
     #[doc(alias = "g_dbus_connection_close")]
-    pub fn close<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    pub fn close<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -399,9 +436,9 @@ impl DBusConnection {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
-        unsafe extern "C" fn close_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
+        unsafe extern "C" fn close_trampoline<Q: FnOnce(Result<(), glib::Error>) + 'static>(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
             user_data: glib::ffi::gpointer,
@@ -413,16 +450,21 @@ impl DBusConnection {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = close_trampoline::<P>;
+        let callback = close_trampoline::<Q>;
         unsafe {
             ffi::g_dbus_connection_close(
                 self.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -443,15 +485,20 @@ impl DBusConnection {
     }
 
     #[doc(alias = "g_dbus_connection_close_sync")]
-    pub fn close_sync(
+    pub fn close_sync<'a, P: IsA<Cancellable>>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_dbus_connection_close_sync(
                 self.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -464,23 +511,23 @@ impl DBusConnection {
     }
 
     #[doc(alias = "g_dbus_connection_emit_signal")]
-    pub fn emit_signal(
+    pub fn emit_signal<'a>(
         &self,
-        destination_bus_name: Option<&str>,
+        destination_bus_name: impl Into<Option<&'a str>>,
         object_path: &str,
         interface_name: &str,
         signal_name: &str,
-        parameters: Option<&glib::Variant>,
+        parameters: impl Into<Option<&'a glib::Variant>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_dbus_connection_emit_signal(
                 self.to_glib_none().0,
-                destination_bus_name.to_glib_none().0,
+                destination_bus_name.into().to_glib_none().0,
                 object_path.to_glib_none().0,
                 interface_name.to_glib_none().0,
                 signal_name.to_glib_none().0,
-                parameters.to_glib_none().0,
+                parameters.into().to_glib_none().0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -493,10 +540,10 @@ impl DBusConnection {
     }
 
     #[doc(alias = "g_dbus_connection_flush")]
-    pub fn flush<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    pub fn flush<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -508,9 +555,9 @@ impl DBusConnection {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
-        unsafe extern "C" fn flush_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
+        unsafe extern "C" fn flush_trampoline<Q: FnOnce(Result<(), glib::Error>) + 'static>(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
             user_data: glib::ffi::gpointer,
@@ -522,16 +569,21 @@ impl DBusConnection {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = flush_trampoline::<P>;
+        let callback = flush_trampoline::<Q>;
         unsafe {
             ffi::g_dbus_connection_flush(
                 self.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -552,15 +604,20 @@ impl DBusConnection {
     }
 
     #[doc(alias = "g_dbus_connection_flush_sync")]
-    pub fn flush_sync(
+    pub fn flush_sync<'a, P: IsA<Cancellable>>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_dbus_connection_flush_sync(
                 self.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -672,13 +729,17 @@ impl DBusConnection {
     }
 
     #[doc(alias = "g_dbus_connection_send_message_with_reply")]
-    pub fn send_message_with_reply<P: FnOnce(Result<DBusMessage, glib::Error>) + 'static>(
+    pub fn send_message_with_reply<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<DBusMessage, glib::Error>) + 'static,
+    >(
         &self,
         message: &DBusMessage,
         flags: DBusSendMessageFlags,
         timeout_msec: i32,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) -> u32 {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -690,10 +751,10 @@ impl DBusConnection {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn send_message_with_reply_trampoline<
-            P: FnOnce(Result<DBusMessage, glib::Error>) + 'static,
+            Q: FnOnce(Result<DBusMessage, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -710,12 +771,12 @@ impl DBusConnection {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = send_message_with_reply_trampoline::<P>;
+        let callback = send_message_with_reply_trampoline::<Q>;
         unsafe {
             let mut out_serial = std::mem::MaybeUninit::uninit();
             ffi::g_dbus_connection_send_message_with_reply(
@@ -724,7 +785,12 @@ impl DBusConnection {
                 flags.into_glib(),
                 timeout_msec,
                 out_serial.as_mut_ptr(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -757,12 +823,12 @@ impl DBusConnection {
     }
 
     #[doc(alias = "g_dbus_connection_send_message_with_reply_sync")]
-    pub fn send_message_with_reply_sync(
+    pub fn send_message_with_reply_sync<'a, P: IsA<Cancellable>>(
         &self,
         message: &DBusMessage,
         flags: DBusSendMessageFlags,
         timeout_msec: i32,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(DBusMessage, u32), glib::Error> {
         unsafe {
             let mut out_serial = std::mem::MaybeUninit::uninit();
@@ -773,7 +839,12 @@ impl DBusConnection {
                 flags.into_glib(),
                 timeout_msec,
                 out_serial.as_mut_ptr(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -809,13 +880,17 @@ impl DBusConnection {
     }
 
     #[doc(alias = "g_dbus_connection_new")]
-    pub fn new<P: FnOnce(Result<DBusConnection, glib::Error>) + 'static>(
+    pub fn new<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<DBusConnection, glib::Error>) + 'static,
+    >(
         stream: &impl IsA<IOStream>,
-        guid: Option<&str>,
+        guid: impl Into<Option<&'a str>>,
         flags: DBusConnectionFlags,
-        observer: Option<&DBusAuthObserver>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        observer: impl Into<Option<&'a DBusAuthObserver>>,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -827,10 +902,10 @@ impl DBusConnection {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn new_trampoline<
-            P: FnOnce(Result<DBusConnection, glib::Error>) + 'static,
+            Q: FnOnce(Result<DBusConnection, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -843,35 +918,40 @@ impl DBusConnection {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = new_trampoline::<P>;
+        let callback = new_trampoline::<Q>;
         unsafe {
             ffi::g_dbus_connection_new(
                 stream.as_ref().to_glib_none().0,
-                guid.to_glib_none().0,
+                guid.into().to_glib_none().0,
                 flags.into_glib(),
-                observer.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                observer.into().to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    pub fn new_future(
+    pub fn new_future<'a>(
         stream: &(impl IsA<IOStream> + Clone + 'static),
-        guid: Option<&str>,
+        guid: impl Into<Option<&'a str>>,
         flags: DBusConnectionFlags,
-        observer: Option<&DBusAuthObserver>,
+        observer: impl Into<Option<&'a DBusAuthObserver>>,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<DBusConnection, glib::Error>> + 'static>>
     {
         let stream = stream.clone();
-        let guid = guid.map(ToOwned::to_owned);
-        let observer = observer.map(ToOwned::to_owned);
+        let guid = guid.into().map(ToOwned::to_owned);
+        let observer = observer.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             &(),
             move |_obj, cancellable, send| {
@@ -891,12 +971,16 @@ impl DBusConnection {
 
     #[doc(alias = "g_dbus_connection_new_for_address")]
     #[doc(alias = "new_for_address")]
-    pub fn for_address<P: FnOnce(Result<DBusConnection, glib::Error>) + 'static>(
+    pub fn for_address<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<DBusConnection, glib::Error>) + 'static,
+    >(
         address: &str,
         flags: DBusConnectionFlags,
-        observer: Option<&DBusAuthObserver>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        observer: impl Into<Option<&'a DBusAuthObserver>>,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -908,10 +992,10 @@ impl DBusConnection {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn for_address_trampoline<
-            P: FnOnce(Result<DBusConnection, glib::Error>) + 'static,
+            Q: FnOnce(Result<DBusConnection, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -924,32 +1008,37 @@ impl DBusConnection {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = for_address_trampoline::<P>;
+        let callback = for_address_trampoline::<Q>;
         unsafe {
             ffi::g_dbus_connection_new_for_address(
                 address.to_glib_none().0,
                 flags.into_glib(),
-                observer.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                observer.into().to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    pub fn for_address_future(
+    pub fn for_address_future<'a>(
         address: &str,
         flags: DBusConnectionFlags,
-        observer: Option<&DBusAuthObserver>,
+        observer: impl Into<Option<&'a DBusAuthObserver>>,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<DBusConnection, glib::Error>> + 'static>>
     {
         let address = String::from(address);
-        let observer = observer.map(ToOwned::to_owned);
+        let observer = observer.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             &(),
             move |_obj, cancellable, send| {
diff --git a/gio/src/auto/dbus_interface.rs b/gio/src/auto/dbus_interface.rs
index ff8d44c5eb0d..9f487a21f220 100644
--- a/gio/src/auto/dbus_interface.rs
+++ b/gio/src/auto/dbus_interface.rs
@@ -40,11 +40,11 @@ pub trait DBusInterfaceExt: IsA<DBusInterface> + 'static {
     }
 
     #[doc(alias = "g_dbus_interface_set_object")]
-    fn set_object(&self, object: Option<&impl IsA<DBusObject>>) {
+    fn set_object<'a, P: IsA<DBusObject>>(&self, object: impl Into<Option<&'a P>>) {
         unsafe {
             ffi::g_dbus_interface_set_object(
                 self.as_ref().to_glib_none().0,
-                object.map(|p| p.as_ref()).to_glib_none().0,
+                object.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
             );
         }
     }
diff --git a/gio/src/auto/dbus_menu_model.rs b/gio/src/auto/dbus_menu_model.rs
index 15c1c3c93a42..f594cddb2ebd 100644
--- a/gio/src/auto/dbus_menu_model.rs
+++ b/gio/src/auto/dbus_menu_model.rs
@@ -16,15 +16,15 @@ glib::wrapper! {
 
 impl DBusMenuModel {
     #[doc(alias = "g_dbus_menu_model_get")]
-    pub fn get(
+    pub fn get<'a>(
         connection: &DBusConnection,
-        bus_name: Option<&str>,
+        bus_name: impl Into<Option<&'a str>>,
         object_path: &str,
     ) -> DBusMenuModel {
         unsafe {
             from_glib_full(ffi::g_dbus_menu_model_get(
                 connection.to_glib_none().0,
-                bus_name.to_glib_none().0,
+                bus_name.into().to_glib_none().0,
                 object_path.to_glib_none().0,
             ))
         }
diff --git a/gio/src/auto/dbus_message.rs b/gio/src/auto/dbus_message.rs
index 9a59019d3c51..3418115a5acd 100644
--- a/gio/src/auto/dbus_message.rs
+++ b/gio/src/auto/dbus_message.rs
@@ -55,17 +55,17 @@ impl DBusMessage {
     }
 
     #[doc(alias = "g_dbus_message_new_method_call")]
-    pub fn new_method_call(
-        name: Option<&str>,
+    pub fn new_method_call<'a>(
+        name: impl Into<Option<&'a str>>,
         path: &str,
-        interface_: Option<&str>,
+        interface_: impl Into<Option<&'a str>>,
         method: &str,
     ) -> DBusMessage {
         unsafe {
             from_glib_full(ffi::g_dbus_message_new_method_call(
-                name.to_glib_none().0,
+                name.into().to_glib_none().0,
                 path.to_glib_none().0,
-                interface_.to_glib_none().0,
+                interface_.into().to_glib_none().0,
                 method.to_glib_none().0,
             ))
         }
@@ -230,7 +230,7 @@ impl DBusMessage {
 
     //#[doc(alias = "g_dbus_message_new_method_error")]
     //#[must_use]
-    //pub fn new_method_error(&self, error_name: &str, error_message_format: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> DBusMessage {
+    //pub fn new_method_error(&self, error_name: &str, error_message_format: &str, : /*Unimplemented*/Basic: VarArgs) -> DBusMessage {
     //    unsafe { TODO: call ffi:g_dbus_message_new_method_error() }
     //}
 
@@ -248,7 +248,7 @@ impl DBusMessage {
 
     //#[doc(alias = "g_dbus_message_new_method_error_valist")]
     //#[must_use]
-    //pub fn new_method_error_valist(&self, error_name: &str, error_message_format: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) -> DBusMessage {
+    //pub fn new_method_error_valist(&self, error_name: &str, error_message_format: &str, var_args: /*Unimplemented*/Unsupported) -> DBusMessage {
     //    unsafe { TODO: call ffi:g_dbus_message_new_method_error_valist() }
     //}
 
@@ -278,9 +278,12 @@ impl DBusMessage {
     }
 
     #[doc(alias = "g_dbus_message_set_destination")]
-    pub fn set_destination(&self, value: Option<&str>) {
+    pub fn set_destination<'a>(&self, value: impl Into<Option<&'a str>>) {
         unsafe {
-            ffi::g_dbus_message_set_destination(self.to_glib_none().0, value.to_glib_none().0);
+            ffi::g_dbus_message_set_destination(
+                self.to_glib_none().0,
+                value.into().to_glib_none().0,
+            );
         }
     }
 
@@ -299,27 +302,31 @@ impl DBusMessage {
     }
 
     #[doc(alias = "g_dbus_message_set_header")]
-    pub fn set_header(&self, header_field: DBusMessageHeaderField, value: Option<&glib::Variant>) {
+    pub fn set_header<'a>(
+        &self,
+        header_field: DBusMessageHeaderField,
+        value: impl Into<Option<&'a glib::Variant>>,
+    ) {
         unsafe {
             ffi::g_dbus_message_set_header(
                 self.to_glib_none().0,
                 header_field.into_glib(),
-                value.to_glib_none().0,
+                value.into().to_glib_none().0,
             );
         }
     }
 
     #[doc(alias = "g_dbus_message_set_interface")]
-    pub fn set_interface(&self, value: Option<&str>) {
+    pub fn set_interface<'a>(&self, value: impl Into<Option<&'a str>>) {
         unsafe {
-            ffi::g_dbus_message_set_interface(self.to_glib_none().0, value.to_glib_none().0);
+            ffi::g_dbus_message_set_interface(self.to_glib_none().0, value.into().to_glib_none().0);
         }
     }
 
     #[doc(alias = "g_dbus_message_set_member")]
-    pub fn set_member(&self, value: Option<&str>) {
+    pub fn set_member<'a>(&self, value: impl Into<Option<&'a str>>) {
         unsafe {
-            ffi::g_dbus_message_set_member(self.to_glib_none().0, value.to_glib_none().0);
+            ffi::g_dbus_message_set_member(self.to_glib_none().0, value.into().to_glib_none().0);
         }
     }
 
@@ -340,9 +347,9 @@ impl DBusMessage {
     }
 
     #[doc(alias = "g_dbus_message_set_path")]
-    pub fn set_path(&self, value: Option<&str>) {
+    pub fn set_path<'a>(&self, value: impl Into<Option<&'a str>>) {
         unsafe {
-            ffi::g_dbus_message_set_path(self.to_glib_none().0, value.to_glib_none().0);
+            ffi::g_dbus_message_set_path(self.to_glib_none().0, value.into().to_glib_none().0);
         }
     }
 
@@ -354,9 +361,9 @@ impl DBusMessage {
     }
 
     #[doc(alias = "g_dbus_message_set_sender")]
-    pub fn set_sender(&self, value: Option<&str>) {
+    pub fn set_sender<'a>(&self, value: impl Into<Option<&'a str>>) {
         unsafe {
-            ffi::g_dbus_message_set_sender(self.to_glib_none().0, value.to_glib_none().0);
+            ffi::g_dbus_message_set_sender(self.to_glib_none().0, value.into().to_glib_none().0);
         }
     }
 
@@ -368,20 +375,20 @@ impl DBusMessage {
     }
 
     #[doc(alias = "g_dbus_message_set_signature")]
-    pub fn set_signature(&self, value: Option<&str>) {
+    pub fn set_signature<'a>(&self, value: impl Into<Option<&'a str>>) {
         unsafe {
-            ffi::g_dbus_message_set_signature(self.to_glib_none().0, value.to_glib_none().0);
+            ffi::g_dbus_message_set_signature(self.to_glib_none().0, value.into().to_glib_none().0);
         }
     }
 
     #[cfg(unix)]
     #[cfg_attr(docsrs, doc(cfg(unix)))]
     #[doc(alias = "g_dbus_message_set_unix_fd_list")]
-    pub fn set_unix_fd_list(&self, fd_list: Option<&impl IsA<UnixFDList>>) {
+    pub fn set_unix_fd_list<'a, P: IsA<UnixFDList>>(&self, fd_list: impl Into<Option<&'a P>>) {
         unsafe {
             ffi::g_dbus_message_set_unix_fd_list(
                 self.to_glib_none().0,
-                fd_list.map(|p| p.as_ref()).to_glib_none().0,
+                fd_list.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
             );
         }
     }
diff --git a/gio/src/auto/dbus_method_invocation.rs b/gio/src/auto/dbus_method_invocation.rs
index 4a6c38b50e41..f453423da9fc 100644
--- a/gio/src/auto/dbus_method_invocation.rs
+++ b/gio/src/auto/dbus_method_invocation.rs
@@ -129,21 +129,21 @@ impl DBusMethodInvocation {
     }
 
     //#[doc(alias = "g_dbus_method_invocation_return_error")]
-    //pub fn return_error(self, domain: glib::Quark, code: i32, format: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
+    //pub fn return_error(self, domain: glib::Quark, code: i32, format: &str, : /*Unimplemented*/Basic: VarArgs) {
     //    unsafe { TODO: call ffi:g_dbus_method_invocation_return_error() }
     //}
 
     //#[doc(alias = "g_dbus_method_invocation_return_error_valist")]
-    //pub fn return_error_valist(self, domain: glib::Quark, code: i32, format: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
+    //pub fn return_error_valist(self, domain: glib::Quark, code: i32, format: &str, var_args: /*Unimplemented*/Unsupported) {
     //    unsafe { TODO: call ffi:g_dbus_method_invocation_return_error_valist() }
     //}
 
     #[doc(alias = "g_dbus_method_invocation_return_value")]
-    pub fn return_value(self, parameters: Option<&glib::Variant>) {
+    pub fn return_value<'a>(self, parameters: impl Into<Option<&'a glib::Variant>>) {
         unsafe {
             ffi::g_dbus_method_invocation_return_value(
                 self.into_glib_ptr(),
-                parameters.to_glib_none().0,
+                parameters.into().to_glib_none().0,
             );
         }
     }
@@ -151,16 +151,16 @@ impl DBusMethodInvocation {
     #[cfg(unix)]
     #[cfg_attr(docsrs, doc(cfg(unix)))]
     #[doc(alias = "g_dbus_method_invocation_return_value_with_unix_fd_list")]
-    pub fn return_value_with_unix_fd_list(
+    pub fn return_value_with_unix_fd_list<'a, P: IsA<UnixFDList>>(
         self,
-        parameters: Option<&glib::Variant>,
-        fd_list: Option<&impl IsA<UnixFDList>>,
+        parameters: impl Into<Option<&'a glib::Variant>>,
+        fd_list: impl Into<Option<&'a P>>,
     ) {
         unsafe {
             ffi::g_dbus_method_invocation_return_value_with_unix_fd_list(
                 self.into_glib_ptr(),
-                parameters.to_glib_none().0,
-                fd_list.map(|p| p.as_ref()).to_glib_none().0,
+                parameters.into().to_glib_none().0,
+                fd_list.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
             );
         }
     }
diff --git a/gio/src/auto/dbus_proxy.rs b/gio/src/auto/dbus_proxy.rs
index e5d0d38711a9..803066bca834 100644
--- a/gio/src/auto/dbus_proxy.rs
+++ b/gio/src/auto/dbus_proxy.rs
@@ -30,25 +30,30 @@ impl DBusProxy {
 
     #[doc(alias = "g_dbus_proxy_new_for_bus_sync")]
     #[doc(alias = "new_for_bus_sync")]
-    pub fn for_bus_sync(
+    pub fn for_bus_sync<'a, P: IsA<Cancellable>>(
         bus_type: BusType,
         flags: DBusProxyFlags,
-        info: Option<&DBusInterfaceInfo>,
+        info: impl Into<Option<&'a DBusInterfaceInfo>>,
         name: &str,
         object_path: &str,
         interface_name: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<DBusProxy, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_dbus_proxy_new_for_bus_sync(
                 bus_type.into_glib(),
                 flags.into_glib(),
-                info.to_glib_none().0,
+                info.into().to_glib_none().0,
                 name.to_glib_none().0,
                 object_path.to_glib_none().0,
                 interface_name.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -60,25 +65,30 @@ impl DBusProxy {
     }
 
     #[doc(alias = "g_dbus_proxy_new_sync")]
-    pub fn new_sync(
+    pub fn new_sync<'a, P: IsA<Cancellable>>(
         connection: &DBusConnection,
         flags: DBusProxyFlags,
-        info: Option<&DBusInterfaceInfo>,
-        name: Option<&str>,
+        info: impl Into<Option<&'a DBusInterfaceInfo>>,
+        name: impl Into<Option<&'a str>>,
         object_path: &str,
         interface_name: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<DBusProxy, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_dbus_proxy_new_sync(
                 connection.to_glib_none().0,
                 flags.into_glib(),
-                info.to_glib_none().0,
-                name.to_glib_none().0,
+                info.into().to_glib_none().0,
+                name.into().to_glib_none().0,
                 object_path.to_glib_none().0,
                 interface_name.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -90,15 +100,15 @@ impl DBusProxy {
     }
 
     #[doc(alias = "g_dbus_proxy_new")]
-    pub fn new<P: FnOnce(Result<DBusProxy, glib::Error>) + 'static>(
+    pub fn new<'a, P: IsA<Cancellable>, Q: FnOnce(Result<DBusProxy, glib::Error>) + 'static>(
         connection: &DBusConnection,
         flags: DBusProxyFlags,
-        info: Option<&DBusInterfaceInfo>,
-        name: Option<&str>,
+        info: impl Into<Option<&'a DBusInterfaceInfo>>,
+        name: impl Into<Option<&'a str>>,
         object_path: &str,
         interface_name: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -110,9 +120,9 @@ impl DBusProxy {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
-        unsafe extern "C" fn new_trampoline<P: FnOnce(Result<DBusProxy, glib::Error>) + 'static>(
+        unsafe extern "C" fn new_trampoline<Q: FnOnce(Result<DBusProxy, glib::Error>) + 'static>(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
             user_data: glib::ffi::gpointer,
@@ -124,38 +134,43 @@ impl DBusProxy {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = new_trampoline::<P>;
+        let callback = new_trampoline::<Q>;
         unsafe {
             ffi::g_dbus_proxy_new(
                 connection.to_glib_none().0,
                 flags.into_glib(),
-                info.to_glib_none().0,
-                name.to_glib_none().0,
+                info.into().to_glib_none().0,
+                name.into().to_glib_none().0,
                 object_path.to_glib_none().0,
                 interface_name.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    pub fn new_future(
+    pub fn new_future<'a>(
         connection: &DBusConnection,
         flags: DBusProxyFlags,
-        info: Option<&DBusInterfaceInfo>,
-        name: Option<&str>,
+        info: impl Into<Option<&'a DBusInterfaceInfo>>,
+        name: impl Into<Option<&'a str>>,
         object_path: &str,
         interface_name: &str,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<DBusProxy, glib::Error>> + 'static>> {
         let connection = connection.clone();
-        let info = info.map(ToOwned::to_owned);
-        let name = name.map(ToOwned::to_owned);
+        let info = info.into().map(ToOwned::to_owned);
+        let name = name.into().map(ToOwned::to_owned);
         let object_path = String::from(object_path);
         let interface_name = String::from(interface_name);
         Box_::pin(crate::GioFuture::new(
@@ -179,15 +194,15 @@ impl DBusProxy {
 
     #[doc(alias = "g_dbus_proxy_new_for_bus")]
     #[doc(alias = "new_for_bus")]
-    pub fn for_bus<P: FnOnce(Result<DBusProxy, glib::Error>) + 'static>(
+    pub fn for_bus<'a, P: IsA<Cancellable>, Q: FnOnce(Result<DBusProxy, glib::Error>) + 'static>(
         bus_type: BusType,
         flags: DBusProxyFlags,
-        info: Option<&DBusInterfaceInfo>,
+        info: impl Into<Option<&'a DBusInterfaceInfo>>,
         name: &str,
         object_path: &str,
         interface_name: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -199,10 +214,10 @@ impl DBusProxy {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn for_bus_trampoline<
-            P: FnOnce(Result<DBusProxy, glib::Error>) + 'static,
+            Q: FnOnce(Result<DBusProxy, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -215,36 +230,41 @@ impl DBusProxy {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = for_bus_trampoline::<P>;
+        let callback = for_bus_trampoline::<Q>;
         unsafe {
             ffi::g_dbus_proxy_new_for_bus(
                 bus_type.into_glib(),
                 flags.into_glib(),
-                info.to_glib_none().0,
+                info.into().to_glib_none().0,
                 name.to_glib_none().0,
                 object_path.to_glib_none().0,
                 interface_name.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    pub fn for_bus_future(
+    pub fn for_bus_future<'a>(
         bus_type: BusType,
         flags: DBusProxyFlags,
-        info: Option<&DBusInterfaceInfo>,
+        info: impl Into<Option<&'a DBusInterfaceInfo>>,
         name: &str,
         object_path: &str,
         interface_name: &str,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<DBusProxy, glib::Error>> + 'static>> {
-        let info = info.map(ToOwned::to_owned);
+        let info = info.into().map(ToOwned::to_owned);
         let name = String::from(name);
         let object_path = String::from(object_path);
         let interface_name = String::from(interface_name);
@@ -273,14 +293,14 @@ unsafe impl Sync for DBusProxy {}
 
 pub trait DBusProxyExt: IsA<DBusProxy> + 'static {
     #[doc(alias = "g_dbus_proxy_call")]
-    fn call<P: FnOnce(Result<glib::Variant, glib::Error>) + 'static>(
+    fn call<'a, P: IsA<Cancellable>, Q: FnOnce(Result<glib::Variant, glib::Error>) + 'static>(
         &self,
         method_name: &str,
-        parameters: Option<&glib::Variant>,
+        parameters: impl Into<Option<&'a glib::Variant>>,
         flags: DBusCallFlags,
         timeout_msec: i32,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -292,10 +312,10 @@ pub trait DBusProxyExt: IsA<DBusProxy> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn call_trampoline<
-            P: FnOnce(Result<glib::Variant, glib::Error>) + 'static,
+            Q: FnOnce(Result<glib::Variant, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -308,36 +328,41 @@ pub trait DBusProxyExt: IsA<DBusProxy> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = call_trampoline::<P>;
+        let callback = call_trampoline::<Q>;
         unsafe {
             ffi::g_dbus_proxy_call(
                 self.as_ref().to_glib_none().0,
                 method_name.to_glib_none().0,
-                parameters.to_glib_none().0,
+                parameters.into().to_glib_none().0,
                 flags.into_glib(),
                 timeout_msec,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn call_future(
+    fn call_future<'a>(
         &self,
         method_name: &str,
-        parameters: Option<&glib::Variant>,
+        parameters: impl Into<Option<&'a glib::Variant>>,
         flags: DBusCallFlags,
         timeout_msec: i32,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::Variant, glib::Error>> + 'static>>
     {
         let method_name = String::from(method_name);
-        let parameters = parameters.map(ToOwned::to_owned);
+        let parameters = parameters.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -356,23 +381,28 @@ pub trait DBusProxyExt: IsA<DBusProxy> + 'static {
     }
 
     #[doc(alias = "g_dbus_proxy_call_sync")]
-    fn call_sync(
+    fn call_sync<'a, P: IsA<Cancellable>>(
         &self,
         method_name: &str,
-        parameters: Option<&glib::Variant>,
+        parameters: impl Into<Option<&'a glib::Variant>>,
         flags: DBusCallFlags,
         timeout_msec: i32,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<glib::Variant, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_dbus_proxy_call_sync(
                 self.as_ref().to_glib_none().0,
                 method_name.to_glib_none().0,
-                parameters.to_glib_none().0,
+                parameters.into().to_glib_none().0,
                 flags.into_glib(),
                 timeout_msec,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -387,16 +417,19 @@ pub trait DBusProxyExt: IsA<DBusProxy> + 'static {
     #[cfg_attr(docsrs, doc(cfg(unix)))]
     #[doc(alias = "g_dbus_proxy_call_with_unix_fd_list")]
     fn call_with_unix_fd_list<
-        P: FnOnce(Result<(glib::Variant, UnixFDList), glib::Error>) + 'static,
+        'a,
+        P: IsA<UnixFDList>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<(glib::Variant, UnixFDList), glib::Error>) + 'static,
     >(
         &self,
         method_name: &str,
-        parameters: Option<&glib::Variant>,
+        parameters: impl Into<Option<&'a glib::Variant>>,
         flags: DBusCallFlags,
         timeout_msec: i32,
-        fd_list: Option<&impl IsA<UnixFDList>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        fd_list: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -408,10 +441,10 @@ pub trait DBusProxyExt: IsA<DBusProxy> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn call_with_unix_fd_list_trampoline<
-            P: FnOnce(Result<(glib::Variant, UnixFDList), glib::Error>) + 'static,
+            R: FnOnce(Result<(glib::Variant, UnixFDList), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -430,21 +463,26 @@ pub trait DBusProxyExt: IsA<DBusProxy> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = call_with_unix_fd_list_trampoline::<P>;
+        let callback = call_with_unix_fd_list_trampoline::<R>;
         unsafe {
             ffi::g_dbus_proxy_call_with_unix_fd_list(
                 self.as_ref().to_glib_none().0,
                 method_name.to_glib_none().0,
-                parameters.to_glib_none().0,
+                parameters.into().to_glib_none().0,
                 flags.into_glib(),
                 timeout_msec,
-                fd_list.map(|p| p.as_ref()).to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                fd_list.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -453,13 +491,13 @@ pub trait DBusProxyExt: IsA<DBusProxy> + 'static {
 
     #[cfg(unix)]
     #[cfg_attr(docsrs, doc(cfg(unix)))]
-    fn call_with_unix_fd_list_future(
+    fn call_with_unix_fd_list_future<'a, P: IsA<UnixFDList> + Clone + 'static>(
         &self,
         method_name: &str,
-        parameters: Option<&glib::Variant>,
+        parameters: impl Into<Option<&'a glib::Variant>>,
         flags: DBusCallFlags,
         timeout_msec: i32,
-        fd_list: Option<&(impl IsA<UnixFDList> + Clone + 'static)>,
+        fd_list: impl Into<Option<&'a P>>,
     ) -> Pin<
         Box_<
             dyn std::future::Future<Output = Result<(glib::Variant, UnixFDList), glib::Error>>
@@ -467,8 +505,8 @@ pub trait DBusProxyExt: IsA<DBusProxy> + 'static {
         >,
     > {
         let method_name = String::from(method_name);
-        let parameters = parameters.map(ToOwned::to_owned);
-        let fd_list = fd_list.map(ToOwned::to_owned);
+        let parameters = parameters.into().map(ToOwned::to_owned);
+        let fd_list = fd_list.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -490,14 +528,14 @@ pub trait DBusProxyExt: IsA<DBusProxy> + 'static {
     #[cfg(unix)]
     #[cfg_attr(docsrs, doc(cfg(unix)))]
     #[doc(alias = "g_dbus_proxy_call_with_unix_fd_list_sync")]
-    fn call_with_unix_fd_list_sync(
+    fn call_with_unix_fd_list_sync<'a, P: IsA<UnixFDList>, Q: IsA<Cancellable>>(
         &self,
         method_name: &str,
-        parameters: Option<&glib::Variant>,
+        parameters: impl Into<Option<&'a glib::Variant>>,
         flags: DBusCallFlags,
         timeout_msec: i32,
-        fd_list: Option<&impl IsA<UnixFDList>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        fd_list: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
     ) -> Result<(glib::Variant, UnixFDList), glib::Error> {
         unsafe {
             let mut out_fd_list = std::ptr::null_mut();
@@ -505,12 +543,17 @@ pub trait DBusProxyExt: IsA<DBusProxy> + 'static {
             let ret = ffi::g_dbus_proxy_call_with_unix_fd_list_sync(
                 self.as_ref().to_glib_none().0,
                 method_name.to_glib_none().0,
-                parameters.to_glib_none().0,
+                parameters.into().to_glib_none().0,
                 flags.into_glib(),
                 timeout_msec,
-                fd_list.map(|p| p.as_ref()).to_glib_none().0,
+                fd_list.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
                 &mut out_fd_list,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -611,12 +654,16 @@ pub trait DBusProxyExt: IsA<DBusProxy> + 'static {
     }
 
     #[doc(alias = "g_dbus_proxy_set_cached_property")]
-    fn set_cached_property(&self, property_name: &str, value: Option<&glib::Variant>) {
+    fn set_cached_property<'a>(
+        &self,
+        property_name: &str,
+        value: impl Into<Option<&'a glib::Variant>>,
+    ) {
         unsafe {
             ffi::g_dbus_proxy_set_cached_property(
                 self.as_ref().to_glib_none().0,
                 property_name.to_glib_none().0,
-                value.to_glib_none().0,
+                value.into().to_glib_none().0,
             );
         }
     }
@@ -629,11 +676,11 @@ pub trait DBusProxyExt: IsA<DBusProxy> + 'static {
     }
 
     #[doc(alias = "g_dbus_proxy_set_interface_info")]
-    fn set_interface_info(&self, info: Option<&DBusInterfaceInfo>) {
+    fn set_interface_info<'a>(&self, info: impl Into<Option<&'a DBusInterfaceInfo>>) {
         unsafe {
             ffi::g_dbus_proxy_set_interface_info(
                 self.as_ref().to_glib_none().0,
-                info.to_glib_none().0,
+                info.into().to_glib_none().0,
             );
         }
     }
@@ -664,8 +711,8 @@ pub trait DBusProxyExt: IsA<DBusProxy> + 'static {
     }
 
     #[doc(alias = "g-interface-info")]
-    fn set_g_interface_info(&self, g_interface_info: Option<&DBusInterfaceInfo>) {
-        ObjectExt::set_property(self.as_ref(), "g-interface-info", g_interface_info)
+    fn set_g_interface_info<'a>(&self, g_interface_info: impl Into<Option<&'a DBusInterfaceInfo>>) {
+        ObjectExt::set_property(self.as_ref(), "g-interface-info", g_interface_info.into())
     }
 
     #[doc(alias = "g-interface-name")]
diff --git a/gio/src/auto/dbus_server.rs b/gio/src/auto/dbus_server.rs
index 17401b44ebfc..977112333bc2 100644
--- a/gio/src/auto/dbus_server.rs
+++ b/gio/src/auto/dbus_server.rs
@@ -21,12 +21,12 @@ glib::wrapper! {
 
 impl DBusServer {
     #[doc(alias = "g_dbus_server_new_sync")]
-    pub fn new_sync(
+    pub fn new_sync<'a, P: IsA<Cancellable>>(
         address: &str,
         flags: DBusServerFlags,
         guid: &str,
-        observer: Option<&DBusAuthObserver>,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        observer: impl Into<Option<&'a DBusAuthObserver>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<DBusServer, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -34,8 +34,13 @@ impl DBusServer {
                 address.to_glib_none().0,
                 flags.into_glib(),
                 guid.to_glib_none().0,
-                observer.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                observer.into().to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
diff --git a/gio/src/auto/debug_controller_dbus.rs b/gio/src/auto/debug_controller_dbus.rs
index cc6be5da96b0..77377dda68d2 100644
--- a/gio/src/auto/debug_controller_dbus.rs
+++ b/gio/src/auto/debug_controller_dbus.rs
@@ -23,15 +23,20 @@ impl DebugControllerDBus {
     pub const NONE: Option<&'static DebugControllerDBus> = None;
 
     #[doc(alias = "g_debug_controller_dbus_new")]
-    pub fn new(
+    pub fn new<'a, P: IsA<Cancellable>>(
         connection: &DBusConnection,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<Option<DebugControllerDBus>, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_debug_controller_dbus_new(
                 connection.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
diff --git a/gio/src/auto/desktop_app_info.rs b/gio/src/auto/desktop_app_info.rs
index bbb79e97c463..ec6412111722 100644
--- a/gio/src/auto/desktop_app_info.rs
+++ b/gio/src/auto/desktop_app_info.rs
@@ -124,11 +124,11 @@ impl DesktopAppInfo {
 
     #[doc(alias = "g_desktop_app_info_get_show_in")]
     #[doc(alias = "get_show_in")]
-    pub fn shows_in(&self, desktop_env: Option<&str>) -> bool {
+    pub fn shows_in<'a>(&self, desktop_env: impl Into<Option<&'a str>>) -> bool {
         unsafe {
             from_glib(ffi::g_desktop_app_info_get_show_in(
                 self.to_glib_none().0,
-                desktop_env.to_glib_none().0,
+                desktop_env.into().to_glib_none().0,
             ))
         }
     }
@@ -184,25 +184,30 @@ impl DesktopAppInfo {
     }
 
     #[doc(alias = "g_desktop_app_info_launch_action")]
-    pub fn launch_action(
+    pub fn launch_action<'a, P: IsA<AppLaunchContext>>(
         &self,
         action_name: &str,
-        launch_context: Option<&impl IsA<AppLaunchContext>>,
+        launch_context: impl Into<Option<&'a P>>,
     ) {
         unsafe {
             ffi::g_desktop_app_info_launch_action(
                 self.to_glib_none().0,
                 action_name.to_glib_none().0,
-                launch_context.map(|p| p.as_ref()).to_glib_none().0,
+                launch_context
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
             );
         }
     }
 
     #[doc(alias = "g_desktop_app_info_launch_uris_as_manager")]
-    pub fn launch_uris_as_manager(
+    pub fn launch_uris_as_manager<'a, P: IsA<AppLaunchContext>>(
         &self,
         uris: &[&str],
-        launch_context: Option<&impl IsA<AppLaunchContext>>,
+        launch_context: impl Into<Option<&'a P>>,
         spawn_flags: glib::SpawnFlags,
         user_setup: Option<Box_<dyn FnOnce() + 'static>>,
         pid_callback: Option<&mut dyn (FnMut(&DesktopAppInfo, glib::Pid))>,
@@ -247,7 +252,12 @@ impl DesktopAppInfo {
             let is_ok = ffi::g_desktop_app_info_launch_uris_as_manager(
                 self.to_glib_none().0,
                 uris.to_glib_none().0,
-                launch_context.map(|p| p.as_ref()).to_glib_none().0,
+                launch_context
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 spawn_flags.into_glib(),
                 user_setup,
                 Box_::into_raw(super_callback0) as *mut _,
diff --git a/gio/src/auto/drive.rs b/gio/src/auto/drive.rs
index 2ca861f67e02..a6d123a79938 100644
--- a/gio/src/auto/drive.rs
+++ b/gio/src/auto/drive.rs
@@ -61,12 +61,17 @@ pub trait DriveExt: IsA<Drive> + 'static {
     }
 
     #[doc(alias = "g_drive_eject_with_operation")]
-    fn eject_with_operation<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn eject_with_operation<
+        'a,
+        P: IsA<MountOperation>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<(), glib::Error>) + 'static,
+    >(
         &self,
         flags: MountUnmountFlags,
-        mount_operation: Option<&impl IsA<MountOperation>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        mount_operation: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -78,10 +83,10 @@ pub trait DriveExt: IsA<Drive> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn eject_with_operation_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            R: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -95,30 +100,40 @@ pub trait DriveExt: IsA<Drive> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = eject_with_operation_trampoline::<P>;
+        let callback = eject_with_operation_trampoline::<R>;
         unsafe {
             ffi::g_drive_eject_with_operation(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                mount_operation
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn eject_with_operation_future(
+    fn eject_with_operation_future<'a, P: IsA<MountOperation> + Clone + 'static>(
         &self,
         flags: MountUnmountFlags,
-        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
+        mount_operation: impl Into<Option<&'a P>>,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
-        let mount_operation = mount_operation.map(ToOwned::to_owned);
+        let mount_operation = mount_operation.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -236,10 +251,10 @@ pub trait DriveExt: IsA<Drive> + 'static {
     }
 
     #[doc(alias = "g_drive_poll_for_media")]
-    fn poll_for_media<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn poll_for_media<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -251,10 +266,10 @@ pub trait DriveExt: IsA<Drive> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn poll_for_media_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            Q: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -267,16 +282,21 @@ pub trait DriveExt: IsA<Drive> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = poll_for_media_trampoline::<P>;
+        let callback = poll_for_media_trampoline::<Q>;
         unsafe {
             ffi::g_drive_poll_for_media(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -297,12 +317,17 @@ pub trait DriveExt: IsA<Drive> + 'static {
     }
 
     #[doc(alias = "g_drive_start")]
-    fn start<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn start<
+        'a,
+        P: IsA<MountOperation>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<(), glib::Error>) + 'static,
+    >(
         &self,
         flags: DriveStartFlags,
-        mount_operation: Option<&impl IsA<MountOperation>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        mount_operation: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -314,9 +339,9 @@ pub trait DriveExt: IsA<Drive> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
-        unsafe extern "C" fn start_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
+        unsafe extern "C" fn start_trampoline<R: FnOnce(Result<(), glib::Error>) + 'static>(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
             user_data: glib::ffi::gpointer,
@@ -328,30 +353,40 @@ pub trait DriveExt: IsA<Drive> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = start_trampoline::<P>;
+        let callback = start_trampoline::<R>;
         unsafe {
             ffi::g_drive_start(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                mount_operation
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn start_future(
+    fn start_future<'a, P: IsA<MountOperation> + Clone + 'static>(
         &self,
         flags: DriveStartFlags,
-        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
+        mount_operation: impl Into<Option<&'a P>>,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
-        let mount_operation = mount_operation.map(ToOwned::to_owned);
+        let mount_operation = mount_operation.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -368,12 +403,17 @@ pub trait DriveExt: IsA<Drive> + 'static {
     }
 
     #[doc(alias = "g_drive_stop")]
-    fn stop<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn stop<
+        'a,
+        P: IsA<MountOperation>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<(), glib::Error>) + 'static,
+    >(
         &self,
         flags: MountUnmountFlags,
-        mount_operation: Option<&impl IsA<MountOperation>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        mount_operation: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -385,9 +425,9 @@ pub trait DriveExt: IsA<Drive> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
-        unsafe extern "C" fn stop_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
+        unsafe extern "C" fn stop_trampoline<R: FnOnce(Result<(), glib::Error>) + 'static>(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
             user_data: glib::ffi::gpointer,
@@ -399,30 +439,40 @@ pub trait DriveExt: IsA<Drive> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = stop_trampoline::<P>;
+        let callback = stop_trampoline::<R>;
         unsafe {
             ffi::g_drive_stop(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                mount_operation
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn stop_future(
+    fn stop_future<'a, P: IsA<MountOperation> + Clone + 'static>(
         &self,
         flags: MountUnmountFlags,
-        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
+        mount_operation: impl Into<Option<&'a P>>,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
-        let mount_operation = mount_operation.map(ToOwned::to_owned);
+        let mount_operation = mount_operation.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
diff --git a/gio/src/auto/emblemed_icon.rs b/gio/src/auto/emblemed_icon.rs
index 1f529e23bc0c..73270d4c5a53 100644
--- a/gio/src/auto/emblemed_icon.rs
+++ b/gio/src/auto/emblemed_icon.rs
@@ -18,11 +18,11 @@ impl EmblemedIcon {
     pub const NONE: Option<&'static EmblemedIcon> = None;
 
     #[doc(alias = "g_emblemed_icon_new")]
-    pub fn new(icon: &impl IsA<Icon>, emblem: Option<&Emblem>) -> EmblemedIcon {
+    pub fn new<'a>(icon: &impl IsA<Icon>, emblem: impl Into<Option<&'a Emblem>>) -> EmblemedIcon {
         unsafe {
             from_glib_full(ffi::g_emblemed_icon_new(
                 icon.as_ref().to_glib_none().0,
-                emblem.to_glib_none().0,
+                emblem.into().to_glib_none().0,
             ))
         }
     }
diff --git a/gio/src/auto/file.rs b/gio/src/auto/file.rs
index 7c4d0c949d70..91a0bc970d0a 100644
--- a/gio/src/auto/file.rs
+++ b/gio/src/auto/file.rs
@@ -24,7 +24,7 @@ impl File {
     pub const NONE: Option<&'static File> = None;
 
     //#[doc(alias = "g_file_new_build_filename")]
-    //pub fn new_build_filename(first_element: impl AsRef<std::path::Path>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> File {
+    //pub fn new_build_filename(first_element: impl AsRef<std::path::Path>, : /*Unimplemented*/Basic: VarArgs) -> File {
     //    unsafe { TODO: call ffi:g_file_new_build_filename() }
     //}
 
@@ -103,17 +103,22 @@ unsafe impl Sync for File {}
 
 pub trait FileExt: IsA<File> + 'static {
     #[doc(alias = "g_file_append_to")]
-    fn append_to(
+    fn append_to<'a, P: IsA<Cancellable>>(
         &self,
         flags: FileCreateFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileOutputStream, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_append_to(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -125,12 +130,16 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_append_to_async")]
-    fn append_to_async<P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static>(
+    fn append_to_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<FileOutputStream, glib::Error>) + 'static,
+    >(
         &self,
         flags: FileCreateFlags,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -142,10 +151,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn append_to_async_trampoline<
-            P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static,
+            Q: FnOnce(Result<FileOutputStream, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -158,18 +167,23 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = append_to_async_trampoline::<P>;
+        let callback = append_to_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_append_to_async(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -195,17 +209,22 @@ pub trait FileExt: IsA<File> + 'static {
     #[cfg(feature = "v2_68")]
     #[cfg_attr(docsrs, doc(cfg(feature = "v2_68")))]
     #[doc(alias = "g_file_build_attribute_list_for_copy")]
-    fn build_attribute_list_for_copy(
+    fn build_attribute_list_for_copy<'a, P: IsA<Cancellable>>(
         &self,
         flags: FileCopyFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<glib::GString, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_build_attribute_list_for_copy(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -217,11 +236,11 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_copy")]
-    fn copy(
+    fn copy<'a, P: IsA<Cancellable>>(
         &self,
         destination: &impl IsA<File>,
         flags: FileCopyFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
         progress_callback: Option<&mut dyn (FnMut(i64, i64))>,
     ) -> Result<(), glib::Error> {
         let mut progress_callback_data: Option<&mut dyn (FnMut(i64, i64))> = progress_callback;
@@ -249,7 +268,12 @@ pub trait FileExt: IsA<File> + 'static {
                 self.as_ref().to_glib_none().0,
                 destination.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 progress_callback,
                 super_callback0 as *mut _ as *mut _,
                 &mut error,
@@ -264,11 +288,11 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_copy_attributes")]
-    fn copy_attributes(
+    fn copy_attributes<'a, P: IsA<Cancellable>>(
         &self,
         destination: &impl IsA<File>,
         flags: FileCopyFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -276,7 +300,12 @@ pub trait FileExt: IsA<File> + 'static {
                 self.as_ref().to_glib_none().0,
                 destination.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -289,17 +318,22 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_create")]
-    fn create(
+    fn create<'a, P: IsA<Cancellable>>(
         &self,
         flags: FileCreateFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileOutputStream, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_create(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -311,12 +345,16 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_create_async")]
-    fn create_async<P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static>(
+    fn create_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<FileOutputStream, glib::Error>) + 'static,
+    >(
         &self,
         flags: FileCreateFlags,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -328,10 +366,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn create_async_trampoline<
-            P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static,
+            Q: FnOnce(Result<FileOutputStream, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -344,18 +382,23 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = create_async_trampoline::<P>;
+        let callback = create_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_create_async(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -379,17 +422,22 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_create_readwrite")]
-    fn create_readwrite(
+    fn create_readwrite<'a, P: IsA<Cancellable>>(
         &self,
         flags: FileCreateFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileIOStream, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_create_readwrite(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -401,12 +449,16 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_create_readwrite_async")]
-    fn create_readwrite_async<P: FnOnce(Result<FileIOStream, glib::Error>) + 'static>(
+    fn create_readwrite_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<FileIOStream, glib::Error>) + 'static,
+    >(
         &self,
         flags: FileCreateFlags,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -418,10 +470,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn create_readwrite_async_trampoline<
-            P: FnOnce(Result<FileIOStream, glib::Error>) + 'static,
+            Q: FnOnce(Result<FileIOStream, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -435,18 +487,23 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = create_readwrite_async_trampoline::<P>;
+        let callback = create_readwrite_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_create_readwrite_async(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -470,12 +527,20 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_delete")]
-    fn delete(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
+    fn delete<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_file_delete(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -488,11 +553,11 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_delete_async")]
-    fn delete_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn delete_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -504,10 +569,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn delete_async_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            Q: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -520,17 +585,22 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = delete_async_trampoline::<P>;
+        let callback = delete_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_delete_async(
                 self.as_ref().to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -558,12 +628,17 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_eject_mountable_with_operation")]
-    fn eject_mountable_with_operation<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn eject_mountable_with_operation<
+        'a,
+        P: IsA<MountOperation>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<(), glib::Error>) + 'static,
+    >(
         &self,
         flags: MountUnmountFlags,
-        mount_operation: Option<&impl IsA<MountOperation>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        mount_operation: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -575,10 +650,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn eject_mountable_with_operation_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            R: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -595,30 +670,40 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = eject_mountable_with_operation_trampoline::<P>;
+        let callback = eject_mountable_with_operation_trampoline::<R>;
         unsafe {
             ffi::g_file_eject_mountable_with_operation(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                mount_operation
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn eject_mountable_with_operation_future(
+    fn eject_mountable_with_operation_future<'a, P: IsA<MountOperation> + Clone + 'static>(
         &self,
         flags: MountUnmountFlags,
-        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
+        mount_operation: impl Into<Option<&'a P>>,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
-        let mount_operation = mount_operation.map(ToOwned::to_owned);
+        let mount_operation = mount_operation.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -635,11 +720,11 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_enumerate_children")]
-    fn enumerate_children(
+    fn enumerate_children<'a, P: IsA<Cancellable>>(
         &self,
         attributes: &str,
         flags: FileQueryInfoFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileEnumerator, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -647,7 +732,12 @@ pub trait FileExt: IsA<File> + 'static {
                 self.as_ref().to_glib_none().0,
                 attributes.to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -669,15 +759,20 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_find_enclosing_mount")]
-    fn find_enclosing_mount(
+    fn find_enclosing_mount<'a, P: IsA<Cancellable>>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<Mount, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_find_enclosing_mount(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -767,11 +862,11 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_has_parent")]
-    fn has_parent(&self, parent: Option<&impl IsA<File>>) -> bool {
+    fn has_parent<'a, P: IsA<File>>(&self, parent: impl Into<Option<&'a P>>) -> bool {
         unsafe {
             from_glib(ffi::g_file_has_parent(
                 self.as_ref().to_glib_none().0,
-                parent.map(|p| p.as_ref()).to_glib_none().0,
+                parent.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
             ))
         }
     }
@@ -802,16 +897,21 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_load_bytes")]
-    fn load_bytes(
+    fn load_bytes<'a, P: IsA<Cancellable>>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(glib::Bytes, Option<glib::GString>), glib::Error> {
         unsafe {
             let mut etag_out = std::ptr::null_mut();
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_load_bytes(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut etag_out,
                 &mut error,
             );
@@ -825,11 +925,13 @@ pub trait FileExt: IsA<File> + 'static {
 
     #[doc(alias = "g_file_load_bytes_async")]
     fn load_bytes_async<
-        P: FnOnce(Result<(glib::Bytes, Option<glib::GString>), glib::Error>) + 'static,
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<(glib::Bytes, Option<glib::GString>), glib::Error>) + 'static,
     >(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -841,10 +943,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn load_bytes_async_trampoline<
-            P: FnOnce(Result<(glib::Bytes, Option<glib::GString>), glib::Error>) + 'static,
+            Q: FnOnce(Result<(glib::Bytes, Option<glib::GString>), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -863,16 +965,21 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = load_bytes_async_trampoline::<P>;
+        let callback = load_bytes_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_load_bytes_async(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -899,15 +1006,20 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_make_directory")]
-    fn make_directory(
+    fn make_directory<'a, P: IsA<Cancellable>>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_file_make_directory(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -920,11 +1032,15 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_make_directory_async")]
-    fn make_directory_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn make_directory_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<(), glib::Error>) + 'static,
+    >(
         &self,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -936,10 +1052,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn make_directory_async_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            Q: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -952,17 +1068,22 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = make_directory_async_trampoline::<P>;
+        let callback = make_directory_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_make_directory_async(
                 self.as_ref().to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -984,15 +1105,20 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_make_directory_with_parents")]
-    fn make_directory_with_parents(
+    fn make_directory_with_parents<'a, P: IsA<Cancellable>>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_file_make_directory_with_parents(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -1005,17 +1131,22 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_make_symbolic_link")]
-    fn make_symbolic_link(
+    fn make_symbolic_link<'a, P: IsA<Cancellable>>(
         &self,
         symlink_value: impl AsRef<std::path::Path>,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_file_make_symbolic_link(
                 self.as_ref().to_glib_none().0,
                 symlink_value.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -1028,17 +1159,22 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_monitor")]
-    fn monitor(
+    fn monitor<'a, P: IsA<Cancellable>>(
         &self,
         flags: FileMonitorFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileMonitor, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_monitor(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -1050,17 +1186,22 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_monitor_directory")]
-    fn monitor_directory(
+    fn monitor_directory<'a, P: IsA<Cancellable>>(
         &self,
         flags: FileMonitorFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileMonitor, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_monitor_directory(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -1072,17 +1213,22 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_monitor_file")]
-    fn monitor_file(
+    fn monitor_file<'a, P: IsA<Cancellable>>(
         &self,
         flags: FileMonitorFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileMonitor, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_monitor_file(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -1094,12 +1240,17 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_mount_enclosing_volume")]
-    fn mount_enclosing_volume<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn mount_enclosing_volume<
+        'a,
+        P: IsA<MountOperation>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<(), glib::Error>) + 'static,
+    >(
         &self,
         flags: MountMountFlags,
-        mount_operation: Option<&impl IsA<MountOperation>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        mount_operation: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -1111,10 +1262,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn mount_enclosing_volume_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            R: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -1131,30 +1282,40 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = mount_enclosing_volume_trampoline::<P>;
+        let callback = mount_enclosing_volume_trampoline::<R>;
         unsafe {
             ffi::g_file_mount_enclosing_volume(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                mount_operation
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn mount_enclosing_volume_future(
+    fn mount_enclosing_volume_future<'a, P: IsA<MountOperation> + Clone + 'static>(
         &self,
         flags: MountMountFlags,
-        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
+        mount_operation: impl Into<Option<&'a P>>,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
-        let mount_operation = mount_operation.map(ToOwned::to_owned);
+        let mount_operation = mount_operation.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -1171,12 +1332,17 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_mount_mountable")]
-    fn mount_mountable<P: FnOnce(Result<File, glib::Error>) + 'static>(
+    fn mount_mountable<
+        'a,
+        P: IsA<MountOperation>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<File, glib::Error>) + 'static,
+    >(
         &self,
         flags: MountMountFlags,
-        mount_operation: Option<&impl IsA<MountOperation>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        mount_operation: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -1188,10 +1354,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn mount_mountable_trampoline<
-            P: FnOnce(Result<File, glib::Error>) + 'static,
+            R: FnOnce(Result<File, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -1204,30 +1370,40 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = mount_mountable_trampoline::<P>;
+        let callback = mount_mountable_trampoline::<R>;
         unsafe {
             ffi::g_file_mount_mountable(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                mount_operation
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn mount_mountable_future(
+    fn mount_mountable_future<'a, P: IsA<MountOperation> + Clone + 'static>(
         &self,
         flags: MountMountFlags,
-        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
+        mount_operation: impl Into<Option<&'a P>>,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<File, glib::Error>> + 'static>> {
-        let mount_operation = mount_operation.map(ToOwned::to_owned);
+        let mount_operation = mount_operation.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -1245,11 +1421,11 @@ pub trait FileExt: IsA<File> + 'static {
 
     #[doc(alias = "g_file_move")]
     #[doc(alias = "move")]
-    fn move_(
+    fn move_<'a, P: IsA<Cancellable>>(
         &self,
         destination: &impl IsA<File>,
         flags: FileCopyFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
         progress_callback: Option<&mut dyn (FnMut(i64, i64))>,
     ) -> Result<(), glib::Error> {
         let mut progress_callback_data: Option<&mut dyn (FnMut(i64, i64))> = progress_callback;
@@ -1277,7 +1453,12 @@ pub trait FileExt: IsA<File> + 'static {
                 self.as_ref().to_glib_none().0,
                 destination.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 progress_callback,
                 super_callback0 as *mut _ as *mut _,
                 &mut error,
@@ -1292,15 +1473,20 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_open_readwrite")]
-    fn open_readwrite(
+    fn open_readwrite<'a, P: IsA<Cancellable>>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileIOStream, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_open_readwrite(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -1312,11 +1498,15 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_open_readwrite_async")]
-    fn open_readwrite_async<P: FnOnce(Result<FileIOStream, glib::Error>) + 'static>(
+    fn open_readwrite_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<FileIOStream, glib::Error>) + 'static,
+    >(
         &self,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -1328,10 +1518,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn open_readwrite_async_trampoline<
-            P: FnOnce(Result<FileIOStream, glib::Error>) + 'static,
+            Q: FnOnce(Result<FileIOStream, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -1344,17 +1534,22 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = open_readwrite_async_trampoline::<P>;
+        let callback = open_readwrite_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_open_readwrite_async(
                 self.as_ref().to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -1382,10 +1577,10 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_poll_mountable")]
-    fn poll_mountable<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn poll_mountable<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -1397,10 +1592,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn poll_mountable_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            Q: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -1413,16 +1608,21 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = poll_mountable_trampoline::<P>;
+        let callback = poll_mountable_trampoline::<Q>;
         unsafe {
             ffi::g_file_poll_mountable(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -1443,15 +1643,20 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_query_default_handler")]
-    fn query_default_handler(
+    fn query_default_handler<'a, P: IsA<Cancellable>>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<AppInfo, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_query_default_handler(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -1465,11 +1670,15 @@ pub trait FileExt: IsA<File> + 'static {
     #[cfg(feature = "v2_60")]
     #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
     #[doc(alias = "g_file_query_default_handler_async")]
-    fn query_default_handler_async<P: FnOnce(Result<AppInfo, glib::Error>) + 'static>(
+    fn query_default_handler_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<AppInfo, glib::Error>) + 'static,
+    >(
         &self,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -1481,10 +1690,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn query_default_handler_async_trampoline<
-            P: FnOnce(Result<AppInfo, glib::Error>) + 'static,
+            Q: FnOnce(Result<AppInfo, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -1498,17 +1707,22 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = query_default_handler_async_trampoline::<P>;
+        let callback = query_default_handler_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_query_default_handler_async(
                 self.as_ref().to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -1532,42 +1746,57 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_query_exists")]
-    fn query_exists(&self, cancellable: Option<&impl IsA<Cancellable>>) -> bool {
+    fn query_exists<'a, P: IsA<Cancellable>>(&self, cancellable: impl Into<Option<&'a P>>) -> bool {
         unsafe {
             from_glib(ffi::g_file_query_exists(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
             ))
         }
     }
 
     #[doc(alias = "g_file_query_file_type")]
-    fn query_file_type(
+    fn query_file_type<'a, P: IsA<Cancellable>>(
         &self,
         flags: FileQueryInfoFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> FileType {
         unsafe {
             from_glib(ffi::g_file_query_file_type(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
             ))
         }
     }
 
     #[doc(alias = "g_file_query_filesystem_info")]
-    fn query_filesystem_info(
+    fn query_filesystem_info<'a, P: IsA<Cancellable>>(
         &self,
         attributes: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileInfo, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_query_filesystem_info(
                 self.as_ref().to_glib_none().0,
                 attributes.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -1579,12 +1808,16 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_query_filesystem_info_async")]
-    fn query_filesystem_info_async<P: FnOnce(Result<FileInfo, glib::Error>) + 'static>(
+    fn query_filesystem_info_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<FileInfo, glib::Error>) + 'static,
+    >(
         &self,
         attributes: &str,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -1596,10 +1829,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn query_filesystem_info_async_trampoline<
-            P: FnOnce(Result<FileInfo, glib::Error>) + 'static,
+            Q: FnOnce(Result<FileInfo, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -1613,18 +1846,23 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = query_filesystem_info_async_trampoline::<P>;
+        let callback = query_filesystem_info_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_query_filesystem_info_async(
                 self.as_ref().to_glib_none().0,
                 attributes.to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -1653,11 +1891,11 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_query_info")]
-    fn query_info(
+    fn query_info<'a, P: IsA<Cancellable>>(
         &self,
         attributes: &str,
         flags: FileQueryInfoFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileInfo, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -1665,7 +1903,12 @@ pub trait FileExt: IsA<File> + 'static {
                 self.as_ref().to_glib_none().0,
                 attributes.to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -1677,13 +1920,17 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_query_info_async")]
-    fn query_info_async<P: FnOnce(Result<FileInfo, glib::Error>) + 'static>(
+    fn query_info_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<FileInfo, glib::Error>) + 'static,
+    >(
         &self,
         attributes: &str,
         flags: FileQueryInfoFlags,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -1695,10 +1942,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn query_info_async_trampoline<
-            P: FnOnce(Result<FileInfo, glib::Error>) + 'static,
+            Q: FnOnce(Result<FileInfo, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -1711,19 +1958,24 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = query_info_async_trampoline::<P>;
+        let callback = query_info_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_query_info_async(
                 self.as_ref().to_glib_none().0,
                 attributes.to_glib_none().0,
                 flags.into_glib(),
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -1754,15 +2006,20 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_query_settable_attributes")]
-    fn query_settable_attributes(
+    fn query_settable_attributes<'a, P: IsA<Cancellable>>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileAttributeInfoList, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_query_settable_attributes(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -1774,15 +2031,20 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_query_writable_namespaces")]
-    fn query_writable_namespaces(
+    fn query_writable_namespaces<'a, P: IsA<Cancellable>>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileAttributeInfoList, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_query_writable_namespaces(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -1794,15 +2056,20 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_read")]
-    fn read(
+    fn read<'a, P: IsA<Cancellable>>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileInputStream, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_read(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -1814,11 +2081,15 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_read_async")]
-    fn read_async<P: FnOnce(Result<FileInputStream, glib::Error>) + 'static>(
+    fn read_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<FileInputStream, glib::Error>) + 'static,
+    >(
         &self,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -1830,10 +2101,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn read_async_trampoline<
-            P: FnOnce(Result<FileInputStream, glib::Error>) + 'static,
+            Q: FnOnce(Result<FileInputStream, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -1846,17 +2117,22 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = read_async_trampoline::<P>;
+        let callback = read_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_read_async(
                 self.as_ref().to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -1879,21 +2155,26 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_replace")]
-    fn replace(
+    fn replace<'a, P: IsA<Cancellable>>(
         &self,
-        etag: Option<&str>,
+        etag: impl Into<Option<&'a str>>,
         make_backup: bool,
         flags: FileCreateFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileOutputStream, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_replace(
                 self.as_ref().to_glib_none().0,
-                etag.to_glib_none().0,
+                etag.into().to_glib_none().0,
                 make_backup.into_glib(),
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -1905,14 +2186,18 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_replace_async")]
-    fn replace_async<P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static>(
+    fn replace_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<FileOutputStream, glib::Error>) + 'static,
+    >(
         &self,
-        etag: Option<&str>,
+        etag: impl Into<Option<&'a str>>,
         make_backup: bool,
         flags: FileCreateFlags,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -1924,10 +2209,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn replace_async_trampoline<
-            P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static,
+            Q: FnOnce(Result<FileOutputStream, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -1940,35 +2225,40 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = replace_async_trampoline::<P>;
+        let callback = replace_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_replace_async(
                 self.as_ref().to_glib_none().0,
-                etag.to_glib_none().0,
+                etag.into().to_glib_none().0,
                 make_backup.into_glib(),
                 flags.into_glib(),
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn replace_future(
+    fn replace_future<'a>(
         &self,
-        etag: Option<&str>,
+        etag: impl Into<Option<&'a str>>,
         make_backup: bool,
         flags: FileCreateFlags,
         io_priority: glib::Priority,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileOutputStream, glib::Error>> + 'static>>
     {
-        let etag = etag.map(ToOwned::to_owned);
+        let etag = etag.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -1987,13 +2277,13 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_replace_contents")]
-    fn replace_contents(
+    fn replace_contents<'a, P: IsA<Cancellable>>(
         &self,
         contents: &[u8],
-        etag: Option<&str>,
+        etag: impl Into<Option<&'a str>>,
         make_backup: bool,
         flags: FileCreateFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<Option<glib::GString>, glib::Error> {
         let length = contents.len() as _;
         unsafe {
@@ -2003,11 +2293,16 @@ pub trait FileExt: IsA<File> + 'static {
                 self.as_ref().to_glib_none().0,
                 contents.to_glib_none().0,
                 length,
-                etag.to_glib_none().0,
+                etag.into().to_glib_none().0,
                 make_backup.into_glib(),
                 flags.into_glib(),
                 &mut new_etag,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -2020,26 +2315,31 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     //#[doc(alias = "g_file_replace_contents_bytes_async")]
-    //fn replace_contents_bytes_async<P: FnOnce(Result<(), glib::Error>) + 'static>(&self, contents: &glib::Bytes, etag: Option<&str>, make_backup: bool, flags: FileCreateFlags, cancellable: Option<&impl IsA<Cancellable>>, callback: P) {
+    //fn replace_contents_bytes_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(&self, contents: &glib::Bytes, etag: impl Into<Option<&'a str>>, make_backup: bool, flags: FileCreateFlags, cancellable: impl Into<Option<&'a P>>, callback: Q) {
     //    unsafe { TODO: call ffi:g_file_replace_contents_bytes_async() }
     //}
 
     #[doc(alias = "g_file_replace_readwrite")]
-    fn replace_readwrite(
+    fn replace_readwrite<'a, P: IsA<Cancellable>>(
         &self,
-        etag: Option<&str>,
+        etag: impl Into<Option<&'a str>>,
         make_backup: bool,
         flags: FileCreateFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileIOStream, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_replace_readwrite(
                 self.as_ref().to_glib_none().0,
-                etag.to_glib_none().0,
+                etag.into().to_glib_none().0,
                 make_backup.into_glib(),
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -2051,14 +2351,18 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_replace_readwrite_async")]
-    fn replace_readwrite_async<P: FnOnce(Result<FileIOStream, glib::Error>) + 'static>(
+    fn replace_readwrite_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<FileIOStream, glib::Error>) + 'static,
+    >(
         &self,
-        etag: Option<&str>,
+        etag: impl Into<Option<&'a str>>,
         make_backup: bool,
         flags: FileCreateFlags,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -2070,10 +2374,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn replace_readwrite_async_trampoline<
-            P: FnOnce(Result<FileIOStream, glib::Error>) + 'static,
+            Q: FnOnce(Result<FileIOStream, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -2087,35 +2391,40 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = replace_readwrite_async_trampoline::<P>;
+        let callback = replace_readwrite_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_replace_readwrite_async(
                 self.as_ref().to_glib_none().0,
-                etag.to_glib_none().0,
+                etag.into().to_glib_none().0,
                 make_backup.into_glib(),
                 flags.into_glib(),
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn replace_readwrite_future(
+    fn replace_readwrite_future<'a>(
         &self,
-        etag: Option<&str>,
+        etag: impl Into<Option<&'a str>>,
         make_backup: bool,
         flags: FileCreateFlags,
         io_priority: glib::Priority,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileIOStream, glib::Error>> + 'static>>
     {
-        let etag = etag.map(ToOwned::to_owned);
+        let etag = etag.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -2145,17 +2454,17 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     //#[doc(alias = "g_file_set_attribute")]
-    //fn set_attribute(&self, attribute: &str, type_: FileAttributeType, value_p: /*Unimplemented*/Option<Basic: Pointer>, flags: FileQueryInfoFlags, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
+    //fn set_attribute<'a, P: IsA<Cancellable>>(&self, attribute: &str, type_: FileAttributeType, value_p: /*Unimplemented*/Option<Basic: Pointer>, flags: FileQueryInfoFlags, cancellable: impl Into<Option<&'a P>>) -> Result<(), glib::Error> {
     //    unsafe { TODO: call ffi:g_file_set_attribute() }
     //}
 
     #[doc(alias = "g_file_set_attribute_byte_string")]
-    fn set_attribute_byte_string(
+    fn set_attribute_byte_string<'a, P: IsA<Cancellable>>(
         &self,
         attribute: &str,
         value: &str,
         flags: FileQueryInfoFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -2164,7 +2473,12 @@ pub trait FileExt: IsA<File> + 'static {
                 attribute.to_glib_none().0,
                 value.to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -2177,12 +2491,12 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_set_attribute_int32")]
-    fn set_attribute_int32(
+    fn set_attribute_int32<'a, P: IsA<Cancellable>>(
         &self,
         attribute: &str,
         value: i32,
         flags: FileQueryInfoFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -2191,7 +2505,12 @@ pub trait FileExt: IsA<File> + 'static {
                 attribute.to_glib_none().0,
                 value,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -2204,12 +2523,12 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_set_attribute_int64")]
-    fn set_attribute_int64(
+    fn set_attribute_int64<'a, P: IsA<Cancellable>>(
         &self,
         attribute: &str,
         value: i64,
         flags: FileQueryInfoFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -2218,7 +2537,12 @@ pub trait FileExt: IsA<File> + 'static {
                 attribute.to_glib_none().0,
                 value,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -2231,12 +2555,12 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_set_attribute_string")]
-    fn set_attribute_string(
+    fn set_attribute_string<'a, P: IsA<Cancellable>>(
         &self,
         attribute: &str,
         value: &str,
         flags: FileQueryInfoFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -2245,7 +2569,12 @@ pub trait FileExt: IsA<File> + 'static {
                 attribute.to_glib_none().0,
                 value.to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -2258,12 +2587,12 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_set_attribute_uint32")]
-    fn set_attribute_uint32(
+    fn set_attribute_uint32<'a, P: IsA<Cancellable>>(
         &self,
         attribute: &str,
         value: u32,
         flags: FileQueryInfoFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -2272,7 +2601,12 @@ pub trait FileExt: IsA<File> + 'static {
                 attribute.to_glib_none().0,
                 value,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -2285,12 +2619,12 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_set_attribute_uint64")]
-    fn set_attribute_uint64(
+    fn set_attribute_uint64<'a, P: IsA<Cancellable>>(
         &self,
         attribute: &str,
         value: u64,
         flags: FileQueryInfoFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -2299,7 +2633,12 @@ pub trait FileExt: IsA<File> + 'static {
                 attribute.to_glib_none().0,
                 value,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -2312,13 +2651,17 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_set_attributes_async")]
-    fn set_attributes_async<P: FnOnce(Result<FileInfo, glib::Error>) + 'static>(
+    fn set_attributes_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<FileInfo, glib::Error>) + 'static,
+    >(
         &self,
         info: &FileInfo,
         flags: FileQueryInfoFlags,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -2330,10 +2673,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn set_attributes_async_trampoline<
-            P: FnOnce(Result<FileInfo, glib::Error>) + 'static,
+            Q: FnOnce(Result<FileInfo, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -2352,19 +2695,24 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = set_attributes_async_trampoline::<P>;
+        let callback = set_attributes_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_set_attributes_async(
                 self.as_ref().to_glib_none().0,
                 info.to_glib_none().0,
                 flags.into_glib(),
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -2395,11 +2743,11 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_set_attributes_from_info")]
-    fn set_attributes_from_info(
+    fn set_attributes_from_info<'a, P: IsA<Cancellable>>(
         &self,
         info: &FileInfo,
         flags: FileQueryInfoFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -2407,7 +2755,12 @@ pub trait FileExt: IsA<File> + 'static {
                 self.as_ref().to_glib_none().0,
                 info.to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -2420,17 +2773,22 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_set_display_name")]
-    fn set_display_name(
+    fn set_display_name<'a, P: IsA<Cancellable>>(
         &self,
         display_name: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<File, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_set_display_name(
                 self.as_ref().to_glib_none().0,
                 display_name.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -2442,12 +2800,16 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_set_display_name_async")]
-    fn set_display_name_async<P: FnOnce(Result<File, glib::Error>) + 'static>(
+    fn set_display_name_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<File, glib::Error>) + 'static,
+    >(
         &self,
         display_name: &str,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -2459,10 +2821,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn set_display_name_async_trampoline<
-            P: FnOnce(Result<File, glib::Error>) + 'static,
+            Q: FnOnce(Result<File, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -2476,18 +2838,23 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = set_display_name_async_trampoline::<P>;
+        let callback = set_display_name_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_set_display_name_async(
                 self.as_ref().to_glib_none().0,
                 display_name.to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -2516,12 +2883,17 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_start_mountable")]
-    fn start_mountable<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn start_mountable<
+        'a,
+        P: IsA<MountOperation>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<(), glib::Error>) + 'static,
+    >(
         &self,
         flags: DriveStartFlags,
-        start_operation: Option<&impl IsA<MountOperation>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        start_operation: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -2533,10 +2905,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn start_mountable_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            R: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -2549,30 +2921,40 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = start_mountable_trampoline::<P>;
+        let callback = start_mountable_trampoline::<R>;
         unsafe {
             ffi::g_file_start_mountable(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                start_operation.map(|p| p.as_ref()).to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                start_operation
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn start_mountable_future(
+    fn start_mountable_future<'a, P: IsA<MountOperation> + Clone + 'static>(
         &self,
         flags: DriveStartFlags,
-        start_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
+        start_operation: impl Into<Option<&'a P>>,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
-        let start_operation = start_operation.map(ToOwned::to_owned);
+        let start_operation = start_operation.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -2589,12 +2971,17 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_stop_mountable")]
-    fn stop_mountable<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn stop_mountable<
+        'a,
+        P: IsA<MountOperation>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<(), glib::Error>) + 'static,
+    >(
         &self,
         flags: MountUnmountFlags,
-        mount_operation: Option<&impl IsA<MountOperation>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        mount_operation: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -2606,10 +2993,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn stop_mountable_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            R: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -2622,30 +3009,40 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = stop_mountable_trampoline::<P>;
+        let callback = stop_mountable_trampoline::<R>;
         unsafe {
             ffi::g_file_stop_mountable(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                mount_operation
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn stop_mountable_future(
+    fn stop_mountable_future<'a, P: IsA<MountOperation> + Clone + 'static>(
         &self,
         flags: MountUnmountFlags,
-        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
+        mount_operation: impl Into<Option<&'a P>>,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
-        let mount_operation = mount_operation.map(ToOwned::to_owned);
+        let mount_operation = mount_operation.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -2671,12 +3068,20 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_trash")]
-    fn trash(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
+    fn trash<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_file_trash(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -2689,11 +3094,11 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_trash_async")]
-    fn trash_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn trash_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -2705,10 +3110,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn trash_async_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            Q: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -2721,17 +3126,22 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = trash_async_trampoline::<P>;
+        let callback = trash_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_trash_async(
                 self.as_ref().to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -2753,12 +3163,17 @@ pub trait FileExt: IsA<File> + 'static {
     }
 
     #[doc(alias = "g_file_unmount_mountable_with_operation")]
-    fn unmount_mountable_with_operation<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn unmount_mountable_with_operation<
+        'a,
+        P: IsA<MountOperation>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<(), glib::Error>) + 'static,
+    >(
         &self,
         flags: MountUnmountFlags,
-        mount_operation: Option<&impl IsA<MountOperation>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        mount_operation: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -2770,10 +3185,10 @@ pub trait FileExt: IsA<File> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn unmount_mountable_with_operation_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            R: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -2790,30 +3205,40 @@ pub trait FileExt: IsA<File> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = unmount_mountable_with_operation_trampoline::<P>;
+        let callback = unmount_mountable_with_operation_trampoline::<R>;
         unsafe {
             ffi::g_file_unmount_mountable_with_operation(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                mount_operation
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn unmount_mountable_with_operation_future(
+    fn unmount_mountable_with_operation_future<'a, P: IsA<MountOperation> + Clone + 'static>(
         &self,
         flags: MountUnmountFlags,
-        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
+        mount_operation: impl Into<Option<&'a P>>,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
-        let mount_operation = mount_operation.map(ToOwned::to_owned);
+        let mount_operation = mount_operation.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
diff --git a/gio/src/auto/file_attribute_matcher.rs b/gio/src/auto/file_attribute_matcher.rs
index bfb163414b7b..ab51ad7e2ac3 100644
--- a/gio/src/auto/file_attribute_matcher.rs
+++ b/gio/src/auto/file_attribute_matcher.rs
@@ -58,14 +58,14 @@ impl FileAttributeMatcher {
 
     #[doc(alias = "g_file_attribute_matcher_subtract")]
     #[must_use]
-    pub fn subtract(
+    pub fn subtract<'a>(
         &self,
-        subtract: Option<&FileAttributeMatcher>,
+        subtract: impl Into<Option<&'a FileAttributeMatcher>>,
     ) -> Option<FileAttributeMatcher> {
         unsafe {
             from_glib_full(ffi::g_file_attribute_matcher_subtract(
                 self.to_glib_none().0,
-                subtract.to_glib_none().0,
+                subtract.into().to_glib_none().0,
             ))
         }
     }
diff --git a/gio/src/auto/file_enumerator.rs b/gio/src/auto/file_enumerator.rs
index 0ed8df045dcd..25d3b1bf5750 100644
--- a/gio/src/auto/file_enumerator.rs
+++ b/gio/src/auto/file_enumerator.rs
@@ -21,12 +21,20 @@ impl FileEnumerator {
 
 pub trait FileEnumeratorExt: IsA<FileEnumerator> + 'static {
     #[doc(alias = "g_file_enumerator_close")]
-    fn close(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
+    fn close<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_file_enumerator_close(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -39,11 +47,11 @@ pub trait FileEnumeratorExt: IsA<FileEnumerator> + 'static {
     }
 
     #[doc(alias = "g_file_enumerator_close_async")]
-    fn close_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn close_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -55,10 +63,10 @@ pub trait FileEnumeratorExt: IsA<FileEnumerator> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn close_async_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            Q: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -71,17 +79,22 @@ pub trait FileEnumeratorExt: IsA<FileEnumerator> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = close_async_trampoline::<P>;
+        let callback = close_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_enumerator_close_async(
                 self.as_ref().to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -142,15 +155,20 @@ pub trait FileEnumeratorExt: IsA<FileEnumerator> + 'static {
     }
 
     #[doc(alias = "g_file_enumerator_next_file")]
-    fn next_file(
+    fn next_file<'a, P: IsA<Cancellable>>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<Option<FileInfo>, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_enumerator_next_file(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -162,12 +180,16 @@ pub trait FileEnumeratorExt: IsA<FileEnumerator> + 'static {
     }
 
     #[doc(alias = "g_file_enumerator_next_files_async")]
-    fn next_files_async<P: FnOnce(Result<Vec<FileInfo>, glib::Error>) + 'static>(
+    fn next_files_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<Vec<FileInfo>, glib::Error>) + 'static,
+    >(
         &self,
         num_files: i32,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -179,10 +201,10 @@ pub trait FileEnumeratorExt: IsA<FileEnumerator> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn next_files_async_trampoline<
-            P: FnOnce(Result<Vec<FileInfo>, glib::Error>) + 'static,
+            Q: FnOnce(Result<Vec<FileInfo>, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -196,18 +218,23 @@ pub trait FileEnumeratorExt: IsA<FileEnumerator> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = next_files_async_trampoline::<P>;
+        let callback = next_files_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_enumerator_next_files_async(
                 self.as_ref().to_glib_none().0,
                 num_files,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gio/src/auto/file_info.rs b/gio/src/auto/file_info.rs
index 2578df1d7103..f87fdb71cb82 100644
--- a/gio/src/auto/file_info.rs
+++ b/gio/src/auto/file_info.rs
@@ -312,11 +312,14 @@ impl FileInfo {
     }
 
     #[doc(alias = "g_file_info_list_attributes")]
-    pub fn list_attributes(&self, name_space: Option<&str>) -> Vec<glib::GString> {
+    pub fn list_attributes<'a>(
+        &self,
+        name_space: impl Into<Option<&'a str>>,
+    ) -> Vec<glib::GString> {
         unsafe {
             FromGlibPtrContainer::from_glib_full(ffi::g_file_info_list_attributes(
                 self.to_glib_none().0,
-                name_space.to_glib_none().0,
+                name_space.into().to_glib_none().0,
             ))
         }
     }
diff --git a/gio/src/auto/file_input_stream.rs b/gio/src/auto/file_input_stream.rs
index 606fd3128629..2a6b4fe16f54 100644
--- a/gio/src/auto/file_input_stream.rs
+++ b/gio/src/auto/file_input_stream.rs
@@ -21,17 +21,22 @@ impl FileInputStream {
 
 pub trait FileInputStreamExt: IsA<FileInputStream> + 'static {
     #[doc(alias = "g_file_input_stream_query_info")]
-    fn query_info(
+    fn query_info<'a, P: IsA<Cancellable>>(
         &self,
         attributes: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileInfo, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_input_stream_query_info(
                 self.as_ref().to_glib_none().0,
                 attributes.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -43,12 +48,16 @@ pub trait FileInputStreamExt: IsA<FileInputStream> + 'static {
     }
 
     #[doc(alias = "g_file_input_stream_query_info_async")]
-    fn query_info_async<P: FnOnce(Result<FileInfo, glib::Error>) + 'static>(
+    fn query_info_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<FileInfo, glib::Error>) + 'static,
+    >(
         &self,
         attributes: &str,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -60,10 +69,10 @@ pub trait FileInputStreamExt: IsA<FileInputStream> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn query_info_async_trampoline<
-            P: FnOnce(Result<FileInfo, glib::Error>) + 'static,
+            Q: FnOnce(Result<FileInfo, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -80,18 +89,23 @@ pub trait FileInputStreamExt: IsA<FileInputStream> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = query_info_async_trampoline::<P>;
+        let callback = query_info_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_input_stream_query_info_async(
                 self.as_ref().to_glib_none().0,
                 attributes.to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gio/src/auto/file_io_stream.rs b/gio/src/auto/file_io_stream.rs
index 083eb18fbc14..411b346fd860 100644
--- a/gio/src/auto/file_io_stream.rs
+++ b/gio/src/auto/file_io_stream.rs
@@ -31,17 +31,22 @@ pub trait FileIOStreamExt: IsA<FileIOStream> + 'static {
     }
 
     #[doc(alias = "g_file_io_stream_query_info")]
-    fn query_info(
+    fn query_info<'a, P: IsA<Cancellable>>(
         &self,
         attributes: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileInfo, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_io_stream_query_info(
                 self.as_ref().to_glib_none().0,
                 attributes.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -53,12 +58,16 @@ pub trait FileIOStreamExt: IsA<FileIOStream> + 'static {
     }
 
     #[doc(alias = "g_file_io_stream_query_info_async")]
-    fn query_info_async<P: FnOnce(Result<FileInfo, glib::Error>) + 'static>(
+    fn query_info_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<FileInfo, glib::Error>) + 'static,
+    >(
         &self,
         attributes: &str,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -70,10 +79,10 @@ pub trait FileIOStreamExt: IsA<FileIOStream> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn query_info_async_trampoline<
-            P: FnOnce(Result<FileInfo, glib::Error>) + 'static,
+            Q: FnOnce(Result<FileInfo, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -87,18 +96,23 @@ pub trait FileIOStreamExt: IsA<FileIOStream> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = query_info_async_trampoline::<P>;
+        let callback = query_info_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_io_stream_query_info_async(
                 self.as_ref().to_glib_none().0,
                 attributes.to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gio/src/auto/file_output_stream.rs b/gio/src/auto/file_output_stream.rs
index 0be40ad6fe14..3fc76f7aa288 100644
--- a/gio/src/auto/file_output_stream.rs
+++ b/gio/src/auto/file_output_stream.rs
@@ -31,17 +31,22 @@ pub trait FileOutputStreamExt: IsA<FileOutputStream> + 'static {
     }
 
     #[doc(alias = "g_file_output_stream_query_info")]
-    fn query_info(
+    fn query_info<'a, P: IsA<Cancellable>>(
         &self,
         attributes: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<FileInfo, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_file_output_stream_query_info(
                 self.as_ref().to_glib_none().0,
                 attributes.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -53,12 +58,16 @@ pub trait FileOutputStreamExt: IsA<FileOutputStream> + 'static {
     }
 
     #[doc(alias = "g_file_output_stream_query_info_async")]
-    fn query_info_async<P: FnOnce(Result<FileInfo, glib::Error>) + 'static>(
+    fn query_info_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<FileInfo, glib::Error>) + 'static,
+    >(
         &self,
         attributes: &str,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -70,10 +79,10 @@ pub trait FileOutputStreamExt: IsA<FileOutputStream> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn query_info_async_trampoline<
-            P: FnOnce(Result<FileInfo, glib::Error>) + 'static,
+            Q: FnOnce(Result<FileInfo, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -90,18 +99,23 @@ pub trait FileOutputStreamExt: IsA<FileOutputStream> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = query_info_async_trampoline::<P>;
+        let callback = query_info_async_trampoline::<Q>;
         unsafe {
             ffi::g_file_output_stream_query_info_async(
                 self.as_ref().to_glib_none().0,
                 attributes.to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gio/src/auto/functions.rs b/gio/src/auto/functions.rs
index aeecbd2a3814..c6cdf7703382 100644
--- a/gio/src/auto/functions.rs
+++ b/gio/src/auto/functions.rs
@@ -10,10 +10,14 @@ use glib::{prelude::*, translate::*};
 use std::{boxed::Box as Box_, pin::Pin};
 
 #[doc(alias = "g_bus_get")]
-pub fn bus_get<P: FnOnce(Result<DBusConnection, glib::Error>) + 'static>(
+pub fn bus_get<
+    'a,
+    P: IsA<Cancellable>,
+    Q: FnOnce(Result<DBusConnection, glib::Error>) + 'static,
+>(
     bus_type: BusType,
-    cancellable: Option<&impl IsA<Cancellable>>,
-    callback: P,
+    cancellable: impl Into<Option<&'a P>>,
+    callback: Q,
 ) {
     let main_context = glib::MainContext::ref_thread_default();
     let is_main_context_owner = main_context.is_owner();
@@ -25,10 +29,10 @@ pub fn bus_get<P: FnOnce(Result<DBusConnection, glib::Error>) + 'static>(
         "Async operations only allowed if the thread is owning the MainContext"
     );
 
-    let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+    let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
         Box_::new(glib::thread_guard::ThreadGuard::new(callback));
     unsafe extern "C" fn bus_get_trampoline<
-        P: FnOnce(Result<DBusConnection, glib::Error>) + 'static,
+        Q: FnOnce(Result<DBusConnection, glib::Error>) + 'static,
     >(
         _source_object: *mut glib::gobject_ffi::GObject,
         res: *mut crate::ffi::GAsyncResult,
@@ -41,16 +45,21 @@ pub fn bus_get<P: FnOnce(Result<DBusConnection, glib::Error>) + 'static>(
         } else {
             Err(from_glib_full(error))
         };
-        let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::from_raw(user_data as *mut _);
-        let callback: P = callback.into_inner();
+        let callback: Q = callback.into_inner();
         callback(result);
     }
-    let callback = bus_get_trampoline::<P>;
+    let callback = bus_get_trampoline::<Q>;
     unsafe {
         ffi::g_bus_get(
             bus_type.into_glib(),
-            cancellable.map(|p| p.as_ref()).to_glib_none().0,
+            cancellable
+                .into()
+                .as_ref()
+                .map(|p| p.as_ref())
+                .to_glib_none()
+                .0,
             Some(callback),
             Box_::into_raw(user_data) as *mut _,
         );
@@ -71,15 +80,20 @@ pub fn bus_get_future(
 }
 
 #[doc(alias = "g_bus_get_sync")]
-pub fn bus_get_sync(
+pub fn bus_get_sync<'a, P: IsA<Cancellable>>(
     bus_type: BusType,
-    cancellable: Option<&impl IsA<Cancellable>>,
+    cancellable: impl Into<Option<&'a P>>,
 ) -> Result<DBusConnection, glib::Error> {
     unsafe {
         let mut error = std::ptr::null_mut();
         let ret = ffi::g_bus_get_sync(
             bus_type.into_glib(),
-            cancellable.map(|p| p.as_ref()).to_glib_none().0,
+            cancellable
+                .into()
+                .as_ref()
+                .map(|p| p.as_ref())
+                .to_glib_none()
+                .0,
             &mut error,
         );
         if error.is_null() {
@@ -250,15 +264,20 @@ pub fn dbus_address_escape_value(string: &str) -> glib::GString {
 }
 
 #[doc(alias = "g_dbus_address_get_for_bus_sync")]
-pub fn dbus_address_get_for_bus_sync(
+pub fn dbus_address_get_for_bus_sync<'a, P: IsA<Cancellable>>(
     bus_type: BusType,
-    cancellable: Option<&impl IsA<Cancellable>>,
+    cancellable: impl Into<Option<&'a P>>,
 ) -> Result<glib::GString, glib::Error> {
     unsafe {
         let mut error = std::ptr::null_mut();
         let ret = ffi::g_dbus_address_get_for_bus_sync(
             bus_type.into_glib(),
-            cancellable.map(|p| p.as_ref()).to_glib_none().0,
+            cancellable
+                .into()
+                .as_ref()
+                .map(|p| p.as_ref())
+                .to_glib_none()
+                .0,
             &mut error,
         );
         if error.is_null() {
@@ -271,11 +290,13 @@ pub fn dbus_address_get_for_bus_sync(
 
 #[doc(alias = "g_dbus_address_get_stream")]
 pub fn dbus_address_get_stream<
-    P: FnOnce(Result<(IOStream, Option<glib::GString>), glib::Error>) + 'static,
+    'a,
+    P: IsA<Cancellable>,
+    Q: FnOnce(Result<(IOStream, Option<glib::GString>), glib::Error>) + 'static,
 >(
     address: &str,
-    cancellable: Option<&impl IsA<Cancellable>>,
-    callback: P,
+    cancellable: impl Into<Option<&'a P>>,
+    callback: Q,
 ) {
     let main_context = glib::MainContext::ref_thread_default();
     let is_main_context_owner = main_context.is_owner();
@@ -287,10 +308,10 @@ pub fn dbus_address_get_stream<
         "Async operations only allowed if the thread is owning the MainContext"
     );
 
-    let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+    let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
         Box_::new(glib::thread_guard::ThreadGuard::new(callback));
     unsafe extern "C" fn dbus_address_get_stream_trampoline<
-        P: FnOnce(Result<(IOStream, Option<glib::GString>), glib::Error>) + 'static,
+        Q: FnOnce(Result<(IOStream, Option<glib::GString>), glib::Error>) + 'static,
     >(
         _source_object: *mut glib::gobject_ffi::GObject,
         res: *mut crate::ffi::GAsyncResult,
@@ -304,16 +325,21 @@ pub fn dbus_address_get_stream<
         } else {
             Err(from_glib_full(error))
         };
-        let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::from_raw(user_data as *mut _);
-        let callback: P = callback.into_inner();
+        let callback: Q = callback.into_inner();
         callback(result);
     }
-    let callback = dbus_address_get_stream_trampoline::<P>;
+    let callback = dbus_address_get_stream_trampoline::<Q>;
     unsafe {
         ffi::g_dbus_address_get_stream(
             address.to_glib_none().0,
-            cancellable.map(|p| p.as_ref()).to_glib_none().0,
+            cancellable
+                .into()
+                .as_ref()
+                .map(|p| p.as_ref())
+                .to_glib_none()
+                .0,
             Some(callback),
             Box_::into_raw(user_data) as *mut _,
         );
@@ -340,9 +366,9 @@ pub fn dbus_address_get_stream_future(
 }
 
 #[doc(alias = "g_dbus_address_get_stream_sync")]
-pub fn dbus_address_get_stream_sync(
+pub fn dbus_address_get_stream_sync<'a, P: IsA<Cancellable>>(
     address: &str,
-    cancellable: Option<&impl IsA<Cancellable>>,
+    cancellable: impl Into<Option<&'a P>>,
 ) -> Result<(IOStream, Option<glib::GString>), glib::Error> {
     unsafe {
         let mut out_guid = std::ptr::null_mut();
@@ -350,7 +376,12 @@ pub fn dbus_address_get_stream_sync(
         let ret = ffi::g_dbus_address_get_stream_sync(
             address.to_glib_none().0,
             &mut out_guid,
-            cancellable.map(|p| p.as_ref()).to_glib_none().0,
+            cancellable
+                .into()
+                .as_ref()
+                .map(|p| p.as_ref())
+                .to_glib_none()
+                .0,
             &mut error,
         );
         if error.is_null() {
@@ -478,16 +509,16 @@ pub fn io_modules_scan_all_in_directory(dirname: impl AsRef<std::path::Path>) {
 //}
 
 #[doc(alias = "g_keyfile_settings_backend_new")]
-pub fn keyfile_settings_backend_new(
+pub fn keyfile_settings_backend_new<'a>(
     filename: &str,
     root_path: &str,
-    root_group: Option<&str>,
+    root_group: impl Into<Option<&'a str>>,
 ) -> SettingsBackend {
     unsafe {
         from_glib_full(ffi::g_keyfile_settings_backend_new(
             filename.to_glib_none().0,
             root_path.to_glib_none().0,
-            root_group.to_glib_none().0,
+            root_group.into().to_glib_none().0,
         ))
     }
 }
diff --git a/gio/src/auto/icon.rs b/gio/src/auto/icon.rs
index 596b692364ec..6bda8f0e9355 100644
--- a/gio/src/auto/icon.rs
+++ b/gio/src/auto/icon.rs
@@ -39,11 +39,11 @@ impl Icon {
 
 pub trait IconExt: IsA<Icon> + 'static {
     #[doc(alias = "g_icon_equal")]
-    fn equal(&self, icon2: Option<&impl IsA<Icon>>) -> bool {
+    fn equal<'a, P: IsA<Icon>>(&self, icon2: impl Into<Option<&'a P>>) -> bool {
         unsafe {
             from_glib(ffi::g_icon_equal(
                 self.as_ref().to_glib_none().0,
-                icon2.map(|p| p.as_ref()).to_glib_none().0,
+                icon2.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
             ))
         }
     }
diff --git a/gio/src/auto/inet_address_mask.rs b/gio/src/auto/inet_address_mask.rs
index cdc41af6f440..6ef8730a5161 100644
--- a/gio/src/auto/inet_address_mask.rs
+++ b/gio/src/auto/inet_address_mask.rs
@@ -119,8 +119,12 @@ pub trait InetAddressMaskExt: IsA<InetAddressMask> + 'static {
         }
     }
 
-    fn set_address<P: IsA<InetAddress>>(&self, address: Option<&P>) {
-        ObjectExt::set_property(self.as_ref(), "address", address)
+    fn set_address<'a, P: IsA<InetAddress>>(&self, address: impl Into<Option<&'a P>>) {
+        ObjectExt::set_property(
+            self.as_ref(),
+            "address",
+            address.into().as_ref().map(|p| p.as_ref()),
+        )
     }
 
     fn set_length(&self, length: u32) {
diff --git a/gio/src/auto/initable.rs b/gio/src/auto/initable.rs
index e8524cfb1185..48c514173a50 100644
--- a/gio/src/auto/initable.rs
+++ b/gio/src/auto/initable.rs
@@ -20,11 +20,19 @@ impl Initable {
 
 pub trait InitableExt: IsA<Initable> + 'static {
     #[doc(alias = "g_initable_init")]
-    unsafe fn init(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
+    unsafe fn init<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<(), glib::Error> {
         let mut error = std::ptr::null_mut();
         let is_ok = ffi::g_initable_init(
             self.as_ref().to_glib_none().0,
-            cancellable.map(|p| p.as_ref()).to_glib_none().0,
+            cancellable
+                .into()
+                .as_ref()
+                .map(|p| p.as_ref())
+                .to_glib_none()
+                .0,
             &mut error,
         );
         debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
diff --git a/gio/src/auto/input_stream.rs b/gio/src/auto/input_stream.rs
index bac40542b5ad..2793b576762d 100644
--- a/gio/src/auto/input_stream.rs
+++ b/gio/src/auto/input_stream.rs
@@ -28,12 +28,20 @@ pub trait InputStreamExt: IsA<InputStream> + 'static {
     }
 
     #[doc(alias = "g_input_stream_close")]
-    fn close(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
+    fn close<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_input_stream_close(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -46,11 +54,11 @@ pub trait InputStreamExt: IsA<InputStream> + 'static {
     }
 
     #[doc(alias = "g_input_stream_close_async")]
-    fn close_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn close_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -62,10 +70,10 @@ pub trait InputStreamExt: IsA<InputStream> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn close_async_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            Q: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -78,17 +86,22 @@ pub trait InputStreamExt: IsA<InputStream> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = close_async_trampoline::<P>;
+        let callback = close_async_trampoline::<Q>;
         unsafe {
             ffi::g_input_stream_close_async(
                 self.as_ref().to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -128,17 +141,22 @@ pub trait InputStreamExt: IsA<InputStream> + 'static {
     }
 
     #[doc(alias = "g_input_stream_read_bytes")]
-    fn read_bytes(
+    fn read_bytes<'a, P: IsA<Cancellable>>(
         &self,
         count: usize,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<glib::Bytes, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_input_stream_read_bytes(
                 self.as_ref().to_glib_none().0,
                 count,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -150,12 +168,16 @@ pub trait InputStreamExt: IsA<InputStream> + 'static {
     }
 
     #[doc(alias = "g_input_stream_read_bytes_async")]
-    fn read_bytes_async<P: FnOnce(Result<glib::Bytes, glib::Error>) + 'static>(
+    fn read_bytes_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<glib::Bytes, glib::Error>) + 'static,
+    >(
         &self,
         count: usize,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -167,10 +189,10 @@ pub trait InputStreamExt: IsA<InputStream> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn read_bytes_async_trampoline<
-            P: FnOnce(Result<glib::Bytes, glib::Error>) + 'static,
+            Q: FnOnce(Result<glib::Bytes, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -184,18 +206,23 @@ pub trait InputStreamExt: IsA<InputStream> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = read_bytes_async_trampoline::<P>;
+        let callback = read_bytes_async_trampoline::<Q>;
         unsafe {
             ffi::g_input_stream_read_bytes_async(
                 self.as_ref().to_glib_none().0,
                 count,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -233,17 +260,22 @@ pub trait InputStreamExt: IsA<InputStream> + 'static {
     }
 
     #[doc(alias = "g_input_stream_skip")]
-    fn skip(
+    fn skip<'a, P: IsA<Cancellable>>(
         &self,
         count: usize,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<isize, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_input_stream_skip(
                 self.as_ref().to_glib_none().0,
                 count,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -255,12 +287,12 @@ pub trait InputStreamExt: IsA<InputStream> + 'static {
     }
 
     #[doc(alias = "g_input_stream_skip_async")]
-    fn skip_async<P: FnOnce(Result<isize, glib::Error>) + 'static>(
+    fn skip_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<isize, glib::Error>) + 'static>(
         &self,
         count: usize,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -272,10 +304,10 @@ pub trait InputStreamExt: IsA<InputStream> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn skip_async_trampoline<
-            P: FnOnce(Result<isize, glib::Error>) + 'static,
+            Q: FnOnce(Result<isize, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -288,18 +320,23 @@ pub trait InputStreamExt: IsA<InputStream> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = skip_async_trampoline::<P>;
+        let callback = skip_async_trampoline::<Q>;
         unsafe {
             ffi::g_input_stream_skip_async(
                 self.as_ref().to_glib_none().0,
                 count,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gio/src/auto/io_stream.rs b/gio/src/auto/io_stream.rs
index 7cdc957bf934..fc5b37021702 100644
--- a/gio/src/auto/io_stream.rs
+++ b/gio/src/auto/io_stream.rs
@@ -32,12 +32,20 @@ pub trait IOStreamExt: IsA<IOStream> + 'static {
     }
 
     #[doc(alias = "g_io_stream_close")]
-    fn close(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
+    fn close<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_io_stream_close(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -50,11 +58,11 @@ pub trait IOStreamExt: IsA<IOStream> + 'static {
     }
 
     #[doc(alias = "g_io_stream_close_async")]
-    fn close_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn close_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -66,10 +74,10 @@ pub trait IOStreamExt: IsA<IOStream> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn close_async_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            Q: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -82,17 +90,22 @@ pub trait IOStreamExt: IsA<IOStream> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = close_async_trampoline::<P>;
+        let callback = close_async_trampoline::<Q>;
         unsafe {
             ffi::g_io_stream_close_async(
                 self.as_ref().to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gio/src/auto/loadable_icon.rs b/gio/src/auto/loadable_icon.rs
index c21e1c18ddf6..aa1bcc72f0e6 100644
--- a/gio/src/auto/loadable_icon.rs
+++ b/gio/src/auto/loadable_icon.rs
@@ -21,10 +21,10 @@ impl LoadableIcon {
 
 pub trait LoadableIconExt: IsA<LoadableIcon> + 'static {
     #[doc(alias = "g_loadable_icon_load")]
-    fn load(
+    fn load<'a, P: IsA<Cancellable>>(
         &self,
         size: i32,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(InputStream, glib::GString), glib::Error> {
         unsafe {
             let mut type_ = std::ptr::null_mut();
@@ -33,7 +33,12 @@ pub trait LoadableIconExt: IsA<LoadableIcon> + 'static {
                 self.as_ref().to_glib_none().0,
                 size,
                 &mut type_,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -45,11 +50,15 @@ pub trait LoadableIconExt: IsA<LoadableIcon> + 'static {
     }
 
     #[doc(alias = "g_loadable_icon_load_async")]
-    fn load_async<P: FnOnce(Result<(InputStream, glib::GString), glib::Error>) + 'static>(
+    fn load_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<(InputStream, glib::GString), glib::Error>) + 'static,
+    >(
         &self,
         size: i32,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -61,10 +70,10 @@ pub trait LoadableIconExt: IsA<LoadableIcon> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn load_async_trampoline<
-            P: FnOnce(Result<(InputStream, glib::GString), glib::Error>) + 'static,
+            Q: FnOnce(Result<(InputStream, glib::GString), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -83,17 +92,22 @@ pub trait LoadableIconExt: IsA<LoadableIcon> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = load_async_trampoline::<P>;
+        let callback = load_async_trampoline::<Q>;
         unsafe {
             ffi::g_loadable_icon_load_async(
                 self.as_ref().to_glib_none().0,
                 size,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gio/src/auto/menu.rs b/gio/src/auto/menu.rs
index 30dbaa216462..4c613f0e8b1c 100644
--- a/gio/src/auto/menu.rs
+++ b/gio/src/auto/menu.rs
@@ -21,12 +21,16 @@ impl Menu {
     }
 
     #[doc(alias = "g_menu_append")]
-    pub fn append(&self, label: Option<&str>, detailed_action: Option<&str>) {
+    pub fn append<'a>(
+        &self,
+        label: impl Into<Option<&'a str>>,
+        detailed_action: impl Into<Option<&'a str>>,
+    ) {
         unsafe {
             ffi::g_menu_append(
                 self.to_glib_none().0,
-                label.to_glib_none().0,
-                detailed_action.to_glib_none().0,
+                label.into().to_glib_none().0,
+                detailed_action.into().to_glib_none().0,
             );
         }
     }
@@ -39,22 +43,30 @@ impl Menu {
     }
 
     #[doc(alias = "g_menu_append_section")]
-    pub fn append_section(&self, label: Option<&str>, section: &impl IsA<MenuModel>) {
+    pub fn append_section<'a>(
+        &self,
+        label: impl Into<Option<&'a str>>,
+        section: &impl IsA<MenuModel>,
+    ) {
         unsafe {
             ffi::g_menu_append_section(
                 self.to_glib_none().0,
-                label.to_glib_none().0,
+                label.into().to_glib_none().0,
                 section.as_ref().to_glib_none().0,
             );
         }
     }
 
     #[doc(alias = "g_menu_append_submenu")]
-    pub fn append_submenu(&self, label: Option<&str>, submenu: &impl IsA<MenuModel>) {
+    pub fn append_submenu<'a>(
+        &self,
+        label: impl Into<Option<&'a str>>,
+        submenu: &impl IsA<MenuModel>,
+    ) {
         unsafe {
             ffi::g_menu_append_submenu(
                 self.to_glib_none().0,
-                label.to_glib_none().0,
+                label.into().to_glib_none().0,
                 submenu.as_ref().to_glib_none().0,
             );
         }
@@ -68,13 +80,18 @@ impl Menu {
     }
 
     #[doc(alias = "g_menu_insert")]
-    pub fn insert(&self, position: i32, label: Option<&str>, detailed_action: Option<&str>) {
+    pub fn insert<'a>(
+        &self,
+        position: i32,
+        label: impl Into<Option<&'a str>>,
+        detailed_action: impl Into<Option<&'a str>>,
+    ) {
         unsafe {
             ffi::g_menu_insert(
                 self.to_glib_none().0,
                 position,
-                label.to_glib_none().0,
-                detailed_action.to_glib_none().0,
+                label.into().to_glib_none().0,
+                detailed_action.into().to_glib_none().0,
             );
         }
     }
@@ -87,46 +104,50 @@ impl Menu {
     }
 
     #[doc(alias = "g_menu_insert_section")]
-    pub fn insert_section(
+    pub fn insert_section<'a>(
         &self,
         position: i32,
-        label: Option<&str>,
+        label: impl Into<Option<&'a str>>,
         section: &impl IsA<MenuModel>,
     ) {
         unsafe {
             ffi::g_menu_insert_section(
                 self.to_glib_none().0,
                 position,
-                label.to_glib_none().0,
+                label.into().to_glib_none().0,
                 section.as_ref().to_glib_none().0,
             );
         }
     }
 
     #[doc(alias = "g_menu_insert_submenu")]
-    pub fn insert_submenu(
+    pub fn insert_submenu<'a>(
         &self,
         position: i32,
-        label: Option<&str>,
+        label: impl Into<Option<&'a str>>,
         submenu: &impl IsA<MenuModel>,
     ) {
         unsafe {
             ffi::g_menu_insert_submenu(
                 self.to_glib_none().0,
                 position,
-                label.to_glib_none().0,
+                label.into().to_glib_none().0,
                 submenu.as_ref().to_glib_none().0,
             );
         }
     }
 
     #[doc(alias = "g_menu_prepend")]
-    pub fn prepend(&self, label: Option<&str>, detailed_action: Option<&str>) {
+    pub fn prepend<'a>(
+        &self,
+        label: impl Into<Option<&'a str>>,
+        detailed_action: impl Into<Option<&'a str>>,
+    ) {
         unsafe {
             ffi::g_menu_prepend(
                 self.to_glib_none().0,
-                label.to_glib_none().0,
-                detailed_action.to_glib_none().0,
+                label.into().to_glib_none().0,
+                detailed_action.into().to_glib_none().0,
             );
         }
     }
@@ -139,22 +160,30 @@ impl Menu {
     }
 
     #[doc(alias = "g_menu_prepend_section")]
-    pub fn prepend_section(&self, label: Option<&str>, section: &impl IsA<MenuModel>) {
+    pub fn prepend_section<'a>(
+        &self,
+        label: impl Into<Option<&'a str>>,
+        section: &impl IsA<MenuModel>,
+    ) {
         unsafe {
             ffi::g_menu_prepend_section(
                 self.to_glib_none().0,
-                label.to_glib_none().0,
+                label.into().to_glib_none().0,
                 section.as_ref().to_glib_none().0,
             );
         }
     }
 
     #[doc(alias = "g_menu_prepend_submenu")]
-    pub fn prepend_submenu(&self, label: Option<&str>, submenu: &impl IsA<MenuModel>) {
+    pub fn prepend_submenu<'a>(
+        &self,
+        label: impl Into<Option<&'a str>>,
+        submenu: &impl IsA<MenuModel>,
+    ) {
         unsafe {
             ffi::g_menu_prepend_submenu(
                 self.to_glib_none().0,
-                label.to_glib_none().0,
+                label.into().to_glib_none().0,
                 submenu.as_ref().to_glib_none().0,
             );
         }
diff --git a/gio/src/auto/menu_item.rs b/gio/src/auto/menu_item.rs
index 588781744440..96f5015c7768 100644
--- a/gio/src/auto/menu_item.rs
+++ b/gio/src/auto/menu_item.rs
@@ -16,11 +16,14 @@ glib::wrapper! {
 
 impl MenuItem {
     #[doc(alias = "g_menu_item_new")]
-    pub fn new(label: Option<&str>, detailed_action: Option<&str>) -> MenuItem {
+    pub fn new<'a>(
+        label: impl Into<Option<&'a str>>,
+        detailed_action: impl Into<Option<&'a str>>,
+    ) -> MenuItem {
         unsafe {
             from_glib_full(ffi::g_menu_item_new(
-                label.to_glib_none().0,
-                detailed_action.to_glib_none().0,
+                label.into().to_glib_none().0,
+                detailed_action.into().to_glib_none().0,
             ))
         }
     }
@@ -37,20 +40,26 @@ impl MenuItem {
     }
 
     #[doc(alias = "g_menu_item_new_section")]
-    pub fn new_section(label: Option<&str>, section: &impl IsA<MenuModel>) -> MenuItem {
+    pub fn new_section<'a>(
+        label: impl Into<Option<&'a str>>,
+        section: &impl IsA<MenuModel>,
+    ) -> MenuItem {
         unsafe {
             from_glib_full(ffi::g_menu_item_new_section(
-                label.to_glib_none().0,
+                label.into().to_glib_none().0,
                 section.as_ref().to_glib_none().0,
             ))
         }
     }
 
     #[doc(alias = "g_menu_item_new_submenu")]
-    pub fn new_submenu(label: Option<&str>, submenu: &impl IsA<MenuModel>) -> MenuItem {
+    pub fn new_submenu<'a>(
+        label: impl Into<Option<&'a str>>,
+        submenu: &impl IsA<MenuModel>,
+    ) -> MenuItem {
         unsafe {
             from_glib_full(ffi::g_menu_item_new_submenu(
-                label.to_glib_none().0,
+                label.into().to_glib_none().0,
                 submenu.as_ref().to_glib_none().0,
             ))
         }
@@ -58,22 +67,22 @@ impl MenuItem {
 
     //#[doc(alias = "g_menu_item_get_attribute")]
     //#[doc(alias = "get_attribute")]
-    //pub fn is_attribute(&self, attribute: &str, format_string: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> bool {
+    //pub fn is_attribute(&self, attribute: &str, format_string: &str, : /*Unimplemented*/Basic: VarArgs) -> bool {
     //    unsafe { TODO: call ffi:g_menu_item_get_attribute() }
     //}
 
     #[doc(alias = "g_menu_item_get_attribute_value")]
     #[doc(alias = "get_attribute_value")]
-    pub fn attribute_value(
+    pub fn attribute_value<'a>(
         &self,
         attribute: &str,
-        expected_type: Option<&glib::VariantTy>,
+        expected_type: impl Into<Option<&'a glib::VariantTy>>,
     ) -> Option<glib::Variant> {
         unsafe {
             from_glib_full(ffi::g_menu_item_get_attribute_value(
                 self.to_glib_none().0,
                 attribute.to_glib_none().0,
-                expected_type.to_glib_none().0,
+                expected_type.into().to_glib_none().0,
             ))
         }
     }
@@ -90,37 +99,41 @@ impl MenuItem {
     }
 
     //#[doc(alias = "g_menu_item_set_action_and_target")]
-    //pub fn set_action_and_target(&self, action: Option<&str>, format_string: Option<&str>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
+    //pub fn set_action_and_target<'a>(&self, action: impl Into<Option<&'a str>>, format_string: impl Into<Option<&'a str>>, : /*Unimplemented*/Basic: VarArgs) {
     //    unsafe { TODO: call ffi:g_menu_item_set_action_and_target() }
     //}
 
     #[doc(alias = "g_menu_item_set_action_and_target_value")]
-    pub fn set_action_and_target_value(
+    pub fn set_action_and_target_value<'a>(
         &self,
-        action: Option<&str>,
-        target_value: Option<&glib::Variant>,
+        action: impl Into<Option<&'a str>>,
+        target_value: impl Into<Option<&'a glib::Variant>>,
     ) {
         unsafe {
             ffi::g_menu_item_set_action_and_target_value(
                 self.to_glib_none().0,
-                action.to_glib_none().0,
-                target_value.to_glib_none().0,
+                action.into().to_glib_none().0,
+                target_value.into().to_glib_none().0,
             );
         }
     }
 
     //#[doc(alias = "g_menu_item_set_attribute")]
-    //pub fn set_attribute(&self, attribute: &str, format_string: Option<&str>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
+    //pub fn set_attribute<'a>(&self, attribute: &str, format_string: impl Into<Option<&'a str>>, : /*Unimplemented*/Basic: VarArgs) {
     //    unsafe { TODO: call ffi:g_menu_item_set_attribute() }
     //}
 
     #[doc(alias = "g_menu_item_set_attribute_value")]
-    pub fn set_attribute_value(&self, attribute: &str, value: Option<&glib::Variant>) {
+    pub fn set_attribute_value<'a>(
+        &self,
+        attribute: &str,
+        value: impl Into<Option<&'a glib::Variant>>,
+    ) {
         unsafe {
             ffi::g_menu_item_set_attribute_value(
                 self.to_glib_none().0,
                 attribute.to_glib_none().0,
-                value.to_glib_none().0,
+                value.into().to_glib_none().0,
             );
         }
     }
@@ -143,39 +156,39 @@ impl MenuItem {
     }
 
     #[doc(alias = "g_menu_item_set_label")]
-    pub fn set_label(&self, label: Option<&str>) {
+    pub fn set_label<'a>(&self, label: impl Into<Option<&'a str>>) {
         unsafe {
-            ffi::g_menu_item_set_label(self.to_glib_none().0, label.to_glib_none().0);
+            ffi::g_menu_item_set_label(self.to_glib_none().0, label.into().to_glib_none().0);
         }
     }
 
     #[doc(alias = "g_menu_item_set_link")]
-    pub fn set_link(&self, link: &str, model: Option<&impl IsA<MenuModel>>) {
+    pub fn set_link<'a, P: IsA<MenuModel>>(&self, link: &str, model: impl Into<Option<&'a P>>) {
         unsafe {
             ffi::g_menu_item_set_link(
                 self.to_glib_none().0,
                 link.to_glib_none().0,
-                model.map(|p| p.as_ref()).to_glib_none().0,
+                model.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
             );
         }
     }
 
     #[doc(alias = "g_menu_item_set_section")]
-    pub fn set_section(&self, section: Option<&impl IsA<MenuModel>>) {
+    pub fn set_section<'a, P: IsA<MenuModel>>(&self, section: impl Into<Option<&'a P>>) {
         unsafe {
             ffi::g_menu_item_set_section(
                 self.to_glib_none().0,
-                section.map(|p| p.as_ref()).to_glib_none().0,
+                section.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
             );
         }
     }
 
     #[doc(alias = "g_menu_item_set_submenu")]
-    pub fn set_submenu(&self, submenu: Option<&impl IsA<MenuModel>>) {
+    pub fn set_submenu<'a, P: IsA<MenuModel>>(&self, submenu: impl Into<Option<&'a P>>) {
         unsafe {
             ffi::g_menu_item_set_submenu(
                 self.to_glib_none().0,
-                submenu.map(|p| p.as_ref()).to_glib_none().0,
+                submenu.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
             );
         }
     }
diff --git a/gio/src/auto/menu_model.rs b/gio/src/auto/menu_model.rs
index 7a2b2f0742f6..535bf314f994 100644
--- a/gio/src/auto/menu_model.rs
+++ b/gio/src/auto/menu_model.rs
@@ -26,24 +26,24 @@ impl MenuModel {
 pub trait MenuModelExt: IsA<MenuModel> + 'static {
     //#[doc(alias = "g_menu_model_get_item_attribute")]
     //#[doc(alias = "get_item_attribute")]
-    //fn is_item_attribute(&self, item_index: i32, attribute: &str, format_string: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> bool {
+    //fn is_item_attribute(&self, item_index: i32, attribute: &str, format_string: &str, : /*Unimplemented*/Basic: VarArgs) -> bool {
     //    unsafe { TODO: call ffi:g_menu_model_get_item_attribute() }
     //}
 
     #[doc(alias = "g_menu_model_get_item_attribute_value")]
     #[doc(alias = "get_item_attribute_value")]
-    fn item_attribute_value(
+    fn item_attribute_value<'a>(
         &self,
         item_index: i32,
         attribute: &str,
-        expected_type: Option<&glib::VariantTy>,
+        expected_type: impl Into<Option<&'a glib::VariantTy>>,
     ) -> Option<glib::Variant> {
         unsafe {
             from_glib_full(ffi::g_menu_model_get_item_attribute_value(
                 self.as_ref().to_glib_none().0,
                 item_index,
                 attribute.to_glib_none().0,
-                expected_type.to_glib_none().0,
+                expected_type.into().to_glib_none().0,
             ))
         }
     }
diff --git a/gio/src/auto/mount.rs b/gio/src/auto/mount.rs
index 4e102fa9661c..e30af8f2251a 100644
--- a/gio/src/auto/mount.rs
+++ b/gio/src/auto/mount.rs
@@ -38,12 +38,17 @@ pub trait MountExt: IsA<Mount> + 'static {
     }
 
     #[doc(alias = "g_mount_eject_with_operation")]
-    fn eject_with_operation<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn eject_with_operation<
+        'a,
+        P: IsA<MountOperation>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<(), glib::Error>) + 'static,
+    >(
         &self,
         flags: MountUnmountFlags,
-        mount_operation: Option<&impl IsA<MountOperation>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        mount_operation: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -55,10 +60,10 @@ pub trait MountExt: IsA<Mount> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn eject_with_operation_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            R: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -72,30 +77,40 @@ pub trait MountExt: IsA<Mount> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = eject_with_operation_trampoline::<P>;
+        let callback = eject_with_operation_trampoline::<R>;
         unsafe {
             ffi::g_mount_eject_with_operation(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                mount_operation
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn eject_with_operation_future(
+    fn eject_with_operation_future<'a, P: IsA<MountOperation> + Clone + 'static>(
         &self,
         flags: MountUnmountFlags,
-        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
+        mount_operation: impl Into<Option<&'a P>>,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
-        let mount_operation = mount_operation.map(ToOwned::to_owned);
+        let mount_operation = mount_operation.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -174,11 +189,15 @@ pub trait MountExt: IsA<Mount> + 'static {
     }
 
     #[doc(alias = "g_mount_guess_content_type")]
-    fn guess_content_type<P: FnOnce(Result<Vec<glib::GString>, glib::Error>) + 'static>(
+    fn guess_content_type<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<Vec<glib::GString>, glib::Error>) + 'static,
+    >(
         &self,
         force_rescan: bool,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -190,10 +209,10 @@ pub trait MountExt: IsA<Mount> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn guess_content_type_trampoline<
-            P: FnOnce(Result<Vec<glib::GString>, glib::Error>) + 'static,
+            Q: FnOnce(Result<Vec<glib::GString>, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -207,17 +226,22 @@ pub trait MountExt: IsA<Mount> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = guess_content_type_trampoline::<P>;
+        let callback = guess_content_type_trampoline::<Q>;
         unsafe {
             ffi::g_mount_guess_content_type(
                 self.as_ref().to_glib_none().0,
                 force_rescan.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -241,17 +265,22 @@ pub trait MountExt: IsA<Mount> + 'static {
     }
 
     #[doc(alias = "g_mount_guess_content_type_sync")]
-    fn guess_content_type_sync(
+    fn guess_content_type_sync<'a, P: IsA<Cancellable>>(
         &self,
         force_rescan: bool,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<Vec<glib::GString>, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_mount_guess_content_type_sync(
                 self.as_ref().to_glib_none().0,
                 force_rescan.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -268,12 +297,17 @@ pub trait MountExt: IsA<Mount> + 'static {
     }
 
     #[doc(alias = "g_mount_remount")]
-    fn remount<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn remount<
+        'a,
+        P: IsA<MountOperation>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<(), glib::Error>) + 'static,
+    >(
         &self,
         flags: MountMountFlags,
-        mount_operation: Option<&impl IsA<MountOperation>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        mount_operation: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -285,9 +319,9 @@ pub trait MountExt: IsA<Mount> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
-        unsafe extern "C" fn remount_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
+        unsafe extern "C" fn remount_trampoline<R: FnOnce(Result<(), glib::Error>) + 'static>(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
             user_data: glib::ffi::gpointer,
@@ -299,30 +333,40 @@ pub trait MountExt: IsA<Mount> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = remount_trampoline::<P>;
+        let callback = remount_trampoline::<R>;
         unsafe {
             ffi::g_mount_remount(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                mount_operation
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn remount_future(
+    fn remount_future<'a, P: IsA<MountOperation> + Clone + 'static>(
         &self,
         flags: MountMountFlags,
-        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
+        mount_operation: impl Into<Option<&'a P>>,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
-        let mount_operation = mount_operation.map(ToOwned::to_owned);
+        let mount_operation = mount_operation.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -346,12 +390,17 @@ pub trait MountExt: IsA<Mount> + 'static {
     }
 
     #[doc(alias = "g_mount_unmount_with_operation")]
-    fn unmount_with_operation<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn unmount_with_operation<
+        'a,
+        P: IsA<MountOperation>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<(), glib::Error>) + 'static,
+    >(
         &self,
         flags: MountUnmountFlags,
-        mount_operation: Option<&impl IsA<MountOperation>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        mount_operation: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -363,10 +412,10 @@ pub trait MountExt: IsA<Mount> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn unmount_with_operation_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            R: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -383,30 +432,40 @@ pub trait MountExt: IsA<Mount> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = unmount_with_operation_trampoline::<P>;
+        let callback = unmount_with_operation_trampoline::<R>;
         unsafe {
             ffi::g_mount_unmount_with_operation(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                mount_operation
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn unmount_with_operation_future(
+    fn unmount_with_operation_future<'a, P: IsA<MountOperation> + Clone + 'static>(
         &self,
         flags: MountUnmountFlags,
-        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
+        mount_operation: impl Into<Option<&'a P>>,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
-        let mount_operation = mount_operation.map(ToOwned::to_owned);
+        let mount_operation = mount_operation.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
diff --git a/gio/src/auto/mount_operation.rs b/gio/src/auto/mount_operation.rs
index 8799d7de4f1a..a90a0ce762d8 100644
--- a/gio/src/auto/mount_operation.rs
+++ b/gio/src/auto/mount_operation.rs
@@ -155,11 +155,11 @@ pub trait MountOperationExt: IsA<MountOperation> + 'static {
 
     #[doc(alias = "g_mount_operation_set_domain")]
     #[doc(alias = "domain")]
-    fn set_domain(&self, domain: Option<&str>) {
+    fn set_domain<'a>(&self, domain: impl Into<Option<&'a str>>) {
         unsafe {
             ffi::g_mount_operation_set_domain(
                 self.as_ref().to_glib_none().0,
-                domain.to_glib_none().0,
+                domain.into().to_glib_none().0,
             );
         }
     }
@@ -192,11 +192,11 @@ pub trait MountOperationExt: IsA<MountOperation> + 'static {
 
     #[doc(alias = "g_mount_operation_set_password")]
     #[doc(alias = "password")]
-    fn set_password(&self, password: Option<&str>) {
+    fn set_password<'a>(&self, password: impl Into<Option<&'a str>>) {
         unsafe {
             ffi::g_mount_operation_set_password(
                 self.as_ref().to_glib_none().0,
-                password.to_glib_none().0,
+                password.into().to_glib_none().0,
             );
         }
     }
@@ -224,11 +224,11 @@ pub trait MountOperationExt: IsA<MountOperation> + 'static {
 
     #[doc(alias = "g_mount_operation_set_username")]
     #[doc(alias = "username")]
-    fn set_username(&self, username: Option<&str>) {
+    fn set_username<'a>(&self, username: impl Into<Option<&'a str>>) {
         unsafe {
             ffi::g_mount_operation_set_username(
                 self.as_ref().to_glib_none().0,
-                username.to_glib_none().0,
+                username.into().to_glib_none().0,
             );
         }
     }
diff --git a/gio/src/auto/network_monitor.rs b/gio/src/auto/network_monitor.rs
index abad9d7e39af..1f972f10e0f8 100644
--- a/gio/src/auto/network_monitor.rs
+++ b/gio/src/auto/network_monitor.rs
@@ -32,17 +32,22 @@ impl NetworkMonitor {
 
 pub trait NetworkMonitorExt: IsA<NetworkMonitor> + 'static {
     #[doc(alias = "g_network_monitor_can_reach")]
-    fn can_reach(
+    fn can_reach<'a, P: IsA<Cancellable>>(
         &self,
         connectable: &impl IsA<SocketConnectable>,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_network_monitor_can_reach(
                 self.as_ref().to_glib_none().0,
                 connectable.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -55,11 +60,11 @@ pub trait NetworkMonitorExt: IsA<NetworkMonitor> + 'static {
     }
 
     #[doc(alias = "g_network_monitor_can_reach_async")]
-    fn can_reach_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn can_reach_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
         connectable: &impl IsA<SocketConnectable>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -71,10 +76,10 @@ pub trait NetworkMonitorExt: IsA<NetworkMonitor> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn can_reach_async_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            Q: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -88,17 +93,22 @@ pub trait NetworkMonitorExt: IsA<NetworkMonitor> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = can_reach_async_trampoline::<P>;
+        let callback = can_reach_async_trampoline::<Q>;
         unsafe {
             ffi::g_network_monitor_can_reach_async(
                 self.as_ref().to_glib_none().0,
                 connectable.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gio/src/auto/notification.rs b/gio/src/auto/notification.rs
index 2932c8e4e300..19f8f33f292a 100644
--- a/gio/src/auto/notification.rs
+++ b/gio/src/auto/notification.rs
@@ -32,40 +32,43 @@ impl Notification {
     }
 
     //#[doc(alias = "g_notification_add_button_with_target")]
-    //pub fn add_button_with_target(&self, label: &str, action: &str, target_format: Option<&str>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
+    //pub fn add_button_with_target<'a>(&self, label: &str, action: &str, target_format: impl Into<Option<&'a str>>, : /*Unimplemented*/Basic: VarArgs) {
     //    unsafe { TODO: call ffi:g_notification_add_button_with_target() }
     //}
 
     #[doc(alias = "g_notification_add_button_with_target_value")]
-    pub fn add_button_with_target_value(
+    pub fn add_button_with_target_value<'a>(
         &self,
         label: &str,
         action: &str,
-        target: Option<&glib::Variant>,
+        target: impl Into<Option<&'a glib::Variant>>,
     ) {
         unsafe {
             ffi::g_notification_add_button_with_target_value(
                 self.to_glib_none().0,
                 label.to_glib_none().0,
                 action.to_glib_none().0,
-                target.to_glib_none().0,
+                target.into().to_glib_none().0,
             );
         }
     }
 
     #[doc(alias = "g_notification_set_body")]
-    pub fn set_body(&self, body: Option<&str>) {
+    pub fn set_body<'a>(&self, body: impl Into<Option<&'a str>>) {
         unsafe {
-            ffi::g_notification_set_body(self.to_glib_none().0, body.to_glib_none().0);
+            ffi::g_notification_set_body(self.to_glib_none().0, body.into().to_glib_none().0);
         }
     }
 
     #[cfg(feature = "v2_70")]
     #[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
     #[doc(alias = "g_notification_set_category")]
-    pub fn set_category(&self, category: Option<&str>) {
+    pub fn set_category<'a>(&self, category: impl Into<Option<&'a str>>) {
         unsafe {
-            ffi::g_notification_set_category(self.to_glib_none().0, category.to_glib_none().0);
+            ffi::g_notification_set_category(
+                self.to_glib_none().0,
+                category.into().to_glib_none().0,
+            );
         }
     }
 
@@ -80,21 +83,21 @@ impl Notification {
     }
 
     //#[doc(alias = "g_notification_set_default_action_and_target")]
-    //pub fn set_default_action_and_target(&self, action: &str, target_format: Option<&str>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
+    //pub fn set_default_action_and_target<'a>(&self, action: &str, target_format: impl Into<Option<&'a str>>, : /*Unimplemented*/Basic: VarArgs) {
     //    unsafe { TODO: call ffi:g_notification_set_default_action_and_target() }
     //}
 
     #[doc(alias = "g_notification_set_default_action_and_target_value")]
-    pub fn set_default_action_and_target_value(
+    pub fn set_default_action_and_target_value<'a>(
         &self,
         action: &str,
-        target: Option<&glib::Variant>,
+        target: impl Into<Option<&'a glib::Variant>>,
     ) {
         unsafe {
             ffi::g_notification_set_default_action_and_target_value(
                 self.to_glib_none().0,
                 action.to_glib_none().0,
-                target.to_glib_none().0,
+                target.into().to_glib_none().0,
             );
         }
     }
diff --git a/gio/src/auto/output_stream.rs b/gio/src/auto/output_stream.rs
index 7f8edecba198..981ba27db4dc 100644
--- a/gio/src/auto/output_stream.rs
+++ b/gio/src/auto/output_stream.rs
@@ -28,12 +28,20 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
     }
 
     #[doc(alias = "g_output_stream_close")]
-    fn close(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
+    fn close<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_output_stream_close(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -46,11 +54,11 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
     }
 
     #[doc(alias = "g_output_stream_close_async")]
-    fn close_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn close_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -62,10 +70,10 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn close_async_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            Q: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -78,17 +86,22 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = close_async_trampoline::<P>;
+        let callback = close_async_trampoline::<Q>;
         unsafe {
             ffi::g_output_stream_close_async(
                 self.as_ref().to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -110,12 +123,20 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
     }
 
     #[doc(alias = "g_output_stream_flush")]
-    fn flush(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
+    fn flush<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_output_stream_flush(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -128,11 +149,11 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
     }
 
     #[doc(alias = "g_output_stream_flush_async")]
-    fn flush_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn flush_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -144,10 +165,10 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn flush_async_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            Q: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -160,17 +181,22 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = flush_async_trampoline::<P>;
+        let callback = flush_async_trampoline::<Q>;
         unsafe {
             ffi::g_output_stream_flush_async(
                 self.as_ref().to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -219,7 +245,7 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
     }
 
     //#[doc(alias = "g_output_stream_printf")]
-    //fn printf(&self, cancellable: Option<&impl IsA<Cancellable>>, error: &mut glib::Error, format: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Option<usize> {
+    //fn printf<'a, P: IsA<Cancellable>>(&self, cancellable: impl Into<Option<&'a P>>, error: &mut glib::Error, format: &str, : /*Unimplemented*/Basic: VarArgs) -> Option<usize> {
     //    unsafe { TODO: call ffi:g_output_stream_printf() }
     //}
 
@@ -239,11 +265,11 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
     }
 
     #[doc(alias = "g_output_stream_splice")]
-    fn splice(
+    fn splice<'a, P: IsA<Cancellable>>(
         &self,
         source: &impl IsA<InputStream>,
         flags: OutputStreamSpliceFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<isize, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -251,7 +277,12 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
                 self.as_ref().to_glib_none().0,
                 source.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -263,13 +294,13 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
     }
 
     #[doc(alias = "g_output_stream_splice_async")]
-    fn splice_async<P: FnOnce(Result<isize, glib::Error>) + 'static>(
+    fn splice_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<isize, glib::Error>) + 'static>(
         &self,
         source: &impl IsA<InputStream>,
         flags: OutputStreamSpliceFlags,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -281,10 +312,10 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn splice_async_trampoline<
-            P: FnOnce(Result<isize, glib::Error>) + 'static,
+            Q: FnOnce(Result<isize, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -297,19 +328,24 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = splice_async_trampoline::<P>;
+        let callback = splice_async_trampoline::<Q>;
         unsafe {
             ffi::g_output_stream_splice_async(
                 self.as_ref().to_glib_none().0,
                 source.as_ref().to_glib_none().0,
                 flags.into_glib(),
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -334,15 +370,15 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
     }
 
     //#[doc(alias = "g_output_stream_vprintf")]
-    //fn vprintf(&self, cancellable: Option<&impl IsA<Cancellable>>, error: &mut glib::Error, format: &str, args: /*Unknown conversion*//*Unimplemented*/Unsupported) -> Option<usize> {
+    //fn vprintf<'a, P: IsA<Cancellable>>(&self, cancellable: impl Into<Option<&'a P>>, error: &mut glib::Error, format: &str, args: /*Unimplemented*/Unsupported) -> Option<usize> {
     //    unsafe { TODO: call ffi:g_output_stream_vprintf() }
     //}
 
     #[doc(alias = "g_output_stream_write")]
-    fn write(
+    fn write<'a, P: IsA<Cancellable>>(
         &self,
         buffer: &[u8],
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<isize, glib::Error> {
         let count = buffer.len() as _;
         unsafe {
@@ -351,7 +387,12 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
                 self.as_ref().to_glib_none().0,
                 buffer.to_glib_none().0,
                 count,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -363,17 +404,22 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
     }
 
     #[doc(alias = "g_output_stream_write_bytes")]
-    fn write_bytes(
+    fn write_bytes<'a, P: IsA<Cancellable>>(
         &self,
         bytes: &glib::Bytes,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<isize, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_output_stream_write_bytes(
                 self.as_ref().to_glib_none().0,
                 bytes.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -385,12 +431,16 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
     }
 
     #[doc(alias = "g_output_stream_write_bytes_async")]
-    fn write_bytes_async<P: FnOnce(Result<isize, glib::Error>) + 'static>(
+    fn write_bytes_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<isize, glib::Error>) + 'static,
+    >(
         &self,
         bytes: &glib::Bytes,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -402,10 +452,10 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn write_bytes_async_trampoline<
-            P: FnOnce(Result<isize, glib::Error>) + 'static,
+            Q: FnOnce(Result<isize, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -419,18 +469,23 @@ pub trait OutputStreamExt: IsA<OutputStream> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = write_bytes_async_trampoline::<P>;
+        let callback = write_bytes_async_trampoline::<Q>;
         unsafe {
             ffi::g_output_stream_write_bytes_async(
                 self.as_ref().to_glib_none().0,
                 bytes.to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gio/src/auto/permission.rs b/gio/src/auto/permission.rs
index 115150ce9961..0057a4cf96b9 100644
--- a/gio/src/auto/permission.rs
+++ b/gio/src/auto/permission.rs
@@ -25,12 +25,20 @@ impl Permission {
 
 pub trait PermissionExt: IsA<Permission> + 'static {
     #[doc(alias = "g_permission_acquire")]
-    fn acquire(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
+    fn acquire<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_permission_acquire(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -43,10 +51,10 @@ pub trait PermissionExt: IsA<Permission> + 'static {
     }
 
     #[doc(alias = "g_permission_acquire_async")]
-    fn acquire_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn acquire_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -58,10 +66,10 @@ pub trait PermissionExt: IsA<Permission> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn acquire_async_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            Q: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -74,16 +82,21 @@ pub trait PermissionExt: IsA<Permission> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = acquire_async_trampoline::<P>;
+        let callback = acquire_async_trampoline::<Q>;
         unsafe {
             ffi::g_permission_acquire_async(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -149,12 +162,20 @@ pub trait PermissionExt: IsA<Permission> + 'static {
     }
 
     #[doc(alias = "g_permission_release")]
-    fn release(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
+    fn release<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_permission_release(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -167,10 +188,10 @@ pub trait PermissionExt: IsA<Permission> + 'static {
     }
 
     #[doc(alias = "g_permission_release_async")]
-    fn release_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn release_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -182,10 +203,10 @@ pub trait PermissionExt: IsA<Permission> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn release_async_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            Q: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -198,16 +219,21 @@ pub trait PermissionExt: IsA<Permission> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = release_async_trampoline::<P>;
+        let callback = release_async_trampoline::<Q>;
         unsafe {
             ffi::g_permission_release_async(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gio/src/auto/pollable_output_stream.rs b/gio/src/auto/pollable_output_stream.rs
index d1997df4b61e..74bd608d1c14 100644
--- a/gio/src/auto/pollable_output_stream.rs
+++ b/gio/src/auto/pollable_output_stream.rs
@@ -38,10 +38,10 @@ pub trait PollableOutputStreamExt: IsA<PollableOutputStream> + 'static {
     }
 
     #[doc(alias = "g_pollable_output_stream_write_nonblocking")]
-    fn write_nonblocking(
+    fn write_nonblocking<'a, P: IsA<Cancellable>>(
         &self,
         buffer: &[u8],
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<isize, glib::Error> {
         let count = buffer.len() as _;
         unsafe {
@@ -50,7 +50,12 @@ pub trait PollableOutputStreamExt: IsA<PollableOutputStream> + 'static {
                 self.as_ref().to_glib_none().0,
                 buffer.to_glib_none().0,
                 count,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
diff --git a/gio/src/auto/proxy.rs b/gio/src/auto/proxy.rs
index fdf44fcbecab..55a03d129ac5 100644
--- a/gio/src/auto/proxy.rs
+++ b/gio/src/auto/proxy.rs
@@ -31,11 +31,11 @@ impl Proxy {
 
 pub trait ProxyExt: IsA<Proxy> + 'static {
     #[doc(alias = "g_proxy_connect")]
-    fn connect(
+    fn connect<'a, P: IsA<Cancellable>>(
         &self,
         connection: &impl IsA<IOStream>,
         proxy_address: &impl IsA<ProxyAddress>,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<IOStream, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -43,7 +43,12 @@ pub trait ProxyExt: IsA<Proxy> + 'static {
                 self.as_ref().to_glib_none().0,
                 connection.as_ref().to_glib_none().0,
                 proxy_address.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -55,12 +60,16 @@ pub trait ProxyExt: IsA<Proxy> + 'static {
     }
 
     #[doc(alias = "g_proxy_connect_async")]
-    fn connect_async<P: FnOnce(Result<IOStream, glib::Error>) + 'static>(
+    fn connect_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<IOStream, glib::Error>) + 'static,
+    >(
         &self,
         connection: &impl IsA<IOStream>,
         proxy_address: &impl IsA<ProxyAddress>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -72,10 +81,10 @@ pub trait ProxyExt: IsA<Proxy> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn connect_async_trampoline<
-            P: FnOnce(Result<IOStream, glib::Error>) + 'static,
+            Q: FnOnce(Result<IOStream, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -88,18 +97,23 @@ pub trait ProxyExt: IsA<Proxy> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = connect_async_trampoline::<P>;
+        let callback = connect_async_trampoline::<Q>;
         unsafe {
             ffi::g_proxy_connect_async(
                 self.as_ref().to_glib_none().0,
                 connection.as_ref().to_glib_none().0,
                 proxy_address.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gio/src/auto/proxy_address.rs b/gio/src/auto/proxy_address.rs
index 86d609ad3930..d9873c160c33 100644
--- a/gio/src/auto/proxy_address.rs
+++ b/gio/src/auto/proxy_address.rs
@@ -18,14 +18,14 @@ impl ProxyAddress {
     pub const NONE: Option<&'static ProxyAddress> = None;
 
     #[doc(alias = "g_proxy_address_new")]
-    pub fn new(
+    pub fn new<'a>(
         inetaddr: &impl IsA<InetAddress>,
         port: u16,
         protocol: &str,
         dest_hostname: &str,
         dest_port: u16,
-        username: Option<&str>,
-        password: Option<&str>,
+        username: impl Into<Option<&'a str>>,
+        password: impl Into<Option<&'a str>>,
     ) -> ProxyAddress {
         unsafe {
             SocketAddress::from_glib_full(ffi::g_proxy_address_new(
@@ -34,8 +34,8 @@ impl ProxyAddress {
                 protocol.to_glib_none().0,
                 dest_hostname.to_glib_none().0,
                 dest_port,
-                username.to_glib_none().0,
-                password.to_glib_none().0,
+                username.into().to_glib_none().0,
+                password.into().to_glib_none().0,
             ))
             .unsafe_cast()
         }
diff --git a/gio/src/auto/proxy_resolver.rs b/gio/src/auto/proxy_resolver.rs
index 9a25a8fdc48e..2be73af248fd 100644
--- a/gio/src/auto/proxy_resolver.rs
+++ b/gio/src/auto/proxy_resolver.rs
@@ -37,17 +37,22 @@ pub trait ProxyResolverExt: IsA<ProxyResolver> + 'static {
     }
 
     #[doc(alias = "g_proxy_resolver_lookup")]
-    fn lookup(
+    fn lookup<'a, P: IsA<Cancellable>>(
         &self,
         uri: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<Vec<glib::GString>, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_proxy_resolver_lookup(
                 self.as_ref().to_glib_none().0,
                 uri.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -59,11 +64,15 @@ pub trait ProxyResolverExt: IsA<ProxyResolver> + 'static {
     }
 
     #[doc(alias = "g_proxy_resolver_lookup_async")]
-    fn lookup_async<P: FnOnce(Result<Vec<glib::GString>, glib::Error>) + 'static>(
+    fn lookup_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<Vec<glib::GString>, glib::Error>) + 'static,
+    >(
         &self,
         uri: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -75,10 +84,10 @@ pub trait ProxyResolverExt: IsA<ProxyResolver> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn lookup_async_trampoline<
-            P: FnOnce(Result<Vec<glib::GString>, glib::Error>) + 'static,
+            Q: FnOnce(Result<Vec<glib::GString>, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -92,17 +101,22 @@ pub trait ProxyResolverExt: IsA<ProxyResolver> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = lookup_async_trampoline::<P>;
+        let callback = lookup_async_trampoline::<Q>;
         unsafe {
             ffi::g_proxy_resolver_lookup_async(
                 self.as_ref().to_glib_none().0,
                 uri.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gio/src/auto/remote_action_group.rs b/gio/src/auto/remote_action_group.rs
index 5bc0912db83c..70ffc6fd05dc 100644
--- a/gio/src/auto/remote_action_group.rs
+++ b/gio/src/auto/remote_action_group.rs
@@ -20,17 +20,17 @@ impl RemoteActionGroup {
 
 pub trait RemoteActionGroupExt: IsA<RemoteActionGroup> + 'static {
     #[doc(alias = "g_remote_action_group_activate_action_full")]
-    fn activate_action_full(
+    fn activate_action_full<'a>(
         &self,
         action_name: &str,
-        parameter: Option<&glib::Variant>,
+        parameter: impl Into<Option<&'a glib::Variant>>,
         platform_data: &glib::Variant,
     ) {
         unsafe {
             ffi::g_remote_action_group_activate_action_full(
                 self.as_ref().to_glib_none().0,
                 action_name.to_glib_none().0,
-                parameter.to_glib_none().0,
+                parameter.into().to_glib_none().0,
                 platform_data.to_glib_none().0,
             );
         }
diff --git a/gio/src/auto/resolver.rs b/gio/src/auto/resolver.rs
index bc52e161a429..3c08f2555d83 100644
--- a/gio/src/auto/resolver.rs
+++ b/gio/src/auto/resolver.rs
@@ -53,17 +53,22 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
     }
 
     #[doc(alias = "g_resolver_lookup_by_address")]
-    fn lookup_by_address(
+    fn lookup_by_address<'a, P: IsA<Cancellable>>(
         &self,
         address: &impl IsA<InetAddress>,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<glib::GString, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_resolver_lookup_by_address(
                 self.as_ref().to_glib_none().0,
                 address.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -75,11 +80,15 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
     }
 
     #[doc(alias = "g_resolver_lookup_by_address_async")]
-    fn lookup_by_address_async<P: FnOnce(Result<glib::GString, glib::Error>) + 'static>(
+    fn lookup_by_address_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<glib::GString, glib::Error>) + 'static,
+    >(
         &self,
         address: &impl IsA<InetAddress>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -91,10 +100,10 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn lookup_by_address_async_trampoline<
-            P: FnOnce(Result<glib::GString, glib::Error>) + 'static,
+            Q: FnOnce(Result<glib::GString, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -108,17 +117,22 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = lookup_by_address_async_trampoline::<P>;
+        let callback = lookup_by_address_async_trampoline::<Q>;
         unsafe {
             ffi::g_resolver_lookup_by_address_async(
                 self.as_ref().to_glib_none().0,
                 address.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -142,17 +156,22 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
     }
 
     #[doc(alias = "g_resolver_lookup_by_name")]
-    fn lookup_by_name(
+    fn lookup_by_name<'a, P: IsA<Cancellable>>(
         &self,
         hostname: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<Vec<InetAddress>, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_resolver_lookup_by_name(
                 self.as_ref().to_glib_none().0,
                 hostname.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -164,11 +183,15 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
     }
 
     #[doc(alias = "g_resolver_lookup_by_name_async")]
-    fn lookup_by_name_async<P: FnOnce(Result<Vec<InetAddress>, glib::Error>) + 'static>(
+    fn lookup_by_name_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + 'static,
+    >(
         &self,
         hostname: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -180,10 +203,10 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn lookup_by_name_async_trampoline<
-            P: FnOnce(Result<Vec<InetAddress>, glib::Error>) + 'static,
+            Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -197,17 +220,22 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = lookup_by_name_async_trampoline::<P>;
+        let callback = lookup_by_name_async_trampoline::<Q>;
         unsafe {
             ffi::g_resolver_lookup_by_name_async(
                 self.as_ref().to_glib_none().0,
                 hostname.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -233,11 +261,11 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
     #[cfg(feature = "v2_60")]
     #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
     #[doc(alias = "g_resolver_lookup_by_name_with_flags")]
-    fn lookup_by_name_with_flags(
+    fn lookup_by_name_with_flags<'a, P: IsA<Cancellable>>(
         &self,
         hostname: &str,
         flags: ResolverNameLookupFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<Vec<InetAddress>, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -245,7 +273,12 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
                 self.as_ref().to_glib_none().0,
                 hostname.to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -260,13 +293,15 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
     #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
     #[doc(alias = "g_resolver_lookup_by_name_with_flags_async")]
     fn lookup_by_name_with_flags_async<
-        P: FnOnce(Result<Vec<InetAddress>, glib::Error>) + 'static,
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + 'static,
     >(
         &self,
         hostname: &str,
         flags: ResolverNameLookupFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -278,10 +313,10 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn lookup_by_name_with_flags_async_trampoline<
-            P: FnOnce(Result<Vec<InetAddress>, glib::Error>) + 'static,
+            Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -298,18 +333,23 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = lookup_by_name_with_flags_async_trampoline::<P>;
+        let callback = lookup_by_name_with_flags_async_trampoline::<Q>;
         unsafe {
             ffi::g_resolver_lookup_by_name_with_flags_async(
                 self.as_ref().to_glib_none().0,
                 hostname.to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -341,11 +381,11 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
     }
 
     #[doc(alias = "g_resolver_lookup_records")]
-    fn lookup_records(
+    fn lookup_records<'a, P: IsA<Cancellable>>(
         &self,
         rrname: &str,
         record_type: ResolverRecordType,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<Vec<glib::Variant>, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -353,7 +393,12 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
                 self.as_ref().to_glib_none().0,
                 rrname.to_glib_none().0,
                 record_type.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -365,12 +410,16 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
     }
 
     #[doc(alias = "g_resolver_lookup_records_async")]
-    fn lookup_records_async<P: FnOnce(Result<Vec<glib::Variant>, glib::Error>) + 'static>(
+    fn lookup_records_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<Vec<glib::Variant>, glib::Error>) + 'static,
+    >(
         &self,
         rrname: &str,
         record_type: ResolverRecordType,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -382,10 +431,10 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn lookup_records_async_trampoline<
-            P: FnOnce(Result<Vec<glib::Variant>, glib::Error>) + 'static,
+            Q: FnOnce(Result<Vec<glib::Variant>, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -399,18 +448,23 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = lookup_records_async_trampoline::<P>;
+        let callback = lookup_records_async_trampoline::<Q>;
         unsafe {
             ffi::g_resolver_lookup_records_async(
                 self.as_ref().to_glib_none().0,
                 rrname.to_glib_none().0,
                 record_type.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -436,12 +490,12 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
     }
 
     #[doc(alias = "g_resolver_lookup_service")]
-    fn lookup_service(
+    fn lookup_service<'a, P: IsA<Cancellable>>(
         &self,
         service: &str,
         protocol: &str,
         domain: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<Vec<SrvTarget>, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -450,7 +504,12 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
                 service.to_glib_none().0,
                 protocol.to_glib_none().0,
                 domain.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -462,13 +521,17 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
     }
 
     #[doc(alias = "g_resolver_lookup_service_async")]
-    fn lookup_service_async<P: FnOnce(Result<Vec<SrvTarget>, glib::Error>) + 'static>(
+    fn lookup_service_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<Vec<SrvTarget>, glib::Error>) + 'static,
+    >(
         &self,
         service: &str,
         protocol: &str,
         domain: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -480,10 +543,10 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn lookup_service_async_trampoline<
-            P: FnOnce(Result<Vec<SrvTarget>, glib::Error>) + 'static,
+            Q: FnOnce(Result<Vec<SrvTarget>, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -497,19 +560,24 @@ pub trait ResolverExt: IsA<Resolver> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = lookup_service_async_trampoline::<P>;
+        let callback = lookup_service_async_trampoline::<Q>;
         unsafe {
             ffi::g_resolver_lookup_service_async(
                 self.as_ref().to_glib_none().0,
                 service.to_glib_none().0,
                 protocol.to_glib_none().0,
                 domain.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gio/src/auto/seekable.rs b/gio/src/auto/seekable.rs
index 126f7c91aaee..3310b420c631 100644
--- a/gio/src/auto/seekable.rs
+++ b/gio/src/auto/seekable.rs
@@ -30,11 +30,11 @@ pub trait SeekableExt: IsA<Seekable> + 'static {
     }
 
     #[doc(alias = "g_seekable_seek")]
-    fn seek(
+    fn seek<'a, P: IsA<Cancellable>>(
         &self,
         offset: i64,
         type_: glib::SeekType,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -42,7 +42,12 @@ pub trait SeekableExt: IsA<Seekable> + 'static {
                 self.as_ref().to_glib_none().0,
                 offset,
                 type_.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -60,17 +65,22 @@ pub trait SeekableExt: IsA<Seekable> + 'static {
     }
 
     #[doc(alias = "g_seekable_truncate")]
-    fn truncate(
+    fn truncate<'a, P: IsA<Cancellable>>(
         &self,
         offset: i64,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_seekable_truncate(
                 self.as_ref().to_glib_none().0,
                 offset,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
diff --git a/gio/src/auto/settings.rs b/gio/src/auto/settings.rs
index e2ce6516e13e..630c15f216e5 100644
--- a/gio/src/auto/settings.rs
+++ b/gio/src/auto/settings.rs
@@ -31,16 +31,16 @@ impl Settings {
     }
 
     #[doc(alias = "g_settings_new_full")]
-    pub fn new_full(
+    pub fn new_full<'a, P: IsA<SettingsBackend>>(
         schema: &SettingsSchema,
-        backend: Option<&impl IsA<SettingsBackend>>,
-        path: Option<&str>,
+        backend: impl Into<Option<&'a P>>,
+        path: impl Into<Option<&'a str>>,
     ) -> Settings {
         unsafe {
             from_glib_full(ffi::g_settings_new_full(
                 schema.to_glib_none().0,
-                backend.map(|p| p.as_ref()).to_glib_none().0,
-                path.to_glib_none().0,
+                backend.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
+                path.into().to_glib_none().0,
             ))
         }
     }
@@ -109,14 +109,14 @@ pub trait SettingsExt: IsA<Settings> + 'static {
     #[cfg(feature = "v2_82")]
     #[cfg_attr(docsrs, doc(cfg(feature = "v2_82")))]
     #[doc(alias = "g_settings_bind_with_mapping_closures")]
-    fn bind_with_mapping_closures(
+    fn bind_with_mapping_closures<'a>(
         &self,
         key: &str,
         object: &impl IsA<glib::Object>,
         property: &str,
         flags: SettingsBindFlags,
-        get_mapping: Option<&glib::Closure>,
-        set_mapping: Option<&glib::Closure>,
+        get_mapping: impl Into<Option<&'a glib::Closure>>,
+        set_mapping: impl Into<Option<&'a glib::Closure>>,
     ) {
         unsafe {
             ffi::g_settings_bind_with_mapping_closures(
@@ -125,8 +125,8 @@ pub trait SettingsExt: IsA<Settings> + 'static {
                 object.as_ref().to_glib_none().0,
                 property.to_glib_none().0,
                 flags.into_glib(),
-                get_mapping.to_glib_none().0,
-                set_mapping.to_glib_none().0,
+                get_mapping.into().to_glib_none().0,
+                set_mapping.into().to_glib_none().0,
             );
         }
     }
@@ -168,7 +168,7 @@ pub trait SettingsExt: IsA<Settings> + 'static {
     }
 
     //#[doc(alias = "g_settings_get")]
-    //fn get(&self, key: &str, format: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
+    //fn get(&self, key: &str, format: &str, : /*Unimplemented*/Basic: VarArgs) {
     //    unsafe { TODO: call ffi:g_settings_get() }
     //}
 
@@ -332,7 +332,7 @@ pub trait SettingsExt: IsA<Settings> + 'static {
     }
 
     //#[doc(alias = "g_settings_set")]
-    //fn set(&self, key: &str, format: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> bool {
+    //fn set(&self, key: &str, format: &str, : /*Unimplemented*/Basic: VarArgs) -> bool {
     //    unsafe { TODO: call ffi:g_settings_set() }
     //}
 
diff --git a/gio/src/auto/settings_schema_source.rs b/gio/src/auto/settings_schema_source.rs
index a93e0805a1a4..12283539bfb1 100644
--- a/gio/src/auto/settings_schema_source.rs
+++ b/gio/src/auto/settings_schema_source.rs
@@ -19,16 +19,16 @@ glib::wrapper! {
 impl SettingsSchemaSource {
     #[doc(alias = "g_settings_schema_source_new_from_directory")]
     #[doc(alias = "new_from_directory")]
-    pub fn from_directory(
+    pub fn from_directory<'a>(
         directory: impl AsRef<std::path::Path>,
-        parent: Option<&SettingsSchemaSource>,
+        parent: impl Into<Option<&'a SettingsSchemaSource>>,
         trusted: bool,
     ) -> Result<SettingsSchemaSource, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_settings_schema_source_new_from_directory(
                 directory.as_ref().to_glib_none().0,
-                parent.to_glib_none().0,
+                parent.into().to_glib_none().0,
                 trusted.into_glib(),
                 &mut error,
             );
diff --git a/gio/src/auto/simple_action.rs b/gio/src/auto/simple_action.rs
index 53ad301c2907..522f5e5a77d7 100644
--- a/gio/src/auto/simple_action.rs
+++ b/gio/src/auto/simple_action.rs
@@ -21,25 +21,28 @@ glib::wrapper! {
 
 impl SimpleAction {
     #[doc(alias = "g_simple_action_new")]
-    pub fn new(name: &str, parameter_type: Option<&glib::VariantTy>) -> SimpleAction {
+    pub fn new<'a>(
+        name: &str,
+        parameter_type: impl Into<Option<&'a glib::VariantTy>>,
+    ) -> SimpleAction {
         unsafe {
             from_glib_full(ffi::g_simple_action_new(
                 name.to_glib_none().0,
-                parameter_type.to_glib_none().0,
+                parameter_type.into().to_glib_none().0,
             ))
         }
     }
 
     #[doc(alias = "g_simple_action_new_stateful")]
-    pub fn new_stateful(
+    pub fn new_stateful<'a>(
         name: &str,
-        parameter_type: Option<&glib::VariantTy>,
+        parameter_type: impl Into<Option<&'a glib::VariantTy>>,
         state: &glib::Variant,
     ) -> SimpleAction {
         unsafe {
             from_glib_full(ffi::g_simple_action_new_stateful(
                 name.to_glib_none().0,
-                parameter_type.to_glib_none().0,
+                parameter_type.into().to_glib_none().0,
                 state.to_glib_none().0,
             ))
         }
@@ -62,9 +65,12 @@ impl SimpleAction {
     }
 
     #[doc(alias = "g_simple_action_set_state_hint")]
-    pub fn set_state_hint(&self, state_hint: Option<&glib::Variant>) {
+    pub fn set_state_hint<'a>(&self, state_hint: impl Into<Option<&'a glib::Variant>>) {
         unsafe {
-            ffi::g_simple_action_set_state_hint(self.to_glib_none().0, state_hint.to_glib_none().0);
+            ffi::g_simple_action_set_state_hint(
+                self.to_glib_none().0,
+                state_hint.into().to_glib_none().0,
+            );
         }
     }
 
diff --git a/gio/src/auto/simple_proxy_resolver.rs b/gio/src/auto/simple_proxy_resolver.rs
index 8615d6c8f18f..a002cbe0b670 100644
--- a/gio/src/auto/simple_proxy_resolver.rs
+++ b/gio/src/auto/simple_proxy_resolver.rs
@@ -26,11 +26,11 @@ impl SimpleProxyResolver {
 pub trait SimpleProxyResolverExt: IsA<SimpleProxyResolver> + 'static {
     #[doc(alias = "g_simple_proxy_resolver_set_default_proxy")]
     #[doc(alias = "default-proxy")]
-    fn set_default_proxy(&self, default_proxy: Option<&str>) {
+    fn set_default_proxy<'a>(&self, default_proxy: impl Into<Option<&'a str>>) {
         unsafe {
             ffi::g_simple_proxy_resolver_set_default_proxy(
                 self.as_ref().to_glib_none().0,
-                default_proxy.to_glib_none().0,
+                default_proxy.into().to_glib_none().0,
             );
         }
     }
diff --git a/gio/src/auto/socket.rs b/gio/src/auto/socket.rs
index 4bbce4a43886..b525212b58b6 100644
--- a/gio/src/auto/socket.rs
+++ b/gio/src/auto/socket.rs
@@ -50,12 +50,20 @@ impl Socket {
 
 pub trait SocketExt: IsA<Socket> + 'static {
     #[doc(alias = "g_socket_accept")]
-    fn accept(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<Socket, glib::Error> {
+    fn accept<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<Socket, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_socket_accept(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -129,11 +137,11 @@ pub trait SocketExt: IsA<Socket> + 'static {
     }
 
     #[doc(alias = "g_socket_condition_timed_wait")]
-    fn condition_timed_wait(
+    fn condition_timed_wait<'a, P: IsA<Cancellable>>(
         &self,
         condition: glib::IOCondition,
         timeout_us: i64,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -141,7 +149,12 @@ pub trait SocketExt: IsA<Socket> + 'static {
                 self.as_ref().to_glib_none().0,
                 condition.into_glib(),
                 timeout_us,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -154,17 +167,22 @@ pub trait SocketExt: IsA<Socket> + 'static {
     }
 
     #[doc(alias = "g_socket_condition_wait")]
-    fn condition_wait(
+    fn condition_wait<'a, P: IsA<Cancellable>>(
         &self,
         condition: glib::IOCondition,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_socket_condition_wait(
                 self.as_ref().to_glib_none().0,
                 condition.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -177,17 +195,22 @@ pub trait SocketExt: IsA<Socket> + 'static {
     }
 
     #[doc(alias = "g_socket_connect")]
-    fn connect(
+    fn connect<'a, P: IsA<Cancellable>>(
         &self,
         address: &impl IsA<SocketAddress>,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_socket_connect(
                 self.as_ref().to_glib_none().0,
                 address.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -371,11 +394,11 @@ pub trait SocketExt: IsA<Socket> + 'static {
     }
 
     #[doc(alias = "g_socket_join_multicast_group")]
-    fn join_multicast_group(
+    fn join_multicast_group<'a>(
         &self,
         group: &impl IsA<InetAddress>,
         source_specific: bool,
-        iface: Option<&str>,
+        iface: impl Into<Option<&'a str>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -383,7 +406,7 @@ pub trait SocketExt: IsA<Socket> + 'static {
                 self.as_ref().to_glib_none().0,
                 group.as_ref().to_glib_none().0,
                 source_specific.into_glib(),
-                iface.to_glib_none().0,
+                iface.into().to_glib_none().0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -396,19 +419,24 @@ pub trait SocketExt: IsA<Socket> + 'static {
     }
 
     #[doc(alias = "g_socket_join_multicast_group_ssm")]
-    fn join_multicast_group_ssm(
+    fn join_multicast_group_ssm<'a, P: IsA<InetAddress>>(
         &self,
         group: &impl IsA<InetAddress>,
-        source_specific: Option<&impl IsA<InetAddress>>,
-        iface: Option<&str>,
+        source_specific: impl Into<Option<&'a P>>,
+        iface: impl Into<Option<&'a str>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_socket_join_multicast_group_ssm(
                 self.as_ref().to_glib_none().0,
                 group.as_ref().to_glib_none().0,
-                source_specific.map(|p| p.as_ref()).to_glib_none().0,
-                iface.to_glib_none().0,
+                source_specific
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                iface.into().to_glib_none().0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -421,11 +449,11 @@ pub trait SocketExt: IsA<Socket> + 'static {
     }
 
     #[doc(alias = "g_socket_leave_multicast_group")]
-    fn leave_multicast_group(
+    fn leave_multicast_group<'a>(
         &self,
         group: &impl IsA<InetAddress>,
         source_specific: bool,
-        iface: Option<&str>,
+        iface: impl Into<Option<&'a str>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -433,7 +461,7 @@ pub trait SocketExt: IsA<Socket> + 'static {
                 self.as_ref().to_glib_none().0,
                 group.as_ref().to_glib_none().0,
                 source_specific.into_glib(),
-                iface.to_glib_none().0,
+                iface.into().to_glib_none().0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -446,19 +474,24 @@ pub trait SocketExt: IsA<Socket> + 'static {
     }
 
     #[doc(alias = "g_socket_leave_multicast_group_ssm")]
-    fn leave_multicast_group_ssm(
+    fn leave_multicast_group_ssm<'a, P: IsA<InetAddress>>(
         &self,
         group: &impl IsA<InetAddress>,
-        source_specific: Option<&impl IsA<InetAddress>>,
-        iface: Option<&str>,
+        source_specific: impl Into<Option<&'a P>>,
+        iface: impl Into<Option<&'a str>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_socket_leave_multicast_group_ssm(
                 self.as_ref().to_glib_none().0,
                 group.as_ref().to_glib_none().0,
-                source_specific.map(|p| p.as_ref()).to_glib_none().0,
-                iface.to_glib_none().0,
+                source_specific
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                iface.into().to_glib_none().0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
diff --git a/gio/src/auto/socket_address_enumerator.rs b/gio/src/auto/socket_address_enumerator.rs
index 963058ac53a0..0c8eb51066d3 100644
--- a/gio/src/auto/socket_address_enumerator.rs
+++ b/gio/src/auto/socket_address_enumerator.rs
@@ -21,15 +21,20 @@ impl SocketAddressEnumerator {
 
 pub trait SocketAddressEnumeratorExt: IsA<SocketAddressEnumerator> + 'static {
     #[doc(alias = "g_socket_address_enumerator_next")]
-    fn next(
+    fn next<'a, P: IsA<Cancellable>>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<Option<SocketAddress>, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_socket_address_enumerator_next(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -41,10 +46,14 @@ pub trait SocketAddressEnumeratorExt: IsA<SocketAddressEnumerator> + 'static {
     }
 
     #[doc(alias = "g_socket_address_enumerator_next_async")]
-    fn next_async<P: FnOnce(Result<Option<SocketAddress>, glib::Error>) + 'static>(
+    fn next_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<Option<SocketAddress>, glib::Error>) + 'static,
+    >(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -56,10 +65,10 @@ pub trait SocketAddressEnumeratorExt: IsA<SocketAddressEnumerator> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn next_async_trampoline<
-            P: FnOnce(Result<Option<SocketAddress>, glib::Error>) + 'static,
+            Q: FnOnce(Result<Option<SocketAddress>, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -76,16 +85,21 @@ pub trait SocketAddressEnumeratorExt: IsA<SocketAddressEnumerator> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = next_async_trampoline::<P>;
+        let callback = next_async_trampoline::<Q>;
         unsafe {
             ffi::g_socket_address_enumerator_next_async(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gio/src/auto/socket_client.rs b/gio/src/auto/socket_client.rs
index cc0388d45cc6..a3a116454563 100644
--- a/gio/src/auto/socket_client.rs
+++ b/gio/src/auto/socket_client.rs
@@ -51,17 +51,22 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
     }
 
     #[doc(alias = "g_socket_client_connect")]
-    fn connect(
+    fn connect<'a, P: IsA<Cancellable>>(
         &self,
         connectable: &impl IsA<SocketConnectable>,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<SocketConnection, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_socket_client_connect(
                 self.as_ref().to_glib_none().0,
                 connectable.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -73,11 +78,15 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
     }
 
     #[doc(alias = "g_socket_client_connect_async")]
-    fn connect_async<P: FnOnce(Result<SocketConnection, glib::Error>) + 'static>(
+    fn connect_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<SocketConnection, glib::Error>) + 'static,
+    >(
         &self,
         connectable: &impl IsA<SocketConnectable>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -89,10 +98,10 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn connect_async_trampoline<
-            P: FnOnce(Result<SocketConnection, glib::Error>) + 'static,
+            Q: FnOnce(Result<SocketConnection, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -106,17 +115,22 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = connect_async_trampoline::<P>;
+        let callback = connect_async_trampoline::<Q>;
         unsafe {
             ffi::g_socket_client_connect_async(
                 self.as_ref().to_glib_none().0,
                 connectable.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -140,11 +154,11 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
     }
 
     #[doc(alias = "g_socket_client_connect_to_host")]
-    fn connect_to_host(
+    fn connect_to_host<'a, P: IsA<Cancellable>>(
         &self,
         host_and_port: &str,
         default_port: u16,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<SocketConnection, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -152,7 +166,12 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
                 self.as_ref().to_glib_none().0,
                 host_and_port.to_glib_none().0,
                 default_port,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -164,12 +183,16 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
     }
 
     #[doc(alias = "g_socket_client_connect_to_host_async")]
-    fn connect_to_host_async<P: FnOnce(Result<SocketConnection, glib::Error>) + 'static>(
+    fn connect_to_host_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<SocketConnection, glib::Error>) + 'static,
+    >(
         &self,
         host_and_port: &str,
         default_port: u16,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -181,10 +204,10 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn connect_to_host_async_trampoline<
-            P: FnOnce(Result<SocketConnection, glib::Error>) + 'static,
+            Q: FnOnce(Result<SocketConnection, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -201,18 +224,23 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = connect_to_host_async_trampoline::<P>;
+        let callback = connect_to_host_async_trampoline::<Q>;
         unsafe {
             ffi::g_socket_client_connect_to_host_async(
                 self.as_ref().to_glib_none().0,
                 host_and_port.to_glib_none().0,
                 default_port,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -242,11 +270,11 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
     }
 
     #[doc(alias = "g_socket_client_connect_to_service")]
-    fn connect_to_service(
+    fn connect_to_service<'a, P: IsA<Cancellable>>(
         &self,
         domain: &str,
         service: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<SocketConnection, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -254,7 +282,12 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
                 self.as_ref().to_glib_none().0,
                 domain.to_glib_none().0,
                 service.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -266,12 +299,16 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
     }
 
     #[doc(alias = "g_socket_client_connect_to_service_async")]
-    fn connect_to_service_async<P: FnOnce(Result<SocketConnection, glib::Error>) + 'static>(
+    fn connect_to_service_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<SocketConnection, glib::Error>) + 'static,
+    >(
         &self,
         domain: &str,
         service: &str,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -283,10 +320,10 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn connect_to_service_async_trampoline<
-            P: FnOnce(Result<SocketConnection, glib::Error>) + 'static,
+            Q: FnOnce(Result<SocketConnection, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -303,18 +340,23 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = connect_to_service_async_trampoline::<P>;
+        let callback = connect_to_service_async_trampoline::<Q>;
         unsafe {
             ffi::g_socket_client_connect_to_service_async(
                 self.as_ref().to_glib_none().0,
                 domain.to_glib_none().0,
                 service.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -340,11 +382,11 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
     }
 
     #[doc(alias = "g_socket_client_connect_to_uri")]
-    fn connect_to_uri(
+    fn connect_to_uri<'a, P: IsA<Cancellable>>(
         &self,
         uri: &str,
         default_port: u16,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<SocketConnection, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -352,7 +394,12 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
                 self.as_ref().to_glib_none().0,
                 uri.to_glib_none().0,
                 default_port,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -364,12 +411,16 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
     }
 
     #[doc(alias = "g_socket_client_connect_to_uri_async")]
-    fn connect_to_uri_async<P: FnOnce(Result<SocketConnection, glib::Error>) + 'static>(
+    fn connect_to_uri_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<SocketConnection, glib::Error>) + 'static,
+    >(
         &self,
         uri: &str,
         default_port: u16,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -381,10 +432,10 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn connect_to_uri_async_trampoline<
-            P: FnOnce(Result<SocketConnection, glib::Error>) + 'static,
+            Q: FnOnce(Result<SocketConnection, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -401,18 +452,23 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = connect_to_uri_async_trampoline::<P>;
+        let callback = connect_to_uri_async_trampoline::<Q>;
         unsafe {
             ffi::g_socket_client_connect_to_uri_async(
                 self.as_ref().to_glib_none().0,
                 uri.to_glib_none().0,
                 default_port,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -546,11 +602,11 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
 
     #[doc(alias = "g_socket_client_set_local_address")]
     #[doc(alias = "local-address")]
-    fn set_local_address(&self, address: Option<&impl IsA<SocketAddress>>) {
+    fn set_local_address<'a, P: IsA<SocketAddress>>(&self, address: impl Into<Option<&'a P>>) {
         unsafe {
             ffi::g_socket_client_set_local_address(
                 self.as_ref().to_glib_none().0,
-                address.map(|p| p.as_ref()).to_glib_none().0,
+                address.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
             );
         }
     }
@@ -565,11 +621,19 @@ pub trait SocketClientExt: IsA<SocketClient> + 'static {
 
     #[doc(alias = "g_socket_client_set_proxy_resolver")]
     #[doc(alias = "proxy-resolver")]
-    fn set_proxy_resolver(&self, proxy_resolver: Option<&impl IsA<ProxyResolver>>) {
+    fn set_proxy_resolver<'a, P: IsA<ProxyResolver>>(
+        &self,
+        proxy_resolver: impl Into<Option<&'a P>>,
+    ) {
         unsafe {
             ffi::g_socket_client_set_proxy_resolver(
                 self.as_ref().to_glib_none().0,
-                proxy_resolver.map(|p| p.as_ref()).to_glib_none().0,
+                proxy_resolver
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
             );
         }
     }
diff --git a/gio/src/auto/socket_connection.rs b/gio/src/auto/socket_connection.rs
index 7933d6dc3877..88db92610476 100644
--- a/gio/src/auto/socket_connection.rs
+++ b/gio/src/auto/socket_connection.rs
@@ -55,17 +55,22 @@ impl SocketConnection {
 
 pub trait SocketConnectionExt: IsA<SocketConnection> + 'static {
     #[doc(alias = "g_socket_connection_connect")]
-    fn connect(
+    fn connect<'a, P: IsA<Cancellable>>(
         &self,
         address: &impl IsA<SocketAddress>,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_socket_connection_connect(
                 self.as_ref().to_glib_none().0,
                 address.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -78,11 +83,11 @@ pub trait SocketConnectionExt: IsA<SocketConnection> + 'static {
     }
 
     #[doc(alias = "g_socket_connection_connect_async")]
-    fn connect_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn connect_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
         address: &impl IsA<SocketAddress>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -94,10 +99,10 @@ pub trait SocketConnectionExt: IsA<SocketConnection> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn connect_async_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            Q: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -111,17 +116,22 @@ pub trait SocketConnectionExt: IsA<SocketConnection> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = connect_async_trampoline::<P>;
+        let callback = connect_async_trampoline::<Q>;
         unsafe {
             ffi::g_socket_connection_connect_async(
                 self.as_ref().to_glib_none().0,
                 address.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gio/src/auto/socket_listener.rs b/gio/src/auto/socket_listener.rs
index 400f3f8b024d..d873887202c9 100644
--- a/gio/src/auto/socket_listener.rs
+++ b/gio/src/auto/socket_listener.rs
@@ -39,9 +39,9 @@ impl Default for SocketListener {
 
 pub trait SocketListenerExt: IsA<SocketListener> + 'static {
     #[doc(alias = "g_socket_listener_accept")]
-    fn accept(
+    fn accept<'a, P: IsA<Cancellable>>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(SocketConnection, Option<glib::Object>), glib::Error> {
         unsafe {
             let mut source_object = std::ptr::null_mut();
@@ -49,7 +49,12 @@ pub trait SocketListenerExt: IsA<SocketListener> + 'static {
             let ret = ffi::g_socket_listener_accept(
                 self.as_ref().to_glib_none().0,
                 &mut source_object,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -62,11 +67,13 @@ pub trait SocketListenerExt: IsA<SocketListener> + 'static {
 
     #[doc(alias = "g_socket_listener_accept_async")]
     fn accept_async<
-        P: FnOnce(Result<(SocketConnection, Option<glib::Object>), glib::Error>) + 'static,
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<(SocketConnection, Option<glib::Object>), glib::Error>) + 'static,
     >(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -78,10 +85,10 @@ pub trait SocketListenerExt: IsA<SocketListener> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn accept_async_trampoline<
-            P: FnOnce(Result<(SocketConnection, Option<glib::Object>), glib::Error>) + 'static,
+            Q: FnOnce(Result<(SocketConnection, Option<glib::Object>), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -100,16 +107,21 @@ pub trait SocketListenerExt: IsA<SocketListener> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = accept_async_trampoline::<P>;
+        let callback = accept_async_trampoline::<Q>;
         unsafe {
             ffi::g_socket_listener_accept_async(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -136,9 +148,9 @@ pub trait SocketListenerExt: IsA<SocketListener> + 'static {
     }
 
     #[doc(alias = "g_socket_listener_accept_socket")]
-    fn accept_socket(
+    fn accept_socket<'a, P: IsA<Cancellable>>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(Socket, Option<glib::Object>), glib::Error> {
         unsafe {
             let mut source_object = std::ptr::null_mut();
@@ -146,7 +158,12 @@ pub trait SocketListenerExt: IsA<SocketListener> + 'static {
             let ret = ffi::g_socket_listener_accept_socket(
                 self.as_ref().to_glib_none().0,
                 &mut source_object,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -159,11 +176,13 @@ pub trait SocketListenerExt: IsA<SocketListener> + 'static {
 
     #[doc(alias = "g_socket_listener_accept_socket_async")]
     fn accept_socket_async<
-        P: FnOnce(Result<(Socket, Option<glib::Object>), glib::Error>) + 'static,
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<(Socket, Option<glib::Object>), glib::Error>) + 'static,
     >(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -175,10 +194,10 @@ pub trait SocketListenerExt: IsA<SocketListener> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn accept_socket_async_trampoline<
-            P: FnOnce(Result<(Socket, Option<glib::Object>), glib::Error>) + 'static,
+            Q: FnOnce(Result<(Socket, Option<glib::Object>), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -197,16 +216,21 @@ pub trait SocketListenerExt: IsA<SocketListener> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = accept_socket_async_trampoline::<P>;
+        let callback = accept_socket_async_trampoline::<Q>;
         unsafe {
             ffi::g_socket_listener_accept_socket_async(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -232,12 +256,12 @@ pub trait SocketListenerExt: IsA<SocketListener> + 'static {
     }
 
     #[doc(alias = "g_socket_listener_add_address")]
-    fn add_address(
+    fn add_address<'a, P: IsA<glib::Object>>(
         &self,
         address: &impl IsA<SocketAddress>,
         type_: SocketType,
         protocol: SocketProtocol,
-        source_object: Option<&impl IsA<glib::Object>>,
+        source_object: impl Into<Option<&'a P>>,
     ) -> Result<SocketAddress, glib::Error> {
         unsafe {
             let mut effective_address = std::ptr::null_mut();
@@ -247,7 +271,12 @@ pub trait SocketListenerExt: IsA<SocketListener> + 'static {
                 address.as_ref().to_glib_none().0,
                 type_.into_glib(),
                 protocol.into_glib(),
-                source_object.map(|p| p.as_ref()).to_glib_none().0,
+                source_object
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut effective_address,
                 &mut error,
             );
@@ -261,15 +290,20 @@ pub trait SocketListenerExt: IsA<SocketListener> + 'static {
     }
 
     #[doc(alias = "g_socket_listener_add_any_inet_port")]
-    fn add_any_inet_port(
+    fn add_any_inet_port<'a, P: IsA<glib::Object>>(
         &self,
-        source_object: Option<&impl IsA<glib::Object>>,
+        source_object: impl Into<Option<&'a P>>,
     ) -> Result<u16, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_socket_listener_add_any_inet_port(
                 self.as_ref().to_glib_none().0,
-                source_object.map(|p| p.as_ref()).to_glib_none().0,
+                source_object
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -281,17 +315,22 @@ pub trait SocketListenerExt: IsA<SocketListener> + 'static {
     }
 
     #[doc(alias = "g_socket_listener_add_inet_port")]
-    fn add_inet_port(
+    fn add_inet_port<'a, P: IsA<glib::Object>>(
         &self,
         port: u16,
-        source_object: Option<&impl IsA<glib::Object>>,
+        source_object: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_socket_listener_add_inet_port(
                 self.as_ref().to_glib_none().0,
                 port,
-                source_object.map(|p| p.as_ref()).to_glib_none().0,
+                source_object
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -304,17 +343,22 @@ pub trait SocketListenerExt: IsA<SocketListener> + 'static {
     }
 
     #[doc(alias = "g_socket_listener_add_socket")]
-    fn add_socket(
+    fn add_socket<'a, P: IsA<glib::Object>>(
         &self,
         socket: &impl IsA<Socket>,
-        source_object: Option<&impl IsA<glib::Object>>,
+        source_object: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_socket_listener_add_socket(
                 self.as_ref().to_glib_none().0,
                 socket.as_ref().to_glib_none().0,
-                source_object.map(|p| p.as_ref()).to_glib_none().0,
+                source_object
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
diff --git a/gio/src/auto/subprocess.rs b/gio/src/auto/subprocess.rs
index fc28eb7f84ff..3d1274ae5346 100644
--- a/gio/src/auto/subprocess.rs
+++ b/gio/src/auto/subprocess.rs
@@ -17,7 +17,7 @@ glib::wrapper! {
 
 impl Subprocess {
     //#[doc(alias = "g_subprocess_new")]
-    //pub fn new(flags: SubprocessFlags, error: Option<&mut glib::Error>, argv0: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Subprocess {
+    //pub fn new<'a>(flags: SubprocessFlags, error: impl Into<Option<&'a mut  glib::Error>>, argv0: &str, : /*Unimplemented*/Basic: VarArgs) -> Subprocess {
     //    unsafe { TODO: call ffi:g_subprocess_new() }
     //}
 
@@ -38,10 +38,10 @@ impl Subprocess {
     }
 
     #[doc(alias = "g_subprocess_communicate")]
-    pub fn communicate(
+    pub fn communicate<'a, P: IsA<Cancellable>>(
         &self,
-        stdin_buf: Option<&glib::Bytes>,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        stdin_buf: impl Into<Option<&'a glib::Bytes>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(Option<glib::Bytes>, Option<glib::Bytes>), glib::Error> {
         unsafe {
             let mut stdout_buf = std::ptr::null_mut();
@@ -49,8 +49,13 @@ impl Subprocess {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_subprocess_communicate(
                 self.to_glib_none().0,
-                stdin_buf.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                stdin_buf.into().to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut stdout_buf,
                 &mut stderr_buf,
                 &mut error,
@@ -66,12 +71,14 @@ impl Subprocess {
 
     #[doc(alias = "g_subprocess_communicate_async")]
     pub fn communicate_async<
-        P: FnOnce(Result<(Option<glib::Bytes>, Option<glib::Bytes>), glib::Error>) + 'static,
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<(Option<glib::Bytes>, Option<glib::Bytes>), glib::Error>) + 'static,
     >(
         &self,
-        stdin_buf: Option<&glib::Bytes>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        stdin_buf: impl Into<Option<&'a glib::Bytes>>,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -83,10 +90,10 @@ impl Subprocess {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn communicate_async_trampoline<
-            P: FnOnce(Result<(Option<glib::Bytes>, Option<glib::Bytes>), glib::Error>) + 'static,
+            Q: FnOnce(Result<(Option<glib::Bytes>, Option<glib::Bytes>), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -107,26 +114,31 @@ impl Subprocess {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = communicate_async_trampoline::<P>;
+        let callback = communicate_async_trampoline::<Q>;
         unsafe {
             ffi::g_subprocess_communicate_async(
                 self.to_glib_none().0,
-                stdin_buf.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                stdin_buf.into().to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    pub fn communicate_future(
+    pub fn communicate_future<'a>(
         &self,
-        stdin_buf: Option<&glib::Bytes>,
+        stdin_buf: impl Into<Option<&'a glib::Bytes>>,
     ) -> Pin<
         Box_<
             dyn std::future::Future<
@@ -134,7 +146,7 @@ impl Subprocess {
                 > + 'static,
         >,
     > {
-        let stdin_buf = stdin_buf.map(ToOwned::to_owned);
+        let stdin_buf = stdin_buf.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -150,10 +162,10 @@ impl Subprocess {
     }
 
     #[doc(alias = "g_subprocess_communicate_utf8")]
-    pub fn communicate_utf8(
+    pub fn communicate_utf8<'a, P: IsA<Cancellable>>(
         &self,
-        stdin_buf: Option<&str>,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        stdin_buf: impl Into<Option<&'a str>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(Option<glib::GString>, Option<glib::GString>), glib::Error> {
         unsafe {
             let mut stdout_buf = std::ptr::null_mut();
@@ -161,8 +173,13 @@ impl Subprocess {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_subprocess_communicate_utf8(
                 self.to_glib_none().0,
-                stdin_buf.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                stdin_buf.into().to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut stdout_buf,
                 &mut stderr_buf,
                 &mut error,
@@ -253,12 +270,20 @@ impl Subprocess {
     }
 
     #[doc(alias = "g_subprocess_wait")]
-    pub fn wait(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
+    pub fn wait<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_subprocess_wait(
                 self.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -271,10 +296,10 @@ impl Subprocess {
     }
 
     #[doc(alias = "g_subprocess_wait_async")]
-    pub fn wait_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    pub fn wait_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -286,9 +311,9 @@ impl Subprocess {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
-        unsafe extern "C" fn wait_async_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
+        unsafe extern "C" fn wait_async_trampoline<Q: FnOnce(Result<(), glib::Error>) + 'static>(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
             user_data: glib::ffi::gpointer,
@@ -300,16 +325,21 @@ impl Subprocess {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = wait_async_trampoline::<P>;
+        let callback = wait_async_trampoline::<Q>;
         unsafe {
             ffi::g_subprocess_wait_async(
                 self.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -330,15 +360,20 @@ impl Subprocess {
     }
 
     #[doc(alias = "g_subprocess_wait_check")]
-    pub fn wait_check(
+    pub fn wait_check<'a, P: IsA<Cancellable>>(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_subprocess_wait_check(
                 self.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -351,10 +386,14 @@ impl Subprocess {
     }
 
     #[doc(alias = "g_subprocess_wait_check_async")]
-    pub fn wait_check_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    pub fn wait_check_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<(), glib::Error>) + 'static,
+    >(
         &self,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -366,10 +405,10 @@ impl Subprocess {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn wait_check_async_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            Q: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -382,16 +421,21 @@ impl Subprocess {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = wait_check_async_trampoline::<P>;
+        let callback = wait_check_async_trampoline::<Q>;
         unsafe {
             ffi::g_subprocess_wait_check_async(
                 self.to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gio/src/auto/subprocess_launcher.rs b/gio/src/auto/subprocess_launcher.rs
index 2855447c02ab..3d4139fdc3ad 100644
--- a/gio/src/auto/subprocess_launcher.rs
+++ b/gio/src/auto/subprocess_launcher.rs
@@ -147,7 +147,7 @@ impl SubprocessLauncher {
     }
 
     //#[doc(alias = "g_subprocess_launcher_spawn")]
-    //pub fn spawn(&self, error: &mut glib::Error, argv0: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Subprocess {
+    //pub fn spawn(&self, error: &mut glib::Error, argv0: &str, : /*Unimplemented*/Basic: VarArgs) -> Subprocess {
     //    unsafe { TODO: call ffi:g_subprocess_launcher_spawn() }
     //}
 
diff --git a/gio/src/auto/tls_backend.rs b/gio/src/auto/tls_backend.rs
index 195f25c9c94e..9fd236e8864b 100644
--- a/gio/src/auto/tls_backend.rs
+++ b/gio/src/auto/tls_backend.rs
@@ -99,11 +99,16 @@ pub trait TlsBackendExt: IsA<TlsBackend> + 'static {
     #[cfg(feature = "v2_60")]
     #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
     #[doc(alias = "g_tls_backend_set_default_database")]
-    fn set_default_database(&self, database: Option<&impl IsA<TlsDatabase>>) {
+    fn set_default_database<'a, P: IsA<TlsDatabase>>(&self, database: impl Into<Option<&'a P>>) {
         unsafe {
             ffi::g_tls_backend_set_default_database(
                 self.as_ref().to_glib_none().0,
-                database.map(|p| p.as_ref()).to_glib_none().0,
+                database
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
             );
         }
     }
diff --git a/gio/src/auto/tls_certificate.rs b/gio/src/auto/tls_certificate.rs
index c41c8827a039..137661679541 100644
--- a/gio/src/auto/tls_certificate.rs
+++ b/gio/src/auto/tls_certificate.rs
@@ -105,15 +105,15 @@ impl TlsCertificate {
     #[cfg_attr(docsrs, doc(cfg(feature = "v2_68")))]
     #[doc(alias = "g_tls_certificate_new_from_pkcs11_uris")]
     #[doc(alias = "new_from_pkcs11_uris")]
-    pub fn from_pkcs11_uris(
+    pub fn from_pkcs11_uris<'a>(
         pkcs11_uri: &str,
-        private_key_pkcs11_uri: Option<&str>,
+        private_key_pkcs11_uri: impl Into<Option<&'a str>>,
     ) -> Result<TlsCertificate, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_tls_certificate_new_from_pkcs11_uris(
                 pkcs11_uri.to_glib_none().0,
-                private_key_pkcs11_uri.to_glib_none().0,
+                private_key_pkcs11_uri.into().to_glib_none().0,
                 &mut error,
             );
             if error.is_null() {
@@ -128,14 +128,17 @@ impl TlsCertificate {
     #[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
     #[doc(alias = "g_tls_certificate_new_from_pkcs12")]
     #[doc(alias = "new_from_pkcs12")]
-    pub fn from_pkcs12(data: &[u8], password: Option<&str>) -> Result<TlsCertificate, glib::Error> {
+    pub fn from_pkcs12<'a>(
+        data: &[u8],
+        password: impl Into<Option<&'a str>>,
+    ) -> Result<TlsCertificate, glib::Error> {
         let length = data.len() as _;
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_tls_certificate_new_from_pkcs12(
                 data.to_glib_none().0,
                 length,
-                password.to_glib_none().0,
+                password.into().to_glib_none().0,
                 &mut error,
             );
             if error.is_null() {
@@ -266,16 +269,26 @@ pub trait TlsCertificateExt: IsA<TlsCertificate> + 'static {
     }
 
     #[doc(alias = "g_tls_certificate_verify")]
-    fn verify(
+    fn verify<'a, P: IsA<SocketConnectable>, Q: IsA<TlsCertificate>>(
         &self,
-        identity: Option<&impl IsA<SocketConnectable>>,
-        trusted_ca: Option<&impl IsA<TlsCertificate>>,
+        identity: impl Into<Option<&'a P>>,
+        trusted_ca: impl Into<Option<&'a Q>>,
     ) -> TlsCertificateFlags {
         unsafe {
             from_glib(ffi::g_tls_certificate_verify(
                 self.as_ref().to_glib_none().0,
-                identity.map(|p| p.as_ref()).to_glib_none().0,
-                trusted_ca.map(|p| p.as_ref()).to_glib_none().0,
+                identity
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                trusted_ca
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
             ))
         }
     }
diff --git a/gio/src/auto/tls_client_connection.rs b/gio/src/auto/tls_client_connection.rs
index 5a9a1b07d164..0e563c709798 100644
--- a/gio/src/auto/tls_client_connection.rs
+++ b/gio/src/auto/tls_client_connection.rs
@@ -24,15 +24,20 @@ impl TlsClientConnection {
     pub const NONE: Option<&'static TlsClientConnection> = None;
 
     #[doc(alias = "g_tls_client_connection_new")]
-    pub fn new(
+    pub fn new<'a, P: IsA<SocketConnectable>>(
         base_io_stream: &impl IsA<IOStream>,
-        server_identity: Option<&impl IsA<SocketConnectable>>,
+        server_identity: impl Into<Option<&'a P>>,
     ) -> Result<TlsClientConnection, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_tls_client_connection_new(
                 base_io_stream.as_ref().to_glib_none().0,
-                server_identity.map(|p| p.as_ref()).to_glib_none().0,
+                server_identity
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
diff --git a/gio/src/auto/tls_connection.rs b/gio/src/auto/tls_connection.rs
index 7027589ffb6c..933463d4db34 100644
--- a/gio/src/auto/tls_connection.rs
+++ b/gio/src/auto/tls_connection.rs
@@ -162,12 +162,20 @@ pub trait TlsConnectionExt: IsA<TlsConnection> + 'static {
     }
 
     #[doc(alias = "g_tls_connection_handshake")]
-    fn handshake(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
+    fn handshake<'a, P: IsA<Cancellable>>(
+        &self,
+        cancellable: impl Into<Option<&'a P>>,
+    ) -> Result<(), glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_tls_connection_handshake(
                 self.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
@@ -180,11 +188,11 @@ pub trait TlsConnectionExt: IsA<TlsConnection> + 'static {
     }
 
     #[doc(alias = "g_tls_connection_handshake_async")]
-    fn handshake_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn handshake_async<'a, P: IsA<Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(
         &self,
         io_priority: glib::Priority,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -196,10 +204,10 @@ pub trait TlsConnectionExt: IsA<TlsConnection> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn handshake_async_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            Q: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -213,17 +221,22 @@ pub trait TlsConnectionExt: IsA<TlsConnection> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = handshake_async_trampoline::<P>;
+        let callback = handshake_async_trampoline::<Q>;
         unsafe {
             ffi::g_tls_connection_handshake_async(
                 self.as_ref().to_glib_none().0,
                 io_priority.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -257,22 +270,32 @@ pub trait TlsConnectionExt: IsA<TlsConnection> + 'static {
 
     #[doc(alias = "g_tls_connection_set_database")]
     #[doc(alias = "database")]
-    fn set_database(&self, database: Option<&impl IsA<TlsDatabase>>) {
+    fn set_database<'a, P: IsA<TlsDatabase>>(&self, database: impl Into<Option<&'a P>>) {
         unsafe {
             ffi::g_tls_connection_set_database(
                 self.as_ref().to_glib_none().0,
-                database.map(|p| p.as_ref()).to_glib_none().0,
+                database
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
             );
         }
     }
 
     #[doc(alias = "g_tls_connection_set_interaction")]
     #[doc(alias = "interaction")]
-    fn set_interaction(&self, interaction: Option<&impl IsA<TlsInteraction>>) {
+    fn set_interaction<'a, P: IsA<TlsInteraction>>(&self, interaction: impl Into<Option<&'a P>>) {
         unsafe {
             ffi::g_tls_connection_set_interaction(
                 self.as_ref().to_glib_none().0,
-                interaction.map(|p| p.as_ref()).to_glib_none().0,
+                interaction
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
             );
         }
     }
diff --git a/gio/src/auto/tls_database.rs b/gio/src/auto/tls_database.rs
index 1e45cd81d0c5..a34f05066bc3 100644
--- a/gio/src/auto/tls_database.rs
+++ b/gio/src/auto/tls_database.rs
@@ -37,21 +37,31 @@ pub trait TlsDatabaseExt: IsA<TlsDatabase> + 'static {
     }
 
     #[doc(alias = "g_tls_database_lookup_certificate_for_handle")]
-    fn lookup_certificate_for_handle(
+    fn lookup_certificate_for_handle<'a, P: IsA<TlsInteraction>, Q: IsA<Cancellable>>(
         &self,
         handle: &str,
-        interaction: Option<&impl IsA<TlsInteraction>>,
+        interaction: impl Into<Option<&'a P>>,
         flags: TlsDatabaseLookupFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a Q>>,
     ) -> Result<Option<TlsCertificate>, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_tls_database_lookup_certificate_for_handle(
                 self.as_ref().to_glib_none().0,
                 handle.to_glib_none().0,
-                interaction.map(|p| p.as_ref()).to_glib_none().0,
+                interaction
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -64,14 +74,17 @@ pub trait TlsDatabaseExt: IsA<TlsDatabase> + 'static {
 
     #[doc(alias = "g_tls_database_lookup_certificate_for_handle_async")]
     fn lookup_certificate_for_handle_async<
-        P: FnOnce(Result<TlsCertificate, glib::Error>) + 'static,
+        'a,
+        P: IsA<TlsInteraction>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<TlsCertificate, glib::Error>) + 'static,
     >(
         &self,
         handle: &str,
-        interaction: Option<&impl IsA<TlsInteraction>>,
+        interaction: impl Into<Option<&'a P>>,
         flags: TlsDatabaseLookupFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -83,10 +96,10 @@ pub trait TlsDatabaseExt: IsA<TlsDatabase> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn lookup_certificate_for_handle_async_trampoline<
-            P: FnOnce(Result<TlsCertificate, glib::Error>) + 'static,
+            R: FnOnce(Result<TlsCertificate, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -103,34 +116,44 @@ pub trait TlsDatabaseExt: IsA<TlsDatabase> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = lookup_certificate_for_handle_async_trampoline::<P>;
+        let callback = lookup_certificate_for_handle_async_trampoline::<R>;
         unsafe {
             ffi::g_tls_database_lookup_certificate_for_handle_async(
                 self.as_ref().to_glib_none().0,
                 handle.to_glib_none().0,
-                interaction.map(|p| p.as_ref()).to_glib_none().0,
+                interaction
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn lookup_certificate_for_handle_future(
+    fn lookup_certificate_for_handle_future<'a, P: IsA<TlsInteraction> + Clone + 'static>(
         &self,
         handle: &str,
-        interaction: Option<&(impl IsA<TlsInteraction> + Clone + 'static)>,
+        interaction: impl Into<Option<&'a P>>,
         flags: TlsDatabaseLookupFlags,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<TlsCertificate, glib::Error>> + 'static>>
     {
         let handle = String::from(handle);
-        let interaction = interaction.map(ToOwned::to_owned);
+        let interaction = interaction.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -148,21 +171,31 @@ pub trait TlsDatabaseExt: IsA<TlsDatabase> + 'static {
     }
 
     #[doc(alias = "g_tls_database_lookup_certificate_issuer")]
-    fn lookup_certificate_issuer(
+    fn lookup_certificate_issuer<'a, P: IsA<TlsInteraction>, Q: IsA<Cancellable>>(
         &self,
         certificate: &impl IsA<TlsCertificate>,
-        interaction: Option<&impl IsA<TlsInteraction>>,
+        interaction: impl Into<Option<&'a P>>,
         flags: TlsDatabaseLookupFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a Q>>,
     ) -> Result<TlsCertificate, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_tls_database_lookup_certificate_issuer(
                 self.as_ref().to_glib_none().0,
                 certificate.as_ref().to_glib_none().0,
-                interaction.map(|p| p.as_ref()).to_glib_none().0,
+                interaction
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -174,13 +207,18 @@ pub trait TlsDatabaseExt: IsA<TlsDatabase> + 'static {
     }
 
     #[doc(alias = "g_tls_database_lookup_certificate_issuer_async")]
-    fn lookup_certificate_issuer_async<P: FnOnce(Result<TlsCertificate, glib::Error>) + 'static>(
+    fn lookup_certificate_issuer_async<
+        'a,
+        P: IsA<TlsInteraction>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<TlsCertificate, glib::Error>) + 'static,
+    >(
         &self,
         certificate: &impl IsA<TlsCertificate>,
-        interaction: Option<&impl IsA<TlsInteraction>>,
+        interaction: impl Into<Option<&'a P>>,
         flags: TlsDatabaseLookupFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -192,10 +230,10 @@ pub trait TlsDatabaseExt: IsA<TlsDatabase> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn lookup_certificate_issuer_async_trampoline<
-            P: FnOnce(Result<TlsCertificate, glib::Error>) + 'static,
+            R: FnOnce(Result<TlsCertificate, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -212,34 +250,44 @@ pub trait TlsDatabaseExt: IsA<TlsDatabase> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = lookup_certificate_issuer_async_trampoline::<P>;
+        let callback = lookup_certificate_issuer_async_trampoline::<R>;
         unsafe {
             ffi::g_tls_database_lookup_certificate_issuer_async(
                 self.as_ref().to_glib_none().0,
                 certificate.as_ref().to_glib_none().0,
-                interaction.map(|p| p.as_ref()).to_glib_none().0,
+                interaction
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn lookup_certificate_issuer_future(
+    fn lookup_certificate_issuer_future<'a, P: IsA<TlsInteraction> + Clone + 'static>(
         &self,
         certificate: &(impl IsA<TlsCertificate> + Clone + 'static),
-        interaction: Option<&(impl IsA<TlsInteraction> + Clone + 'static)>,
+        interaction: impl Into<Option<&'a P>>,
         flags: TlsDatabaseLookupFlags,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<TlsCertificate, glib::Error>> + 'static>>
     {
         let certificate = certificate.clone();
-        let interaction = interaction.map(ToOwned::to_owned);
+        let interaction = interaction.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -257,21 +305,31 @@ pub trait TlsDatabaseExt: IsA<TlsDatabase> + 'static {
     }
 
     #[doc(alias = "g_tls_database_lookup_certificates_issued_by")]
-    fn lookup_certificates_issued_by(
+    fn lookup_certificates_issued_by<'a, P: IsA<TlsInteraction>, Q: IsA<Cancellable>>(
         &self,
         issuer_raw_dn: &glib::ByteArray,
-        interaction: Option<&impl IsA<TlsInteraction>>,
+        interaction: impl Into<Option<&'a P>>,
         flags: TlsDatabaseLookupFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a Q>>,
     ) -> Result<Vec<TlsCertificate>, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_tls_database_lookup_certificates_issued_by(
                 self.as_ref().to_glib_none().0,
                 issuer_raw_dn.to_glib_none().0,
-                interaction.map(|p| p.as_ref()).to_glib_none().0,
+                interaction
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -284,14 +342,17 @@ pub trait TlsDatabaseExt: IsA<TlsDatabase> + 'static {
 
     #[doc(alias = "g_tls_database_lookup_certificates_issued_by_async")]
     fn lookup_certificates_issued_by_async<
-        P: FnOnce(Result<Vec<TlsCertificate>, glib::Error>) + 'static,
+        'a,
+        P: IsA<TlsInteraction>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<Vec<TlsCertificate>, glib::Error>) + 'static,
     >(
         &self,
         issuer_raw_dn: &glib::ByteArray,
-        interaction: Option<&impl IsA<TlsInteraction>>,
+        interaction: impl Into<Option<&'a P>>,
         flags: TlsDatabaseLookupFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -303,10 +364,10 @@ pub trait TlsDatabaseExt: IsA<TlsDatabase> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn lookup_certificates_issued_by_async_trampoline<
-            P: FnOnce(Result<Vec<TlsCertificate>, glib::Error>) + 'static,
+            R: FnOnce(Result<Vec<TlsCertificate>, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -323,35 +384,45 @@ pub trait TlsDatabaseExt: IsA<TlsDatabase> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = lookup_certificates_issued_by_async_trampoline::<P>;
+        let callback = lookup_certificates_issued_by_async_trampoline::<R>;
         unsafe {
             ffi::g_tls_database_lookup_certificates_issued_by_async(
                 self.as_ref().to_glib_none().0,
                 issuer_raw_dn.to_glib_none().0,
-                interaction.map(|p| p.as_ref()).to_glib_none().0,
+                interaction
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn lookup_certificates_issued_by_future(
+    fn lookup_certificates_issued_by_future<'a, P: IsA<TlsInteraction> + Clone + 'static>(
         &self,
         issuer_raw_dn: &glib::ByteArray,
-        interaction: Option<&(impl IsA<TlsInteraction> + Clone + 'static)>,
+        interaction: impl Into<Option<&'a P>>,
         flags: TlsDatabaseLookupFlags,
     ) -> Pin<
         Box_<dyn std::future::Future<Output = Result<Vec<TlsCertificate>, glib::Error>> + 'static>,
     > {
         let issuer_raw_dn = issuer_raw_dn.clone();
-        let interaction = interaction.map(ToOwned::to_owned);
+        let interaction = interaction.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -369,14 +440,14 @@ pub trait TlsDatabaseExt: IsA<TlsDatabase> + 'static {
     }
 
     #[doc(alias = "g_tls_database_verify_chain")]
-    fn verify_chain(
+    fn verify_chain<'a, P: IsA<SocketConnectable>, Q: IsA<TlsInteraction>, R: IsA<Cancellable>>(
         &self,
         chain: &impl IsA<TlsCertificate>,
         purpose: &str,
-        identity: Option<&impl IsA<SocketConnectable>>,
-        interaction: Option<&impl IsA<TlsInteraction>>,
+        identity: impl Into<Option<&'a P>>,
+        interaction: impl Into<Option<&'a Q>>,
         flags: TlsDatabaseVerifyFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a R>>,
     ) -> Result<TlsCertificateFlags, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -384,10 +455,25 @@ pub trait TlsDatabaseExt: IsA<TlsDatabase> + 'static {
                 self.as_ref().to_glib_none().0,
                 chain.as_ref().to_glib_none().0,
                 purpose.to_glib_none().0,
-                identity.map(|p| p.as_ref()).to_glib_none().0,
-                interaction.map(|p| p.as_ref()).to_glib_none().0,
+                identity
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                interaction
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -399,15 +485,21 @@ pub trait TlsDatabaseExt: IsA<TlsDatabase> + 'static {
     }
 
     #[doc(alias = "g_tls_database_verify_chain_async")]
-    fn verify_chain_async<P: FnOnce(Result<TlsCertificateFlags, glib::Error>) + 'static>(
+    fn verify_chain_async<
+        'a,
+        P: IsA<SocketConnectable>,
+        Q: IsA<TlsInteraction>,
+        R: IsA<Cancellable>,
+        S: FnOnce(Result<TlsCertificateFlags, glib::Error>) + 'static,
+    >(
         &self,
         chain: &impl IsA<TlsCertificate>,
         purpose: &str,
-        identity: Option<&impl IsA<SocketConnectable>>,
-        interaction: Option<&impl IsA<TlsInteraction>>,
+        identity: impl Into<Option<&'a P>>,
+        interaction: impl Into<Option<&'a Q>>,
         flags: TlsDatabaseVerifyFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a R>>,
+        callback: S,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -419,10 +511,10 @@ pub trait TlsDatabaseExt: IsA<TlsDatabase> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<S>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn verify_chain_async_trampoline<
-            P: FnOnce(Result<TlsCertificateFlags, glib::Error>) + 'static,
+            S: FnOnce(Result<TlsCertificateFlags, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -436,41 +528,60 @@ pub trait TlsDatabaseExt: IsA<TlsDatabase> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<S>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: S = callback.into_inner();
             callback(result);
         }
-        let callback = verify_chain_async_trampoline::<P>;
+        let callback = verify_chain_async_trampoline::<S>;
         unsafe {
             ffi::g_tls_database_verify_chain_async(
                 self.as_ref().to_glib_none().0,
                 chain.as_ref().to_glib_none().0,
                 purpose.to_glib_none().0,
-                identity.map(|p| p.as_ref()).to_glib_none().0,
-                interaction.map(|p| p.as_ref()).to_glib_none().0,
+                identity
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                interaction
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn verify_chain_future(
+    fn verify_chain_future<
+        'a,
+        P: IsA<SocketConnectable> + Clone + 'static,
+        Q: IsA<TlsInteraction> + Clone + 'static,
+    >(
         &self,
         chain: &(impl IsA<TlsCertificate> + Clone + 'static),
         purpose: &str,
-        identity: Option<&(impl IsA<SocketConnectable> + Clone + 'static)>,
-        interaction: Option<&(impl IsA<TlsInteraction> + Clone + 'static)>,
+        identity: impl Into<Option<&'a P>>,
+        interaction: impl Into<Option<&'a Q>>,
         flags: TlsDatabaseVerifyFlags,
     ) -> Pin<
         Box_<dyn std::future::Future<Output = Result<TlsCertificateFlags, glib::Error>> + 'static>,
     > {
         let chain = chain.clone();
         let purpose = String::from(purpose);
-        let identity = identity.map(ToOwned::to_owned);
-        let interaction = interaction.map(ToOwned::to_owned);
+        let identity = identity.into().map(ToOwned::to_owned);
+        let interaction = interaction.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
diff --git a/gio/src/auto/tls_file_database.rs b/gio/src/auto/tls_file_database.rs
index 878326074e3a..14227bf53567 100644
--- a/gio/src/auto/tls_file_database.rs
+++ b/gio/src/auto/tls_file_database.rs
@@ -41,8 +41,8 @@ pub trait TlsFileDatabaseExt: IsA<TlsFileDatabase> + 'static {
         ObjectExt::property(self.as_ref(), "anchors")
     }
 
-    fn set_anchors(&self, anchors: Option<&str>) {
-        ObjectExt::set_property(self.as_ref(), "anchors", anchors)
+    fn set_anchors<'a>(&self, anchors: impl Into<Option<&'a str>>) {
+        ObjectExt::set_property(self.as_ref(), "anchors", anchors.into())
     }
 
     #[doc(alias = "anchors")]
diff --git a/gio/src/auto/tls_interaction.rs b/gio/src/auto/tls_interaction.rs
index 964f36184320..43b42691627b 100644
--- a/gio/src/auto/tls_interaction.rs
+++ b/gio/src/auto/tls_interaction.rs
@@ -24,17 +24,22 @@ impl TlsInteraction {
 
 pub trait TlsInteractionExt: IsA<TlsInteraction> + 'static {
     #[doc(alias = "g_tls_interaction_ask_password")]
-    fn ask_password(
+    fn ask_password<'a, P: IsA<Cancellable>>(
         &self,
         password: &impl IsA<TlsPassword>,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<TlsInteractionResult, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_tls_interaction_ask_password(
                 self.as_ref().to_glib_none().0,
                 password.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -46,11 +51,15 @@ pub trait TlsInteractionExt: IsA<TlsInteraction> + 'static {
     }
 
     #[doc(alias = "g_tls_interaction_ask_password_async")]
-    fn ask_password_async<P: FnOnce(Result<TlsInteractionResult, glib::Error>) + 'static>(
+    fn ask_password_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<TlsInteractionResult, glib::Error>) + 'static,
+    >(
         &self,
         password: &impl IsA<TlsPassword>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -62,10 +71,10 @@ pub trait TlsInteractionExt: IsA<TlsInteraction> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn ask_password_async_trampoline<
-            P: FnOnce(Result<TlsInteractionResult, glib::Error>) + 'static,
+            Q: FnOnce(Result<TlsInteractionResult, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -82,17 +91,22 @@ pub trait TlsInteractionExt: IsA<TlsInteraction> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = ask_password_async_trampoline::<P>;
+        let callback = ask_password_async_trampoline::<Q>;
         unsafe {
             ffi::g_tls_interaction_ask_password_async(
                 self.as_ref().to_glib_none().0,
                 password.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
@@ -117,17 +131,22 @@ pub trait TlsInteractionExt: IsA<TlsInteraction> + 'static {
     }
 
     #[doc(alias = "g_tls_interaction_invoke_ask_password")]
-    fn invoke_ask_password(
+    fn invoke_ask_password<'a, P: IsA<Cancellable>>(
         &self,
         password: &impl IsA<TlsPassword>,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<TlsInteractionResult, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_tls_interaction_invoke_ask_password(
                 self.as_ref().to_glib_none().0,
                 password.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -139,11 +158,11 @@ pub trait TlsInteractionExt: IsA<TlsInteraction> + 'static {
     }
 
     #[doc(alias = "g_tls_interaction_invoke_request_certificate")]
-    fn invoke_request_certificate(
+    fn invoke_request_certificate<'a, P: IsA<Cancellable>>(
         &self,
         connection: &impl IsA<TlsConnection>,
         flags: TlsCertificateRequestFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<TlsInteractionResult, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -151,7 +170,12 @@ pub trait TlsInteractionExt: IsA<TlsInteraction> + 'static {
                 self.as_ref().to_glib_none().0,
                 connection.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -163,11 +187,11 @@ pub trait TlsInteractionExt: IsA<TlsInteraction> + 'static {
     }
 
     #[doc(alias = "g_tls_interaction_request_certificate")]
-    fn request_certificate(
+    fn request_certificate<'a, P: IsA<Cancellable>>(
         &self,
         connection: &impl IsA<TlsConnection>,
         flags: TlsCertificateRequestFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<TlsInteractionResult, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -175,7 +199,12 @@ pub trait TlsInteractionExt: IsA<TlsInteraction> + 'static {
                 self.as_ref().to_glib_none().0,
                 connection.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -187,12 +216,16 @@ pub trait TlsInteractionExt: IsA<TlsInteraction> + 'static {
     }
 
     #[doc(alias = "g_tls_interaction_request_certificate_async")]
-    fn request_certificate_async<P: FnOnce(Result<TlsInteractionResult, glib::Error>) + 'static>(
+    fn request_certificate_async<
+        'a,
+        P: IsA<Cancellable>,
+        Q: FnOnce(Result<TlsInteractionResult, glib::Error>) + 'static,
+    >(
         &self,
         connection: &impl IsA<TlsConnection>,
         flags: TlsCertificateRequestFlags,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -204,10 +237,10 @@ pub trait TlsInteractionExt: IsA<TlsInteraction> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn request_certificate_async_trampoline<
-            P: FnOnce(Result<TlsInteractionResult, glib::Error>) + 'static,
+            Q: FnOnce(Result<TlsInteractionResult, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -224,18 +257,23 @@ pub trait TlsInteractionExt: IsA<TlsInteraction> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = request_certificate_async_trampoline::<P>;
+        let callback = request_certificate_async_trampoline::<Q>;
         unsafe {
             ffi::g_tls_interaction_request_certificate_async(
                 self.as_ref().to_glib_none().0,
                 connection.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
diff --git a/gio/src/auto/tls_server_connection.rs b/gio/src/auto/tls_server_connection.rs
index 6b2a33b42f33..203137390c72 100644
--- a/gio/src/auto/tls_server_connection.rs
+++ b/gio/src/auto/tls_server_connection.rs
@@ -23,15 +23,20 @@ impl TlsServerConnection {
     pub const NONE: Option<&'static TlsServerConnection> = None;
 
     #[doc(alias = "g_tls_server_connection_new")]
-    pub fn new(
+    pub fn new<'a, P: IsA<TlsCertificate>>(
         base_io_stream: &impl IsA<IOStream>,
-        certificate: Option<&impl IsA<TlsCertificate>>,
+        certificate: impl Into<Option<&'a P>>,
     ) -> Result<TlsServerConnection, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_tls_server_connection_new(
                 base_io_stream.as_ref().to_glib_none().0,
-                certificate.map(|p| p.as_ref()).to_glib_none().0,
+                certificate
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
diff --git a/gio/src/auto/versions.txt b/gio/src/auto/versions.txt
index 558f7e6574ab..b73621765b9b 100644
--- a/gio/src/auto/versions.txt
+++ b/gio/src/auto/versions.txt
@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ 1b34ebba86cb)
+Generated by gir (https://github.com/gtk-rs/gir @ 24f0d6639caa)
 from gir-files (https://github.com/gtk-rs/gir-files @ dfdf5ed146d5)
diff --git a/gio/src/auto/volume.rs b/gio/src/auto/volume.rs
index fc5a0682a858..0f1ade21c613 100644
--- a/gio/src/auto/volume.rs
+++ b/gio/src/auto/volume.rs
@@ -38,12 +38,17 @@ pub trait VolumeExt: IsA<Volume> + 'static {
     }
 
     #[doc(alias = "g_volume_eject_with_operation")]
-    fn eject_with_operation<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn eject_with_operation<
+        'a,
+        P: IsA<MountOperation>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<(), glib::Error>) + 'static,
+    >(
         &self,
         flags: MountUnmountFlags,
-        mount_operation: Option<&impl IsA<MountOperation>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        mount_operation: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -55,10 +60,10 @@ pub trait VolumeExt: IsA<Volume> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn eject_with_operation_trampoline<
-            P: FnOnce(Result<(), glib::Error>) + 'static,
+            R: FnOnce(Result<(), glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
@@ -75,30 +80,40 @@ pub trait VolumeExt: IsA<Volume> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = eject_with_operation_trampoline::<P>;
+        let callback = eject_with_operation_trampoline::<R>;
         unsafe {
             ffi::g_volume_eject_with_operation(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                mount_operation
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn eject_with_operation_future(
+    fn eject_with_operation_future<'a, P: IsA<MountOperation> + Clone + 'static>(
         &self,
         flags: MountUnmountFlags,
-        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
+        mount_operation: impl Into<Option<&'a P>>,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
-        let mount_operation = mount_operation.map(ToOwned::to_owned);
+        let mount_operation = mount_operation.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
@@ -190,12 +205,17 @@ pub trait VolumeExt: IsA<Volume> + 'static {
     }
 
     #[doc(alias = "g_volume_mount")]
-    fn mount<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    fn mount<
+        'a,
+        P: IsA<MountOperation>,
+        Q: IsA<Cancellable>,
+        R: FnOnce(Result<(), glib::Error>) + 'static,
+    >(
         &self,
         flags: MountMountFlags,
-        mount_operation: Option<&impl IsA<MountOperation>>,
-        cancellable: Option<&impl IsA<Cancellable>>,
-        callback: P,
+        mount_operation: impl Into<Option<&'a P>>,
+        cancellable: impl Into<Option<&'a Q>>,
+        callback: R,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -207,9 +227,9 @@ pub trait VolumeExt: IsA<Volume> + 'static {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<R>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
-        unsafe extern "C" fn mount_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
+        unsafe extern "C" fn mount_trampoline<R: FnOnce(Result<(), glib::Error>) + 'static>(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut crate::ffi::GAsyncResult,
             user_data: glib::ffi::gpointer,
@@ -221,30 +241,40 @@ pub trait VolumeExt: IsA<Volume> + 'static {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<R>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: R = callback.into_inner();
             callback(result);
         }
-        let callback = mount_trampoline::<P>;
+        let callback = mount_trampoline::<R>;
         unsafe {
             ffi::g_volume_mount(
                 self.as_ref().to_glib_none().0,
                 flags.into_glib(),
-                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                mount_operation
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );
         }
     }
 
-    fn mount_future(
+    fn mount_future<'a, P: IsA<MountOperation> + Clone + 'static>(
         &self,
         flags: MountMountFlags,
-        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
+        mount_operation: impl Into<Option<&'a P>>,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
-        let mount_operation = mount_operation.map(ToOwned::to_owned);
+        let mount_operation = mount_operation.into().map(ToOwned::to_owned);
         Box_::pin(crate::GioFuture::new(
             self,
             move |obj, cancellable, send| {
diff --git a/gio/src/auto/zlib_compressor.rs b/gio/src/auto/zlib_compressor.rs
index 87613837a369..12d1abb17cc0 100644
--- a/gio/src/auto/zlib_compressor.rs
+++ b/gio/src/auto/zlib_compressor.rs
@@ -34,9 +34,12 @@ impl ZlibCompressor {
 
     #[doc(alias = "g_zlib_compressor_set_file_info")]
     #[doc(alias = "file-info")]
-    pub fn set_file_info(&self, file_info: Option<&FileInfo>) {
+    pub fn set_file_info<'a>(&self, file_info: impl Into<Option<&'a FileInfo>>) {
         unsafe {
-            ffi::g_zlib_compressor_set_file_info(self.to_glib_none().0, file_info.to_glib_none().0);
+            ffi::g_zlib_compressor_set_file_info(
+                self.to_glib_none().0,
+                file_info.into().to_glib_none().0,
+            );
         }
     }
 
diff --git a/gio/sys/versions.txt b/gio/sys/versions.txt
index 558f7e6574ab..b73621765b9b 100644
--- a/gio/sys/versions.txt
+++ b/gio/sys/versions.txt
@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ 1b34ebba86cb)
+Generated by gir (https://github.com/gtk-rs/gir @ 24f0d6639caa)
 from gir-files (https://github.com/gtk-rs/gir-files @ dfdf5ed146d5)
diff --git a/gio/tests/dbus_peer.rs b/gio/tests/dbus_peer.rs
index 67e66b35bd90..110dadf0b9f0 100644
--- a/gio/tests/dbus_peer.rs
+++ b/gio/tests/dbus_peer.rs
@@ -31,7 +31,7 @@ fn test_gdbus_peer_connection() {
 
         let connection = DBusConnection::new_future(
             &socket_connection,
-            Some(&guid),
+            guid.as_str(),
             DBusConnectionFlags::AUTHENTICATION_SERVER
                 .union(DBusConnectionFlags::DELAY_MESSAGE_PROCESSING),
             None,
diff --git a/gir b/gir
index 1b34ebba86cb..24f0d6639caa 160000
--- a/gir
+++ b/gir
@@ -1 +1 @@
-Subproject commit 1b34ebba86cb5c5c6b474b1693f8aeb55b88477d
+Subproject commit 24f0d6639caa6dfb17ce2c92f67499bc7ba3a7af
diff --git a/glib/gobject-sys/versions.txt b/glib/gobject-sys/versions.txt
index 558f7e6574ab..b73621765b9b 100644
--- a/glib/gobject-sys/versions.txt
+++ b/glib/gobject-sys/versions.txt
@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ 1b34ebba86cb)
+Generated by gir (https://github.com/gtk-rs/gir @ 24f0d6639caa)
 from gir-files (https://github.com/gtk-rs/gir-files @ dfdf5ed146d5)
diff --git a/glib/src/auto/date_time.rs b/glib/src/auto/date_time.rs
index 9199cf28799b..27cecd64a574 100644
--- a/glib/src/auto/date_time.rs
+++ b/glib/src/auto/date_time.rs
@@ -42,11 +42,14 @@ impl DateTime {
 
     #[doc(alias = "g_date_time_new_from_iso8601")]
     #[doc(alias = "new_from_iso8601")]
-    pub fn from_iso8601(text: &str, default_tz: Option<&TimeZone>) -> Result<DateTime, BoolError> {
+    pub fn from_iso8601<'a>(
+        text: &str,
+        default_tz: impl Into<Option<&'a TimeZone>>,
+    ) -> Result<DateTime, BoolError> {
         unsafe {
             Option::<_>::from_glib_full(ffi::g_date_time_new_from_iso8601(
                 text.to_glib_none().0,
-                default_tz.to_glib_none().0,
+                default_tz.into().to_glib_none().0,
             ))
             .ok_or_else(|| crate::bool_error!("Invalid date"))
         }
diff --git a/glib/src/auto/functions.rs b/glib/src/auto/functions.rs
index 815147662c16..465f5824bbbe 100644
--- a/glib/src/auto/functions.rs
+++ b/glib/src/auto/functions.rs
@@ -34,7 +34,7 @@ pub fn base64_decode(text: &str) -> Vec<u8> {
 //}
 
 //#[doc(alias = "g_base64_decode_step")]
-//pub fn base64_decode_step(in_: &[u8], out: Vec<u8>, state: &mut i32, save: &mut u32) -> usize {
+//pub fn base64_decode_step(in_: &[u8], out: &mut Vec<u8>, state: &mut i32, save: &mut u32) -> usize {
 //    unsafe { TODO: call ffi:g_base64_decode_step() }
 //}
 
@@ -45,12 +45,12 @@ pub fn base64_encode(data: &[u8]) -> crate::GString {
 }
 
 //#[doc(alias = "g_base64_encode_close")]
-//pub fn base64_encode_close(break_lines: bool, out: Vec<u8>, state: &mut i32, save: &mut i32) -> usize {
+//pub fn base64_encode_close(break_lines: bool, out: &mut Vec<u8>, state: &mut i32, save: &mut i32) -> usize {
 //    unsafe { TODO: call ffi:g_base64_encode_close() }
 //}
 
 //#[doc(alias = "g_base64_encode_step")]
-//pub fn base64_encode_step(in_: &[u8], break_lines: bool, out: Vec<u8>, state: &mut i32, save: &mut i32) -> usize {
+//pub fn base64_encode_step(in_: &[u8], break_lines: bool, out: &mut Vec<u8>, state: &mut i32, save: &mut i32) -> usize {
 //    unsafe { TODO: call ffi:g_base64_encode_step() }
 //}
 
@@ -128,10 +128,14 @@ pub fn compute_hmac_for_data(digest_type: ChecksumType, key: &[u8], data: &[u8])
 }
 
 #[doc(alias = "g_dcgettext")]
-pub fn dcgettext(domain: Option<&str>, msgid: &str, category: i32) -> crate::GString {
+pub fn dcgettext<'a>(
+    domain: impl Into<Option<&'a str>>,
+    msgid: &str,
+    category: i32,
+) -> crate::GString {
     unsafe {
         from_glib_none(ffi::g_dcgettext(
-            domain.to_glib_none().0,
+            domain.into().to_glib_none().0,
             msgid.to_glib_none().0,
             category,
         ))
@@ -139,25 +143,25 @@ pub fn dcgettext(domain: Option<&str>, msgid: &str, category: i32) -> crate::GSt
 }
 
 #[doc(alias = "g_dgettext")]
-pub fn dgettext(domain: Option<&str>, msgid: &str) -> crate::GString {
+pub fn dgettext<'a>(domain: impl Into<Option<&'a str>>, msgid: &str) -> crate::GString {
     unsafe {
         from_glib_none(ffi::g_dgettext(
-            domain.to_glib_none().0,
+            domain.into().to_glib_none().0,
             msgid.to_glib_none().0,
         ))
     }
 }
 
 #[doc(alias = "g_dngettext")]
-pub fn dngettext(
-    domain: Option<&str>,
+pub fn dngettext<'a>(
+    domain: impl Into<Option<&'a str>>,
     msgid: &str,
     msgid_plural: &str,
     n: libc::c_ulong,
 ) -> crate::GString {
     unsafe {
         from_glib_none(ffi::g_dngettext(
-            domain.to_glib_none().0,
+            domain.into().to_glib_none().0,
             msgid.to_glib_none().0,
             msgid_plural.to_glib_none().0,
             n,
@@ -166,10 +170,14 @@ pub fn dngettext(
 }
 
 #[doc(alias = "g_dpgettext")]
-pub fn dpgettext(domain: Option<&str>, msgctxtid: &str, msgidoffset: usize) -> crate::GString {
+pub fn dpgettext<'a>(
+    domain: impl Into<Option<&'a str>>,
+    msgctxtid: &str,
+    msgidoffset: usize,
+) -> crate::GString {
     unsafe {
         from_glib_none(ffi::g_dpgettext(
-            domain.to_glib_none().0,
+            domain.into().to_glib_none().0,
             msgctxtid.to_glib_none().0,
             msgidoffset,
         ))
@@ -177,10 +185,14 @@ pub fn dpgettext(domain: Option<&str>, msgctxtid: &str, msgidoffset: usize) -> c
 }
 
 #[doc(alias = "g_dpgettext2")]
-pub fn dpgettext2(domain: Option<&str>, context: &str, msgid: &str) -> crate::GString {
+pub fn dpgettext2<'a>(
+    domain: impl Into<Option<&'a str>>,
+    context: &str,
+    msgid: &str,
+) -> crate::GString {
     unsafe {
         from_glib_none(ffi::g_dpgettext2(
-            domain.to_glib_none().0,
+            domain.into().to_glib_none().0,
             context.to_glib_none().0,
             msgid.to_glib_none().0,
         ))
@@ -285,15 +297,15 @@ pub fn filename_from_uri(
 }
 
 #[doc(alias = "g_filename_to_uri")]
-pub fn filename_to_uri(
+pub fn filename_to_uri<'a>(
     filename: impl AsRef<std::path::Path>,
-    hostname: Option<&str>,
+    hostname: impl Into<Option<&'a str>>,
 ) -> Result<crate::GString, crate::Error> {
     unsafe {
         let mut error = std::ptr::null_mut();
         let ret = ffi::g_filename_to_uri(
             filename.as_ref().to_glib_none().0,
-            hostname.to_glib_none().0,
+            hostname.into().to_glib_none().0,
             &mut error,
         );
         if error.is_null() {
@@ -559,9 +571,9 @@ pub fn on_error_query(prg_name: &str) {
 }
 
 #[doc(alias = "g_on_error_stack_trace")]
-pub fn on_error_stack_trace(prg_name: Option<&str>) {
+pub fn on_error_stack_trace<'a>(prg_name: impl Into<Option<&'a str>>) {
     unsafe {
-        ffi::g_on_error_stack_trace(prg_name.to_glib_none().0);
+        ffi::g_on_error_stack_trace(prg_name.into().to_glib_none().0);
     }
 }
 
@@ -812,12 +824,12 @@ pub fn spawn_command_line_async(
 }
 
 //#[doc(alias = "g_spawn_command_line_sync")]
-//pub fn spawn_command_line_sync(command_line: impl AsRef<std::path::Path>, standard_output: Vec<u8>, standard_error: Vec<u8>) -> Result<i32, crate::Error> {
+//pub fn spawn_command_line_sync(command_line: impl AsRef<std::path::Path>, standard_output: &mut Vec<u8>, standard_error: &mut Vec<u8>) -> Result<i32, crate::Error> {
 //    unsafe { TODO: call ffi:g_spawn_command_line_sync() }
 //}
 
 //#[doc(alias = "g_spawn_sync")]
-//pub fn spawn_sync(working_directory: Option<impl AsRef<std::path::Path>>, argv: &[&std::path::Path], envp: &[&std::path::Path], flags: SpawnFlags, child_setup: Option<&mut dyn (FnMut())>, standard_output: Vec<u8>, standard_error: Vec<u8>) -> Result<i32, crate::Error> {
+//pub fn spawn_sync(working_directory: Option<impl AsRef<std::path::Path>>, argv: &[&std::path::Path], envp: &[&std::path::Path], flags: SpawnFlags, child_setup: Option<&mut dyn (FnMut())>, standard_output: &mut Vec<u8>, standard_error: &mut Vec<u8>) -> Result<i32, crate::Error> {
 //    unsafe { TODO: call ffi:g_spawn_sync() }
 //}
 
diff --git a/glib/src/auto/key_file.rs b/glib/src/auto/key_file.rs
index e88276ad1952..c1d694fe1e26 100644
--- a/glib/src/auto/key_file.rs
+++ b/glib/src/auto/key_file.rs
@@ -23,17 +23,17 @@ impl KeyFile {
 
     #[doc(alias = "g_key_file_get_comment")]
     #[doc(alias = "get_comment")]
-    pub fn comment(
+    pub fn comment<'a>(
         &self,
-        group_name: Option<&str>,
-        key: Option<&str>,
+        group_name: impl Into<Option<&'a str>>,
+        key: impl Into<Option<&'a str>>,
     ) -> Result<crate::GString, crate::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_key_file_get_comment(
                 self.to_glib_none().0,
-                group_name.to_glib_none().0,
-                key.to_glib_none().0,
+                group_name.into().to_glib_none().0,
+                key.into().to_glib_none().0,
                 &mut error,
             );
             if error.is_null() {
@@ -151,18 +151,18 @@ impl KeyFile {
 
     #[doc(alias = "g_key_file_get_locale_for_key")]
     #[doc(alias = "get_locale_for_key")]
-    pub fn locale_for_key(
+    pub fn locale_for_key<'a>(
         &self,
         group_name: &str,
         key: &str,
-        locale: Option<&str>,
+        locale: impl Into<Option<&'a str>>,
     ) -> Option<crate::GString> {
         unsafe {
             from_glib_full(ffi::g_key_file_get_locale_for_key(
                 self.to_glib_none().0,
                 group_name.to_glib_none().0,
                 key.to_glib_none().0,
-                locale.to_glib_none().0,
+                locale.into().to_glib_none().0,
             ))
         }
     }
@@ -285,17 +285,17 @@ impl KeyFile {
     }
 
     #[doc(alias = "g_key_file_remove_comment")]
-    pub fn remove_comment(
+    pub fn remove_comment<'a>(
         &self,
-        group_name: Option<&str>,
-        key: Option<&str>,
+        group_name: impl Into<Option<&'a str>>,
+        key: impl Into<Option<&'a str>>,
     ) -> Result<(), crate::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_key_file_remove_comment(
                 self.to_glib_none().0,
-                group_name.to_glib_none().0,
-                key.to_glib_none().0,
+                group_name.into().to_glib_none().0,
+                key.into().to_glib_none().0,
                 &mut error,
             );
             debug_assert_eq!(is_ok == crate::ffi::GFALSE, !error.is_null());
@@ -362,18 +362,18 @@ impl KeyFile {
     //}
 
     #[doc(alias = "g_key_file_set_comment")]
-    pub fn set_comment(
+    pub fn set_comment<'a>(
         &self,
-        group_name: Option<&str>,
-        key: Option<&str>,
+        group_name: impl Into<Option<&'a str>>,
+        key: impl Into<Option<&'a str>>,
         comment: &str,
     ) -> Result<(), crate::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let is_ok = ffi::g_key_file_set_comment(
                 self.to_glib_none().0,
-                group_name.to_glib_none().0,
-                key.to_glib_none().0,
+                group_name.into().to_glib_none().0,
+                key.into().to_glib_none().0,
                 comment.to_glib_none().0,
                 &mut error,
             );
diff --git a/glib/src/auto/main_context.rs b/glib/src/auto/main_context.rs
index eaa868c9ca5a..888bf11cc1a9 100644
--- a/glib/src/auto/main_context.rs
+++ b/glib/src/auto/main_context.rs
@@ -61,7 +61,7 @@ impl MainContext {
 
     //#[doc(alias = "g_main_context_get_poll_func")]
     //#[doc(alias = "get_poll_func")]
-    //pub fn poll_func(&self) -> /*Unimplemented*/Fn(/*Ignored*/PollFD, u32) -> i32 {
+    //pub fn poll_func(&self) -> /*Unimplemented*/Fn(/*Ignored*/&PollFD, u32) -> i32 + 'static {
     //    unsafe { TODO: call ffi:g_main_context_get_poll_func() }
     //}
 
@@ -88,12 +88,12 @@ impl MainContext {
     //#[cfg(feature = "v2_64")]
     //#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
     //#[doc(alias = "g_main_context_pusher_new")]
-    //pub fn pusher_new(&self) -> /*Unknown conversion*//*Unimplemented*/MainContextPusher {
+    //pub fn pusher_new(&self) -> /*Unimplemented*/MainContextPusher {
     //    unsafe { TODO: call ffi:g_main_context_pusher_new() }
     //}
 
     //#[doc(alias = "g_main_context_query")]
-    //pub fn query(&self, max_priority: i32, fds: /*Ignored*/Vec<PollFD>) -> (i32, i32) {
+    //pub fn query(&self, max_priority: i32, fds: /*Ignored*/&mut Vec<PollFD>) -> (i32, i32) {
     //    unsafe { TODO: call ffi:g_main_context_query() }
     //}
 
@@ -103,7 +103,7 @@ impl MainContext {
     //}
 
     //#[doc(alias = "g_main_context_set_poll_func")]
-    //pub fn set_poll_func(&self, func: /*Unimplemented*/Fn(/*Ignored*/PollFD, u32) -> i32) {
+    //pub fn set_poll_func(&self, func: /*Unimplemented*/Fn(/*Ignored*/&PollFD, u32) -> i32 + 'static) {
     //    unsafe { TODO: call ffi:g_main_context_set_poll_func() }
     //}
 
@@ -136,7 +136,7 @@ impl MainContext {
     //#[cfg(feature = "v2_64")]
     //#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
     //#[doc(alias = "g_main_context_pusher_free")]
-    //pub fn pusher_free(pusher: /*Unknown conversion*//*Unimplemented*/MainContextPusher) {
+    //pub fn pusher_free(pusher: /*Unimplemented*/MainContextPusher) {
     //    unsafe { TODO: call ffi:g_main_context_pusher_free() }
     //}
 
diff --git a/glib/src/auto/main_loop.rs b/glib/src/auto/main_loop.rs
index 86ba4730bacd..832c7a56ac80 100644
--- a/glib/src/auto/main_loop.rs
+++ b/glib/src/auto/main_loop.rs
@@ -17,10 +17,10 @@ crate::wrapper! {
 
 impl MainLoop {
     #[doc(alias = "g_main_loop_new")]
-    pub fn new(context: Option<&MainContext>, is_running: bool) -> MainLoop {
+    pub fn new<'a>(context: impl Into<Option<&'a MainContext>>, is_running: bool) -> MainLoop {
         unsafe {
             from_glib_full(ffi::g_main_loop_new(
-                context.to_glib_none().0,
+                context.into().to_glib_none().0,
                 is_running.into_glib(),
             ))
         }
diff --git a/glib/src/auto/regex.rs b/glib/src/auto/regex.rs
index 5c0464d87b3b..f7bb4ed7f2eb 100644
--- a/glib/src/auto/regex.rs
+++ b/glib/src/auto/regex.rs
@@ -81,7 +81,7 @@ impl Regex {
     }
 
     //#[doc(alias = "g_regex_replace_eval")]
-    //pub fn replace_eval(&self, string: &[&str], start_position: i32, match_options: RegexMatchFlags, eval: /*Unimplemented*/FnMut(&MatchInfo, /*Ignored*/String) -> bool, user_data: /*Unimplemented*/Option<Basic: Pointer>) -> Result<crate::GString, crate::Error> {
+    //pub fn replace_eval(&self, string: &[&str], start_position: i32, match_options: RegexMatchFlags, eval: /*Unimplemented*/FnMut(&MatchInfo, /*Ignored*/&String) -> bool, user_data: /*Unimplemented*/Option<Basic: Pointer>) -> Result<crate::GString, crate::Error> {
     //    unsafe { TODO: call ffi:g_regex_replace_eval() }
     //}
 }
diff --git a/glib/src/auto/time_zone.rs b/glib/src/auto/time_zone.rs
index c5fc556e33be..a6a537a502ee 100644
--- a/glib/src/auto/time_zone.rs
+++ b/glib/src/auto/time_zone.rs
@@ -19,16 +19,20 @@ impl TimeZone {
     #[cfg_attr(feature = "v2_68", deprecated = "Since 2.68")]
     #[allow(deprecated)]
     #[doc(alias = "g_time_zone_new")]
-    pub fn new(identifier: Option<&str>) -> TimeZone {
-        unsafe { from_glib_full(ffi::g_time_zone_new(identifier.to_glib_none().0)) }
+    pub fn new<'a>(identifier: impl Into<Option<&'a str>>) -> TimeZone {
+        unsafe { from_glib_full(ffi::g_time_zone_new(identifier.into().to_glib_none().0)) }
     }
 
     #[cfg(feature = "v2_68")]
     #[cfg_attr(docsrs, doc(cfg(feature = "v2_68")))]
     #[doc(alias = "g_time_zone_new_identifier")]
     #[doc(alias = "new_identifier")]
-    pub fn from_identifier(identifier: Option<&str>) -> Option<TimeZone> {
-        unsafe { from_glib_full(ffi::g_time_zone_new_identifier(identifier.to_glib_none().0)) }
+    pub fn from_identifier<'a>(identifier: impl Into<Option<&'a str>>) -> Option<TimeZone> {
+        unsafe {
+            from_glib_full(ffi::g_time_zone_new_identifier(
+                identifier.into().to_glib_none().0,
+            ))
+        }
     }
 
     #[doc(alias = "g_time_zone_new_local")]
diff --git a/glib/src/auto/uri.rs b/glib/src/auto/uri.rs
index 15d5f21a8c0e..6d2bbab8b246 100644
--- a/glib/src/auto/uri.rs
+++ b/glib/src/auto/uri.rs
@@ -117,81 +117,84 @@ impl Uri {
     }
 
     #[doc(alias = "g_uri_build")]
-    pub fn build(
+    pub fn build<'a>(
         flags: UriFlags,
         scheme: &str,
-        userinfo: Option<&str>,
-        host: Option<&str>,
+        userinfo: impl Into<Option<&'a str>>,
+        host: impl Into<Option<&'a str>>,
         port: i32,
         path: &str,
-        query: Option<&str>,
-        fragment: Option<&str>,
+        query: impl Into<Option<&'a str>>,
+        fragment: impl Into<Option<&'a str>>,
     ) -> Uri {
         unsafe {
             from_glib_full(ffi::g_uri_build(
                 flags.into_glib(),
                 scheme.to_glib_none().0,
-                userinfo.to_glib_none().0,
-                host.to_glib_none().0,
+                userinfo.into().to_glib_none().0,
+                host.into().to_glib_none().0,
                 port,
                 path.to_glib_none().0,
-                query.to_glib_none().0,
-                fragment.to_glib_none().0,
+                query.into().to_glib_none().0,
+                fragment.into().to_glib_none().0,
             ))
         }
     }
 
     #[doc(alias = "g_uri_build_with_user")]
-    pub fn build_with_user(
+    pub fn build_with_user<'a>(
         flags: UriFlags,
         scheme: &str,
-        user: Option<&str>,
-        password: Option<&str>,
-        auth_params: Option<&str>,
-        host: Option<&str>,
+        user: impl Into<Option<&'a str>>,
+        password: impl Into<Option<&'a str>>,
+        auth_params: impl Into<Option<&'a str>>,
+        host: impl Into<Option<&'a str>>,
         port: i32,
         path: &str,
-        query: Option<&str>,
-        fragment: Option<&str>,
+        query: impl Into<Option<&'a str>>,
+        fragment: impl Into<Option<&'a str>>,
     ) -> Uri {
         unsafe {
             from_glib_full(ffi::g_uri_build_with_user(
                 flags.into_glib(),
                 scheme.to_glib_none().0,
-                user.to_glib_none().0,
-                password.to_glib_none().0,
-                auth_params.to_glib_none().0,
-                host.to_glib_none().0,
+                user.into().to_glib_none().0,
+                password.into().to_glib_none().0,
+                auth_params.into().to_glib_none().0,
+                host.into().to_glib_none().0,
                 port,
                 path.to_glib_none().0,
-                query.to_glib_none().0,
-                fragment.to_glib_none().0,
+                query.into().to_glib_none().0,
+                fragment.into().to_glib_none().0,
             ))
         }
     }
 
     #[doc(alias = "g_uri_escape_bytes")]
-    pub fn escape_bytes(unescaped: &[u8], reserved_chars_allowed: Option<&str>) -> crate::GString {
+    pub fn escape_bytes<'a>(
+        unescaped: &[u8],
+        reserved_chars_allowed: impl Into<Option<&'a str>>,
+    ) -> crate::GString {
         let length = unescaped.len() as _;
         unsafe {
             from_glib_full(ffi::g_uri_escape_bytes(
                 unescaped.to_glib_none().0,
                 length,
-                reserved_chars_allowed.to_glib_none().0,
+                reserved_chars_allowed.into().to_glib_none().0,
             ))
         }
     }
 
     #[doc(alias = "g_uri_escape_string")]
-    pub fn escape_string(
+    pub fn escape_string<'a>(
         unescaped: &str,
-        reserved_chars_allowed: Option<&str>,
+        reserved_chars_allowed: impl Into<Option<&'a str>>,
         allow_utf8: bool,
     ) -> crate::GString {
         unsafe {
             from_glib_full(ffi::g_uri_escape_string(
                 unescaped.to_glib_none().0,
-                reserved_chars_allowed.to_glib_none().0,
+                reserved_chars_allowed.into().to_glib_none().0,
                 allow_utf8.into_glib(),
             ))
         }
@@ -213,55 +216,55 @@ impl Uri {
     }
 
     #[doc(alias = "g_uri_join")]
-    pub fn join(
+    pub fn join<'a>(
         flags: UriFlags,
-        scheme: Option<&str>,
-        userinfo: Option<&str>,
-        host: Option<&str>,
+        scheme: impl Into<Option<&'a str>>,
+        userinfo: impl Into<Option<&'a str>>,
+        host: impl Into<Option<&'a str>>,
         port: i32,
         path: &str,
-        query: Option<&str>,
-        fragment: Option<&str>,
+        query: impl Into<Option<&'a str>>,
+        fragment: impl Into<Option<&'a str>>,
     ) -> crate::GString {
         unsafe {
             from_glib_full(ffi::g_uri_join(
                 flags.into_glib(),
-                scheme.to_glib_none().0,
-                userinfo.to_glib_none().0,
-                host.to_glib_none().0,
+                scheme.into().to_glib_none().0,
+                userinfo.into().to_glib_none().0,
+                host.into().to_glib_none().0,
                 port,
                 path.to_glib_none().0,
-                query.to_glib_none().0,
-                fragment.to_glib_none().0,
+                query.into().to_glib_none().0,
+                fragment.into().to_glib_none().0,
             ))
         }
     }
 
     #[doc(alias = "g_uri_join_with_user")]
-    pub fn join_with_user(
+    pub fn join_with_user<'a>(
         flags: UriFlags,
-        scheme: Option<&str>,
-        user: Option<&str>,
-        password: Option<&str>,
-        auth_params: Option<&str>,
-        host: Option<&str>,
+        scheme: impl Into<Option<&'a str>>,
+        user: impl Into<Option<&'a str>>,
+        password: impl Into<Option<&'a str>>,
+        auth_params: impl Into<Option<&'a str>>,
+        host: impl Into<Option<&'a str>>,
         port: i32,
         path: &str,
-        query: Option<&str>,
-        fragment: Option<&str>,
+        query: impl Into<Option<&'a str>>,
+        fragment: impl Into<Option<&'a str>>,
     ) -> crate::GString {
         unsafe {
             from_glib_full(ffi::g_uri_join_with_user(
                 flags.into_glib(),
-                scheme.to_glib_none().0,
-                user.to_glib_none().0,
-                password.to_glib_none().0,
-                auth_params.to_glib_none().0,
-                host.to_glib_none().0,
+                scheme.into().to_glib_none().0,
+                user.into().to_glib_none().0,
+                password.into().to_glib_none().0,
+                auth_params.into().to_glib_none().0,
+                host.into().to_glib_none().0,
                 port,
                 path.to_glib_none().0,
-                query.to_glib_none().0,
-                fragment.to_glib_none().0,
+                query.into().to_glib_none().0,
+                fragment.into().to_glib_none().0,
             ))
         }
     }
@@ -289,7 +292,7 @@ impl Uri {
     }
 
     //#[doc(alias = "g_uri_parse_params")]
-    //pub fn parse_params(params: &str, separators: &str, flags: UriParamsFlags) -> Result</*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 0, id: 28 }, crate::Error> {
+    //pub fn parse_params(params: &str, separators: &str, flags: UriParamsFlags) -> Result</*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 0, id: 28 }, crate::Error> {
     //    unsafe { TODO: call ffi:g_uri_parse_params() }
     //}
 
@@ -304,15 +307,15 @@ impl Uri {
     }
 
     #[doc(alias = "g_uri_resolve_relative")]
-    pub fn resolve_relative(
-        base_uri_string: Option<&str>,
+    pub fn resolve_relative<'a>(
+        base_uri_string: impl Into<Option<&'a str>>,
         uri_ref: &str,
         flags: UriFlags,
     ) -> Result<crate::GString, crate::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::g_uri_resolve_relative(
-                base_uri_string.to_glib_none().0,
+                base_uri_string.into().to_glib_none().0,
                 uri_ref.to_glib_none().0,
                 flags.into_glib(),
                 &mut error,
@@ -473,9 +476,9 @@ impl Uri {
     }
 
     #[doc(alias = "g_uri_unescape_bytes")]
-    pub fn unescape_bytes(
+    pub fn unescape_bytes<'a>(
         escaped_string: &str,
-        illegal_characters: Option<&str>,
+        illegal_characters: impl Into<Option<&'a str>>,
     ) -> Result<Bytes, crate::Error> {
         let length = escaped_string.len() as _;
         unsafe {
@@ -483,7 +486,7 @@ impl Uri {
             let ret = ffi::g_uri_unescape_bytes(
                 escaped_string.to_glib_none().0,
                 length,
-                illegal_characters.to_glib_none().0,
+                illegal_characters.into().to_glib_none().0,
                 &mut error,
             );
             if error.is_null() {
@@ -495,29 +498,29 @@ impl Uri {
     }
 
     #[doc(alias = "g_uri_unescape_segment")]
-    pub fn unescape_segment(
-        escaped_string: Option<&str>,
-        escaped_string_end: Option<&str>,
-        illegal_characters: Option<&str>,
+    pub fn unescape_segment<'a>(
+        escaped_string: impl Into<Option<&'a str>>,
+        escaped_string_end: impl Into<Option<&'a str>>,
+        illegal_characters: impl Into<Option<&'a str>>,
     ) -> Option<crate::GString> {
         unsafe {
             from_glib_full(ffi::g_uri_unescape_segment(
-                escaped_string.to_glib_none().0,
-                escaped_string_end.to_glib_none().0,
-                illegal_characters.to_glib_none().0,
+                escaped_string.into().to_glib_none().0,
+                escaped_string_end.into().to_glib_none().0,
+                illegal_characters.into().to_glib_none().0,
             ))
         }
     }
 
     #[doc(alias = "g_uri_unescape_string")]
-    pub fn unescape_string(
+    pub fn unescape_string<'a>(
         escaped_string: &str,
-        illegal_characters: Option<&str>,
+        illegal_characters: impl Into<Option<&'a str>>,
     ) -> Option<crate::GString> {
         unsafe {
             from_glib_full(ffi::g_uri_unescape_string(
                 escaped_string.to_glib_none().0,
-                illegal_characters.to_glib_none().0,
+                illegal_characters.into().to_glib_none().0,
             ))
         }
     }
diff --git a/glib/src/auto/versions.txt b/glib/src/auto/versions.txt
index 558f7e6574ab..b73621765b9b 100644
--- a/glib/src/auto/versions.txt
+++ b/glib/src/auto/versions.txt
@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ 1b34ebba86cb)
+Generated by gir (https://github.com/gtk-rs/gir @ 24f0d6639caa)
 from gir-files (https://github.com/gtk-rs/gir-files @ dfdf5ed146d5)
diff --git a/glib/src/gobject/auto/binding_group.rs b/glib/src/gobject/auto/binding_group.rs
index e02aa0e11913..209c96f071bc 100644
--- a/glib/src/gobject/auto/binding_group.rs
+++ b/glib/src/gobject/auto/binding_group.rs
@@ -38,11 +38,11 @@ impl BindingGroup {
 
     #[doc(alias = "g_binding_group_set_source")]
     #[doc(alias = "source")]
-    pub fn set_source(&self, source: Option<&impl IsA<Object>>) {
+    pub fn set_source<'a, P: IsA<Object>>(&self, source: impl Into<Option<&'a P>>) {
         unsafe {
             crate::gobject_ffi::g_binding_group_set_source(
                 self.to_glib_none().0,
-                source.map(|p| p.as_ref()).to_glib_none().0,
+                source.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
             );
         }
     }
diff --git a/glib/src/gobject/auto/signal_group.rs b/glib/src/gobject/auto/signal_group.rs
index db27a9484c41..85859738f59f 100644
--- a/glib/src/gobject/auto/signal_group.rs
+++ b/glib/src/gobject/auto/signal_group.rs
@@ -43,11 +43,11 @@ impl SignalGroup {
 
     #[doc(alias = "g_signal_group_set_target")]
     #[doc(alias = "target")]
-    pub fn set_target(&self, target: Option<&impl IsA<Object>>) {
+    pub fn set_target<'a, P: IsA<Object>>(&self, target: impl Into<Option<&'a P>>) {
         unsafe {
             crate::gobject_ffi::g_signal_group_set_target(
                 self.to_glib_none().0,
-                target.map(|p| p.as_ref()).to_glib_none().0,
+                target.into().as_ref().map(|p| p.as_ref()).to_glib_none().0,
             );
         }
     }
diff --git a/glib/sys/versions.txt b/glib/sys/versions.txt
index 558f7e6574ab..b73621765b9b 100644
--- a/glib/sys/versions.txt
+++ b/glib/sys/versions.txt
@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ 1b34ebba86cb)
+Generated by gir (https://github.com/gtk-rs/gir @ 24f0d6639caa)
 from gir-files (https://github.com/gtk-rs/gir-files @ dfdf5ed146d5)
diff --git a/graphene/src/auto/plane.rs b/graphene/src/auto/plane.rs
index 503989f5ef7e..ce6bdd466d08 100644
--- a/graphene/src/auto/plane.rs
+++ b/graphene/src/auto/plane.rs
@@ -64,13 +64,17 @@ impl Plane {
 
     #[doc(alias = "graphene_plane_transform")]
     #[must_use]
-    pub fn transform(&self, matrix: &Matrix, normal_matrix: Option<&Matrix>) -> Plane {
+    pub fn transform<'a>(
+        &self,
+        matrix: &Matrix,
+        normal_matrix: impl Into<Option<&'a Matrix>>,
+    ) -> Plane {
         unsafe {
             let mut res = Plane::uninitialized();
             ffi::graphene_plane_transform(
                 self.to_glib_none().0,
                 matrix.to_glib_none().0,
-                normal_matrix.to_glib_none().0,
+                normal_matrix.into().to_glib_none().0,
                 res.to_glib_none_mut().0,
             );
             res
diff --git a/graphene/src/auto/triangle.rs b/graphene/src/auto/triangle.rs
index f5f4433d73ec..4debe117f5f3 100644
--- a/graphene/src/auto/triangle.rs
+++ b/graphene/src/auto/triangle.rs
@@ -34,12 +34,12 @@ impl Triangle {
 
     #[doc(alias = "graphene_triangle_get_barycoords")]
     #[doc(alias = "get_barycoords")]
-    pub fn barycoords(&self, p: Option<&Point3D>) -> Option<Vec2> {
+    pub fn barycoords<'a>(&self, p: impl Into<Option<&'a Point3D>>) -> Option<Vec2> {
         unsafe {
             let mut res = Vec2::uninitialized();
             let ret = ffi::graphene_triangle_get_barycoords(
                 self.to_glib_none().0,
-                p.to_glib_none().0,
+                p.into().to_glib_none().0,
                 res.to_glib_none_mut().0,
             );
             if ret {
@@ -112,12 +112,18 @@ impl Triangle {
 
     #[doc(alias = "graphene_triangle_get_uv")]
     #[doc(alias = "get_uv")]
-    pub fn uv(&self, p: Option<&Point3D>, uv_a: &Vec2, uv_b: &Vec2, uv_c: &Vec2) -> Option<Vec2> {
+    pub fn uv<'a>(
+        &self,
+        p: impl Into<Option<&'a Point3D>>,
+        uv_a: &Vec2,
+        uv_b: &Vec2,
+        uv_c: &Vec2,
+    ) -> Option<Vec2> {
         unsafe {
             let mut res = Vec2::uninitialized();
             let ret = ffi::graphene_triangle_get_uv(
                 self.to_glib_none().0,
-                p.to_glib_none().0,
+                p.into().to_glib_none().0,
                 uv_a.to_glib_none().0,
                 uv_b.to_glib_none().0,
                 uv_c.to_glib_none().0,
diff --git a/graphene/src/auto/versions.txt b/graphene/src/auto/versions.txt
index 558f7e6574ab..b73621765b9b 100644
--- a/graphene/src/auto/versions.txt
+++ b/graphene/src/auto/versions.txt
@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ 1b34ebba86cb)
+Generated by gir (https://github.com/gtk-rs/gir @ 24f0d6639caa)
 from gir-files (https://github.com/gtk-rs/gir-files @ dfdf5ed146d5)
diff --git a/graphene/sys/versions.txt b/graphene/sys/versions.txt
index 558f7e6574ab..b73621765b9b 100644
--- a/graphene/sys/versions.txt
+++ b/graphene/sys/versions.txt
@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ 1b34ebba86cb)
+Generated by gir (https://github.com/gtk-rs/gir @ 24f0d6639caa)
 from gir-files (https://github.com/gtk-rs/gir-files @ dfdf5ed146d5)
diff --git a/pango/Gir.toml b/pango/Gir.toml
index cf3136ac5a65..a3da52ea878f 100644
--- a/pango/Gir.toml
+++ b/pango/Gir.toml
@@ -95,14 +95,12 @@ status = "generate"
     ignore = true
     [[object.function]]
     name = "itemize"
-        [[object.function.parameter]]
-        name = "cached_iter"
-        const = true
+    # Needs explicit lifetime for AttrIterator
+    manual = true
     [[object.function]]
     name = "itemize_with_base_dir"
-        [[object.function.parameter]]
-        name = "cached_iter"
-        const = true
+    # Needs explicit lifetime for AttrIterator
+    manual = true
     [[object.function]]
     name = "reorder_items"
     manual = true
diff --git a/pango/src/auto/context.rs b/pango/src/auto/context.rs
index 69f1b4f600f4..f288abce1535 100644
--- a/pango/src/auto/context.rs
+++ b/pango/src/auto/context.rs
@@ -84,16 +84,16 @@ impl Context {
 
     #[doc(alias = "pango_context_get_metrics")]
     #[doc(alias = "get_metrics")]
-    pub fn metrics(
+    pub fn metrics<'a>(
         &self,
-        desc: Option<&FontDescription>,
-        language: Option<&Language>,
+        desc: impl Into<Option<&'a FontDescription>>,
+        language: impl Into<Option<&'a Language>>,
     ) -> FontMetrics {
         unsafe {
             from_glib_full(ffi::pango_context_get_metrics(
                 self.to_glib_none().0,
-                desc.to_glib_none().0,
-                mut_override(language.to_glib_none().0),
+                desc.into().to_glib_none().0,
+                mut_override(language.into().to_glib_none().0),
             ))
         }
     }
@@ -166,18 +166,26 @@ impl Context {
     }
 
     #[doc(alias = "pango_context_set_font_description")]
-    pub fn set_font_description(&self, desc: Option<&FontDescription>) {
+    pub fn set_font_description<'a>(&self, desc: impl Into<Option<&'a FontDescription>>) {
         unsafe {
-            ffi::pango_context_set_font_description(self.to_glib_none().0, desc.to_glib_none().0);
+            ffi::pango_context_set_font_description(
+                self.to_glib_none().0,
+                desc.into().to_glib_none().0,
+            );
         }
     }
 
     #[doc(alias = "pango_context_set_font_map")]
-    pub fn set_font_map(&self, font_map: Option<&impl IsA<FontMap>>) {
+    pub fn set_font_map<'a, P: IsA<FontMap>>(&self, font_map: impl Into<Option<&'a P>>) {
         unsafe {
             ffi::pango_context_set_font_map(
                 self.to_glib_none().0,
-                font_map.map(|p| p.as_ref()).to_glib_none().0,
+                font_map
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
             );
         }
     }
@@ -190,19 +198,19 @@ impl Context {
     }
 
     #[doc(alias = "pango_context_set_language")]
-    pub fn set_language(&self, language: Option<&Language>) {
+    pub fn set_language<'a>(&self, language: impl Into<Option<&'a Language>>) {
         unsafe {
             ffi::pango_context_set_language(
                 self.to_glib_none().0,
-                mut_override(language.to_glib_none().0),
+                mut_override(language.into().to_glib_none().0),
             );
         }
     }
 
     #[doc(alias = "pango_context_set_matrix")]
-    pub fn set_matrix(&self, matrix: Option<&Matrix>) {
+    pub fn set_matrix<'a>(&self, matrix: impl Into<Option<&'a Matrix>>) {
         unsafe {
-            ffi::pango_context_set_matrix(self.to_glib_none().0, matrix.to_glib_none().0);
+            ffi::pango_context_set_matrix(self.to_glib_none().0, matrix.into().to_glib_none().0);
         }
     }
 
diff --git a/pango/src/auto/enums.rs b/pango/src/auto/enums.rs
index a2c294ba9066..f4835669d84b 100644
--- a/pango/src/auto/enums.rs
+++ b/pango/src/auto/enums.rs
@@ -1127,8 +1127,12 @@ pub enum Gravity {
 impl Gravity {
     #[doc(alias = "pango_gravity_get_for_matrix")]
     #[doc(alias = "get_for_matrix")]
-    pub fn for_matrix(matrix: Option<&Matrix>) -> Gravity {
-        unsafe { from_glib(ffi::pango_gravity_get_for_matrix(matrix.to_glib_none().0)) }
+    pub fn for_matrix<'a>(matrix: impl Into<Option<&'a Matrix>>) -> Gravity {
+        unsafe {
+            from_glib(ffi::pango_gravity_get_for_matrix(
+                matrix.into().to_glib_none().0,
+            ))
+        }
     }
 
     #[doc(alias = "pango_gravity_get_for_script")]
diff --git a/pango/src/auto/font.rs b/pango/src/auto/font.rs
index ba5c8f2a9539..75be44e7e242 100644
--- a/pango/src/auto/font.rs
+++ b/pango/src/auto/font.rs
@@ -120,11 +120,11 @@ pub trait FontExt: IsA<Font> + 'static {
 
     #[doc(alias = "pango_font_get_metrics")]
     #[doc(alias = "get_metrics")]
-    fn metrics(&self, language: Option<&Language>) -> FontMetrics {
+    fn metrics<'a>(&self, language: impl Into<Option<&'a Language>>) -> FontMetrics {
         unsafe {
             from_glib_full(ffi::pango_font_get_metrics(
                 self.as_ref().to_glib_none().0,
-                mut_override(language.to_glib_none().0),
+                mut_override(language.into().to_glib_none().0),
             ))
         }
     }
diff --git a/pango/src/auto/font_description.rs b/pango/src/auto/font_description.rs
index 78df0169ee00..d139124bbf86 100644
--- a/pango/src/auto/font_description.rs
+++ b/pango/src/auto/font_description.rs
@@ -23,15 +23,15 @@ impl FontDescription {
     }
 
     #[doc(alias = "pango_font_description_better_match")]
-    pub fn better_match(
+    pub fn better_match<'a>(
         &self,
-        old_match: Option<&FontDescription>,
+        old_match: impl Into<Option<&'a FontDescription>>,
         new_match: &FontDescription,
     ) -> bool {
         unsafe {
             from_glib(ffi::pango_font_description_better_match(
                 self.to_glib_none().0,
-                old_match.to_glib_none().0,
+                old_match.into().to_glib_none().0,
                 new_match.to_glib_none().0,
             ))
         }
@@ -147,11 +147,15 @@ impl FontDescription {
     }
 
     #[doc(alias = "pango_font_description_merge")]
-    pub fn merge(&mut self, desc_to_merge: Option<&FontDescription>, replace_existing: bool) {
+    pub fn merge<'a>(
+        &mut self,
+        desc_to_merge: impl Into<Option<&'a FontDescription>>,
+        replace_existing: bool,
+    ) {
         unsafe {
             ffi::pango_font_description_merge(
                 self.to_glib_none_mut().0,
-                desc_to_merge.to_glib_none().0,
+                desc_to_merge.into().to_glib_none().0,
                 replace_existing.into_glib(),
             );
         }
@@ -212,11 +216,11 @@ impl FontDescription {
     #[cfg(feature = "v1_42")]
     #[cfg_attr(docsrs, doc(cfg(feature = "v1_42")))]
     #[doc(alias = "pango_font_description_set_variations")]
-    pub fn set_variations(&mut self, variations: Option<&str>) {
+    pub fn set_variations<'a>(&mut self, variations: impl Into<Option<&'a str>>) {
         unsafe {
             ffi::pango_font_description_set_variations(
                 self.to_glib_none_mut().0,
-                variations.to_glib_none().0,
+                variations.into().to_glib_none().0,
             );
         }
     }
diff --git a/pango/src/auto/font_family.rs b/pango/src/auto/font_family.rs
index 17fc44b8f9f0..dd2952d3ba4c 100644
--- a/pango/src/auto/font_family.rs
+++ b/pango/src/auto/font_family.rs
@@ -36,11 +36,11 @@ pub trait FontFamilyExt: IsA<FontFamily> + 'static {
     #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
     #[doc(alias = "pango_font_family_get_face")]
     #[doc(alias = "get_face")]
-    fn face(&self, name: Option<&str>) -> Option<FontFace> {
+    fn face<'a>(&self, name: impl Into<Option<&'a str>>) -> Option<FontFace> {
         unsafe {
             from_glib_none(ffi::pango_font_family_get_face(
                 self.as_ref().to_glib_none().0,
-                name.to_glib_none().0,
+                name.into().to_glib_none().0,
             ))
         }
     }
diff --git a/pango/src/auto/font_map.rs b/pango/src/auto/font_map.rs
index 3953f19ac650..4d27b84e9613 100644
--- a/pango/src/auto/font_map.rs
+++ b/pango/src/auto/font_map.rs
@@ -119,20 +119,20 @@ pub trait FontMapExt: IsA<FontMap> + 'static {
     #[cfg(feature = "v1_52")]
     #[cfg_attr(docsrs, doc(cfg(feature = "v1_52")))]
     #[doc(alias = "pango_font_map_reload_font")]
-    fn reload_font(
+    fn reload_font<'a>(
         &self,
         font: &impl IsA<Font>,
         scale: f64,
-        context: Option<&Context>,
-        variations: Option<&str>,
+        context: impl Into<Option<&'a Context>>,
+        variations: impl Into<Option<&'a str>>,
     ) -> Font {
         unsafe {
             from_glib_full(ffi::pango_font_map_reload_font(
                 self.as_ref().to_glib_none().0,
                 font.as_ref().to_glib_none().0,
                 scale,
-                context.to_glib_none().0,
-                variations.to_glib_none().0,
+                context.into().to_glib_none().0,
+                variations.into().to_glib_none().0,
             ))
         }
     }
diff --git a/pango/src/auto/functions.rs b/pango/src/auto/functions.rs
index 152f48b6494e..0d46b1016e5b 100644
--- a/pango/src/auto/functions.rs
+++ b/pango/src/auto/functions.rs
@@ -2,10 +2,7 @@
 // from gir-files (https://github.com/gtk-rs/gir-files)
 // DO NOT EDIT
 
-use crate::{
-    ffi, Analysis, AttrIterator, AttrList, Context, Direction, GlyphString, Item, Stretch, Style,
-    Variant, Weight,
-};
+use crate::{ffi, Analysis, AttrList, Direction, GlyphString, Stretch, Style, Variant, Weight};
 use glib::translate::*;
 
 //#[cfg_attr(feature = "v1_44", deprecated = "Since 1.44")]
@@ -17,7 +14,7 @@ use glib::translate::*;
 //}
 
 //#[doc(alias = "pango_default_break")]
-//pub fn default_break(text: &str, analysis: Option<&mut Analysis>, attrs: /*Ignored*/&mut LogAttr, attrs_len: i32) {
+//pub fn default_break<'a>(text: &str, analysis: impl Into<Option<&'a mut  Analysis>>, attrs: /*Ignored*/&mut LogAttr, attrs_len: i32) {
 //    unsafe { TODO: call ffi:pango_default_break() }
 //}
 
@@ -57,50 +54,6 @@ pub fn is_zero_width(ch: char) -> bool {
     unsafe { from_glib(ffi::pango_is_zero_width(ch.into_glib())) }
 }
 
-#[doc(alias = "pango_itemize")]
-pub fn itemize(
-    context: &Context,
-    text: &str,
-    start_index: i32,
-    length: i32,
-    attrs: &AttrList,
-    cached_iter: Option<&AttrIterator>,
-) -> Vec<Item> {
-    unsafe {
-        FromGlibPtrContainer::from_glib_full(ffi::pango_itemize(
-            context.to_glib_none().0,
-            text.to_glib_none().0,
-            start_index,
-            length,
-            attrs.to_glib_none().0,
-            mut_override(cached_iter.to_glib_none().0),
-        ))
-    }
-}
-
-#[doc(alias = "pango_itemize_with_base_dir")]
-pub fn itemize_with_base_dir(
-    context: &Context,
-    base_dir: Direction,
-    text: &str,
-    start_index: i32,
-    length: i32,
-    attrs: &AttrList,
-    cached_iter: Option<&AttrIterator>,
-) -> Vec<Item> {
-    unsafe {
-        FromGlibPtrContainer::from_glib_full(ffi::pango_itemize_with_base_dir(
-            context.to_glib_none().0,
-            base_dir.into_glib(),
-            text.to_glib_none().0,
-            start_index,
-            length,
-            attrs.to_glib_none().0,
-            mut_override(cached_iter.to_glib_none().0),
-        ))
-    }
-}
-
 #[doc(alias = "pango_markup_parser_finish")]
 pub fn markup_parser_finish(
     context: &glib::MarkupParseContext,
@@ -261,7 +214,7 @@ pub fn shape(text: &str, analysis: &Analysis, glyphs: &mut GlyphString) {
 //#[cfg(feature = "v1_50")]
 //#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
 //#[doc(alias = "pango_shape_item")]
-//pub fn shape_item(item: &mut Item, paragraph_text: Option<&str>, log_attrs: /*Ignored*/Option<&mut LogAttr>, glyphs: &mut GlyphString, flags: ShapeFlags) {
+//pub fn shape_item<'a>(item: &mut Item, paragraph_text: impl Into<Option<&'a str>>, log_attrs: /*Ignored*/Option<&mut LogAttr>, glyphs: &mut GlyphString, flags: ShapeFlags) {
 //    unsafe { TODO: call ffi:pango_shape_item() }
 //}
 
diff --git a/pango/src/auto/layout.rs b/pango/src/auto/layout.rs
index aeb9fcc7088d..1ebaee5839d6 100644
--- a/pango/src/auto/layout.rs
+++ b/pango/src/auto/layout.rs
@@ -243,7 +243,7 @@ impl Layout {
 
     //#[doc(alias = "pango_layout_get_log_attrs")]
     //#[doc(alias = "get_log_attrs")]
-    //pub fn log_attrs(&self, attrs: /*Ignored*/Vec<LogAttr>) -> i32 {
+    //pub fn log_attrs(&self, attrs: /*Ignored*/&mut Vec<LogAttr>) -> i32 {
     //    unsafe { TODO: call ffi:pango_layout_get_log_attrs() }
     //}
 
@@ -429,9 +429,9 @@ impl Layout {
     }
 
     #[doc(alias = "pango_layout_set_attributes")]
-    pub fn set_attributes(&self, attrs: Option<&AttrList>) {
+    pub fn set_attributes<'a>(&self, attrs: impl Into<Option<&'a AttrList>>) {
         unsafe {
-            ffi::pango_layout_set_attributes(self.to_glib_none().0, attrs.to_glib_none().0);
+            ffi::pango_layout_set_attributes(self.to_glib_none().0, attrs.into().to_glib_none().0);
         }
     }
 
@@ -450,9 +450,12 @@ impl Layout {
     }
 
     #[doc(alias = "pango_layout_set_font_description")]
-    pub fn set_font_description(&self, desc: Option<&FontDescription>) {
+    pub fn set_font_description<'a>(&self, desc: impl Into<Option<&'a FontDescription>>) {
         unsafe {
-            ffi::pango_layout_set_font_description(self.to_glib_none().0, desc.to_glib_none().0);
+            ffi::pango_layout_set_font_description(
+                self.to_glib_none().0,
+                desc.into().to_glib_none().0,
+            );
         }
     }
 
@@ -535,9 +538,12 @@ impl Layout {
     }
 
     #[doc(alias = "pango_layout_set_tabs")]
-    pub fn set_tabs(&self, tabs: Option<&TabArray>) {
+    pub fn set_tabs<'a>(&self, tabs: impl Into<Option<&'a TabArray>>) {
         unsafe {
-            ffi::pango_layout_set_tabs(self.to_glib_none().0, mut_override(tabs.to_glib_none().0));
+            ffi::pango_layout_set_tabs(
+                self.to_glib_none().0,
+                mut_override(tabs.into().to_glib_none().0),
+            );
         }
     }
 
diff --git a/pango/src/auto/renderer.rs b/pango/src/auto/renderer.rs
index 01ab525c6f04..074b8a0e21ff 100644
--- a/pango/src/auto/renderer.rs
+++ b/pango/src/auto/renderer.rs
@@ -62,11 +62,17 @@ pub trait RendererExt: IsA<Renderer> + 'static {
     }
 
     #[doc(alias = "pango_renderer_draw_glyph_item")]
-    fn draw_glyph_item(&self, text: Option<&str>, glyph_item: &mut GlyphItem, x: i32, y: i32) {
+    fn draw_glyph_item<'a>(
+        &self,
+        text: impl Into<Option<&'a str>>,
+        glyph_item: &mut GlyphItem,
+        x: i32,
+        y: i32,
+    ) {
         unsafe {
             ffi::pango_renderer_draw_glyph_item(
                 self.as_ref().to_glib_none().0,
-                text.to_glib_none().0,
+                text.into().to_glib_none().0,
                 glyph_item.to_glib_none_mut().0,
                 x,
                 y,
@@ -212,20 +218,23 @@ pub trait RendererExt: IsA<Renderer> + 'static {
     }
 
     #[doc(alias = "pango_renderer_set_color")]
-    fn set_color(&self, part: RenderPart, color: Option<&Color>) {
+    fn set_color<'a>(&self, part: RenderPart, color: impl Into<Option<&'a Color>>) {
         unsafe {
             ffi::pango_renderer_set_color(
                 self.as_ref().to_glib_none().0,
                 part.into_glib(),
-                color.to_glib_none().0,
+                color.into().to_glib_none().0,
             );
         }
     }
 
     #[doc(alias = "pango_renderer_set_matrix")]
-    fn set_matrix(&self, matrix: Option<&Matrix>) {
+    fn set_matrix<'a>(&self, matrix: impl Into<Option<&'a Matrix>>) {
         unsafe {
-            ffi::pango_renderer_set_matrix(self.as_ref().to_glib_none().0, matrix.to_glib_none().0);
+            ffi::pango_renderer_set_matrix(
+                self.as_ref().to_glib_none().0,
+                matrix.into().to_glib_none().0,
+            );
         }
     }
 }
diff --git a/pango/src/auto/tab_array.rs b/pango/src/auto/tab_array.rs
index 943e12b5cb6d..b6f58f673828 100644
--- a/pango/src/auto/tab_array.rs
+++ b/pango/src/auto/tab_array.rs
@@ -29,7 +29,7 @@ impl TabArray {
 
     //#[doc(alias = "pango_tab_array_new_with_positions")]
     //#[doc(alias = "new_with_positions")]
-    //pub fn with_positions(size: i32, positions_in_pixels: bool, first_alignment: TabAlign, first_position: i32, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> TabArray {
+    //pub fn with_positions(size: i32, positions_in_pixels: bool, first_alignment: TabAlign, first_position: i32, : /*Unimplemented*/Basic: VarArgs) -> TabArray {
     //    unsafe { TODO: call ffi:pango_tab_array_new_with_positions() }
     //}
 
diff --git a/pango/src/auto/versions.txt b/pango/src/auto/versions.txt
index 558f7e6574ab..b73621765b9b 100644
--- a/pango/src/auto/versions.txt
+++ b/pango/src/auto/versions.txt
@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ 1b34ebba86cb)
+Generated by gir (https://github.com/gtk-rs/gir @ 24f0d6639caa)
 from gir-files (https://github.com/gtk-rs/gir-files @ dfdf5ed146d5)
diff --git a/pango/src/functions.rs b/pango/src/functions.rs
index 6f2aec065596..1272c8a9cfef 100644
--- a/pango/src/functions.rs
+++ b/pango/src/functions.rs
@@ -5,7 +5,51 @@ use glib::translate::*;
 pub use crate::auto::functions::*;
 #[cfg(feature = "v1_44")]
 use crate::ShapeFlags;
-use crate::{ffi, Analysis, GlyphString, Item};
+use crate::{ffi, Analysis, AttrIterator, AttrList, Context, Direction, GlyphString, Item};
+
+#[doc(alias = "pango_itemize")]
+pub fn itemize<'a>(
+    context: &Context,
+    text: &str,
+    start_index: i32,
+    length: i32,
+    attrs: &AttrList,
+    cached_iter: impl Into<Option<&'a AttrIterator<'a>>>,
+) -> Vec<Item> {
+    unsafe {
+        FromGlibPtrContainer::from_glib_full(ffi::pango_itemize(
+            context.to_glib_none().0,
+            text.to_glib_none().0,
+            start_index,
+            length,
+            attrs.to_glib_none().0,
+            mut_override(cached_iter.into().to_glib_none().0),
+        ))
+    }
+}
+
+#[doc(alias = "pango_itemize_with_base_dir")]
+pub fn itemize_with_base_dir<'a>(
+    context: &Context,
+    base_dir: Direction,
+    text: &str,
+    start_index: i32,
+    length: i32,
+    attrs: &AttrList,
+    cached_iter: impl Into<Option<&'a AttrIterator<'a>>>,
+) -> Vec<Item> {
+    unsafe {
+        FromGlibPtrContainer::from_glib_full(ffi::pango_itemize_with_base_dir(
+            context.to_glib_none().0,
+            base_dir.into_glib(),
+            text.to_glib_none().0,
+            start_index,
+            length,
+            attrs.to_glib_none().0,
+            mut_override(cached_iter.into().to_glib_none().0),
+        ))
+    }
+}
 
 #[doc(alias = "pango_reorder_items")]
 pub fn reorder_items(logical_items: &glib::List<Item>) -> glib::List<Item> {
diff --git a/pango/sys/versions.txt b/pango/sys/versions.txt
index 558f7e6574ab..b73621765b9b 100644
--- a/pango/sys/versions.txt
+++ b/pango/sys/versions.txt
@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ 1b34ebba86cb)
+Generated by gir (https://github.com/gtk-rs/gir @ 24f0d6639caa)
 from gir-files (https://github.com/gtk-rs/gir-files @ dfdf5ed146d5)
diff --git a/pangocairo/src/auto/functions.rs b/pangocairo/src/auto/functions.rs
index 96f341a0e4c8..486c75451737 100644
--- a/pangocairo/src/auto/functions.rs
+++ b/pangocairo/src/auto/functions.rs
@@ -11,16 +11,19 @@ pub fn context_get_resolution(context: &pango::Context) -> f64 {
 }
 
 //#[doc(alias = "pango_cairo_context_get_shape_renderer")]
-//pub fn context_get_shape_renderer(context: &pango::Context, data: /*Unimplemented*/Option<Basic: Pointer>) -> /*Unimplemented*/Fn(&cairo::Context, /*Ignored*/pango::AttrShape, bool) {
+//pub fn context_get_shape_renderer(context: &pango::Context, data: /*Unimplemented*/Option<Basic: Pointer>) -> /*Unimplemented*/Option<Box_<dyn Fn(&cairo::Context, /*Ignored*/&pango::AttrShape, bool) + 'static>> {
 //    unsafe { TODO: call ffi:pango_cairo_context_get_shape_renderer() }
 //}
 
 #[doc(alias = "pango_cairo_context_set_font_options")]
-pub fn context_set_font_options(context: &pango::Context, options: Option<&cairo::FontOptions>) {
+pub fn context_set_font_options<'a>(
+    context: &pango::Context,
+    options: impl Into<Option<&'a cairo::FontOptions>>,
+) {
     unsafe {
         ffi::pango_cairo_context_set_font_options(
             context.to_glib_none().0,
-            options.to_glib_none().0,
+            options.into().to_glib_none().0,
         );
     }
 }
@@ -33,7 +36,7 @@ pub fn context_set_resolution(context: &pango::Context, dpi: f64) {
 }
 
 //#[doc(alias = "pango_cairo_context_set_shape_renderer")]
-//pub fn context_set_shape_renderer(context: &pango::Context, func: /*Unimplemented*/Fn(&cairo::Context, /*Ignored*/pango::AttrShape, bool), data: /*Unimplemented*/Option<Basic: Pointer>) {
+//pub fn context_set_shape_renderer(context: &pango::Context, func: /*Unimplemented*/Option<Box_<dyn Fn(&cairo::Context, /*Ignored*/&pango::AttrShape, bool) + 'static>>, data: /*Unimplemented*/Option<Basic: Pointer>) {
 //    unsafe { TODO: call ffi:pango_cairo_context_set_shape_renderer() }
 //}
 
diff --git a/pangocairo/src/auto/versions.txt b/pangocairo/src/auto/versions.txt
index 558f7e6574ab..b73621765b9b 100644
--- a/pangocairo/src/auto/versions.txt
+++ b/pangocairo/src/auto/versions.txt
@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ 1b34ebba86cb)
+Generated by gir (https://github.com/gtk-rs/gir @ 24f0d6639caa)
 from gir-files (https://github.com/gtk-rs/gir-files @ dfdf5ed146d5)
diff --git a/pangocairo/sys/versions.txt b/pangocairo/sys/versions.txt
index 558f7e6574ab..b73621765b9b 100644
--- a/pangocairo/sys/versions.txt
+++ b/pangocairo/sys/versions.txt
@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ 1b34ebba86cb)
+Generated by gir (https://github.com/gtk-rs/gir @ 24f0d6639caa)
 from gir-files (https://github.com/gtk-rs/gir-files @ dfdf5ed146d5)