nm_rs/auto/

client.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir
// from gtk-girs (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT
#![allow(deprecated)]

#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
use crate::DnsEntry;
#[cfg(feature = "v1_38")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_38")))]
use crate::RadioFlags;
use crate::{
    ActiveConnection, ClientPermission, ClientPermissionResult, Connection, ConnectivityState,
    Device, RemoteConnection, State, ffi,
};
#[cfg(feature = "v1_12")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
use crate::{Checkpoint, CheckpointCreateFlags};
#[cfg(feature = "v1_24")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
use crate::{ClientInstanceFlags, Object, Ternary};
#[cfg(feature = "v1_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
use crate::{ManagerReloadFlags, Metered};
use glib::{
    GString,
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::{boxed::Box as Box_, pin::Pin};

#[cfg(feature = "gio_v2_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "gio_v2_22")))]
glib::wrapper! {
    /// NMClient contains a cache of the objects of NetworkManager's D-Bus API.
    /// It uses #GMainContext and #GDBusConnection for that and registers to
    /// D-Bus signals. That means, when iterating the associated #GMainContext,
    /// D-Bus signals gets processed and the #NMClient instance updates and
    /// emits #GObject signals.
    ///
    /// ## Properties
    ///
    ///
    /// #### `activating-connection`
    ///  The #NMActiveConnection of the activating connection that is
    /// likely to become the new #NMClient:primary-connection.
    ///
    /// Readable
    ///
    ///
    /// #### `active-connections`
    ///  The active connections.
    ///
    /// Readable
    ///
    ///
    /// #### `all-devices`
    ///  List of both real devices and device placeholders.
    ///
    /// Readable
    ///
    ///
    /// #### `can-modify`
    ///  If [`true`], adding and modifying connections is supported.
    ///
    /// Readable
    ///
    ///
    /// #### `capabilities`
    ///  The list of capabilities numbers as guint32 or [`None`] if
    /// there are no capabilities. The numeric value correspond
    /// to `NMCapability` enum.
    ///
    /// Readable
    ///
    ///
    /// #### `checkpoints`
    ///  The list of active checkpoints.
    ///
    /// Readable
    ///
    ///
    /// #### `connections`
    ///  The list of configured connections that are available to the user. (Note
    /// that this differs from the underlying D-Bus property, which may also
    /// contain the object paths of connections that the user does not have
    /// permission to read the details of.)
    ///
    /// Readable
    ///
    ///
    /// #### `connectivity`
    ///  The network connectivity state.
    ///
    /// Readable
    ///
    ///
    /// #### `connectivity-check-available`
    ///  Readable
    ///
    ///
    /// #### `connectivity-check-enabled`
    ///  Readable | Writeable
    ///
    ///
    /// #### `connectivity-check-uri`
    ///  The used URI for connectivity checking.
    ///
    /// Readable
    ///
    ///
    /// #### `dbus-connection`
    ///  The #GDBusConnection to use.
    ///
    /// If this is not set during object construction, the D-Bus connection will
    /// automatically be chosen during async/sync initalization via g_bus_get().
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `dbus-name-owner`
    ///  The name owner of the NetworkManager D-Bus service.
    ///
    /// Readable
    ///
    ///
    /// #### `devices`
    ///  List of real network devices.  Does not include placeholder devices.
    ///
    /// Readable
    ///
    ///
    /// #### `dns-configuration`
    ///  The current DNS configuration, represented as an array
    /// of #NMDnsEntry objects.
    ///
    /// Readable
    ///
    ///
    /// #### `dns-mode`
    ///  The current DNS processing mode.
    ///
    /// Readable
    ///
    ///
    /// #### `dns-rc-manager`
    ///  The current resolv.conf management mode.
    ///
    /// Readable
    ///
    ///
    /// #### `hostname`
    ///  The machine hostname stored in persistent configuration. This can be
    /// modified by calling nm_client_save_hostname().
    ///
    /// Readable
    ///
    ///
    /// #### `instance-flags`
    ///  #NMClientInstanceFlags for the instance. These affect behavior of #NMClient.
    /// This is a construct property and you may only set most flags only during
    /// construction.
    ///
    /// The flag [`ClientInstanceFlags::NO_AUTO_FETCH_PERMISSIONS`][crate::ClientInstanceFlags::NO_AUTO_FETCH_PERMISSIONS] can be toggled any time,
    /// even after constructing the instance. Note that you may want to watch NMClient:permissions-state
    /// property to know whether permissions are ready. Note that permissions are only fetched
    /// when NMClient has a D-Bus name owner.
    ///
    /// The flags [`ClientInstanceFlags::INITIALIZED_GOOD`][crate::ClientInstanceFlags::INITIALIZED_GOOD] and [`ClientInstanceFlags::INITIALIZED_BAD`][crate::ClientInstanceFlags::INITIALIZED_BAD]
    /// cannot be set, however they will be returned by the getter after initialization completes.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `metered`
    ///  Whether the connectivity is metered.
    ///
    /// Readable
    ///
    ///
    /// #### `networking-enabled`
    ///  Whether networking is enabled.
    ///
    /// The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `nm-running`
    ///  Whether the daemon is running.
    ///
    /// Readable
    ///
    ///
    /// #### `permissions-state`
    ///  The state of the cached permissions. The value [`Ternary::Default`][crate::Ternary::Default]
    /// means that no permissions are yet received (or not yet requested).
    /// [`Ternary::True`][crate::Ternary::True] means that permissions are received, cached and up
    /// to date. [`Ternary::False`][crate::Ternary::False] means that permissions were received and are
    /// cached, but in the meantime a "CheckPermissions" signal was received
    /// that invalidated the cached permissions.
    /// Note that NMClient will always emit a notify::permissions-state signal
    /// when a "CheckPermissions" signal got received or after new permissions
    /// got received (that is regardless whether the value of the permission state
    /// actually changed). With this you can watch the permissions-state property
    /// to know whether the permissions are ready. Note that while NMClient has
    /// no D-Bus name owner, no permissions are fetched (and this property won't
    /// change).
    ///
    /// Readable
    ///
    ///
    /// #### `primary-connection`
    ///  The #NMActiveConnection of the device with the default route;
    /// see nm_client_get_primary_connection() for more details.
    ///
    /// Readable
    ///
    ///
    /// #### `radio-flags`
    ///  Flags for radio interfaces. See #NMRadioFlags.
    ///
    /// Readable
    ///
    ///
    /// #### `startup`
    ///  Whether the daemon is still starting up.
    ///
    /// Readable
    ///
    ///
    /// #### `state`
    ///  The current daemon state.
    ///
    /// Readable
    ///
    ///
    /// #### `version`
    ///  The NetworkManager version.
    ///
    /// Readable
    ///
    ///
    /// #### `version-info`
    ///  Expose version info and capabilities of NetworkManager. If non-empty,
    /// the first element is NM_VERSION, which encodes the version of the
    /// daemon as "(major << 16 | minor << 8 | micro)". The following elements
    /// is a bitfields of `NMVersionInfoCapability`. If a bit is set, then
    /// the running NetworkManager has the respective capability.
    ///
    /// Readable
    ///
    ///
    /// #### `wimax-enabled`
    ///  Whether WiMAX functionality is enabled.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `wimax-hardware-enabled`
    ///  Whether the WiMAX hardware is enabled.
    ///
    /// Readable
    ///
    ///
    /// #### `wireless-enabled`
    ///  Whether wireless is enabled.
    ///
    /// The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `wireless-hardware-enabled`
    ///  Whether the wireless hardware is enabled.
    ///
    /// Readable
    ///
    ///
    /// #### `wwan-enabled`
    ///  Whether WWAN functionality is enabled.
    ///
    /// The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `wwan-hardware-enabled`
    ///  Whether the WWAN hardware is enabled.
    ///
    /// Readable
    ///
    /// ## Signals
    ///
    ///
    /// #### `active-connection-added`
    ///  Notifies that a #NMActiveConnection has been added.
    ///
    ///
    ///
    ///
    /// #### `active-connection-removed`
    ///  Notifies that a #NMActiveConnection has been removed.
    ///
    ///
    ///
    ///
    /// #### `any-device-added`
    ///  Notifies that a #NMDevice is added.  This signal is emitted for both
    /// regular devices and placeholder devices.
    ///
    ///
    ///
    ///
    /// #### `any-device-removed`
    ///  Notifies that a #NMDevice is removed.  This signal is emitted for both
    /// regular devices and placeholder devices.
    ///
    ///
    ///
    ///
    /// #### `connection-added`
    ///  Notifies that a #NMConnection has been added.
    ///
    ///
    ///
    ///
    /// #### `connection-removed`
    ///  Notifies that a #NMConnection has been removed.
    ///
    ///
    ///
    ///
    /// #### `device-added`
    ///  Notifies that a #NMDevice is added.  This signal is not emitted for
    /// placeholder devices.
    ///
    ///
    ///
    ///
    /// #### `device-removed`
    ///  Notifies that a #NMDevice is removed.  This signal is not emitted for
    /// placeholder devices.
    ///
    ///
    ///
    ///
    /// #### `permission-changed`
    ///  Notifies that a permission has changed
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`trait@gio::prelude::AsyncInitableExt`], [`trait@gio::prelude::InitableExt`]
    #[doc(alias = "NMClient")]
    pub struct Client(Object<ffi::NMClient, ffi::NMClientClass>) @implements gio::AsyncInitable, gio::Initable;

    match fn {
        type_ => || ffi::nm_client_get_type(),
    }
}

#[cfg(not(any(feature = "gio_v2_22")))]
#[cfg(feature = "gio_v2_22")]
glib::wrapper! {
    #[doc(alias = "NMClient")]
    pub struct Client(Object<ffi::NMClient, ffi::NMClientClass>) @implements gio::Initable;

    match fn {
        type_ => || ffi::nm_client_get_type(),
    }
}

#[cfg(not(any(feature = "gio_v2_22")))]
glib::wrapper! {
    #[doc(alias = "NMClient")]
    pub struct Client(Object<ffi::NMClient, ffi::NMClientClass>);

    match fn {
        type_ => || ffi::nm_client_get_type(),
    }
}

