nma4_sys/

lib.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from ../girs
// from ../gtk-girs
// DO NOT EDIT

#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(
    clippy::approx_constant,
    clippy::type_complexity,
    clippy::unreadable_literal,
    clippy::upper_case_acronyms
)]
#![cfg_attr(docsrs, feature(doc_cfg))]

use gio_sys as gio;
use glib_sys as glib;

#[cfg(unix)]
#[allow(unused_imports)]
use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
#[allow(unused_imports)]
use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
#[allow(unused_imports)]
use std::ffi::{
    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
};

#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};

// Enums
pub type NMACertChooserFlags = c_int;
pub const NMA_CERT_CHOOSER_FLAG_NONE: NMACertChooserFlags = 0;
pub const NMA_CERT_CHOOSER_FLAG_CERT: NMACertChooserFlags = 1;
pub const NMA_CERT_CHOOSER_FLAG_PASSWORDS: NMACertChooserFlags = 2;
pub const NMA_CERT_CHOOSER_FLAG_PEM: NMACertChooserFlags = 4;
pub const NMA_CERT_CHOOSER_FLAG_NO_PASSWORDS: NMACertChooserFlags = 8;

pub type NMAMobileFamily = c_int;
pub const NMA_MOBILE_FAMILY_UNKNOWN: NMAMobileFamily = 0;
pub const NMA_MOBILE_FAMILY_3GPP: NMAMobileFamily = 1;
pub const NMA_MOBILE_FAMILY_CDMA: NMAMobileFamily = 2;

// Constants
pub const NMA_BAR_CODE_SIZE: &[u8] = b"size\0";
pub const NMA_BAR_CODE_TEXT: &[u8] = b"text\0";
pub const NMA_BAR_CODE_WIDGET_CONNECTION: &[u8] = b"connection\0";
pub const NMA_MAJOR_VERSION: c_int = 1;
pub const NMA_MICRO_VERSION: c_int = 6;
pub const NMA_MINOR_VERSION: c_int = 10;

// Callbacks
pub type NMAMobileWizardCallback = Option<
    unsafe extern "C" fn(
        *mut NMAMobileWizard,
        gboolean,
        *mut NMAMobileWizardAccessMethod,
        gpointer,
    ),
>;

// Records
#[repr(C)]
#[allow(dead_code)]
pub struct _NMABarCodeClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMABarCodeClass = _NMABarCodeClass;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMABarCodeWidgetClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMABarCodeWidgetClass = _NMABarCodeWidgetClass;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMACertChooserClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMACertChooserClass = _NMACertChooserClass;