impl Client {
    /// Creates a new #NMClient synchronously.
    ///
    /// Note that this will block until a NMClient instance is fully initialized.
    /// This does nothing beside calling g_initable_new(). You are free to call
    /// g_initable_new() or g_object_new()/g_initable_init() directly for more
    /// control, to set GObject properties or get access to the NMClient instance
    /// while it is still initializing.
    ///
    /// Using the synchronous initialization creates an #NMClient instance
    /// that uses an internal #GMainContext. This context is invisible to the
    /// user. This introduces an additional overhead that is payed not
    /// only during object initialization, but for the entire lifetime of
    /// this object.
    /// Also, due to this internal #GMainContext, the events are no longer
    /// in sync with other messages from #GDBusConnection (but all events
    /// of the NMClient will themselves still be ordered).
    /// For a serious program, you should therefore avoid these problems by
    /// using g_async_initable_init_async() or nm_client_new_async() instead.
    /// The sync initialization is still useful for simple scripts or interactive
    /// testing for example via pygobject.
    ///
    /// Creating an #NMClient instance can only fail for two reasons. First, if you didn't
    /// provide a [`CLIENT_DBUS_CONNECTION`][crate::CLIENT_DBUS_CONNECTION] and the call to g_bus_get()
    /// fails. You can avoid that by using g_initable_new() directly and
    /// set a D-Bus connection.
    /// Second, if you cancelled the creation. If you do that, then note
    /// that after the failure there might still be idle actions pending
    /// which keep nm_client_get_main_context() alive. That means,
    /// in that case you must continue iterating the context to avoid
    /// leaks. See nm_client_get_context_busy_watcher().
    ///
    /// Creating an #NMClient instance when NetworkManager is not running
    /// does not cause a failure.
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    ///
    /// # Returns
    ///
    /// a new #NMClient or NULL on an error
    #[doc(alias = "nm_client_new")]
    pub fn new(cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Client, glib::Error> {
        assert_initialized_main_thread!();
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret =
                ffi::nm_client_new(cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`Client`] objects.
    ///
    /// This method returns an instance of [`ClientBuilder`](crate::builders::ClientBuilder) which can be used to create [`Client`] objects.
    pub fn builder() -> ClientBuilder {
        ClientBuilder::new()
    }

    /// Asynchronously starts a connection to a particular network using the
    /// configuration settings from @connection and the network device @device.
    /// Certain connection types also take a "specific object" which is the object
    /// path of a connection- specific object, like an #NMAccessPoint for Wi-Fi
    /// connections, or an #NMWimaxNsp for WiMAX connections, to which you wish to
    /// connect.  If the specific object is not given, NetworkManager can, in some
    /// cases, automatically determine which network to connect to given the settings
    /// in @connection.
    ///
    /// If @connection is not given for a device-based activation, NetworkManager
    /// picks the best available connection for the device and activates it.
    ///
    /// Note that the callback is invoked when NetworkManager has started activating
    /// the new connection, not when it finishes. You can use the returned
    /// #NMActiveConnection object (in particular, #NMActiveConnection:state) to
    /// track the activation to its completion.
    /// ## `connection`
    /// an #NMConnection
    /// ## `device`
    /// the #NMDevice
    /// ## `specific_object`
    /// the object path of a connection-type-specific
    ///   object this activation should use. This parameter is currently ignored for
    ///   wired and mobile broadband connections, and the value of [`None`] should be used
    ///   (ie, no specific object).  For Wi-Fi or WiMAX connections, pass the object
    ///   path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can
    ///   get using nm_object_get_path(), and which will be used to complete the
    ///   details of the newly added connection.
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to be called when the activation has started
    #[doc(alias = "nm_client_activate_connection_async")]
    pub fn activate_connection_async<P: FnOnce(Result<ActiveConnection, glib::Error>) + 'static>(
        &self,
        connection: Option<&impl IsA<Connection>>,
        device: Option<&impl IsA<Device>>,
        specific_object: Option<&str>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn activate_connection_async_trampoline<
            P: FnOnce(Result<ActiveConnection, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            let ret = ffi::nm_client_activate_connection_finish(
                _source_object as *mut _,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = activate_connection_async_trampoline::<P>;
        unsafe {
            ffi::nm_client_activate_connection_async(
                self.to_glib_none().0,
                connection.map(|p| p.as_ref()).to_glib_none().0,
                device.map(|p| p.as_ref()).to_glib_none().0,
                specific_object.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn activate_connection_future(
        &self,
        connection: Option<&(impl IsA<Connection> + Clone + 'static)>,
        device: Option<&(impl IsA<Device> + Clone + 'static)>,
        specific_object: Option<&str>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<ActiveConnection, glib::Error>> + 'static>>
    {
        let connection = connection.map(ToOwned::to_owned);
        let device = device.map(ToOwned::to_owned);
        let specific_object = specific_object.map(ToOwned::to_owned);
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.activate_connection_async(
                connection.as_ref().map(::std::borrow::Borrow::borrow),
                device.as_ref().map(::std::borrow::Borrow::borrow),
                specific_object.as_ref().map(::std::borrow::Borrow::borrow),
                Some(cancellable),
                move |res| {
                    send.resolve(res);
                },
            );
        }))
    }

    //#[cfg(feature = "v1_16")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    //#[doc(alias = "nm_client_add_and_activate_connection2")]
    //pub fn add_and_activate_connection2<P: FnOnce(Result<(ActiveConnection, /*Ignored*/Option<glib::Variant>), glib::Error>) + 'static>(&self, partial: Option<&impl IsA<Connection>>, device: Option<&impl IsA<Device>>, specific_object: Option<&str>, options: /*Ignored*/&glib::Variant, cancellable: Option<&impl IsA<gio::Cancellable>>, callback: P) {
    //    unsafe { TODO: call ffi:nm_client_add_and_activate_connection2() }
    //}

    //
    //#[cfg(feature = "v1_16")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    //pub fn add_and_activate_connection2_future(&self, partial: Option<&(impl IsA<Connection> + Clone + 'static)>, device: Option<&(impl IsA<Device> + Clone + 'static)>, specific_object: Option<&str>, options: /*Ignored*/&glib::Variant) -> Pin<Box_<dyn std::future::Future<Output = Result<(ActiveConnection, /*Ignored*/Option<glib::Variant>), glib::Error>> + 'static>> {

    //let partial = partial.map(ToOwned::to_owned);
    //let device = device.map(ToOwned::to_owned);
    //let specific_object = specific_object.map(ToOwned::to_owned);
    //let options = options.clone();
    //Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
    //    obj.add_and_activate_connection2(
    //        partial.as_ref().map(::std::borrow::Borrow::borrow),
    //        device.as_ref().map(::std::borrow::Borrow::borrow),
    //        specific_object.as_ref().map(::std::borrow::Borrow::borrow),
    //        &options,
    //        Some(cancellable),
    //        move |res| {
    //            send.resolve(res);
    //        },
    //    );
    //}))
    //}

    /// Adds a new connection using the given details (if any) as a template,
    /// automatically filling in missing settings with the capabilities of the given
    /// device and specific object.  The new connection is then asynchronously
    /// activated as with nm_client_activate_connection_async(). Cannot be used for
    /// VPN connections at this time.
    ///
    /// Note that the callback is invoked when NetworkManager has started activating
    /// the new connection, not when it finishes. You can used the returned
    /// #NMActiveConnection object (in particular, #NMActiveConnection:state) to
    /// track the activation to its completion.
    /// ## `partial`
    /// an #NMConnection to add; the connection may be
    ///   partially filled (or even [`None`]) and will be completed by NetworkManager
    ///   using the given @device and @specific_object before being added
    /// ## `device`
    /// the #NMDevice
    /// ## `specific_object`
    /// the object path of a connection-type-specific
    ///   object this activation should use. This parameter is currently ignored for
    ///   wired and mobile broadband connections, and the value of [`None`] should be used
    ///   (ie, no specific object).  For Wi-Fi or WiMAX connections, pass the object
    ///   path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can
    ///   get using nm_object_get_path(), and which will be used to complete the
    ///   details of the newly added connection.
    ///   If the variant is floating, it will be consumed.
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to be called when the activation has started
    #[doc(alias = "nm_client_add_and_activate_connection_async")]
    pub fn add_and_activate_connection_async<
        P: FnOnce(Result<ActiveConnection, glib::Error>) + 'static,
    >(
        &self,
        partial: Option<&impl IsA<Connection>>,
        device: Option<&impl IsA<Device>>,
        specific_object: Option<&str>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn add_and_activate_connection_async_trampoline<
            P: FnOnce(Result<ActiveConnection, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            let ret = ffi::nm_client_add_and_activate_connection_finish(
                _source_object as *mut _,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = add_and_activate_connection_async_trampoline::<P>;
        unsafe {
            ffi::nm_client_add_and_activate_connection_async(
                self.to_glib_none().0,
                partial.map(|p| p.as_ref()).to_glib_none().0,
                device.map(|p| p.as_ref()).to_glib_none().0,
                specific_object.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn add_and_activate_connection_future(
        &self,
        partial: Option<&(impl IsA<Connection> + Clone + 'static)>,
        device: Option<&(impl IsA<Device> + Clone + 'static)>,
        specific_object: Option<&str>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<ActiveConnection, glib::Error>> + 'static>>
    {
        let partial = partial.map(ToOwned::to_owned);
        let device = device.map(ToOwned::to_owned);
        let specific_object = specific_object.map(ToOwned::to_owned);
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.add_and_activate_connection_async(
                partial.as_ref().map(::std::borrow::Borrow::borrow),
                device.as_ref().map(::std::borrow::Borrow::borrow),
                specific_object.as_ref().map(::std::borrow::Borrow::borrow),
                Some(cancellable),
                move |res| {
                    send.resolve(res);
                },
            );
        }))
    }

    //#[cfg(feature = "v1_20")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
    //#[doc(alias = "nm_client_add_connection2")]
    //pub fn add_connection2<P: FnOnce(Result<(RemoteConnection, /*Ignored*/Option<glib::Variant>), glib::Error>) + 'static>(&self, settings: /*Ignored*/&glib::Variant, flags: SettingsAddConnection2Flags, args: /*Ignored*/Option<&glib::Variant>, ignore_out_result: bool, cancellable: Option<&impl IsA<gio::Cancellable>>, callback: P) {
    //    unsafe { TODO: call ffi:nm_client_add_connection2() }
    //}

    //
    //#[cfg(feature = "v1_20")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
    //pub fn add_connection2_future(&self, settings: /*Ignored*/&glib::Variant, flags: SettingsAddConnection2Flags, args: /*Ignored*/Option<&glib::Variant>, ignore_out_result: bool) -> Pin<Box_<dyn std::future::Future<Output = Result<(RemoteConnection, /*Ignored*/Option<glib::Variant>), glib::Error>> + 'static>> {

    //let settings = settings.clone();
    //let args = args.map(ToOwned::to_owned);
    //Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
    //    obj.add_connection2(
    //        &settings,
    //        flags,
    //        args.as_ref().map(::std::borrow::Borrow::borrow),
    //        ignore_out_result,
    //        Some(cancellable),
    //        move |res| {
    //            send.resolve(res);
    //        },
    //    );
    //}))
    //}

    /// Requests that the remote settings service add the given settings to a new
    /// connection.  If @save_to_disk is [`true`], the connection is immediately written
    /// to disk; otherwise it is initially only stored in memory, but may be saved
    /// later by calling the connection's nm_remote_connection_commit_changes()
    /// method.
    ///
    /// @connection is untouched by this function and only serves as a template of
    /// the settings to add.  The #NMRemoteConnection object that represents what
    /// NetworkManager actually added is returned to @callback when the addition
    /// operation is complete.
    ///
    /// Note that the #NMRemoteConnection returned in @callback may not contain
    /// identical settings to @connection as NetworkManager may perform automatic
    /// completion and/or normalization of connection properties.
    /// ## `connection`
    /// the connection to add. Note that this object's settings will be
    ///   added, not the object itself
    /// ## `save_to_disk`
    /// whether to immediately save the connection to disk
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to be called when the add operation completes
    #[doc(alias = "nm_client_add_connection_async")]
    pub fn add_connection_async<P: FnOnce(Result<RemoteConnection, glib::Error>) + 'static>(
        &self,
        connection: &impl IsA<Connection>,
        save_to_disk: bool,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn add_connection_async_trampoline<
            P: FnOnce(Result<RemoteConnection, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            let ret =
                ffi::nm_client_add_connection_finish(_source_object as *mut _, res, &mut error);
            let result = if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = add_connection_async_trampoline::<P>;
        unsafe {
            ffi::nm_client_add_connection_async(
                self.to_glib_none().0,
                connection.as_ref().to_glib_none().0,
                save_to_disk.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn add_connection_future(
        &self,
        connection: &(impl IsA<Connection> + Clone + 'static),
        save_to_disk: bool,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<RemoteConnection, glib::Error>> + 'static>>
    {
        let connection = connection.clone();
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.add_connection_async(&connection, save_to_disk, Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Updates the network connectivity state and returns the (new)
    /// current state. Contrast nm_client_get_connectivity(), which returns
    /// the most recent known state without re-checking.
    ///
    /// This is a blocking call; use nm_client_check_connectivity_async()
    /// if you do not want to block.
    ///
    /// # Deprecated since 1.22
    ///
    /// Use nm_client_check_connectivity_async() or GDBusConnection.
    /// ## `cancellable`
    /// a #GCancellable
    ///
    /// # Returns
    ///
    /// the (new) current connectivity state
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[allow(deprecated)]
    #[doc(alias = "nm_client_check_connectivity")]
    pub fn check_connectivity(
        &self,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<ConnectivityState, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::nm_client_check_connectivity(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously updates the network connectivity state and invokes
    /// @callback when complete. Contrast nm_client_get_connectivity(),
    /// which (immediately) returns the most recent known state without
    /// re-checking, and nm_client_check_connectivity(), which blocks.
    /// ## `cancellable`
    /// a #GCancellable
    /// ## `callback`
    /// callback to call with the result
    #[doc(alias = "nm_client_check_connectivity_async")]
    pub fn check_connectivity_async<P: FnOnce(Result<ConnectivityState, glib::Error>) + 'static>(
        &self,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn check_connectivity_async_trampoline<
            P: FnOnce(Result<ConnectivityState, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            let ret =
                ffi::nm_client_check_connectivity_finish(_source_object as *mut _, res, &mut error);
            let result = if error.is_null() {
                Ok(from_glib(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = check_connectivity_async_trampoline::<P>;
        unsafe {
            ffi::nm_client_check_connectivity_async(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn check_connectivity_future(
        &self,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<ConnectivityState, glib::Error>> + 'static>>
    {
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.check_connectivity_async(Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Resets the timeout for the checkpoint with path @checkpoint_path
    /// to @timeout_add.
    /// ## `checkpoint_path`
    /// a D-Bus path to a checkpoint
    /// ## `add_timeout`
    /// the timeout in seconds counting from now.
    ///   Set to zero, to disable the timeout.
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to be called when the add operation completes
    #[cfg(feature = "v1_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    #[doc(alias = "nm_client_checkpoint_adjust_rollback_timeout")]
    pub fn checkpoint_adjust_rollback_timeout<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        checkpoint_path: &str,
        add_timeout: u32,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn checkpoint_adjust_rollback_timeout_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            ffi::nm_client_checkpoint_adjust_rollback_timeout_finish(
                _source_object as *mut _,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = checkpoint_adjust_rollback_timeout_trampoline::<P>;
        unsafe {
            ffi::nm_client_checkpoint_adjust_rollback_timeout(
                self.to_glib_none().0,
                checkpoint_path.to_glib_none().0,
                add_timeout,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    #[cfg(feature = "v1_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    pub fn checkpoint_adjust_rollback_timeout_future(
        &self,
        checkpoint_path: &str,
        add_timeout: u32,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        let checkpoint_path = String::from(checkpoint_path);
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.checkpoint_adjust_rollback_timeout(
                &checkpoint_path,
                add_timeout,
                Some(cancellable),
                move |res| {
                    send.resolve(res);
                },
            );
        }))
    }

    /// Creates a checkpoint of the current networking configuration
    /// for given interfaces. An empty @devices argument means all
    /// devices. If @rollback_timeout is not zero, a rollback is
    /// automatically performed after the given timeout.
    /// ## `devices`
    /// a list of devices for which a
    ///   checkpoint should be created.
    /// ## `rollback_timeout`
    /// the rollback timeout in seconds
    /// ## `flags`
    /// creation flags
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to be called when the add operation completes
    #[cfg(feature = "v1_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    #[doc(alias = "nm_client_checkpoint_create")]
    pub fn checkpoint_create<P: FnOnce(Result<Checkpoint, glib::Error>) + 'static>(
        &self,
        devices: &[Device],
        rollback_timeout: u32,
        flags: CheckpointCreateFlags,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn checkpoint_create_trampoline<
            P: FnOnce(Result<Checkpoint, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            let ret =
                ffi::nm_client_checkpoint_create_finish(_source_object as *mut _, res, &mut error);
            let result = if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = checkpoint_create_trampoline::<P>;
        unsafe {
            ffi::nm_client_checkpoint_create(
                self.to_glib_none().0,
                devices.to_glib_none().0,
                rollback_timeout,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    #[cfg(feature = "v1_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    pub fn checkpoint_create_future(
        &self,
        devices: &[Device],
        rollback_timeout: u32,
        flags: CheckpointCreateFlags,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<Checkpoint, glib::Error>> + 'static>>
    {
        let devices = devices.to_vec();
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.checkpoint_create(
                devices.as_slice(),
                rollback_timeout,
                flags,
                Some(cancellable),
                move |res| {
                    send.resolve(res);
                },
            );
        }))
    }

    #[cfg(feature = "v1_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    #[doc(alias = "nm_client_checkpoint_destroy")]
    pub fn checkpoint_destroy<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        checkpoint_path: &str,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn checkpoint_destroy_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            ffi::nm_client_checkpoint_destroy_finish(_source_object as *mut _, res, &mut error);
            let result = if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = checkpoint_destroy_trampoline::<P>;
        unsafe {
            ffi::nm_client_checkpoint_destroy(
                self.to_glib_none().0,
                checkpoint_path.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    #[cfg(feature = "v1_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    pub fn checkpoint_destroy_future(
        &self,
        checkpoint_path: &str,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        let checkpoint_path = String::from(checkpoint_path);
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.checkpoint_destroy(&checkpoint_path, Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    //#[cfg(feature = "v1_12")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    //#[doc(alias = "nm_client_checkpoint_rollback")]
    //pub fn checkpoint_rollback<P: FnOnce(Result</*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 0, id: 7 }, glib::Error>) + 'static>(&self, checkpoint_path: &str, cancellable: Option<&impl IsA<gio::Cancellable>>, callback: P) {
    //    unsafe { TODO: call ffi:nm_client_checkpoint_rollback() }
    //}

    //
    //#[cfg(feature = "v1_12")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    //pub fn checkpoint_rollback_future(&self, checkpoint_path: &str) -> Pin<Box_<dyn std::future::Future<Output = Result</*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 0, id: 7 }, glib::Error>> + 'static>> {

    //let checkpoint_path = String::from(checkpoint_path);
    //Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
    //    obj.checkpoint_rollback(
    //        &checkpoint_path,
    //        Some(cancellable),
    //        move |res| {
    //            send.resolve(res);
    //        },
    //    );
    //}))
    //}

    /// Determine whether connectivity checking is available.  This
    /// requires that the URI of a connectivity service has been set in the
    /// configuration file.
    ///
    /// # Returns
    ///
    /// [`true`] if connectivity checking is available.
    #[cfg(feature = "v1_10")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_10")))]
    #[doc(alias = "nm_client_connectivity_check_get_available")]
    pub fn connectivity_check_get_available(&self) -> bool {
        unsafe {
            from_glib(ffi::nm_client_connectivity_check_get_available(
                self.to_glib_none().0,
            ))
        }
    }

    /// Determine whether connectivity checking is enabled.
    ///
    /// # Returns
    ///
    /// [`true`] if connectivity checking is enabled.
    #[cfg(feature = "v1_10")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_10")))]
    #[doc(alias = "nm_client_connectivity_check_get_enabled")]
    pub fn connectivity_check_get_enabled(&self) -> bool {
        unsafe {
            from_glib(ffi::nm_client_connectivity_check_get_enabled(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the URI that will be queried to determine if there is internet
    /// connectivity.
    ///
    /// # Returns
    ///
    /// the connectivity URI in use
    #[cfg(feature = "v1_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
    #[doc(alias = "nm_client_connectivity_check_get_uri")]
    pub fn connectivity_check_get_uri(&self) -> glib::GString {
        unsafe {
            from_glib_none(ffi::nm_client_connectivity_check_get_uri(
                self.to_glib_none().0,
            ))
        }
    }

    /// Enable or disable connectivity checking.  Note that if a
    /// connectivity checking URI has not been configured, this will not
    /// have any effect.
    ///
    /// # Deprecated since 1.22
    ///
    /// Use the async command nm_client_dbus_set_property() on [`DBUS_PATH`][crate::DBUS_PATH],
    /// [`DBUS_INTERFACE`][crate::DBUS_INTERFACE] to set "ConnectivityCheckEnabled" property to a "(b)" value.
    /// ## `enabled`
    /// [`true`] to enable connectivity checking
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[cfg(feature = "v1_10")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_10")))]
    #[allow(deprecated)]
    #[doc(alias = "nm_client_connectivity_check_set_enabled")]
    pub fn connectivity_check_set_enabled(&self, enabled: bool) {
        unsafe {
            ffi::nm_client_connectivity_check_set_enabled(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    //#[cfg(feature = "v1_24")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
    //#[doc(alias = "nm_client_dbus_call")]
    //pub fn dbus_call<P: FnOnce(Result</*Ignored*/glib::Variant, glib::Error>) + 'static>(&self, object_path: &str, interface_name: &str, method_name: &str, parameters: /*Ignored*/Option<&glib::Variant>, reply_type: /*Ignored*/Option<&glib::VariantTy>, timeout_msec: i32, cancellable: Option<&impl IsA<gio::Cancellable>>, callback: P) {
    //    unsafe { TODO: call ffi:nm_client_dbus_call() }
    //}

    //
    //#[cfg(feature = "v1_24")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
    //pub fn dbus_call_future(&self, object_path: &str, interface_name: &str, method_name: &str, parameters: /*Ignored*/Option<&glib::Variant>, reply_type: /*Ignored*/Option<&glib::VariantTy>, timeout_msec: i32) -> Pin<Box_<dyn std::future::Future<Output = Result</*Ignored*/glib::Variant, glib::Error>> + 'static>> {

    //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);
    //Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
    //    obj.dbus_call(
    //        &object_path,
    //        &interface_name,
    //        &method_name,
    //        parameters.as_ref().map(::std::borrow::Borrow::borrow),
    //        reply_type.as_ref().map(::std::borrow::Borrow::borrow),
    //        timeout_msec,
    //        Some(cancellable),
    //        move |res| {
    //            send.resolve(res);
    //        },
    //    );
    //}))
    //}

    //#[cfg(feature = "v1_24")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
    //#[doc(alias = "nm_client_dbus_set_property")]
    //pub fn dbus_set_property<P: FnOnce(Result<(), glib::Error>) + 'static>(&self, object_path: &str, interface_name: &str, property_name: &str, value: /*Ignored*/&glib::Variant, timeout_msec: i32, cancellable: Option<&impl IsA<gio::Cancellable>>, callback: P) {
    //    unsafe { TODO: call ffi:nm_client_dbus_set_property() }
    //}

    //
    //#[cfg(feature = "v1_24")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
    //pub fn dbus_set_property_future(&self, object_path: &str, interface_name: &str, property_name: &str, value: /*Ignored*/&glib::Variant, timeout_msec: i32) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {

    //let object_path = String::from(object_path);
    //let interface_name = String::from(interface_name);
    //let property_name = String::from(property_name);
    //let value = value.clone();
    //Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
    //    obj.dbus_set_property(
    //        &object_path,
    //        &interface_name,
    //        &property_name,
    //        &value,
    //        timeout_msec,
    //        Some(cancellable),
    //        move |res| {
    //            send.resolve(res);
    //        },
    //    );
    //}))
    //}

    /// Deactivates an active #NMActiveConnection.
    ///
    /// # Deprecated since 1.22
    ///
    /// Use nm_client_deactivate_connection_async() or GDBusConnection.
    /// ## `active`
    /// the #NMActiveConnection to deactivate
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    ///
    /// # Returns
    ///
    /// success or failure
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[allow(deprecated)]
    #[doc(alias = "nm_client_deactivate_connection")]
    pub fn deactivate_connection(
        &self,
        active: &impl IsA<ActiveConnection>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::nm_client_deactivate_connection(
                self.to_glib_none().0,
                active.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously deactivates an active #NMActiveConnection.
    /// ## `active`
    /// the #NMActiveConnection to deactivate
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to be called when the deactivation has completed
    #[doc(alias = "nm_client_deactivate_connection_async")]
    pub fn deactivate_connection_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        active: &impl IsA<ActiveConnection>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn deactivate_connection_async_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            ffi::nm_client_deactivate_connection_finish(_source_object as *mut _, res, &mut error);
            let result = if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = deactivate_connection_async_trampoline::<P>;
        unsafe {
            ffi::nm_client_deactivate_connection_async(
                self.to_glib_none().0,
                active.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn deactivate_connection_future(
        &self,
        active: &(impl IsA<ActiveConnection> + Clone + 'static),
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        let active = active.clone();
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.deactivate_connection_async(&active, Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Gets the #NMActiveConnection corresponding to a
    /// currently-activating connection that is expected to become the new
    /// #NMClient:primary-connection upon successful activation.
    ///
    /// # Returns
    ///
    /// the appropriate #NMActiveConnection, if
    /// any.
    #[doc(alias = "nm_client_get_activating_connection")]
    #[doc(alias = "get_activating_connection")]
    #[doc(alias = "activating-connection")]
    pub fn activating_connection(&self) -> ActiveConnection {
        unsafe {
            from_glib_none(ffi::nm_client_get_activating_connection(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the active connections.
    ///
    /// # Returns
    ///
    /// a #GPtrArray
    ///  containing all the active #NMActiveConnections.
    /// The returned array is owned by the client and should not be modified.
    #[doc(alias = "nm_client_get_active_connections")]
    #[doc(alias = "get_active_connections")]
    #[doc(alias = "active-connections")]
    pub fn active_connections(&self) -> Vec<ActiveConnection> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::nm_client_get_active_connections(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets both real devices and device placeholders (eg, software devices which
    /// do not currently exist, but could be created automatically by NetworkManager
    /// if one of their NMDevice::ActivatableConnections was activated).  Use
    /// nm_device_is_real() to determine whether each device is a real device or
    /// a placeholder.
    ///
    /// Use nm_device_get_type() or the NM_IS_DEVICE_XXXX() functions to determine
    /// what kind of device each member of the returned array is, and then you may
    /// use device-specific methods such as nm_device_ethernet_get_hw_address().
    ///
    /// # Returns
    ///
    /// a #GPtrArray
    /// containing all the #NMDevices.  The returned array is owned by the
    /// #NMClient object and should not be modified.
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "nm_client_get_all_devices")]
    #[doc(alias = "get_all_devices")]
    #[doc(alias = "all-devices")]
    pub fn all_devices(&self) -> Vec<Device> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::nm_client_get_all_devices(
                self.to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// the
    ///   list of capabilities reported by the server or [`None`]
    ///   if the capabilities are unknown.
    ///   The numeric values correspond to #NMCapability enum.
    ///   The array is terminated by a numeric zero sentinel
    ///   at position @length.
    #[cfg(feature = "v1_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
    #[doc(alias = "nm_client_get_capabilities")]
    #[doc(alias = "get_capabilities")]
    pub fn capabilities(&self) -> Vec<u32> {
        unsafe {
            let mut length = std::mem::MaybeUninit::uninit();
            let ret = FromGlibContainer::from_glib_none_num(
                ffi::nm_client_get_capabilities(self.to_glib_none().0, length.as_mut_ptr()),
                length.assume_init() as _,
            );
            ret
        }
    }

    /// Gets all the active checkpoints.
    ///
    /// # Returns
    ///
    /// a #GPtrArray
    /// containing all the #NMCheckpoint.  The returned array is owned by the
    /// #NMClient object and should not be modified.
    #[cfg(feature = "v1_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    #[doc(alias = "nm_client_get_checkpoints")]
    #[doc(alias = "get_checkpoints")]
    pub fn checkpoints(&self) -> Vec<Checkpoint> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::nm_client_get_checkpoints(
                self.to_glib_none().0,
            ))
        }
    }

    /// Returns the first matching `NMRemoteConnection` matching a given @id.
    /// ## `id`
    /// the id of the remote connection
    ///
    /// # Returns
    ///
    /// the remote connection object on success, or [`None`] if no
    ///  matching object was found.
    ///
    /// The connection is as received from D-Bus and might not validate according
    /// to nm_connection_verify().
    #[doc(alias = "nm_client_get_connection_by_id")]
    #[doc(alias = "get_connection_by_id")]
    pub fn connection_by_id(&self, id: &str) -> RemoteConnection {
        unsafe {
            from_glib_none(ffi::nm_client_get_connection_by_id(
                self.to_glib_none().0,
                id.to_glib_none().0,
            ))
        }
    }

    /// Returns the `NMRemoteConnection` representing the connection at @path.
    /// ## `path`
    /// the D-Bus object path of the remote connection
    ///
    /// # Returns
    ///
    /// the remote connection object on success, or [`None`] if the object was
    ///  not known
    ///
    /// The connection is as received from D-Bus and might not validate according
    /// to nm_connection_verify().
    #[doc(alias = "nm_client_get_connection_by_path")]
    #[doc(alias = "get_connection_by_path")]
    pub fn connection_by_path(&self, path: &str) -> RemoteConnection {
        unsafe {
            from_glib_none(ffi::nm_client_get_connection_by_path(
                self.to_glib_none().0,
                path.to_glib_none().0,
            ))
        }
    }

    /// Returns the `NMRemoteConnection` identified by @uuid.
    /// ## `uuid`
    /// the UUID of the remote connection
    ///
    /// # Returns
    ///
    /// the remote connection object on success, or [`None`] if the object was
    ///  not known
    ///
    /// The connection is as received from D-Bus and might not validate according
    /// to nm_connection_verify().
    #[doc(alias = "nm_client_get_connection_by_uuid")]
    #[doc(alias = "get_connection_by_uuid")]
    pub fn connection_by_uuid(&self, uuid: &str) -> RemoteConnection {
        unsafe {
            from_glib_none(ffi::nm_client_get_connection_by_uuid(
                self.to_glib_none().0,
                uuid.to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// an array
    /// containing all connections provided by the remote settings service.  The
    /// returned array is owned by the #NMClient object and should not be modified.
    ///
    /// The connections are as received from D-Bus and might not validate according
    /// to nm_connection_verify().
    #[doc(alias = "nm_client_get_connections")]
    #[doc(alias = "get_connections")]
    pub fn connections(&self) -> Vec<RemoteConnection> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::nm_client_get_connections(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the current network connectivity state. Contrast
    /// nm_client_check_connectivity() and
    /// nm_client_check_connectivity_async(), which re-check the
    /// connectivity state first before returning any information.
    ///
    /// # Returns
    ///
    /// the current connectivity state
    #[doc(alias = "nm_client_get_connectivity")]
    #[doc(alias = "get_connectivity")]
    pub fn connectivity(&self) -> ConnectivityState {
        unsafe { from_glib(ffi::nm_client_get_connectivity(self.to_glib_none().0)) }
    }

    //#[cfg(feature = "v1_22")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
    //#[doc(alias = "nm_client_get_context_busy_watcher")]
    //#[doc(alias = "get_context_busy_watcher")]
    //pub fn context_busy_watcher(&self) -> /*Ignored*/glib::Object {
    //    unsafe { TODO: call ffi:nm_client_get_context_busy_watcher() }
    //}

    //#[cfg(feature = "v1_22")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
    //#[doc(alias = "nm_client_get_dbus_connection")]
    //#[doc(alias = "get_dbus_connection")]
    //#[doc(alias = "dbus-connection")]
    //pub fn dbus_connection(&self) -> /*Ignored*/gio::DBusConnection {
    //    unsafe { TODO: call ffi:nm_client_get_dbus_connection() }
    //}

    ///
    /// # Returns
    ///
    /// the current name owner of the D-Bus service of NetworkManager.
    #[cfg(feature = "v1_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
    #[doc(alias = "nm_client_get_dbus_name_owner")]
    #[doc(alias = "get_dbus_name_owner")]
    #[doc(alias = "dbus-name-owner")]
    pub fn dbus_name_owner(&self) -> glib::GString {
        unsafe { from_glib_none(ffi::nm_client_get_dbus_name_owner(self.to_glib_none().0)) }
    }

    /// Gets a #NMDevice from a #NMClient.
    /// ## `iface`
    /// the interface name to search for
    ///
    /// # Returns
    ///
    /// the #NMDevice for the given @iface or [`None`] if none is found.
    #[doc(alias = "nm_client_get_device_by_iface")]
    #[doc(alias = "get_device_by_iface")]
    pub fn device_by_iface(&self, iface: &str) -> Device {
        unsafe {
            from_glib_none(ffi::nm_client_get_device_by_iface(
                self.to_glib_none().0,
                iface.to_glib_none().0,
            ))
        }
    }

    /// Gets a #NMDevice from a #NMClient.
    /// ## `object_path`
    /// the object path to search for
    ///
    /// # Returns
    ///
    /// the #NMDevice for the given @object_path or [`None`] if none is found.
    #[doc(alias = "nm_client_get_device_by_path")]
    #[doc(alias = "get_device_by_path")]
    pub fn device_by_path(&self, object_path: &str) -> Device {
        unsafe {
            from_glib_none(ffi::nm_client_get_device_by_path(
                self.to_glib_none().0,
                object_path.to_glib_none().0,
            ))
        }
    }

    /// Gets all the known network devices.  Use nm_device_get_type() or the
    /// <literal>NM_IS_DEVICE_XXXX</literal> functions to determine what kind of
    /// device member of the returned array is, and then you may use device-specific
    /// methods such as nm_device_ethernet_get_hw_address().
    ///
    /// # Returns
    ///
    /// a #GPtrArray
    /// containing all the #NMDevices.  The returned array is owned by the
    /// #NMClient object and should not be modified.
    #[doc(alias = "nm_client_get_devices")]
    #[doc(alias = "get_devices")]
    pub fn devices(&self) -> Vec<Device> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::nm_client_get_devices(self.to_glib_none().0))
        }
    }

    /// Gets the current DNS configuration
    ///
    /// # Returns
    ///
    /// a #GPtrArray
    /// containing #NMDnsEntry elements or [`None`] in case the value is not
    /// available.  The returned array is owned by the #NMClient object
    /// and should not be modified.
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    #[doc(alias = "nm_client_get_dns_configuration")]
    #[doc(alias = "get_dns_configuration")]
    #[doc(alias = "dns-configuration")]
    pub fn dns_configuration(&self) -> Vec<DnsEntry> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::nm_client_get_dns_configuration(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the current DNS processing mode.
    ///
    /// # Returns
    ///
    /// the DNS processing mode, or [`None`] in case the
    ///   value is not available.
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    #[doc(alias = "nm_client_get_dns_mode")]
    #[doc(alias = "get_dns_mode")]
    #[doc(alias = "dns-mode")]
    pub fn dns_mode(&self) -> glib::GString {
        unsafe { from_glib_none(ffi::nm_client_get_dns_mode(self.to_glib_none().0)) }
    }

    /// Gets the current DNS resolv.conf manager.
    ///
    /// # Returns
    ///
    /// the resolv.conf manager or [`None`] in case the
    ///   value is not available.
    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    #[doc(alias = "nm_client_get_dns_rc_manager")]
    #[doc(alias = "get_dns_rc_manager")]
    #[doc(alias = "dns-rc-manager")]
    pub fn dns_rc_manager(&self) -> glib::GString {
        unsafe { from_glib_none(ffi::nm_client_get_dns_rc_manager(self.to_glib_none().0)) }
    }

    ///
    /// # Returns
    ///
    /// the #NMClientInstanceFlags flags.
    #[cfg(feature = "v1_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
    #[doc(alias = "nm_client_get_instance_flags")]
    #[doc(alias = "get_instance_flags")]
    #[doc(alias = "instance-flags")]
    pub fn instance_flags(&self) -> ClientInstanceFlags {
        unsafe { from_glib(ffi::nm_client_get_instance_flags(self.to_glib_none().0)) }
    }

    /// Gets NetworkManager current logging level and domains.
    ///
    /// # Deprecated since 1.22
    ///
    /// Use the async command nm_client_dbus_call() on [`DBUS_PATH`][crate::DBUS_PATH],
    /// [`DBUS_INTERFACE`][crate::DBUS_INTERFACE] to call "GetLogging" with no arguments to get "(ss)" for level
    /// and domains.
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] otherwise
    ///
    /// ## `level`
    /// return location for logging level string
    ///
    /// ## `domains`
    /// return location for log domains string. The string is
    ///   a list of domains separated by ","
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[allow(deprecated)]
    #[doc(alias = "nm_client_get_logging")]
    #[doc(alias = "get_logging")]
    pub fn logging(&self) -> Result<(Option<glib::GString>, Option<glib::GString>), glib::Error> {
        unsafe {
            let mut level = std::ptr::null_mut();
            let mut domains = std::ptr::null_mut();
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::nm_client_get_logging(
                self.to_glib_none().0,
                &mut level,
                &mut domains,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok((from_glib_full(level), from_glib_full(domains)))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    //#[cfg(feature = "v1_22")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
    //#[doc(alias = "nm_client_get_main_context")]
    //#[doc(alias = "get_main_context")]
    //pub fn main_context(&self) -> /*Ignored*/glib::MainContext {
    //    unsafe { TODO: call ffi:nm_client_get_main_context() }
    //}

    ///
    /// # Returns
    ///
    /// whether the default route is metered.
    #[cfg(feature = "v1_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
    #[doc(alias = "nm_client_get_metered")]
    #[doc(alias = "get_metered")]
    pub fn metered(&self) -> Metered {
        unsafe { from_glib(ffi::nm_client_get_metered(self.to_glib_none().0)) }
    }

    /// Determines whether the daemon is running.
    ///
    /// # Returns
    ///
    /// [`true`] if the daemon is running
    #[doc(alias = "nm_client_get_nm_running")]
    #[doc(alias = "get_nm_running")]
    #[doc(alias = "nm-running")]
    pub fn is_nm_running(&self) -> bool {
        unsafe { from_glib(ffi::nm_client_get_nm_running(self.to_glib_none().0)) }
    }

    /// ## `dbus_path`
    /// the D-Bus path of the object to look up
    ///
    /// # Returns
    ///
    /// the #NMObject instance that is
    ///   cached under @dbus_path, or [`None`] if no such object exists.
    #[cfg(feature = "v1_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
    #[doc(alias = "nm_client_get_object_by_path")]
    #[doc(alias = "get_object_by_path")]
    pub fn object_by_path(&self, dbus_path: &str) -> Object {
        unsafe {
            from_glib_none(ffi::nm_client_get_object_by_path(
                self.to_glib_none().0,
                dbus_path.to_glib_none().0,
            ))
        }
    }

    /// Requests the result of a specific permission, which indicates whether the
    /// client can or cannot perform the action the permission represents
    /// ## `permission`
    /// the permission for which to return the result, one of #NMClientPermission
    ///
    /// # Returns
    ///
    /// the permission's result, one of #NMClientPermissionResult
    #[doc(alias = "nm_client_get_permission_result")]
    #[doc(alias = "get_permission_result")]
    pub fn permission_result(&self, permission: ClientPermission) -> ClientPermissionResult {
        unsafe {
            from_glib(ffi::nm_client_get_permission_result(
                self.to_glib_none().0,
                permission.into_glib(),
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// the state of the cached permissions. [`Ternary::Default`][crate::Ternary::Default]
    ///   means that no permissions result was yet received. All permissions
    ///   are unknown. [`Ternary::True`][crate::Ternary::True] means that the permissions got received
    ///   and are cached. %[`Ternary::False`][crate::Ternary::False] means that permissions are cached,
    ///   but they are invalided as "CheckPermissions" signal was received
    ///   in the meantime.
    #[cfg(feature = "v1_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
    #[doc(alias = "nm_client_get_permissions_state")]
    #[doc(alias = "get_permissions_state")]
    #[doc(alias = "permissions-state")]
    pub fn permissions_state(&self) -> Ternary {
        unsafe { from_glib(ffi::nm_client_get_permissions_state(self.to_glib_none().0)) }
    }

    /// Gets the #NMActiveConnection corresponding to the primary active
    /// network device.
    ///
    /// In particular, when there is no VPN active, or the VPN does not
    /// have the default route, this returns the active connection that has
    /// the default route. If there is a VPN active with the default route,
    /// then this function returns the active connection that contains the
    /// route to the VPN endpoint.
    ///
    /// If there is no default route, or the default route is over a
    /// non-NetworkManager-recognized device, this will return [`None`].
    ///
    /// # Returns
    ///
    /// the appropriate #NMActiveConnection, if
    /// any
    #[doc(alias = "nm_client_get_primary_connection")]
    #[doc(alias = "get_primary_connection")]
    #[doc(alias = "primary-connection")]
    pub fn primary_connection(&self) -> ActiveConnection {
        unsafe { from_glib_none(ffi::nm_client_get_primary_connection(self.to_glib_none().0)) }
    }

    /// Get radio flags.
    ///
    /// # Returns
    ///
    /// the #NMRadioFlags.
    #[cfg(feature = "v1_38")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_38")))]
    #[doc(alias = "nm_client_get_radio_flags")]
    #[doc(alias = "get_radio_flags")]
    #[doc(alias = "radio-flags")]
    pub fn radio_flags(&self) -> RadioFlags {
        unsafe { from_glib(ffi::nm_client_get_radio_flags(self.to_glib_none().0)) }
    }

    /// Tests whether the daemon is still in the process of activating
    /// connections at startup.
    ///
    /// # Returns
    ///
    /// whether the daemon is still starting up
    #[doc(alias = "nm_client_get_startup")]
    #[doc(alias = "get_startup")]
    #[doc(alias = "startup")]
    pub fn is_startup(&self) -> bool {
        unsafe { from_glib(ffi::nm_client_get_startup(self.to_glib_none().0)) }
    }

    /// Gets the current daemon state.
    ///
    /// # Returns
    ///
    /// the current `NMState`
    #[doc(alias = "nm_client_get_state")]
    #[doc(alias = "get_state")]
    pub fn state(&self) -> State {
        unsafe { from_glib(ffi::nm_client_get_state(self.to_glib_none().0)) }
    }

    /// Gets NetworkManager version.
    ///
    /// # Returns
    ///
    /// string with the version (or [`None`] if NetworkManager is not running)
    #[doc(alias = "nm_client_get_version")]
    #[doc(alias = "get_version")]
    pub fn version(&self) -> glib::GString {
        unsafe { glib::GString::from_glib_none(ffi::nm_client_get_version(self.to_glib_none().0)) }
    }

    /// If available, the first element in the array is NM_VERSION which
    /// encodes the daemon version as "(major << 16 | minor << 8 | micro)".
    /// The following elements are a bitfield of `NMVersionInfoCapability`
    /// that indicate that the daemon supports a certain capability.
    ///
    /// # Returns
    ///
    /// the
    ///   list of capabilities reported by the server or [`None`]
    ///   if the capabilities are unknown.
    #[cfg(feature = "v1_42")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_42")))]
    #[doc(alias = "nm_client_get_version_info")]
    #[doc(alias = "get_version_info")]
    #[doc(alias = "version-info")]
    pub fn version_info(&self) -> Vec<u32> {
        unsafe {
            let mut length = std::mem::MaybeUninit::uninit();
            let ret = FromGlibContainer::from_glib_none_num(
                ffi::nm_client_get_version_info(self.to_glib_none().0, length.as_mut_ptr()),
                length.assume_init() as _,
            );
            ret
        }
    }

    /// Requests that the remote settings service load or reload the given files,
    /// adding or updating the connections described within.
    ///
    /// The changes to the indicated files will not yet be reflected in
    /// @self's connections array when the function returns.
    ///
    /// If all of the indicated files were successfully loaded, the
    /// function will return [`true`], and @failures will be set to [`None`]. If
    /// NetworkManager tried to load the files, but some (or all) failed,
    /// then @failures will be set to a [`None`]-terminated array of the
    /// filenames that failed to load.
    ///
    /// # Deprecated since 1.22
    ///
    /// Use nm_client_load_connections_async() or GDBusConnection.
    /// ## `filenames`
    /// [`None`]-terminated array of filenames to load
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on success.
    ///
    /// Warning: before libnm 1.22, the boolean return value was inconsistent.
    ///   That is made worse, because when running against certain server versions
    ///   before 1.20, the server would return wrong values for success/failure.
    ///   This means, if you use this function in libnm before 1.22, you are advised
    ///   to ignore the boolean return value and only look at @failures and @error.
    ///   With libnm >= 1.22, the boolean return value corresponds to whether @error was
    ///   set. Note that even in the success case, you might have individual @failures.
    ///   With 1.22, the return value is consistent with nm_client_load_connections_finish().
    ///
    /// ## `failures`
    /// on return, a [`None`]-terminated array of
    ///   filenames that failed to load
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[allow(deprecated)]
    #[doc(alias = "nm_client_load_connections")]
    pub fn load_connections(
        &self,
        filenames: &[&str],
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<glib::GString, glib::Error> {
        unsafe {
            let mut failures = std::ptr::null_mut();
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::nm_client_load_connections(
                self.to_glib_none().0,
                filenames.to_glib_none().0,
                &mut failures,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(from_glib_full(std::ptr::read(failures)))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Requests that the remote settings service asynchronously load or reload the
    /// given files, adding or updating the connections described within.
    ///
    /// See nm_client_load_connections() for more details.
    /// ## `filenames`
    /// [`None`]-terminated array of filenames to load
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to be called when the operation completes
    #[doc(alias = "nm_client_load_connections_async")]
    pub fn load_connections_async<P: FnOnce(Result<Vec<glib::GString>, glib::Error>) + 'static>(
        &self,
        filenames: &[&str],
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn load_connections_async_trampoline<
            P: FnOnce(Result<Vec<glib::GString>, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            let mut failures = std::ptr::null_mut();
            ffi::nm_client_load_connections_finish(
                _source_object as *mut _,
                &mut failures,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_full(failures))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = load_connections_async_trampoline::<P>;
        unsafe {
            ffi::nm_client_load_connections_async(
                self.to_glib_none().0,
                filenames.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn load_connections_future(
        &self,
        filenames: &[&str],
    ) -> Pin<
        Box_<dyn std::future::Future<Output = Result<Vec<glib::GString>, glib::Error>> + 'static>,
    > {
        let filenames = filenames
            .iter()
            .map(ToString::to_string)
            .collect::<Vec<_>>();
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.load_connections_async(
                filenames
                    .iter()
                    .map(|s| s.as_str())
                    .collect::<Vec<&str>>()
                    .as_slice(),
                Some(cancellable),
                move |res| {
                    send.resolve(res);
                },
            );
        }))
    }

    /// Whether networking is enabled or disabled.
    ///
    /// # Returns
    ///
    /// [`true`] if networking is enabled, [`false`] if networking is disabled
    #[doc(alias = "nm_client_networking_get_enabled")]
    pub fn networking_get_enabled(&self) -> bool {
        unsafe { from_glib(ffi::nm_client_networking_get_enabled(self.to_glib_none().0)) }
    }

    /// Enables or disables networking.  When networking is disabled, all controlled
    /// interfaces are disconnected and deactivated.  When networking is enabled,
    /// all controlled interfaces are available for activation.
    ///
    /// # Deprecated since 1.22
    ///
    /// Use the async command nm_client_dbus_call() on [`DBUS_PATH`][crate::DBUS_PATH],
    /// [`DBUS_INTERFACE`][crate::DBUS_INTERFACE] to call "Enable" with "(b)" arguments and no return value.
    /// ## `enabled`
    /// [`true`] to set networking enabled, [`false`] to set networking disabled
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] otherwise
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[allow(deprecated)]
    #[doc(alias = "nm_client_networking_set_enabled")]
    pub fn networking_set_enabled(&self, enabled: bool) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::nm_client_networking_set_enabled(
                self.to_glib_none().0,
                enabled.into_glib(),
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Reload NetworkManager's configuration and perform certain updates, like
    /// flushing caches or rewriting external state to disk. This is similar to
    /// sending SIGHUP to NetworkManager but it allows for more fine-grained control
    /// over what to reload (see @flags). It also allows non-root access via
    /// PolicyKit and contrary to signals it is synchronous.
    /// ## `flags`
    /// flags indicating what to reload.
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to be called when the add operation completes
    #[cfg(feature = "v1_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
    #[doc(alias = "nm_client_reload")]
    pub fn reload<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        flags: ManagerReloadFlags,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn reload_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            ffi::nm_client_reload_finish(_source_object as *mut _, res, &mut error);
            let result = if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = reload_trampoline::<P>;
        unsafe {
            ffi::nm_client_reload(
                self.to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    #[cfg(feature = "v1_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
    pub fn reload_future(
        &self,
        flags: ManagerReloadFlags,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.reload(flags, Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Requests that the remote settings service reload all connection
    /// files from disk, adding, updating, and removing connections until
    /// the in-memory state matches the on-disk state.
    ///
    /// # Deprecated since 1.22
    ///
    /// Use nm_client_reload_connections_async() or GDBusConnection.
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on failure
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[allow(deprecated)]
    #[doc(alias = "nm_client_reload_connections")]
    pub fn reload_connections(
        &self,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::nm_client_reload_connections(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Requests that the remote settings service begin reloading all connection
    /// files from disk, adding, updating, and removing connections until the
    /// in-memory state matches the on-disk state.
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to be called when the reload operation completes
    #[doc(alias = "nm_client_reload_connections_async")]
    pub fn reload_connections_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn reload_connections_async_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            ffi::nm_client_reload_connections_finish(_source_object as *mut _, res, &mut error);
            let result = if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = reload_connections_async_trampoline::<P>;
        unsafe {
            ffi::nm_client_reload_connections_async(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn reload_connections_future(
        &self,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.reload_connections_async(Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Requests that the machine's persistent hostname be set to the specified value
    /// or cleared.
    ///
    /// # Deprecated since 1.22
    ///
    /// Use nm_client_save_hostname_async() or GDBusConnection.
    /// ## `hostname`
    /// the new persistent hostname to set, or [`None`] to
    ///   clear any existing persistent hostname
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] if the request was successful, [`false`] if it failed
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[allow(deprecated)]
    #[doc(alias = "nm_client_save_hostname")]
    pub fn save_hostname(
        &self,
        hostname: Option<&str>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::nm_client_save_hostname(
                self.to_glib_none().0,
                hostname.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Requests that the machine's persistent hostname be set to the specified value
    /// or cleared.
    /// ## `hostname`
    /// the new persistent hostname to set, or [`None`] to
    ///   clear any existing persistent hostname
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to be called when the operation completes
    #[doc(alias = "nm_client_save_hostname_async")]
    pub fn save_hostname_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        hostname: Option<&str>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn save_hostname_async_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            ffi::nm_client_save_hostname_finish(_source_object as *mut _, res, &mut error);
            let result = if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = save_hostname_async_trampoline::<P>;
        unsafe {
            ffi::nm_client_save_hostname_async(
                self.to_glib_none().0,
                hostname.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn save_hostname_future(
        &self,
        hostname: Option<&str>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        let hostname = hostname.map(ToOwned::to_owned);
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.save_hostname_async(
                hostname.as_ref().map(::std::borrow::Borrow::borrow),
                Some(cancellable),
                move |res| {
                    send.resolve(res);
                },
            );
        }))
    }

    /// Sets NetworkManager logging level and/or domains.
    ///
    /// # Deprecated since 1.22
    ///
    /// Use the async command nm_client_dbus_call() on [`DBUS_PATH`][crate::DBUS_PATH],
    /// [`DBUS_INTERFACE`][crate::DBUS_INTERFACE] to call "SetLogging" with "(ss)" arguments for level and domains.
    /// ## `level`
    /// logging level to set ([`None`] or an empty string for no change)
    /// ## `domains`
    /// logging domains to set. The string should be a list of log
    ///   domains separated by ",". ([`None`] or an empty string for no change)
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] otherwise
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[allow(deprecated)]
    #[doc(alias = "nm_client_set_logging")]
    pub fn set_logging(
        &self,
        level: Option<&str>,
        domains: Option<&str>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::nm_client_set_logging(
                self.to_glib_none().0,
                level.to_glib_none().0,
                domains.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// The way to stop #NMClient is by unrefing it. That will cancel all
    /// internally pending async operations. However, as async operations in
    /// NMClient use GTask, hence they cannot complete right away. Instead,
    /// their (internal) result callback still needs to be dispatched by iterating
    /// the client's main context.
    ///
    /// You thus cannot stop iterating the client's main context until
    /// everything is wrapped up. nm_client_get_context_busy_watcher()
    /// helps to watch how long that will be.
    ///
    /// This function automates that waiting. Like all glib async operations
    /// this honors the current g_main_context_get_thread_default().
    ///
    /// In any case, to complete the shutdown, nm_client_get_main_context()
    /// must be iterated. If the current g_main_context_get_thread_default() is
    /// the same as nm_client_get_main_context(), then @integrate_maincontext
    /// is ignored. In that case, the caller is required to iterate the context
    /// for shutdown to complete. Otherwise, if g_main_context_get_thread_default()
    /// differs from nm_client_get_main_context() and @integrate_maincontext
    /// is [`false`], the caller must make sure that both contexts are iterated
    /// until completion. Otherwise, if @integrate_maincontext is [`true`], then
    /// nm_client_get_main_context() will be integrated in g_main_context_get_thread_default().
    /// This means, the caller gives nm_client_get_main_context() up until the waiting
    /// completes, the function will acquire the context and hook it into
    /// g_main_context_get_thread_default().
    /// It is a bug to request @integrate_maincontext while having nm_client_get_main_context()
    /// acquired or iterated otherwise because a context can only be acquired once
    /// at a time.
    ///
    /// Shutdown can only complete after all references to @self were released.
    ///
    /// It is possible to call this function multiple times for the same client.
    /// But note that with @integrate_maincontext the client's context is acquired,
    /// which can only be done once at a time.
    ///
    /// It is permissible to start waiting before the objects is fully initialized.
    ///
    /// The function really allows two separate things. To get a notification (callback) when
    /// shutdown is complete, and to integrate the client's context in another context.
    /// The latter case is useful if the client has a separate context and you hand it
    /// over to another GMainContext to wrap up.
    ///
    /// The main use is to have a NMClient and a separate GMainContext on a worker
    /// thread. When being done, you can hand over the cleanup of the context
    /// to g_main_context_default(), assuming that the main thread iterates
    /// the default context. In that case, you don't need to care about passing
    /// a callback to know when shutdown completed.
    /// ## `integrate_maincontext`
    /// whether to hook the client's maincontext
    ///   in the current thread default. Otherwise, you must ensure
    ///   that the client's maincontext gets iterated so that it can complete.
    ///   By integrating the maincontext in the current thread default, you
    ///   may instead only iterate the latter.
    /// ## `cancellable`
    /// the #GCancellable to abort the shutdown.
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the request
    ///   is satisfied or [`None`] if you don't care about the result of the
    ///   method invocation.
    #[cfg(feature = "v1_42")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_42")))]
    #[doc(alias = "nm_client_wait_shutdown")]
    pub fn wait_shutdown<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        integrate_maincontext: bool,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn wait_shutdown_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error: *mut glib::ffi::GError = std::ptr::null_mut();
            ffi::nm_client_wait_shutdown_finish(res, &mut error);
            let result = if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = wait_shutdown_trampoline::<P>;
        unsafe {
            ffi::nm_client_wait_shutdown(
                self.to_glib_none().0,
                integrate_maincontext.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    #[cfg(feature = "v1_42")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_42")))]
    pub fn wait_shutdown_future(
        &self,
        integrate_maincontext: bool,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.wait_shutdown(integrate_maincontext, Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Determines whether WiMAX is enabled.
    ///
    /// # Deprecated since 1.22
    ///
    /// This function always returns FALSE because WiMax is no longer supported.
    ///
    /// # Returns
    ///
    /// [`true`] if WiMAX is enabled
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[allow(deprecated)]
    #[doc(alias = "nm_client_wimax_get_enabled")]
    pub fn wimax_get_enabled(&self) -> bool {
        unsafe { from_glib(ffi::nm_client_wimax_get_enabled(self.to_glib_none().0)) }
    }

    /// Determines whether the WiMAX hardware is enabled.
    ///
    /// # Deprecated since 1.22
    ///
    /// This function always returns FALSE because WiMax is no longer supported.
    ///
    /// # Returns
    ///
    /// [`true`] if the WiMAX hardware is enabled
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[allow(deprecated)]
    #[doc(alias = "nm_client_wimax_hardware_get_enabled")]
    pub fn wimax_hardware_get_enabled(&self) -> bool {
        unsafe {
            from_glib(ffi::nm_client_wimax_hardware_get_enabled(
                self.to_glib_none().0,
            ))
        }
    }

    /// Enables or disables WiMAX devices.
    ///
    /// # Deprecated since 1.22
    ///
    /// This function does nothing because WiMax is no longer supported.
    /// ## `enabled`
    /// [`true`] to enable WiMAX
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[allow(deprecated)]
    #[doc(alias = "nm_client_wimax_set_enabled")]
    pub fn wimax_set_enabled(&self, enabled: bool) {
        unsafe {
            ffi::nm_client_wimax_set_enabled(self.to_glib_none().0, enabled.into_glib());
        }
    }

    /// Determines whether the wireless is enabled.
    ///
    /// # Returns
    ///
    /// [`true`] if wireless is enabled
    #[doc(alias = "nm_client_wireless_get_enabled")]
    pub fn wireless_get_enabled(&self) -> bool {
        unsafe { from_glib(ffi::nm_client_wireless_get_enabled(self.to_glib_none().0)) }
    }

    /// Determines whether the wireless hardware is enabled.
    ///
    /// # Returns
    ///
    /// [`true`] if the wireless hardware is enabled
    #[doc(alias = "nm_client_wireless_hardware_get_enabled")]
    pub fn wireless_hardware_get_enabled(&self) -> bool {
        unsafe {
            from_glib(ffi::nm_client_wireless_hardware_get_enabled(
                self.to_glib_none().0,
            ))
        }
    }

    /// Enables or disables wireless devices.
    ///
    /// # Deprecated since 1.22
    ///
    /// Use the async command nm_client_dbus_set_property() on [`DBUS_PATH`][crate::DBUS_PATH],
    /// [`DBUS_INTERFACE`][crate::DBUS_INTERFACE] to set "WirelessEnabled" property to a "(b)" value.
    /// ## `enabled`
    /// [`true`] to enable wireless
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[allow(deprecated)]
    #[doc(alias = "nm_client_wireless_set_enabled")]
    pub fn wireless_set_enabled(&self, enabled: bool) {
        unsafe {
            ffi::nm_client_wireless_set_enabled(self.to_glib_none().0, enabled.into_glib());
        }
    }

    /// Determines whether WWAN is enabled.
    ///
    /// # Returns
    ///
    /// [`true`] if WWAN is enabled
    #[doc(alias = "nm_client_wwan_get_enabled")]
    pub fn wwan_get_enabled(&self) -> bool {
        unsafe { from_glib(ffi::nm_client_wwan_get_enabled(self.to_glib_none().0)) }
    }

    /// Determines whether the WWAN hardware is enabled.
    ///
    /// # Returns
    ///
    /// [`true`] if the WWAN hardware is enabled
    #[doc(alias = "nm_client_wwan_hardware_get_enabled")]
    pub fn wwan_hardware_get_enabled(&self) -> bool {
        unsafe {
            from_glib(ffi::nm_client_wwan_hardware_get_enabled(
                self.to_glib_none().0,
            ))
        }
    }

    /// Enables or disables WWAN devices.
    ///
    /// # Deprecated since 1.22
    ///
    /// Use the async command nm_client_dbus_set_property() on [`DBUS_PATH`][crate::DBUS_PATH],
    /// [`DBUS_INTERFACE`][crate::DBUS_INTERFACE] to set "WwanEnabled" property to a "(b)" value.
    /// ## `enabled`
    /// [`true`] to enable WWAN
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[allow(deprecated)]
    #[doc(alias = "nm_client_wwan_set_enabled")]
    pub fn wwan_set_enabled(&self, enabled: bool) {
        unsafe {
            ffi::nm_client_wwan_set_enabled(self.to_glib_none().0, enabled.into_glib());
        }
    }

    /// If [`true`], adding and modifying connections is supported.
    #[doc(alias = "can-modify")]
    pub fn can_modify(&self) -> bool {
        ObjectExt::property(self, "can-modify")
    }

    #[doc(alias = "connectivity-check-available")]
    pub fn is_connectivity_check_available(&self) -> bool {
        ObjectExt::property(self, "connectivity-check-available")
    }

    #[doc(alias = "connectivity-check-enabled")]
    pub fn is_connectivity_check_enabled(&self) -> bool {
        ObjectExt::property(self, "connectivity-check-enabled")
    }

    #[doc(alias = "connectivity-check-enabled")]
    pub fn set_connectivity_check_enabled(&self, connectivity_check_enabled: bool) {
        ObjectExt::set_property(
            self,
            "connectivity-check-enabled",
            connectivity_check_enabled,
        )
    }

    /// The used URI for connectivity checking.
    #[cfg(feature = "v1_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
    #[doc(alias = "connectivity-check-uri")]
    pub fn connectivity_check_uri(&self) -> Option<glib::GString> {
        ObjectExt::property(self, "connectivity-check-uri")
    }

    /// The machine hostname stored in persistent configuration. This can be
    /// modified by calling nm_client_save_hostname().
    pub fn hostname(&self) -> Option<glib::GString> {
        ObjectExt::property(self, "hostname")
    }

    /// #NMClientInstanceFlags for the instance. These affect behavior of #NMClient.
    /// This is a construct property and you may only set most flags only during
    /// construction.
    ///
    /// The flag [`ClientInstanceFlags::NO_AUTO_FETCH_PERMISSIONS`][crate::ClientInstanceFlags::NO_AUTO_FETCH_PERMISSIONS] can be toggled any time,
    /// even after constructing the instance. Note that you may want to watch NMClient:permissions-state
    /// property to know whether permissions are ready. Note that permissions are only fetched
    /// when NMClient has a D-Bus name owner.
    ///
    /// The flags [`ClientInstanceFlags::INITIALIZED_GOOD`][crate::ClientInstanceFlags::INITIALIZED_GOOD] and [`ClientInstanceFlags::INITIALIZED_BAD`][crate::ClientInstanceFlags::INITIALIZED_BAD]
    /// cannot be set, however they will be returned by the getter after initialization completes.
    #[cfg(feature = "v1_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
    #[doc(alias = "instance-flags")]
    pub fn set_instance_flags(&self, instance_flags: u32) {
        ObjectExt::set_property(self, "instance-flags", instance_flags)
    }

    #[cfg(not(feature = "v1_22"))]
    #[cfg_attr(docsrs, doc(cfg(not(feature = "v1_22"))))]
    pub fn metered(&self) -> u32 {
        ObjectExt::property(self, "metered")
    }

    /// Whether networking is enabled.
    ///
    /// The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
    #[doc(alias = "networking-enabled")]
    pub fn is_networking_enabled(&self) -> bool {
        ObjectExt::property(self, "networking-enabled")
    }

    /// Whether networking is enabled.
    ///
    /// The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
    #[doc(alias = "networking-enabled")]
    pub fn set_networking_enabled(&self, networking_enabled: bool) {
        ObjectExt::set_property(self, "networking-enabled", networking_enabled)
    }

    /// Whether WiMAX functionality is enabled.
    ///
    /// # Deprecated since 1.22
    ///
    /// WiMAX is no longer supported and this always returns FALSE. The setter has no effect.
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[doc(alias = "wimax-enabled")]
    pub fn is_wimax_enabled(&self) -> bool {
        ObjectExt::property(self, "wimax-enabled")
    }

    /// Whether WiMAX functionality is enabled.
    ///
    /// # Deprecated since 1.22
    ///
    /// WiMAX is no longer supported and this always returns FALSE. The setter has no effect.
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[doc(alias = "wimax-enabled")]
    pub fn set_wimax_enabled(&self, wimax_enabled: bool) {
        ObjectExt::set_property(self, "wimax-enabled", wimax_enabled)
    }

    /// Whether the WiMAX hardware is enabled.
    ///
    /// # Deprecated since 1.22
    ///
    /// WiMAX is no longer supported and this always returns FALSE.
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[doc(alias = "wimax-hardware-enabled")]
    pub fn is_wimax_hardware_enabled(&self) -> bool {
        ObjectExt::property(self, "wimax-hardware-enabled")
    }

    /// Whether wireless is enabled.
    ///
    /// The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
    #[doc(alias = "wireless-enabled")]
    pub fn is_wireless_enabled(&self) -> bool {
        ObjectExt::property(self, "wireless-enabled")
    }

    /// Whether wireless is enabled.
    ///
    /// The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
    #[doc(alias = "wireless-enabled")]
    pub fn set_wireless_enabled(&self, wireless_enabled: bool) {
        ObjectExt::set_property(self, "wireless-enabled", wireless_enabled)
    }

    /// Whether the wireless hardware is enabled.
    #[doc(alias = "wireless-hardware-enabled")]
    pub fn is_wireless_hardware_enabled(&self) -> bool {
        ObjectExt::property(self, "wireless-hardware-enabled")
    }

    /// Whether WWAN functionality is enabled.
    ///
    /// The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
    #[doc(alias = "wwan-enabled")]
    pub fn is_wwan_enabled(&self) -> bool {
        ObjectExt::property(self, "wwan-enabled")
    }

    /// Whether WWAN functionality is enabled.
    ///
    /// The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
    #[doc(alias = "wwan-enabled")]
    pub fn set_wwan_enabled(&self, wwan_enabled: bool) {
        ObjectExt::set_property(self, "wwan-enabled", wwan_enabled)
    }

    /// Whether the WWAN hardware is enabled.
    #[doc(alias = "wwan-hardware-enabled")]
    pub fn is_wwan_hardware_enabled(&self) -> bool {
        ObjectExt::property(self, "wwan-hardware-enabled")
    }

    /// Creates a new #NMClient asynchronously.
    /// @callback will be called when it is done. Use
    /// nm_client_new_finish() to get the result.
    ///
    /// This does nothing beside calling g_async_initable_new_async(). You are free to
    /// call g_async_initable_new_async() or g_object_new()/g_async_initable_init_async()
    /// directly for more control, to set GObject properties or get access to the NMClient
    /// instance while it is still initializing.
    ///
    /// Creating an #NMClient instance can only fail for two reasons. First, if you didn't
    /// provide a [`CLIENT_DBUS_CONNECTION`][crate::CLIENT_DBUS_CONNECTION] and the call to g_bus_get()
    /// fails. You can avoid that by using g_async_initable_new_async() directly and
    /// set a D-Bus connection.
    /// Second, if you cancelled the creation. If you do that, then note
    /// that after the failure there might still be idle actions pending
    /// which keep nm_client_get_main_context() alive. That means,
    /// in that case you must continue iterating the context to avoid
    /// leaks. See nm_client_get_context_busy_watcher().
    ///
    /// Creating an #NMClient instance when NetworkManager is not running
    /// does not cause a failure.
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to call when the client is created
    #[doc(alias = "nm_client_new_async")]
    pub fn new_async<P: FnOnce(Result<Client, glib::Error>) + 'static>(
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        assert_initialized_main_thread!();

        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn new_async_trampoline<
            P: FnOnce(Result<Client, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            let ret = ffi::nm_client_new_finish(res, &mut error);
            let result = if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = new_async_trampoline::<P>;
        unsafe {
            ffi::nm_client_new_async(
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn new_future()
    -> Pin<Box_<dyn std::future::Future<Output = Result<Client, glib::Error>> + 'static>> {
        skip_assert_initialized!();
        Box_::pin(gio::GioFuture::new(&(), move |_obj, cancellable, send| {
            Self::new_async(Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Notifies that a #NMActiveConnection has been added.
    /// ## `active_connection`
    /// the new active connection
    #[doc(alias = "active-connection-added")]
    pub fn connect_active_connection_added<F: Fn(&Self, &ActiveConnection) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn active_connection_added_trampoline<
            F: Fn(&Client, &ActiveConnection) + 'static,
        >(
            this: *mut ffi::NMClient,
            active_connection: *mut ffi::NMActiveConnection,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                &from_glib_borrow(this),
                &from_glib_borrow(active_connection),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"active-connection-added".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    active_connection_added_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Notifies that a #NMActiveConnection has been removed.
    /// ## `active_connection`
    /// the removed active connection
    #[doc(alias = "active-connection-removed")]
    pub fn connect_active_connection_removed<F: Fn(&Self, &ActiveConnection) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn active_connection_removed_trampoline<
            F: Fn(&Client, &ActiveConnection) + 'static,
        >(
            this: *mut ffi::NMClient,
            active_connection: *mut ffi::NMActiveConnection,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                &from_glib_borrow(this),
                &from_glib_borrow(active_connection),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"active-connection-removed".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    active_connection_removed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Notifies that a #NMDevice is added.  This signal is emitted for both
    /// regular devices and placeholder devices.
    /// ## `device`
    /// the new device
    #[doc(alias = "any-device-added")]
    pub fn connect_any_device_added<F: Fn(&Self, &Device) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn any_device_added_trampoline<F: Fn(&Client, &Device) + 'static>(
            this: *mut ffi::NMClient,
            device: *mut ffi::NMDevice,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(device))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"any-device-added".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    any_device_added_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Notifies that a #NMDevice is removed.  This signal is emitted for both
    /// regular devices and placeholder devices.
    /// ## `device`
    /// the removed device
    #[doc(alias = "any-device-removed")]
    pub fn connect_any_device_removed<F: Fn(&Self, &Device) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn any_device_removed_trampoline<F: Fn(&Client, &Device) + 'static>(
            this: *mut ffi::NMClient,
            device: *mut ffi::NMDevice,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(device))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"any-device-removed".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    any_device_removed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Notifies that a #NMConnection has been added.
    /// ## `connection`
    /// the new connection
    #[doc(alias = "connection-added")]
    pub fn connect_connection_added<F: Fn(&Self, &RemoteConnection) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn connection_added_trampoline<
            F: Fn(&Client, &RemoteConnection) + 'static,
        >(
            this: *mut ffi::NMClient,
            connection: *mut ffi::NMRemoteConnection,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(connection))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"connection-added".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    connection_added_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Notifies that a #NMConnection has been removed.
    /// ## `connection`
    /// the removed connection
    #[doc(alias = "connection-removed")]
    pub fn connect_connection_removed<F: Fn(&Self, &RemoteConnection) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn connection_removed_trampoline<
            F: Fn(&Client, &RemoteConnection) + 'static,
        >(
            this: *mut ffi::NMClient,
            connection: *mut ffi::NMRemoteConnection,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(connection))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"connection-removed".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    connection_removed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Notifies that a #NMDevice is added.  This signal is not emitted for
    /// placeholder devices.
    /// ## `device`
    /// the new device
    #[doc(alias = "device-added")]
    pub fn connect_device_added<F: Fn(&Self, &Device) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn device_added_trampoline<F: Fn(&Client, &Device) + 'static>(
            this: *mut ffi::NMClient,
            device: *mut ffi::NMDevice,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(device))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"device-added".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    device_added_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Notifies that a #NMDevice is removed.  This signal is not emitted for
    /// placeholder devices.
    /// ## `device`
    /// the removed device
    #[doc(alias = "device-removed")]
    pub fn connect_device_removed<F: Fn(&Self, &Device) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn device_removed_trampoline<F: Fn(&Client, &Device) + 'static>(
            this: *mut ffi::NMClient,
            device: *mut ffi::NMDevice,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(device))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"device-removed".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    device_removed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Notifies that a permission has changed
    /// ## `permission`
    /// a permission from #NMClientPermission
    /// ## `result`
    /// the permission's result, one of #NMClientPermissionResult
    #[doc(alias = "permission-changed")]
    pub fn connect_permission_changed<F: Fn(&Self, u32, u32) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn permission_changed_trampoline<F: Fn(&Client, u32, u32) + 'static>(
            this: *mut ffi::NMClient,
            permission: std::ffi::c_uint,
            result: std::ffi::c_uint,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), permission, result)
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"permission-changed".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    permission_changed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "activating-connection")]
    pub fn connect_activating_connection_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_activating_connection_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::activating-connection".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_activating_connection_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "active-connections")]
    pub fn connect_active_connections_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_active_connections_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::active-connections".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_active_connections_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "all-devices")]
    pub fn connect_all_devices_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_all_devices_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::all-devices".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_all_devices_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "can-modify")]
    pub fn connect_can_modify_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_can_modify_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::can-modify".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_can_modify_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
    #[doc(alias = "capabilities")]
    pub fn connect_capabilities_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_capabilities_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::capabilities".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_capabilities_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    #[doc(alias = "checkpoints")]
    pub fn connect_checkpoints_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_checkpoints_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::checkpoints".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_checkpoints_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "connections")]
    pub fn connect_connections_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_connections_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::connections".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_connections_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "connectivity")]
    pub fn connect_connectivity_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_connectivity_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::connectivity".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_connectivity_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "connectivity-check-available")]
    pub fn connect_connectivity_check_available_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_connectivity_check_available_trampoline<
            F: Fn(&Client) + 'static,
        >(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::connectivity-check-available".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_connectivity_check_available_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "connectivity-check-enabled")]
    pub fn connect_connectivity_check_enabled_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_connectivity_check_enabled_trampoline<
            F: Fn(&Client) + 'static,
        >(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::connectivity-check-enabled".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_connectivity_check_enabled_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
    #[doc(alias = "connectivity-check-uri")]
    pub fn connect_connectivity_check_uri_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_connectivity_check_uri_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::connectivity-check-uri".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_connectivity_check_uri_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
    #[doc(alias = "dbus-name-owner")]
    pub fn connect_dbus_name_owner_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_dbus_name_owner_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::dbus-name-owner".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_dbus_name_owner_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "devices")]
    pub fn connect_devices_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_devices_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::devices".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_devices_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    #[doc(alias = "dns-configuration")]
    pub fn connect_dns_configuration_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_dns_configuration_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::dns-configuration".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_dns_configuration_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    #[doc(alias = "dns-mode")]
    pub fn connect_dns_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_dns_mode_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::dns-mode".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_dns_mode_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    #[doc(alias = "dns-rc-manager")]
    pub fn connect_dns_rc_manager_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_dns_rc_manager_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::dns-rc-manager".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_dns_rc_manager_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "hostname")]
    pub fn connect_hostname_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_hostname_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::hostname".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_hostname_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
    #[doc(alias = "instance-flags")]
    pub fn connect_instance_flags_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_instance_flags_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::instance-flags".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_instance_flags_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "metered")]
    pub fn connect_metered_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_metered_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::metered".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_metered_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "networking-enabled")]
    pub fn connect_networking_enabled_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_networking_enabled_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::networking-enabled".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_networking_enabled_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "nm-running")]
    pub fn connect_nm_running_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_nm_running_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::nm-running".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_nm_running_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
    #[doc(alias = "permissions-state")]
    pub fn connect_permissions_state_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_permissions_state_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::permissions-state".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_permissions_state_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "primary-connection")]
    pub fn connect_primary_connection_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_primary_connection_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::primary-connection".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_primary_connection_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_38")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_38")))]
    #[doc(alias = "radio-flags")]
    pub fn connect_radio_flags_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_radio_flags_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::radio-flags".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_radio_flags_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "startup")]
    pub fn connect_startup_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_startup_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::startup".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_startup_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "state")]
    pub fn connect_state_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_state_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::state".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_state_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "version")]
    pub fn connect_version_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_version_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::version".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_version_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_42")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_42")))]
    #[doc(alias = "version-info")]
    pub fn connect_version_info_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_version_info_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::version-info".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_version_info_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[doc(alias = "wimax-enabled")]
    pub fn connect_wimax_enabled_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_wimax_enabled_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::wimax-enabled".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_wimax_enabled_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[doc(alias = "wimax-hardware-enabled")]
    pub fn connect_wimax_hardware_enabled_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_wimax_hardware_enabled_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::wimax-hardware-enabled".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_wimax_hardware_enabled_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "wireless-enabled")]
    pub fn connect_wireless_enabled_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_wireless_enabled_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::wireless-enabled".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_wireless_enabled_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "wireless-hardware-enabled")]
    pub fn connect_wireless_hardware_enabled_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_wireless_hardware_enabled_trampoline<
            F: Fn(&Client) + 'static,
        >(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::wireless-hardware-enabled".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_wireless_hardware_enabled_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "wwan-enabled")]
    pub fn connect_wwan_enabled_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_wwan_enabled_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::wwan-enabled".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_wwan_enabled_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "wwan-hardware-enabled")]
    pub fn connect_wwan_hardware_enabled_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_wwan_hardware_enabled_trampoline<F: Fn(&Client) + 'static>(
            this: *mut ffi::NMClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::wwan-hardware-enabled".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_wwan_hardware_enabled_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl Default for Client {
    fn default() -> Self {
        glib::object::Object::new::<Self>()
    }
}

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`Client`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct ClientBuilder {
    builder: glib::object::ObjectBuilder<'static, Client>,
}

impl ClientBuilder {
    fn new() -> Self {
        Self {
            builder: glib::object::Object::builder(),
        }
    }

    pub fn connectivity_check_enabled(self, connectivity_check_enabled: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("connectivity-check-enabled", connectivity_check_enabled),
        }
    }

    //    #[cfg(feature = "v1_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
    //pub fn dbus_connection(self, dbus_connection: /*Ignored*/&gio::DBusConnection) -> Self {
    //    Self { builder: self.builder.property("dbus-connection", dbus_connection), }
    //}
    /// #NMClientInstanceFlags for the instance. These affect behavior of #NMClient.
    /// This is a construct property and you may only set most flags only during
    /// construction.
    ///
    /// The flag [`ClientInstanceFlags::NO_AUTO_FETCH_PERMISSIONS`][crate::ClientInstanceFlags::NO_AUTO_FETCH_PERMISSIONS] can be toggled any time,
    /// even after constructing the instance. Note that you may want to watch NMClient:permissions-state
    /// property to know whether permissions are ready. Note that permissions are only fetched
    /// when NMClient has a D-Bus name owner.
    ///
    /// The flags [`ClientInstanceFlags::INITIALIZED_GOOD`][crate::ClientInstanceFlags::INITIALIZED_GOOD] and [`ClientInstanceFlags::INITIALIZED_BAD`][crate::ClientInstanceFlags::INITIALIZED_BAD]
    /// cannot be set, however they will be returned by the getter after initialization completes.
    #[cfg(feature = "v1_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
    pub fn instance_flags(self, instance_flags: u32) -> Self {
        Self {
            builder: self.builder.property("instance-flags", instance_flags),
        }
    }

    /// Whether networking is enabled.
    ///
    /// The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
    pub fn networking_enabled(self, networking_enabled: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("networking-enabled", networking_enabled),
        }
    }

    /// Whether WiMAX functionality is enabled.
    /// WiMAX is no longer supported and this always returns FALSE. The setter has no effect.
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    pub fn wimax_enabled(self, wimax_enabled: bool) -> Self {
        Self {
            builder: self.builder.property("wimax-enabled", wimax_enabled),
        }
    }

    /// Whether wireless is enabled.
    ///
    /// The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
    pub fn wireless_enabled(self, wireless_enabled: bool) -> Self {
        Self {
            builder: self.builder.property("wireless-enabled", wireless_enabled),
        }
    }

    /// Whether WWAN functionality is enabled.
    ///
    /// The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
    pub fn wwan_enabled(self, wwan_enabled: bool) -> Self {
        Self {
            builder: self.builder.property("wwan-enabled", wwan_enabled),
        }
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`Client`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> Client {
        assert_initialized_main_thread!();
        self.builder.build()
    }
}