#[repr(C)]
#[allow(dead_code)]
pub struct NMACountryInfo {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for NMACountryInfo {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("NMACountryInfo @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct NMAMobileAccessMethod {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for NMAMobileAccessMethod {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("NMAMobileAccessMethod @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct NMAMobileProvider {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for NMAMobileProvider {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("NMAMobileProvider @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct NMAMobileProvidersDatabaseClass {
    pub parent: gobject::GObjectClass,
}

impl ::std::fmt::Debug for NMAMobileProvidersDatabaseClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("NMAMobileProvidersDatabaseClass @ {self:p}"))
            .field("parent", &self.parent)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAMobileProvidersDatabasePrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAMobileProvidersDatabasePrivate = _NMAMobileProvidersDatabasePrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct NMAMobileWizardAccessMethod {
    pub provider_name: *mut c_char,
    pub plan_name: *mut c_char,
    pub devtype: nm::NMDeviceModemCapabilities,
    pub username: *mut c_char,
    pub password: *mut c_char,
    pub gsm_apn: *mut c_char,
}

impl ::std::fmt::Debug for NMAMobileWizardAccessMethod {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("NMAMobileWizardAccessMethod @ {self:p}"))
            .field("provider_name", &self.provider_name)
            .field("plan_name", &self.plan_name)
            .field("devtype", &self.devtype)
            .field("username", &self.username)
            .field("password", &self.password)
            .field("gsm_apn", &self.gsm_apn)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAMobileWizardClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAMobileWizardClass = _NMAMobileWizardClass;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct NMAVpnPasswordDialogClass {
    pub parent_class: gtk::GtkDialogClass,
}

impl ::std::fmt::Debug for NMAVpnPasswordDialogClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("NMAVpnPasswordDialogClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct NMAWifiDialogClass {
    pub parent: gtk::GtkDialogClass,
}

impl ::std::fmt::Debug for NMAWifiDialogClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("NMAWifiDialogClass @ {self:p}"))
            .field("parent", &self.parent)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWs {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWs = _NMAWs;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWs8021x {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWs8021x = _NMAWs8021x;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWs8021xClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWs8021xClass = _NMAWs8021xClass;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWsDynamicWep {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWsDynamicWep = _NMAWsDynamicWep;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWsDynamicWepClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWsDynamicWepClass = _NMAWsDynamicWepClass;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWsInterface {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWsInterface = _NMAWsInterface;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWsLeap {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWsLeap = _NMAWsLeap;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWsLeapClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWsLeapClass = _NMAWsLeapClass;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWsOwe {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWsOwe = _NMAWsOwe;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWsOweClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWsOweClass = _NMAWsOweClass;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWsSae {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWsSae = _NMAWsSae;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWsSaeClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWsSaeClass = _NMAWsSaeClass;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWsWepKey {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWsWepKey = _NMAWsWepKey;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWsWepKeyClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWsWepKeyClass = _NMAWsWepKeyClass;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWsWpaEap {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWsWpaEap = _NMAWsWpaEap;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWsWpaEapClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWsWpaEapClass = _NMAWsWpaEapClass;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWsWpaPsk {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWsWpaPsk = _NMAWsWpaPsk;

#[repr(C)]
#[allow(dead_code)]
pub struct _NMAWsWpaPskClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type NMAWsWpaPskClass = _NMAWsWpaPskClass;

// Classes
#[repr(C)]
#[allow(dead_code)]
pub struct NMABarCode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for NMABarCode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("NMABarCode @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct NMABarCodeWidget {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for NMABarCodeWidget {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("NMABarCodeWidget @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct NMACertChooser {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for NMACertChooser {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("NMACertChooser @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct NMAMobileProvidersDatabase {
    pub parent: gobject::GObject,
    pub priv_: *mut NMAMobileProvidersDatabasePrivate,
}

impl ::std::fmt::Debug for NMAMobileProvidersDatabase {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("NMAMobileProvidersDatabase @ {self:p}"))
            .field("parent", &self.parent)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct NMAMobileWizard {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for NMAMobileWizard {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("NMAMobileWizard @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct NMAVpnPasswordDialog {
    pub parent: gtk::GtkDialog,
}

impl ::std::fmt::Debug for NMAVpnPasswordDialog {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("NMAVpnPasswordDialog @ {self:p}"))
            .field("parent", &self.parent)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct NMAWifiDialog {
    pub parent: gtk::GtkDialog,
}

impl ::std::fmt::Debug for NMAWifiDialog {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("NMAWifiDialog @ {self:p}"))
            .field("parent", &self.parent)
            .finish()
    }
}

extern "C" {

    //=========================================================================
    // NMACountryInfo
    //=========================================================================
    pub fn nma_country_info_get_type() -> GType;
    pub fn nma_country_info_get_country_code(country_info: *mut NMACountryInfo) -> *const c_char;
    pub fn nma_country_info_get_country_name(country_info: *mut NMACountryInfo) -> *const c_char;
    pub fn nma_country_info_get_providers(country_info: *mut NMACountryInfo) -> *mut glib::GSList;
    pub fn nma_country_info_ref(country_info: *mut NMACountryInfo) -> *mut NMACountryInfo;
    pub fn nma_country_info_unref(country_info: *mut NMACountryInfo);

    //=========================================================================
    // NMAMobileAccessMethod
    //=========================================================================
    pub fn nma_mobile_access_method_get_type() -> GType;
    pub fn nma_mobile_access_method_get_3gpp_apn(
        method: *mut NMAMobileAccessMethod,
    ) -> *const c_char;
    pub fn nma_mobile_access_method_get_dns(
        method: *mut NMAMobileAccessMethod,
    ) -> *mut *const c_char;
    pub fn nma_mobile_access_method_get_family(
        method: *mut NMAMobileAccessMethod,
    ) -> NMAMobileFamily;
    pub fn nma_mobile_access_method_get_gateway(
        method: *mut NMAMobileAccessMethod,
    ) -> *const c_char;
    pub fn nma_mobile_access_method_get_name(method: *mut NMAMobileAccessMethod) -> *const c_char;
    pub fn nma_mobile_access_method_get_password(
        method: *mut NMAMobileAccessMethod,
    ) -> *const c_char;
    pub fn nma_mobile_access_method_get_username(
        method: *mut NMAMobileAccessMethod,
    ) -> *const c_char;
    pub fn nma_mobile_access_method_ref(
        method: *mut NMAMobileAccessMethod,
    ) -> *mut NMAMobileAccessMethod;
    pub fn nma_mobile_access_method_unref(method: *mut NMAMobileAccessMethod);

    //=========================================================================
    // NMAMobileProvider
    //=========================================================================
    pub fn nma_mobile_provider_get_type() -> GType;
    pub fn nma_mobile_provider_get_3gpp_mcc_mnc(
        provider: *mut NMAMobileProvider,
    ) -> *mut *const c_char;
    pub fn nma_mobile_provider_get_cdma_sid(provider: *mut NMAMobileProvider) -> *const u32;
    pub fn nma_mobile_provider_get_methods(provider: *mut NMAMobileProvider) -> *mut glib::GSList;
    pub fn nma_mobile_provider_get_name(provider: *mut NMAMobileProvider) -> *const c_char;
    pub fn nma_mobile_provider_ref(provider: *mut NMAMobileProvider) -> *mut NMAMobileProvider;
    pub fn nma_mobile_provider_unref(provider: *mut NMAMobileProvider);

    //=========================================================================
    // NMAWs
    //=========================================================================
    pub fn nma_ws_adhoc_compatible(self_: *mut NMAWs) -> gboolean;
    pub fn nma_ws_hotspot_compatible(self_: *mut NMAWs) -> gboolean;
    pub fn nma_ws_validate(self_: *mut NMAWs, error: *mut *mut glib::GError) -> gboolean;

    //=========================================================================
    // NMABarCode
    //=========================================================================
    pub fn nma_bar_code_get_type() -> GType;
    #[cfg(feature = "v1_8_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8_22")))]
    pub fn nma_bar_code_new(text: *const c_char) -> *mut NMABarCode;
    #[cfg(feature = "v1_8_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8_22")))]
    pub fn nma_bar_code_draw(self_: *mut NMABarCode, cr: *mut cairo::cairo_t);
    #[cfg(feature = "v1_8_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8_22")))]
    pub fn nma_bar_code_get_size(self_: *mut NMABarCode) -> c_int;
    #[cfg(feature = "v1_8_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8_22")))]
    pub fn nma_bar_code_set_text(self_: *mut NMABarCode, text: *const c_char);

    //=========================================================================
    // NMABarCodeWidget
    //=========================================================================
    pub fn nma_bar_code_widget_get_type() -> GType;

    //=========================================================================
    // NMACertChooser
    //=========================================================================
    pub fn nma_cert_chooser_get_type() -> GType;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_new(
        title: *const c_char,
        flags: NMACertChooserFlags,
    ) -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_add_to_size_group(
        cert_chooser: *mut NMACertChooser,
        group: *mut gtk::GtkSizeGroup,
    );
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_get_cert(
        cert_chooser: *mut NMACertChooser,
        scheme: *mut nm::NMSetting8021xCKScheme,
    ) -> *mut c_char;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_get_cert_password(cert_chooser: *mut NMACertChooser) -> *const c_char;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_get_cert_password_flags(
        cert_chooser: *mut NMACertChooser,
    ) -> nm::NMSettingSecretFlags;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_get_cert_uri(cert_chooser: *mut NMACertChooser) -> *mut c_char;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_get_key(
        cert_chooser: *mut NMACertChooser,
        scheme: *mut nm::NMSetting8021xCKScheme,
    ) -> *mut c_char;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_get_key_password(cert_chooser: *mut NMACertChooser) -> *const c_char;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_get_key_password_flags(
        cert_chooser: *mut NMACertChooser,
    ) -> nm::NMSettingSecretFlags;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_get_key_uri(cert_chooser: *mut NMACertChooser) -> *mut c_char;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_set_cert(
        cert_chooser: *mut NMACertChooser,
        value: *const c_char,
        scheme: nm::NMSetting8021xCKScheme,
    );
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_set_cert_password(
        cert_chooser: *mut NMACertChooser,
        password: *const c_char,
    );
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_set_cert_uri(cert_chooser: *mut NMACertChooser, uri: *const c_char);
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_set_key(
        cert_chooser: *mut NMACertChooser,
        value: *const c_char,
        scheme: nm::NMSetting8021xCKScheme,
    );
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_set_key_password(
        cert_chooser: *mut NMACertChooser,
        password: *const c_char,
    );
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_set_key_uri(cert_chooser: *mut NMACertChooser, uri: *const c_char);
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_setup_cert_password_storage(
        cert_chooser: *mut NMACertChooser,
        initial_flags: nm::NMSettingSecretFlags,
        setting: *mut nm::NMSetting,
        password_flags_name: *const c_char,
        with_not_required: gboolean,
        ask_mode: gboolean,
    );
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_setup_key_password_storage(
        cert_chooser: *mut NMACertChooser,
        initial_flags: nm::NMSettingSecretFlags,
        setting: *mut nm::NMSetting,
        password_flags_name: *const c_char,
        with_not_required: gboolean,
        ask_mode: gboolean,
    );
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_update_cert_password_storage(
        cert_chooser: *mut NMACertChooser,
        secret_flags: nm::NMSettingSecretFlags,
        setting: *mut nm::NMSetting,
        password_flags_name: *const c_char,
    );
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_update_key_password_storage(
        cert_chooser: *mut NMACertChooser,
        secret_flags: nm::NMSettingSecretFlags,
        setting: *mut nm::NMSetting,
        password_flags_name: *const c_char,
    );
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn nma_cert_chooser_validate(
        cert_chooser: *mut NMACertChooser,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // NMAMobileProvidersDatabase
    //=========================================================================
    pub fn nma_mobile_providers_database_get_type() -> GType;
    pub fn nma_mobile_providers_database_new_finish(
        res: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> *mut NMAMobileProvidersDatabase;
    pub fn nma_mobile_providers_database_new_sync(
        country_codes: *const c_char,
        service_providers: *const c_char,
        cancellable: *mut gio::GCancellable,
        error: *mut *mut glib::GError,
    ) -> *mut NMAMobileProvidersDatabase;
    pub fn nma_mobile_providers_database_new(
        country_codes: *const c_char,
        service_providers: *const c_char,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn nma_mobile_providers_database_dump(self_: *mut NMAMobileProvidersDatabase);
    pub fn nma_mobile_providers_database_get_countries(
        self_: *mut NMAMobileProvidersDatabase,
    ) -> *mut glib::GHashTable;
    pub fn nma_mobile_providers_database_lookup_3gpp_mcc_mnc(
        self_: *mut NMAMobileProvidersDatabase,
        mccmnc: *const c_char,
    ) -> *mut NMAMobileProvider;
    pub fn nma_mobile_providers_database_lookup_cdma_sid(
        self_: *mut NMAMobileProvidersDatabase,
        sid: u32,
    ) -> *mut NMAMobileProvider;
    pub fn nma_mobile_providers_database_lookup_country(
        self_: *mut NMAMobileProvidersDatabase,
        country_code: *const c_char,
    ) -> *mut NMACountryInfo;

    //=========================================================================
    // NMAMobileWizard
    //=========================================================================
    pub fn nma_mobile_wizard_get_type() -> GType;
    pub fn nma_mobile_wizard_new(
        parent: *mut gtk::GtkWindow,
        window_group: *mut gtk::GtkWindowGroup,
        modem_caps: nm::NMDeviceModemCapabilities,
        will_connect_after: gboolean,
        cb: NMAMobileWizardCallback,
        user_data: gpointer,
    ) -> *mut NMAMobileWizard;
    pub fn nma_mobile_wizard_destroy(self_: *mut NMAMobileWizard);
    pub fn nma_mobile_wizard_present(wizard: *mut NMAMobileWizard);

    //=========================================================================
    // NMAVpnPasswordDialog
    //=========================================================================
    pub fn nma_vpn_password_dialog_get_type() -> GType;
    pub fn nma_vpn_password_dialog_new(
        title: *const c_char,
        message: *const c_char,
        password: *const c_char,
    ) -> *mut gtk::GtkWidget;
    pub fn nma_vpn_password_dialog_focus_password(dialog: *mut NMAVpnPasswordDialog);
    pub fn nma_vpn_password_dialog_focus_password_secondary(dialog: *mut NMAVpnPasswordDialog);
    pub fn nma_vpn_password_dialog_focus_password_ternary(dialog: *mut NMAVpnPasswordDialog);
    pub fn nma_vpn_password_dialog_get_password(dialog: *mut NMAVpnPasswordDialog)
        -> *const c_char;
    pub fn nma_vpn_password_dialog_get_password_secondary(
        dialog: *mut NMAVpnPasswordDialog,
    ) -> *const c_char;
    pub fn nma_vpn_password_dialog_get_password_ternary(
        dialog: *mut NMAVpnPasswordDialog,
    ) -> *const c_char;
    pub fn nma_vpn_password_dialog_run_and_block(dialog: *mut NMAVpnPasswordDialog) -> gboolean;
    pub fn nma_vpn_password_dialog_set_password(
        dialog: *mut NMAVpnPasswordDialog,
        password: *const c_char,
    );
    pub fn nma_vpn_password_dialog_set_password_label(
        dialog: *mut NMAVpnPasswordDialog,
        label: *const c_char,
    );
    pub fn nma_vpn_password_dialog_set_password_secondary(
        dialog: *mut NMAVpnPasswordDialog,
        password_secondary: *const c_char,
    );
    pub fn nma_vpn_password_dialog_set_password_secondary_label(
        dialog: *mut NMAVpnPasswordDialog,
        label: *const c_char,
    );
    pub fn nma_vpn_password_dialog_set_password_ternary(
        dialog: *mut NMAVpnPasswordDialog,
        password_ternary: *const c_char,
    );
    pub fn nma_vpn_password_dialog_set_password_ternary_label(
        dialog: *mut NMAVpnPasswordDialog,
        label: *const c_char,
    );
    pub fn nma_vpn_password_dialog_set_show_password(
        dialog: *mut NMAVpnPasswordDialog,
        show: gboolean,
    );
    pub fn nma_vpn_password_dialog_set_show_password_secondary(
        dialog: *mut NMAVpnPasswordDialog,
        show: gboolean,
    );
    pub fn nma_vpn_password_dialog_set_show_password_ternary(
        dialog: *mut NMAVpnPasswordDialog,
        show: gboolean,
    );

    //=========================================================================
    // NMAWifiDialog
    //=========================================================================
    pub fn nma_wifi_dialog_get_type() -> GType;
    pub fn nma_wifi_dialog_new(
        client: *mut nm::NMClient,
        connection: *mut nm::NMConnection,
        device: *mut nm::NMDevice,
        ap: *mut nm::NMAccessPoint,
        secrets_only: gboolean,
    ) -> *mut gtk::GtkWidget;
    pub fn nma_wifi_dialog_new_for_create(client: *mut nm::NMClient) -> *mut gtk::GtkWidget;
    pub fn nma_wifi_dialog_new_for_hidden(client: *mut nm::NMClient) -> *mut gtk::GtkWidget;
    pub fn nma_wifi_dialog_new_for_other(client: *mut nm::NMClient) -> *mut gtk::GtkWidget;
    pub fn nma_wifi_dialog_new_for_secrets(
        client: *mut nm::NMClient,
        connection: *mut nm::NMConnection,
        secrets_setting_name: *const c_char,
        secrets_hints: *const *const c_char,
    ) -> *mut gtk::GtkWidget;
    pub fn nma_wifi_dialog_get_connection(
        self_: *mut NMAWifiDialog,
        device: *mut *mut nm::NMDevice,
        ap: *mut *mut nm::NMAccessPoint,
    ) -> *mut nm::NMConnection;
    pub fn nma_wifi_dialog_get_nag_ignored(self_: *mut NMAWifiDialog) -> gboolean;
    pub fn nma_wifi_dialog_nag_user(self_: *mut NMAWifiDialog) -> *mut gtk::GtkWidget;
    pub fn nma_wifi_dialog_set_nag_ignored(self_: *mut NMAWifiDialog, ignored: gboolean);

    //=========================================================================
    // Other functions
    //=========================================================================
    pub fn nma_mobile_providers_split_3gpp_mcc_mnc(
        mccmnc: *const c_char,
        mcc: *mut *mut c_char,
        mnc: *mut *mut c_char,
    ) -> gboolean;
    pub fn nma_utils_menu_to_secret_flags(
        passwd_entry: *mut gtk::GtkWidget,
    ) -> nm::NMSettingSecretFlags;
    pub fn nma_utils_setup_password_storage(
        passwd_entry: *mut gtk::GtkWidget,
        initial_flags: nm::NMSettingSecretFlags,
        setting: *mut nm::NMSetting,
        password_flags_name: *const c_char,
        with_not_required: gboolean,
        ask_mode: gboolean,
    );
    pub fn nma_utils_update_password_storage(
        passwd_entry: *mut gtk::GtkWidget,
        secret_flags: nm::NMSettingSecretFlags,
        setting: *mut nm::NMSetting,
        password_flags_name: *const c_char,
    );

}