gio/auto/

enums.rs

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

use crate::ffi;
use glib::{prelude::*, translate::*};

/// An enumeration for well-known message buses.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GBusType")]
pub enum BusType {
    /// An alias for the message bus that activated the process, if any.
    #[doc(alias = "G_BUS_TYPE_STARTER")]
    Starter,
    /// Not a message bus.
    #[doc(alias = "G_BUS_TYPE_NONE")]
    None,
    /// The system-wide message bus.
    #[doc(alias = "G_BUS_TYPE_SYSTEM")]
    System,
    /// The login session message bus.
    #[doc(alias = "G_BUS_TYPE_SESSION")]
    Session,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for BusType {
    type GlibType = ffi::GBusType;

    #[inline]
    fn into_glib(self) -> ffi::GBusType {
        match self {
            Self::Starter => ffi::G_BUS_TYPE_STARTER,
            Self::None => ffi::G_BUS_TYPE_NONE,
            Self::System => ffi::G_BUS_TYPE_SYSTEM,
            Self::Session => ffi::G_BUS_TYPE_SESSION,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GBusType> for BusType {
    #[inline]
    unsafe fn from_glib(value: ffi::GBusType) -> Self {
        match value {
            ffi::G_BUS_TYPE_STARTER => Self::Starter,
            ffi::G_BUS_TYPE_NONE => Self::None,
            ffi::G_BUS_TYPE_SYSTEM => Self::System,
            ffi::G_BUS_TYPE_SESSION => Self::Session,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for BusType {
    #[inline]
    #[doc(alias = "g_bus_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_bus_type_get_type()) }
    }
}

impl glib::HasParamSpec for BusType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for BusType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for BusType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for BusType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<BusType> for glib::Value {
    #[inline]
    fn from(v: BusType) -> Self {
        ToValue::to_value(&v)
    }
}

/// Results returned from g_converter_convert().
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GConverterResult")]
pub enum ConverterResult {
    /// There was an error during conversion.
    #[doc(alias = "G_CONVERTER_ERROR")]
    Error,
    /// Some data was consumed or produced
    #[doc(alias = "G_CONVERTER_CONVERTED")]
    Converted,
    /// The conversion is finished
    #[doc(alias = "G_CONVERTER_FINISHED")]
    Finished,
    /// Flushing is finished
    #[doc(alias = "G_CONVERTER_FLUSHED")]
    Flushed,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ConverterResult {
    type GlibType = ffi::GConverterResult;

    #[inline]
    fn into_glib(self) -> ffi::GConverterResult {
        match self {
            Self::Error => ffi::G_CONVERTER_ERROR,
            Self::Converted => ffi::G_CONVERTER_CONVERTED,
            Self::Finished => ffi::G_CONVERTER_FINISHED,
            Self::Flushed => ffi::G_CONVERTER_FLUSHED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GConverterResult> for ConverterResult {
    #[inline]
    unsafe fn from_glib(value: ffi::GConverterResult) -> Self {
        match value {
            ffi::G_CONVERTER_ERROR => Self::Error,
            ffi::G_CONVERTER_CONVERTED => Self::Converted,
            ffi::G_CONVERTER_FINISHED => Self::Finished,
            ffi::G_CONVERTER_FLUSHED => Self::Flushed,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ConverterResult {
    #[inline]
    #[doc(alias = "g_converter_result_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_converter_result_get_type()) }
    }
}

impl glib::HasParamSpec for ConverterResult {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ConverterResult {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ConverterResult {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ConverterResult {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ConverterResult> for glib::Value {
    #[inline]
    fn from(v: ConverterResult) -> Self {
        ToValue::to_value(&v)
    }
}

/// Enumeration describing different kinds of native credential types.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GCredentialsType")]
pub enum CredentialsType {
    /// Indicates an invalid native credential type.
    #[doc(alias = "G_CREDENTIALS_TYPE_INVALID")]
    Invalid,
    /// The native credentials type is a `struct ucred`.
    #[doc(alias = "G_CREDENTIALS_TYPE_LINUX_UCRED")]
    LinuxUcred,
    /// The native credentials type is a `struct cmsgcred`.
    #[doc(alias = "G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED")]
    FreebsdCmsgcred,
    /// The native credentials type is a `struct sockpeercred`. Added in 2.30.
    #[doc(alias = "G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED")]
    OpenbsdSockpeercred,
    /// The native credentials type is a `ucred_t`. Added in 2.40.
    #[doc(alias = "G_CREDENTIALS_TYPE_SOLARIS_UCRED")]
    SolarisUcred,
    /// The native credentials type is a `struct unpcbid`. Added in 2.42.
    #[doc(alias = "G_CREDENTIALS_TYPE_NETBSD_UNPCBID")]
    NetbsdUnpcbid,
    /// The native credentials type is a `struct xucred`. Added in 2.66.
    #[doc(alias = "G_CREDENTIALS_TYPE_APPLE_XUCRED")]
    AppleXucred,
    /// The native credentials type is a PID `DWORD`. Added in 2.72.
    #[cfg(feature = "v2_72")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
    #[doc(alias = "G_CREDENTIALS_TYPE_WIN32_PID")]
    Win32Pid,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for CredentialsType {
    type GlibType = ffi::GCredentialsType;

    #[inline]
    fn into_glib(self) -> ffi::GCredentialsType {
        match self {
            Self::Invalid => ffi::G_CREDENTIALS_TYPE_INVALID,
            Self::LinuxUcred => ffi::G_CREDENTIALS_TYPE_LINUX_UCRED,
            Self::FreebsdCmsgcred => ffi::G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED,
            Self::OpenbsdSockpeercred => ffi::G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED,
            Self::SolarisUcred => ffi::G_CREDENTIALS_TYPE_SOLARIS_UCRED,
            Self::NetbsdUnpcbid => ffi::G_CREDENTIALS_TYPE_NETBSD_UNPCBID,
            Self::AppleXucred => ffi::G_CREDENTIALS_TYPE_APPLE_XUCRED,
            #[cfg(feature = "v2_72")]
            Self::Win32Pid => ffi::G_CREDENTIALS_TYPE_WIN32_PID,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GCredentialsType> for CredentialsType {
    #[inline]
    unsafe fn from_glib(value: ffi::GCredentialsType) -> Self {
        match value {
            ffi::G_CREDENTIALS_TYPE_INVALID => Self::Invalid,
            ffi::G_CREDENTIALS_TYPE_LINUX_UCRED => Self::LinuxUcred,
            ffi::G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED => Self::FreebsdCmsgcred,
            ffi::G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED => Self::OpenbsdSockpeercred,
            ffi::G_CREDENTIALS_TYPE_SOLARIS_UCRED => Self::SolarisUcred,
            ffi::G_CREDENTIALS_TYPE_NETBSD_UNPCBID => Self::NetbsdUnpcbid,
            ffi::G_CREDENTIALS_TYPE_APPLE_XUCRED => Self::AppleXucred,
            #[cfg(feature = "v2_72")]
            ffi::G_CREDENTIALS_TYPE_WIN32_PID => Self::Win32Pid,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for CredentialsType {
    #[inline]
    #[doc(alias = "g_credentials_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_credentials_type_get_type()) }
    }
}

impl glib::HasParamSpec for CredentialsType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for CredentialsType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for CredentialsType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for CredentialsType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<CredentialsType> for glib::Value {
    #[inline]
    fn from(v: CredentialsType) -> Self {
        ToValue::to_value(&v)
    }
}

/// Error codes for the `G_DBUS_ERROR` error domain.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GDBusError")]
pub enum DBusError {
    /// A generic error; "something went wrong" - see the error message for
    /// more.
    #[doc(alias = "G_DBUS_ERROR_FAILED")]
    Failed,
    /// There was not enough memory to complete an operation.
    #[doc(alias = "G_DBUS_ERROR_NO_MEMORY")]
    NoMemory,
    /// The bus doesn't know how to launch a service to supply the bus name
    /// you wanted.
    #[doc(alias = "G_DBUS_ERROR_SERVICE_UNKNOWN")]
    ServiceUnknown,
    /// The bus name you referenced doesn't exist (i.e. no application owns
    /// it).
    #[doc(alias = "G_DBUS_ERROR_NAME_HAS_NO_OWNER")]
    NameHasNoOwner,
    /// No reply to a message expecting one, usually means a timeout occurred.
    #[doc(alias = "G_DBUS_ERROR_NO_REPLY")]
    NoReply,
    /// Something went wrong reading or writing to a socket, for example.
    #[doc(alias = "G_DBUS_ERROR_IO_ERROR")]
    IoError,
    /// A D-Bus bus address was malformed.
    #[doc(alias = "G_DBUS_ERROR_BAD_ADDRESS")]
    BadAddress,
    /// Requested operation isn't supported (like ENOSYS on UNIX).
    #[doc(alias = "G_DBUS_ERROR_NOT_SUPPORTED")]
    NotSupported,
    /// Some limited resource is exhausted.
    #[doc(alias = "G_DBUS_ERROR_LIMITS_EXCEEDED")]
    LimitsExceeded,
    /// Security restrictions don't allow doing what you're trying to do.
    #[doc(alias = "G_DBUS_ERROR_ACCESS_DENIED")]
    AccessDenied,
    /// Authentication didn't work.
    #[doc(alias = "G_DBUS_ERROR_AUTH_FAILED")]
    AuthFailed,
    /// Unable to connect to server (probably caused by ECONNREFUSED on a
    /// socket).
    #[doc(alias = "G_DBUS_ERROR_NO_SERVER")]
    NoServer,
    /// Certain timeout errors, possibly ETIMEDOUT on a socket.  Note that
    /// [`NoReply`][Self::NoReply] is used for message reply timeouts. Warning:
    /// this is confusingly-named given that [`TimedOut`][Self::TimedOut] also
    /// exists. We can't fix it for compatibility reasons so just be
    /// careful.
    #[doc(alias = "G_DBUS_ERROR_TIMEOUT")]
    Timeout,
    /// No network access (probably ENETUNREACH on a socket).
    #[doc(alias = "G_DBUS_ERROR_NO_NETWORK")]
    NoNetwork,
    /// Can't bind a socket since its address is in use (i.e. EADDRINUSE).
    #[doc(alias = "G_DBUS_ERROR_ADDRESS_IN_USE")]
    AddressInUse,
    /// The connection is disconnected and you're trying to use it.
    #[doc(alias = "G_DBUS_ERROR_DISCONNECTED")]
    Disconnected,
    /// Invalid arguments passed to a method call.
    #[doc(alias = "G_DBUS_ERROR_INVALID_ARGS")]
    InvalidArgs,
    /// Missing file.
    #[doc(alias = "G_DBUS_ERROR_FILE_NOT_FOUND")]
    FileNotFound,
    /// Existing file and the operation you're using does not silently overwrite.
    #[doc(alias = "G_DBUS_ERROR_FILE_EXISTS")]
    FileExists,
    /// Method name you invoked isn't known by the object you invoked it on.
    #[doc(alias = "G_DBUS_ERROR_UNKNOWN_METHOD")]
    UnknownMethod,
    /// Certain timeout errors, e.g. while starting a service. Warning: this is
    /// confusingly-named given that [`Timeout`][Self::Timeout] also exists. We
    /// can't fix it for compatibility reasons so just be careful.
    #[doc(alias = "G_DBUS_ERROR_TIMED_OUT")]
    TimedOut,
    /// Tried to remove or modify a match rule that didn't exist.
    #[doc(alias = "G_DBUS_ERROR_MATCH_RULE_NOT_FOUND")]
    MatchRuleNotFound,
    /// The match rule isn't syntactically valid.
    #[doc(alias = "G_DBUS_ERROR_MATCH_RULE_INVALID")]
    MatchRuleInvalid,
    /// While starting a new process, the exec() call failed.
    #[doc(alias = "G_DBUS_ERROR_SPAWN_EXEC_FAILED")]
    SpawnExecFailed,
    /// While starting a new process, the fork() call failed.
    #[doc(alias = "G_DBUS_ERROR_SPAWN_FORK_FAILED")]
    SpawnForkFailed,
    /// While starting a new process, the child exited with a status code.
    #[doc(alias = "G_DBUS_ERROR_SPAWN_CHILD_EXITED")]
    SpawnChildExited,
    /// While starting a new process, the child exited on a signal.
    #[doc(alias = "G_DBUS_ERROR_SPAWN_CHILD_SIGNALED")]
    SpawnChildSignaled,
    /// While starting a new process, something went wrong.
    #[doc(alias = "G_DBUS_ERROR_SPAWN_FAILED")]
    SpawnFailed,
    /// We failed to setup the environment correctly.
    #[doc(alias = "G_DBUS_ERROR_SPAWN_SETUP_FAILED")]
    SpawnSetupFailed,
    /// We failed to setup the config parser correctly.
    #[doc(alias = "G_DBUS_ERROR_SPAWN_CONFIG_INVALID")]
    SpawnConfigInvalid,
    /// Bus name was not valid.
    #[doc(alias = "G_DBUS_ERROR_SPAWN_SERVICE_INVALID")]
    SpawnServiceInvalid,
    /// Service file not found in system-services directory.
    #[doc(alias = "G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND")]
    SpawnServiceNotFound,
    /// Permissions are incorrect on the setuid helper.
    #[doc(alias = "G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID")]
    SpawnPermissionsInvalid,
    /// Service file invalid (Name, User or Exec missing).
    #[doc(alias = "G_DBUS_ERROR_SPAWN_FILE_INVALID")]
    SpawnFileInvalid,
    /// Tried to get a UNIX process ID and it wasn't available.
    #[doc(alias = "G_DBUS_ERROR_SPAWN_NO_MEMORY")]
    SpawnNoMemory,
    /// Tried to get a UNIX process ID and it wasn't available.
    #[doc(alias = "G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN")]
    UnixProcessIdUnknown,
    /// A type signature is not valid.
    #[doc(alias = "G_DBUS_ERROR_INVALID_SIGNATURE")]
    InvalidSignature,
    /// A file contains invalid syntax or is otherwise broken.
    #[doc(alias = "G_DBUS_ERROR_INVALID_FILE_CONTENT")]
    InvalidFileContent,
    /// Asked for SELinux security context and it wasn't available.
    #[doc(alias = "G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN")]
    SelinuxSecurityContextUnknown,
    /// Asked for ADT audit data and it wasn't available.
    #[doc(alias = "G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN")]
    AdtAuditDataUnknown,
    /// There's already an object with the requested object path.
    #[doc(alias = "G_DBUS_ERROR_OBJECT_PATH_IN_USE")]
    ObjectPathInUse,
    /// Object you invoked a method on isn't known. Since 2.42
    #[doc(alias = "G_DBUS_ERROR_UNKNOWN_OBJECT")]
    UnknownObject,
    /// Interface you invoked a method on isn't known by the object. Since 2.42
    #[doc(alias = "G_DBUS_ERROR_UNKNOWN_INTERFACE")]
    UnknownInterface,
    /// Property you tried to access isn't known by the object. Since 2.42
    #[doc(alias = "G_DBUS_ERROR_UNKNOWN_PROPERTY")]
    UnknownProperty,
    /// Property you tried to set is read-only. Since 2.42
    #[doc(alias = "G_DBUS_ERROR_PROPERTY_READ_ONLY")]
    PropertyReadOnly,
    #[doc(hidden)]
    __Unknown(i32),
}

impl DBusError {
    #[doc(alias = "g_dbus_error_encode_gerror")]
    pub fn encode_gerror(error: &glib::Error) -> glib::GString {
        unsafe { from_glib_full(ffi::g_dbus_error_encode_gerror(error.to_glib_none().0)) }
    }

    #[doc(alias = "g_dbus_error_get_remote_error")]
    #[doc(alias = "get_remote_error")]
    pub fn remote_error(error: &glib::Error) -> Option<glib::GString> {
        unsafe { from_glib_full(ffi::g_dbus_error_get_remote_error(error.to_glib_none().0)) }
    }

    #[doc(alias = "g_dbus_error_is_remote_error")]
    pub fn is_remote_error(error: &glib::Error) -> bool {
        unsafe { from_glib(ffi::g_dbus_error_is_remote_error(error.to_glib_none().0)) }
    }

    #[doc(alias = "g_dbus_error_new_for_dbus_error")]
    pub fn new_for_dbus_error(dbus_error_name: &str, dbus_error_message: &str) -> glib::Error {
        unsafe {
            from_glib_full(ffi::g_dbus_error_new_for_dbus_error(
                dbus_error_name.to_glib_none().0,
                dbus_error_message.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "g_dbus_error_register_error")]
    pub fn register_error(
        error_domain: glib::Quark,
        error_code: i32,
        dbus_error_name: &str,
    ) -> bool {
        unsafe {
            from_glib(ffi::g_dbus_error_register_error(
                error_domain.into_glib(),
                error_code,
                dbus_error_name.to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "g_dbus_error_register_error_domain")]
    //pub fn register_error_domain(error_domain_quark_name: &str, entries: /*Ignored*/&[DBusErrorEntry]) -> usize {
    //    unsafe { TODO: call ffi:g_dbus_error_register_error_domain() }
    //}

    //#[doc(alias = "g_dbus_error_set_dbus_error")]
    //pub fn set_dbus_error(dbus_error_name: &str, dbus_error_message: &str, format: Option<&str>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Option<glib::Error> {
    //    unsafe { TODO: call ffi:g_dbus_error_set_dbus_error() }
    //}

    //#[doc(alias = "g_dbus_error_set_dbus_error_valist")]
    //pub fn set_dbus_error_valist(dbus_error_name: &str, dbus_error_message: &str, format: Option<&str>, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) -> Option<glib::Error> {
    //    unsafe { TODO: call ffi:g_dbus_error_set_dbus_error_valist() }
    //}

    #[doc(alias = "g_dbus_error_strip_remote_error")]
    pub fn strip_remote_error(error: &mut glib::Error) -> bool {
        unsafe {
            from_glib(ffi::g_dbus_error_strip_remote_error(
                error.to_glib_none_mut().0,
            ))
        }
    }

    #[doc(alias = "g_dbus_error_unregister_error")]
    pub fn unregister_error(
        error_domain: glib::Quark,
        error_code: i32,
        dbus_error_name: &str,
    ) -> bool {
        unsafe {
            from_glib(ffi::g_dbus_error_unregister_error(
                error_domain.into_glib(),
                error_code,
                dbus_error_name.to_glib_none().0,
            ))
        }
    }
}

#[doc(hidden)]
impl IntoGlib for DBusError {
    type GlibType = ffi::GDBusError;

    fn into_glib(self) -> ffi::GDBusError {
        match self {
            Self::Failed => ffi::G_DBUS_ERROR_FAILED,
            Self::NoMemory => ffi::G_DBUS_ERROR_NO_MEMORY,
            Self::ServiceUnknown => ffi::G_DBUS_ERROR_SERVICE_UNKNOWN,
            Self::NameHasNoOwner => ffi::G_DBUS_ERROR_NAME_HAS_NO_OWNER,
            Self::NoReply => ffi::G_DBUS_ERROR_NO_REPLY,
            Self::IoError => ffi::G_DBUS_ERROR_IO_ERROR,
            Self::BadAddress => ffi::G_DBUS_ERROR_BAD_ADDRESS,
            Self::NotSupported => ffi::G_DBUS_ERROR_NOT_SUPPORTED,
            Self::LimitsExceeded => ffi::G_DBUS_ERROR_LIMITS_EXCEEDED,
            Self::AccessDenied => ffi::G_DBUS_ERROR_ACCESS_DENIED,
            Self::AuthFailed => ffi::G_DBUS_ERROR_AUTH_FAILED,
            Self::NoServer => ffi::G_DBUS_ERROR_NO_SERVER,
            Self::Timeout => ffi::G_DBUS_ERROR_TIMEOUT,
            Self::NoNetwork => ffi::G_DBUS_ERROR_NO_NETWORK,
            Self::AddressInUse => ffi::G_DBUS_ERROR_ADDRESS_IN_USE,
            Self::Disconnected => ffi::G_DBUS_ERROR_DISCONNECTED,
            Self::InvalidArgs => ffi::G_DBUS_ERROR_INVALID_ARGS,
            Self::FileNotFound => ffi::G_DBUS_ERROR_FILE_NOT_FOUND,
            Self::FileExists => ffi::G_DBUS_ERROR_FILE_EXISTS,
            Self::UnknownMethod => ffi::G_DBUS_ERROR_UNKNOWN_METHOD,
            Self::TimedOut => ffi::G_DBUS_ERROR_TIMED_OUT,
            Self::MatchRuleNotFound => ffi::G_DBUS_ERROR_MATCH_RULE_NOT_FOUND,
            Self::MatchRuleInvalid => ffi::G_DBUS_ERROR_MATCH_RULE_INVALID,
            Self::SpawnExecFailed => ffi::G_DBUS_ERROR_SPAWN_EXEC_FAILED,
            Self::SpawnForkFailed => ffi::G_DBUS_ERROR_SPAWN_FORK_FAILED,
            Self::SpawnChildExited => ffi::G_DBUS_ERROR_SPAWN_CHILD_EXITED,
            Self::SpawnChildSignaled => ffi::G_DBUS_ERROR_SPAWN_CHILD_SIGNALED,
            Self::SpawnFailed => ffi::G_DBUS_ERROR_SPAWN_FAILED,
            Self::SpawnSetupFailed => ffi::G_DBUS_ERROR_SPAWN_SETUP_FAILED,
            Self::SpawnConfigInvalid => ffi::G_DBUS_ERROR_SPAWN_CONFIG_INVALID,
            Self::SpawnServiceInvalid => ffi::G_DBUS_ERROR_SPAWN_SERVICE_INVALID,
            Self::SpawnServiceNotFound => ffi::G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND,
            Self::SpawnPermissionsInvalid => ffi::G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID,
            Self::SpawnFileInvalid => ffi::G_DBUS_ERROR_SPAWN_FILE_INVALID,
            Self::SpawnNoMemory => ffi::G_DBUS_ERROR_SPAWN_NO_MEMORY,
            Self::UnixProcessIdUnknown => ffi::G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN,
            Self::InvalidSignature => ffi::G_DBUS_ERROR_INVALID_SIGNATURE,
            Self::InvalidFileContent => ffi::G_DBUS_ERROR_INVALID_FILE_CONTENT,
            Self::SelinuxSecurityContextUnknown => {
                ffi::G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN
            }
            Self::AdtAuditDataUnknown => ffi::G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN,
            Self::ObjectPathInUse => ffi::G_DBUS_ERROR_OBJECT_PATH_IN_USE,
            Self::UnknownObject => ffi::G_DBUS_ERROR_UNKNOWN_OBJECT,
            Self::UnknownInterface => ffi::G_DBUS_ERROR_UNKNOWN_INTERFACE,
            Self::UnknownProperty => ffi::G_DBUS_ERROR_UNKNOWN_PROPERTY,
            Self::PropertyReadOnly => ffi::G_DBUS_ERROR_PROPERTY_READ_ONLY,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GDBusError> for DBusError {
    unsafe fn from_glib(value: ffi::GDBusError) -> Self {
        match value {
            ffi::G_DBUS_ERROR_FAILED => Self::Failed,
            ffi::G_DBUS_ERROR_NO_MEMORY => Self::NoMemory,
            ffi::G_DBUS_ERROR_SERVICE_UNKNOWN => Self::ServiceUnknown,
            ffi::G_DBUS_ERROR_NAME_HAS_NO_OWNER => Self::NameHasNoOwner,
            ffi::G_DBUS_ERROR_NO_REPLY => Self::NoReply,
            ffi::G_DBUS_ERROR_IO_ERROR => Self::IoError,
            ffi::G_DBUS_ERROR_BAD_ADDRESS => Self::BadAddress,
            ffi::G_DBUS_ERROR_NOT_SUPPORTED => Self::NotSupported,
            ffi::G_DBUS_ERROR_LIMITS_EXCEEDED => Self::LimitsExceeded,
            ffi::G_DBUS_ERROR_ACCESS_DENIED => Self::AccessDenied,
            ffi::G_DBUS_ERROR_AUTH_FAILED => Self::AuthFailed,
            ffi::G_DBUS_ERROR_NO_SERVER => Self::NoServer,
            ffi::G_DBUS_ERROR_TIMEOUT => Self::Timeout,
            ffi::G_DBUS_ERROR_NO_NETWORK => Self::NoNetwork,
            ffi::G_DBUS_ERROR_ADDRESS_IN_USE => Self::AddressInUse,
            ffi::G_DBUS_ERROR_DISCONNECTED => Self::Disconnected,
            ffi::G_DBUS_ERROR_INVALID_ARGS => Self::InvalidArgs,
            ffi::G_DBUS_ERROR_FILE_NOT_FOUND => Self::FileNotFound,
            ffi::G_DBUS_ERROR_FILE_EXISTS => Self::FileExists,
            ffi::G_DBUS_ERROR_UNKNOWN_METHOD => Self::UnknownMethod,
            ffi::G_DBUS_ERROR_TIMED_OUT => Self::TimedOut,
            ffi::G_DBUS_ERROR_MATCH_RULE_NOT_FOUND => Self::MatchRuleNotFound,
            ffi::G_DBUS_ERROR_MATCH_RULE_INVALID => Self::MatchRuleInvalid,
            ffi::G_DBUS_ERROR_SPAWN_EXEC_FAILED => Self::SpawnExecFailed,
            ffi::G_DBUS_ERROR_SPAWN_FORK_FAILED => Self::SpawnForkFailed,
            ffi::G_DBUS_ERROR_SPAWN_CHILD_EXITED => Self::SpawnChildExited,
            ffi::G_DBUS_ERROR_SPAWN_CHILD_SIGNALED => Self::SpawnChildSignaled,
            ffi::G_DBUS_ERROR_SPAWN_FAILED => Self::SpawnFailed,
            ffi::G_DBUS_ERROR_SPAWN_SETUP_FAILED => Self::SpawnSetupFailed,
            ffi::G_DBUS_ERROR_SPAWN_CONFIG_INVALID => Self::SpawnConfigInvalid,
            ffi::G_DBUS_ERROR_SPAWN_SERVICE_INVALID => Self::SpawnServiceInvalid,
            ffi::G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND => Self::SpawnServiceNotFound,
            ffi::G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID => Self::SpawnPermissionsInvalid,
            ffi::G_DBUS_ERROR_SPAWN_FILE_INVALID => Self::SpawnFileInvalid,
            ffi::G_DBUS_ERROR_SPAWN_NO_MEMORY => Self::SpawnNoMemory,
            ffi::G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN => Self::UnixProcessIdUnknown,
            ffi::G_DBUS_ERROR_INVALID_SIGNATURE => Self::InvalidSignature,
            ffi::G_DBUS_ERROR_INVALID_FILE_CONTENT => Self::InvalidFileContent,
            ffi::G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN => {
                Self::SelinuxSecurityContextUnknown
            }
            ffi::G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN => Self::AdtAuditDataUnknown,
            ffi::G_DBUS_ERROR_OBJECT_PATH_IN_USE => Self::ObjectPathInUse,
            ffi::G_DBUS_ERROR_UNKNOWN_OBJECT => Self::UnknownObject,
            ffi::G_DBUS_ERROR_UNKNOWN_INTERFACE => Self::UnknownInterface,
            ffi::G_DBUS_ERROR_UNKNOWN_PROPERTY => Self::UnknownProperty,
            ffi::G_DBUS_ERROR_PROPERTY_READ_ONLY => Self::PropertyReadOnly,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for DBusError {
    #[inline]
    fn domain() -> glib::Quark {
        unsafe { from_glib(ffi::g_dbus_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        match unsafe { from_glib(code) } {
            Self::__Unknown(_) => Some(Self::Failed),
            value => Some(value),
        }
    }
}

impl StaticType for DBusError {
    #[inline]
    #[doc(alias = "g_dbus_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_dbus_error_get_type()) }
    }
}

impl glib::HasParamSpec for DBusError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for DBusError {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for DBusError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for DBusError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<DBusError> for glib::Value {
    #[inline]
    fn from(v: DBusError) -> Self {
        ToValue::to_value(&v)
    }
}

/// Enumeration used to describe the byte order of a D-Bus message.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GDBusMessageByteOrder")]
pub enum DBusMessageByteOrder {
    /// The byte order is big endian.
    #[doc(alias = "G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN")]
    BigEndian,
    /// The byte order is little endian.
    #[doc(alias = "G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN")]
    LittleEndian,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for DBusMessageByteOrder {
    type GlibType = ffi::GDBusMessageByteOrder;

    #[inline]
    fn into_glib(self) -> ffi::GDBusMessageByteOrder {
        match self {
            Self::BigEndian => ffi::G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN,
            Self::LittleEndian => ffi::G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GDBusMessageByteOrder> for DBusMessageByteOrder {
    #[inline]
    unsafe fn from_glib(value: ffi::GDBusMessageByteOrder) -> Self {
        match value {
            ffi::G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN => Self::BigEndian,
            ffi::G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN => Self::LittleEndian,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for DBusMessageByteOrder {
    #[inline]
    #[doc(alias = "g_dbus_message_byte_order_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_dbus_message_byte_order_get_type()) }
    }
}

impl glib::HasParamSpec for DBusMessageByteOrder {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for DBusMessageByteOrder {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for DBusMessageByteOrder {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for DBusMessageByteOrder {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<DBusMessageByteOrder> for glib::Value {
    #[inline]
    fn from(v: DBusMessageByteOrder) -> Self {
        ToValue::to_value(&v)
    }
}

/// Header fields used in #GDBusMessage.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GDBusMessageHeaderField")]
pub enum DBusMessageHeaderField {
    /// Not a valid header field.
    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_INVALID")]
    Invalid,
    /// The object path.
    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_PATH")]
    Path,
    /// The interface name.
    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE")]
    Interface,
    /// The method or signal name.
    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_MEMBER")]
    Member,
    /// The name of the error that occurred.
    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME")]
    ErrorName,
    /// The serial number the message is a reply to.
    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL")]
    ReplySerial,
    /// The name the message is intended for.
    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION")]
    Destination,
    /// Unique name of the sender of the message (filled in by the bus).
    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_SENDER")]
    Sender,
    /// The signature of the message body.
    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE")]
    Signature,
    /// The number of UNIX file descriptors that accompany the message.
    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS")]
    NumUnixFds,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for DBusMessageHeaderField {
    type GlibType = ffi::GDBusMessageHeaderField;

    #[inline]
    fn into_glib(self) -> ffi::GDBusMessageHeaderField {
        match self {
            Self::Invalid => ffi::G_DBUS_MESSAGE_HEADER_FIELD_INVALID,
            Self::Path => ffi::G_DBUS_MESSAGE_HEADER_FIELD_PATH,
            Self::Interface => ffi::G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE,
            Self::Member => ffi::G_DBUS_MESSAGE_HEADER_FIELD_MEMBER,
            Self::ErrorName => ffi::G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME,
            Self::ReplySerial => ffi::G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL,
            Self::Destination => ffi::G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION,
            Self::Sender => ffi::G_DBUS_MESSAGE_HEADER_FIELD_SENDER,
            Self::Signature => ffi::G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE,
            Self::NumUnixFds => ffi::G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GDBusMessageHeaderField> for DBusMessageHeaderField {
    #[inline]
    unsafe fn from_glib(value: ffi::GDBusMessageHeaderField) -> Self {
        match value {
            ffi::G_DBUS_MESSAGE_HEADER_FIELD_INVALID => Self::Invalid,
            ffi::G_DBUS_MESSAGE_HEADER_FIELD_PATH => Self::Path,
            ffi::G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE => Self::Interface,
            ffi::G_DBUS_MESSAGE_HEADER_FIELD_MEMBER => Self::Member,
            ffi::G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME => Self::ErrorName,
            ffi::G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL => Self::ReplySerial,
            ffi::G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION => Self::Destination,
            ffi::G_DBUS_MESSAGE_HEADER_FIELD_SENDER => Self::Sender,
            ffi::G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE => Self::Signature,
            ffi::G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS => Self::NumUnixFds,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for DBusMessageHeaderField {
    #[inline]
    #[doc(alias = "g_dbus_message_header_field_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_dbus_message_header_field_get_type()) }
    }
}

impl glib::HasParamSpec for DBusMessageHeaderField {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for DBusMessageHeaderField {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for DBusMessageHeaderField {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for DBusMessageHeaderField {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<DBusMessageHeaderField> for glib::Value {
    #[inline]
    fn from(v: DBusMessageHeaderField) -> Self {
        ToValue::to_value(&v)
    }
}

/// Message types used in #GDBusMessage.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GDBusMessageType")]
pub enum DBusMessageType {
    /// Message is of invalid type.
    #[doc(alias = "G_DBUS_MESSAGE_TYPE_INVALID")]
    Invalid,
    /// Method call.
    #[doc(alias = "G_DBUS_MESSAGE_TYPE_METHOD_CALL")]
    MethodCall,
    /// Method reply.
    #[doc(alias = "G_DBUS_MESSAGE_TYPE_METHOD_RETURN")]
    MethodReturn,
    /// Error reply.
    #[doc(alias = "G_DBUS_MESSAGE_TYPE_ERROR")]
    Error,
    /// Signal emission.
    #[doc(alias = "G_DBUS_MESSAGE_TYPE_SIGNAL")]
    Signal,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for DBusMessageType {
    type GlibType = ffi::GDBusMessageType;

    #[inline]
    fn into_glib(self) -> ffi::GDBusMessageType {
        match self {
            Self::Invalid => ffi::G_DBUS_MESSAGE_TYPE_INVALID,
            Self::MethodCall => ffi::G_DBUS_MESSAGE_TYPE_METHOD_CALL,
            Self::MethodReturn => ffi::G_DBUS_MESSAGE_TYPE_METHOD_RETURN,
            Self::Error => ffi::G_DBUS_MESSAGE_TYPE_ERROR,
            Self::Signal => ffi::G_DBUS_MESSAGE_TYPE_SIGNAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GDBusMessageType> for DBusMessageType {
    #[inline]
    unsafe fn from_glib(value: ffi::GDBusMessageType) -> Self {
        match value {
            ffi::G_DBUS_MESSAGE_TYPE_INVALID => Self::Invalid,
            ffi::G_DBUS_MESSAGE_TYPE_METHOD_CALL => Self::MethodCall,
            ffi::G_DBUS_MESSAGE_TYPE_METHOD_RETURN => Self::MethodReturn,
            ffi::G_DBUS_MESSAGE_TYPE_ERROR => Self::Error,
            ffi::G_DBUS_MESSAGE_TYPE_SIGNAL => Self::Signal,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for DBusMessageType {
    #[inline]
    #[doc(alias = "g_dbus_message_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_dbus_message_type_get_type()) }
    }
}

impl glib::HasParamSpec for DBusMessageType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for DBusMessageType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for DBusMessageType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for DBusMessageType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<DBusMessageType> for glib::Value {
    #[inline]
    fn from(v: DBusMessageType) -> Self {
        ToValue::to_value(&v)
    }
}

/// #GDataStreamByteOrder is used to ensure proper endianness of streaming data sources
/// across various machine architectures.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GDataStreamByteOrder")]
pub enum DataStreamByteOrder {
    /// Selects Big Endian byte order.
    #[doc(alias = "G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN")]
    BigEndian,
    /// Selects Little Endian byte order.
    #[doc(alias = "G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN")]
    LittleEndian,
    /// Selects endianness based on host machine's architecture.
    #[doc(alias = "G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN")]
    HostEndian,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for DataStreamByteOrder {
    type GlibType = ffi::GDataStreamByteOrder;

    #[inline]
    fn into_glib(self) -> ffi::GDataStreamByteOrder {
        match self {
            Self::BigEndian => ffi::G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN,
            Self::LittleEndian => ffi::G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN,
            Self::HostEndian => ffi::G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GDataStreamByteOrder> for DataStreamByteOrder {
    #[inline]
    unsafe fn from_glib(value: ffi::GDataStreamByteOrder) -> Self {
        match value {
            ffi::G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN => Self::BigEndian,
            ffi::G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN => Self::LittleEndian,
            ffi::G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN => Self::HostEndian,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for DataStreamByteOrder {
    #[inline]
    #[doc(alias = "g_data_stream_byte_order_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_data_stream_byte_order_get_type()) }
    }
}

impl glib::HasParamSpec for DataStreamByteOrder {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for DataStreamByteOrder {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for DataStreamByteOrder {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for DataStreamByteOrder {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<DataStreamByteOrder> for glib::Value {
    #[inline]
    fn from(v: DataStreamByteOrder) -> Self {
        ToValue::to_value(&v)
    }
}

/// #GDataStreamNewlineType is used when checking for or setting the line endings for a given file.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GDataStreamNewlineType")]
pub enum DataStreamNewlineType {
    /// Selects "LF" line endings, common on most modern UNIX platforms.
    #[doc(alias = "G_DATA_STREAM_NEWLINE_TYPE_LF")]
    Lf,
    /// Selects "CR" line endings.
    #[doc(alias = "G_DATA_STREAM_NEWLINE_TYPE_CR")]
    Cr,
    /// Selects "CR, LF" line ending, common on Microsoft Windows.
    #[doc(alias = "G_DATA_STREAM_NEWLINE_TYPE_CR_LF")]
    CrLf,
    /// Automatically try to handle any line ending type.
    #[doc(alias = "G_DATA_STREAM_NEWLINE_TYPE_ANY")]
    Any,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for DataStreamNewlineType {
    type GlibType = ffi::GDataStreamNewlineType;

    #[inline]
    fn into_glib(self) -> ffi::GDataStreamNewlineType {
        match self {
            Self::Lf => ffi::G_DATA_STREAM_NEWLINE_TYPE_LF,
            Self::Cr => ffi::G_DATA_STREAM_NEWLINE_TYPE_CR,
            Self::CrLf => ffi::G_DATA_STREAM_NEWLINE_TYPE_CR_LF,
            Self::Any => ffi::G_DATA_STREAM_NEWLINE_TYPE_ANY,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GDataStreamNewlineType> for DataStreamNewlineType {
    #[inline]
    unsafe fn from_glib(value: ffi::GDataStreamNewlineType) -> Self {
        match value {
            ffi::G_DATA_STREAM_NEWLINE_TYPE_LF => Self::Lf,
            ffi::G_DATA_STREAM_NEWLINE_TYPE_CR => Self::Cr,
            ffi::G_DATA_STREAM_NEWLINE_TYPE_CR_LF => Self::CrLf,
            ffi::G_DATA_STREAM_NEWLINE_TYPE_ANY => Self::Any,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for DataStreamNewlineType {
    #[inline]
    #[doc(alias = "g_data_stream_newline_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_data_stream_newline_type_get_type()) }
    }
}

impl glib::HasParamSpec for DataStreamNewlineType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for DataStreamNewlineType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for DataStreamNewlineType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for DataStreamNewlineType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<DataStreamNewlineType> for glib::Value {
    #[inline]
    fn from(v: DataStreamNewlineType) -> Self {
        ToValue::to_value(&v)
    }
}

/// Enumeration describing how a drive can be started/stopped.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GDriveStartStopType")]
pub enum DriveStartStopType {
    /// Unknown or drive doesn't support
    ///    start/stop.
    #[doc(alias = "G_DRIVE_START_STOP_TYPE_UNKNOWN")]
    Unknown,
    /// The stop method will physically
    ///    shut down the drive and e.g. power down the port the drive is
    ///    attached to.
    #[doc(alias = "G_DRIVE_START_STOP_TYPE_SHUTDOWN")]
    Shutdown,
    /// The start/stop methods are used
    ///    for connecting/disconnect to the drive over the network.
    #[doc(alias = "G_DRIVE_START_STOP_TYPE_NETWORK")]
    Network,
    /// The start/stop methods will
    ///    assemble/disassemble a virtual drive from several physical
    ///    drives.
    #[doc(alias = "G_DRIVE_START_STOP_TYPE_MULTIDISK")]
    Multidisk,
    /// The start/stop methods will
    ///    unlock/lock the disk (for example using the ATA `SECURITY UNLOCK
    ///    DEVICE` command)
    #[doc(alias = "G_DRIVE_START_STOP_TYPE_PASSWORD")]
    Password,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for DriveStartStopType {
    type GlibType = ffi::GDriveStartStopType;

    #[inline]
    fn into_glib(self) -> ffi::GDriveStartStopType {
        match self {
            Self::Unknown => ffi::G_DRIVE_START_STOP_TYPE_UNKNOWN,
            Self::Shutdown => ffi::G_DRIVE_START_STOP_TYPE_SHUTDOWN,
            Self::Network => ffi::G_DRIVE_START_STOP_TYPE_NETWORK,
            Self::Multidisk => ffi::G_DRIVE_START_STOP_TYPE_MULTIDISK,
            Self::Password => ffi::G_DRIVE_START_STOP_TYPE_PASSWORD,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GDriveStartStopType> for DriveStartStopType {
    #[inline]
    unsafe fn from_glib(value: ffi::GDriveStartStopType) -> Self {
        match value {
            ffi::G_DRIVE_START_STOP_TYPE_UNKNOWN => Self::Unknown,
            ffi::G_DRIVE_START_STOP_TYPE_SHUTDOWN => Self::Shutdown,
            ffi::G_DRIVE_START_STOP_TYPE_NETWORK => Self::Network,
            ffi::G_DRIVE_START_STOP_TYPE_MULTIDISK => Self::Multidisk,
            ffi::G_DRIVE_START_STOP_TYPE_PASSWORD => Self::Password,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for DriveStartStopType {
    #[inline]
    #[doc(alias = "g_drive_start_stop_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_drive_start_stop_type_get_type()) }
    }
}

impl glib::HasParamSpec for DriveStartStopType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for DriveStartStopType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for DriveStartStopType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for DriveStartStopType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<DriveStartStopType> for glib::Value {
    #[inline]
    fn from(v: DriveStartStopType) -> Self {
        ToValue::to_value(&v)
    }
}

/// Possible values of Explicit Congestion Notification code points.
///
/// These appear in `TOS` (IPv4) or `TCLASS` (IPv6) packet headers and
/// are described in [RFC 3168](https://www.rfc-editor.org/rfc/rfc3168#section-5).
#[cfg(feature = "v2_88")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GEcnCodePoint")]
pub enum EcnCodePoint {
    /// Not ECN-capable transport
    #[doc(alias = "G_ECN_NO_ECN")]
    NoEcn,
    /// ECN Capable Transport(1)
    #[doc(alias = "G_ECN_ECT_1")]
    Ect1,
    /// ECN Capable Transport(0)
    #[doc(alias = "G_ECN_ECT_0")]
    Ect0,
    /// Congestion Experienced
    #[doc(alias = "G_ECN_ECT_CE")]
    EctCe,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v2_88")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
#[doc(hidden)]
impl IntoGlib for EcnCodePoint {
    type GlibType = ffi::GEcnCodePoint;

    #[inline]
    fn into_glib(self) -> ffi::GEcnCodePoint {
        match self {
            Self::NoEcn => ffi::G_ECN_NO_ECN,
            Self::Ect1 => ffi::G_ECN_ECT_1,
            Self::Ect0 => ffi::G_ECN_ECT_0,
            Self::EctCe => ffi::G_ECN_ECT_CE,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v2_88")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
#[doc(hidden)]
impl FromGlib<ffi::GEcnCodePoint> for EcnCodePoint {
    #[inline]
    unsafe fn from_glib(value: ffi::GEcnCodePoint) -> Self {
        match value {
            ffi::G_ECN_NO_ECN => Self::NoEcn,
            ffi::G_ECN_ECT_1 => Self::Ect1,
            ffi::G_ECN_ECT_0 => Self::Ect0,
            ffi::G_ECN_ECT_CE => Self::EctCe,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v2_88")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
impl StaticType for EcnCodePoint {
    #[inline]
    #[doc(alias = "g_ecn_code_point_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_ecn_code_point_get_type()) }
    }
}

#[cfg(feature = "v2_88")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
impl glib::HasParamSpec for EcnCodePoint {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v2_88")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
impl glib::value::ValueType for EcnCodePoint {
    type Type = Self;
}

#[cfg(feature = "v2_88")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
unsafe impl<'a> glib::value::FromValue<'a> for EcnCodePoint {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v2_88")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
impl ToValue for EcnCodePoint {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v2_88")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
impl From<EcnCodePoint> for glib::Value {
    #[inline]
    fn from(v: EcnCodePoint) -> Self {
        ToValue::to_value(&v)
    }
}

/// GEmblemOrigin is used to add information about the origin of the emblem
/// to #GEmblem.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GEmblemOrigin")]
pub enum EmblemOrigin {
    /// Emblem of unknown origin
    #[doc(alias = "G_EMBLEM_ORIGIN_UNKNOWN")]
    Unknown,
    /// Emblem adds device-specific information
    #[doc(alias = "G_EMBLEM_ORIGIN_DEVICE")]
    Device,
    /// Emblem depicts live metadata, such as "readonly"
    #[doc(alias = "G_EMBLEM_ORIGIN_LIVEMETADATA")]
    Livemetadata,
    /// Emblem comes from a user-defined tag, e.g. set by nautilus (in the future)
    #[doc(alias = "G_EMBLEM_ORIGIN_TAG")]
    Tag,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for EmblemOrigin {
    type GlibType = ffi::GEmblemOrigin;

    #[inline]
    fn into_glib(self) -> ffi::GEmblemOrigin {
        match self {
            Self::Unknown => ffi::G_EMBLEM_ORIGIN_UNKNOWN,
            Self::Device => ffi::G_EMBLEM_ORIGIN_DEVICE,
            Self::Livemetadata => ffi::G_EMBLEM_ORIGIN_LIVEMETADATA,
            Self::Tag => ffi::G_EMBLEM_ORIGIN_TAG,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GEmblemOrigin> for EmblemOrigin {
    #[inline]
    unsafe fn from_glib(value: ffi::GEmblemOrigin) -> Self {
        match value {
            ffi::G_EMBLEM_ORIGIN_UNKNOWN => Self::Unknown,
            ffi::G_EMBLEM_ORIGIN_DEVICE => Self::Device,
            ffi::G_EMBLEM_ORIGIN_LIVEMETADATA => Self::Livemetadata,
            ffi::G_EMBLEM_ORIGIN_TAG => Self::Tag,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for EmblemOrigin {
    #[inline]
    #[doc(alias = "g_emblem_origin_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_emblem_origin_get_type()) }
    }
}

impl glib::HasParamSpec for EmblemOrigin {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for EmblemOrigin {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for EmblemOrigin {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for EmblemOrigin {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<EmblemOrigin> for glib::Value {
    #[inline]
    fn from(v: EmblemOrigin) -> Self {
        ToValue::to_value(&v)
    }
}

/// Used by g_file_set_attributes_from_info() when setting file attributes.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GFileAttributeStatus")]
pub enum FileAttributeStatus {
    /// Attribute value is unset (empty).
    #[doc(alias = "G_FILE_ATTRIBUTE_STATUS_UNSET")]
    Unset,
    /// Attribute value is set.
    #[doc(alias = "G_FILE_ATTRIBUTE_STATUS_SET")]
    Set,
    /// Indicates an error in setting the value.
    #[doc(alias = "G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING")]
    ErrorSetting,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for FileAttributeStatus {
    type GlibType = ffi::GFileAttributeStatus;

    #[inline]
    fn into_glib(self) -> ffi::GFileAttributeStatus {
        match self {
            Self::Unset => ffi::G_FILE_ATTRIBUTE_STATUS_UNSET,
            Self::Set => ffi::G_FILE_ATTRIBUTE_STATUS_SET,
            Self::ErrorSetting => ffi::G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GFileAttributeStatus> for FileAttributeStatus {
    #[inline]
    unsafe fn from_glib(value: ffi::GFileAttributeStatus) -> Self {
        match value {
            ffi::G_FILE_ATTRIBUTE_STATUS_UNSET => Self::Unset,
            ffi::G_FILE_ATTRIBUTE_STATUS_SET => Self::Set,
            ffi::G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING => Self::ErrorSetting,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for FileAttributeStatus {
    #[inline]
    #[doc(alias = "g_file_attribute_status_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_file_attribute_status_get_type()) }
    }
}

impl glib::HasParamSpec for FileAttributeStatus {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for FileAttributeStatus {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for FileAttributeStatus {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for FileAttributeStatus {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<FileAttributeStatus> for glib::Value {
    #[inline]
    fn from(v: FileAttributeStatus) -> Self {
        ToValue::to_value(&v)
    }
}

/// The data types for file attributes.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GFileAttributeType")]
pub enum FileAttributeType {
    /// indicates an invalid or uninitialized type.
    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_INVALID")]
    Invalid,
    /// a null terminated UTF8 string.
    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_STRING")]
    String,
    /// a zero terminated string of non-zero bytes.
    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_BYTE_STRING")]
    ByteString,
    /// a boolean value.
    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_BOOLEAN")]
    Boolean,
    /// an unsigned 4-byte/32-bit integer.
    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_UINT32")]
    Uint32,
    /// a signed 4-byte/32-bit integer.
    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_INT32")]
    Int32,
    /// an unsigned 8-byte/64-bit integer.
    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_UINT64")]
    Uint64,
    /// a signed 8-byte/64-bit integer.
    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_INT64")]
    Int64,
    /// a #GObject.
    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_OBJECT")]
    Object,
    /// a [`None`] terminated char **. Since 2.22
    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_STRINGV")]
    Stringv,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for FileAttributeType {
    type GlibType = ffi::GFileAttributeType;

    #[inline]
    fn into_glib(self) -> ffi::GFileAttributeType {
        match self {
            Self::Invalid => ffi::G_FILE_ATTRIBUTE_TYPE_INVALID,
            Self::String => ffi::G_FILE_ATTRIBUTE_TYPE_STRING,
            Self::ByteString => ffi::G_FILE_ATTRIBUTE_TYPE_BYTE_STRING,
            Self::Boolean => ffi::G_FILE_ATTRIBUTE_TYPE_BOOLEAN,
            Self::Uint32 => ffi::G_FILE_ATTRIBUTE_TYPE_UINT32,
            Self::Int32 => ffi::G_FILE_ATTRIBUTE_TYPE_INT32,
            Self::Uint64 => ffi::G_FILE_ATTRIBUTE_TYPE_UINT64,
            Self::Int64 => ffi::G_FILE_ATTRIBUTE_TYPE_INT64,
            Self::Object => ffi::G_FILE_ATTRIBUTE_TYPE_OBJECT,
            Self::Stringv => ffi::G_FILE_ATTRIBUTE_TYPE_STRINGV,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GFileAttributeType> for FileAttributeType {
    #[inline]
    unsafe fn from_glib(value: ffi::GFileAttributeType) -> Self {
        match value {
            ffi::G_FILE_ATTRIBUTE_TYPE_INVALID => Self::Invalid,
            ffi::G_FILE_ATTRIBUTE_TYPE_STRING => Self::String,
            ffi::G_FILE_ATTRIBUTE_TYPE_BYTE_STRING => Self::ByteString,
            ffi::G_FILE_ATTRIBUTE_TYPE_BOOLEAN => Self::Boolean,
            ffi::G_FILE_ATTRIBUTE_TYPE_UINT32 => Self::Uint32,
            ffi::G_FILE_ATTRIBUTE_TYPE_INT32 => Self::Int32,
            ffi::G_FILE_ATTRIBUTE_TYPE_UINT64 => Self::Uint64,
            ffi::G_FILE_ATTRIBUTE_TYPE_INT64 => Self::Int64,
            ffi::G_FILE_ATTRIBUTE_TYPE_OBJECT => Self::Object,
            ffi::G_FILE_ATTRIBUTE_TYPE_STRINGV => Self::Stringv,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for FileAttributeType {
    #[inline]
    #[doc(alias = "g_file_attribute_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_file_attribute_type_get_type()) }
    }
}

impl glib::HasParamSpec for FileAttributeType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for FileAttributeType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for FileAttributeType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for FileAttributeType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<FileAttributeType> for glib::Value {
    #[inline]
    fn from(v: FileAttributeType) -> Self {
        ToValue::to_value(&v)
    }
}

/// Specifies what type of event a monitor event is.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GFileMonitorEvent")]
pub enum FileMonitorEvent {
    /// a file changed.
    #[doc(alias = "G_FILE_MONITOR_EVENT_CHANGED")]
    Changed,
    /// a hint that this was probably the last change in a set of changes.
    #[doc(alias = "G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT")]
    ChangesDoneHint,
    /// a file was deleted.
    #[doc(alias = "G_FILE_MONITOR_EVENT_DELETED")]
    Deleted,
    /// a file was created.
    #[doc(alias = "G_FILE_MONITOR_EVENT_CREATED")]
    Created,
    /// a file attribute was changed.
    #[doc(alias = "G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED")]
    AttributeChanged,
    /// the file location will soon be unmounted.
    #[doc(alias = "G_FILE_MONITOR_EVENT_PRE_UNMOUNT")]
    PreUnmount,
    /// the file location was unmounted.
    #[doc(alias = "G_FILE_MONITOR_EVENT_UNMOUNTED")]
    Unmounted,
    /// the file was moved -- only sent if the
    ///   (deprecated) [`FileMonitorFlags::SEND_MOVED`][crate::FileMonitorFlags::SEND_MOVED] flag is set
    #[doc(alias = "G_FILE_MONITOR_EVENT_MOVED")]
    Moved,
    /// the file was renamed within the
    ///   current directory -- only sent if the [`FileMonitorFlags::WATCH_MOVES`][crate::FileMonitorFlags::WATCH_MOVES]
    ///   flag is set.  Since: 2.46.
    #[doc(alias = "G_FILE_MONITOR_EVENT_RENAMED")]
    Renamed,
    /// the file was moved into the
    ///   monitored directory from another location -- only sent if the
    ///   [`FileMonitorFlags::WATCH_MOVES`][crate::FileMonitorFlags::WATCH_MOVES] flag is set.  Since: 2.46.
    #[doc(alias = "G_FILE_MONITOR_EVENT_MOVED_IN")]
    MovedIn,
    /// the file was moved out of the
    ///   monitored directory to another location -- only sent if the
    ///   [`FileMonitorFlags::WATCH_MOVES`][crate::FileMonitorFlags::WATCH_MOVES] flag is set.  Since: 2.46
    #[doc(alias = "G_FILE_MONITOR_EVENT_MOVED_OUT")]
    MovedOut,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for FileMonitorEvent {
    type GlibType = ffi::GFileMonitorEvent;

    #[inline]
    fn into_glib(self) -> ffi::GFileMonitorEvent {
        match self {
            Self::Changed => ffi::G_FILE_MONITOR_EVENT_CHANGED,
            Self::ChangesDoneHint => ffi::G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT,
            Self::Deleted => ffi::G_FILE_MONITOR_EVENT_DELETED,
            Self::Created => ffi::G_FILE_MONITOR_EVENT_CREATED,
            Self::AttributeChanged => ffi::G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED,
            Self::PreUnmount => ffi::G_FILE_MONITOR_EVENT_PRE_UNMOUNT,
            Self::Unmounted => ffi::G_FILE_MONITOR_EVENT_UNMOUNTED,
            Self::Moved => ffi::G_FILE_MONITOR_EVENT_MOVED,
            Self::Renamed => ffi::G_FILE_MONITOR_EVENT_RENAMED,
            Self::MovedIn => ffi::G_FILE_MONITOR_EVENT_MOVED_IN,
            Self::MovedOut => ffi::G_FILE_MONITOR_EVENT_MOVED_OUT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GFileMonitorEvent> for FileMonitorEvent {
    #[inline]
    unsafe fn from_glib(value: ffi::GFileMonitorEvent) -> Self {
        match value {
            ffi::G_FILE_MONITOR_EVENT_CHANGED => Self::Changed,
            ffi::G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT => Self::ChangesDoneHint,
            ffi::G_FILE_MONITOR_EVENT_DELETED => Self::Deleted,
            ffi::G_FILE_MONITOR_EVENT_CREATED => Self::Created,
            ffi::G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED => Self::AttributeChanged,
            ffi::G_FILE_MONITOR_EVENT_PRE_UNMOUNT => Self::PreUnmount,
            ffi::G_FILE_MONITOR_EVENT_UNMOUNTED => Self::Unmounted,
            ffi::G_FILE_MONITOR_EVENT_MOVED => Self::Moved,
            ffi::G_FILE_MONITOR_EVENT_RENAMED => Self::Renamed,
            ffi::G_FILE_MONITOR_EVENT_MOVED_IN => Self::MovedIn,
            ffi::G_FILE_MONITOR_EVENT_MOVED_OUT => Self::MovedOut,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for FileMonitorEvent {
    #[inline]
    #[doc(alias = "g_file_monitor_event_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_file_monitor_event_get_type()) }
    }
}

impl glib::HasParamSpec for FileMonitorEvent {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for FileMonitorEvent {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for FileMonitorEvent {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for FileMonitorEvent {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<FileMonitorEvent> for glib::Value {
    #[inline]
    fn from(v: FileMonitorEvent) -> Self {
        ToValue::to_value(&v)
    }
}

/// Indicates the file's on-disk type.
///
/// On Windows systems a file will never have [`SymbolicLink`][Self::SymbolicLink] type;
/// use #GFileInfo and [`FILE_ATTRIBUTE_STANDARD_IS_SYMLINK`][crate::FILE_ATTRIBUTE_STANDARD_IS_SYMLINK] to determine
/// whether a file is a symlink or not. This is due to the fact that NTFS does
/// not have a single filesystem object type for symbolic links - it has
/// files that symlink to files, and directories that symlink to directories.
/// #GFileType enumeration cannot precisely represent this important distinction,
/// which is why all Windows symlinks will continue to be reported as
/// [`Regular`][Self::Regular] or [`Directory`][Self::Directory].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GFileType")]
pub enum FileType {
    /// File's type is unknown.
    #[doc(alias = "G_FILE_TYPE_UNKNOWN")]
    Unknown,
    /// File handle represents a regular file.
    #[doc(alias = "G_FILE_TYPE_REGULAR")]
    Regular,
    /// File handle represents a directory.
    #[doc(alias = "G_FILE_TYPE_DIRECTORY")]
    Directory,
    /// File handle represents a symbolic link
    ///    (Unix systems).
    #[doc(alias = "G_FILE_TYPE_SYMBOLIC_LINK")]
    SymbolicLink,
    /// File is a "special" file, such as a socket, fifo,
    ///    block device, or character device.
    #[doc(alias = "G_FILE_TYPE_SPECIAL")]
    Special,
    /// File is a shortcut (Windows systems).
    #[doc(alias = "G_FILE_TYPE_SHORTCUT")]
    Shortcut,
    /// File is a mountable location.
    #[doc(alias = "G_FILE_TYPE_MOUNTABLE")]
    Mountable,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for FileType {
    type GlibType = ffi::GFileType;

    #[inline]
    fn into_glib(self) -> ffi::GFileType {
        match self {
            Self::Unknown => ffi::G_FILE_TYPE_UNKNOWN,
            Self::Regular => ffi::G_FILE_TYPE_REGULAR,
            Self::Directory => ffi::G_FILE_TYPE_DIRECTORY,
            Self::SymbolicLink => ffi::G_FILE_TYPE_SYMBOLIC_LINK,
            Self::Special => ffi::G_FILE_TYPE_SPECIAL,
            Self::Shortcut => ffi::G_FILE_TYPE_SHORTCUT,
            Self::Mountable => ffi::G_FILE_TYPE_MOUNTABLE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GFileType> for FileType {
    #[inline]
    unsafe fn from_glib(value: ffi::GFileType) -> Self {
        match value {
            ffi::G_FILE_TYPE_UNKNOWN => Self::Unknown,
            ffi::G_FILE_TYPE_REGULAR => Self::Regular,
            ffi::G_FILE_TYPE_DIRECTORY => Self::Directory,
            ffi::G_FILE_TYPE_SYMBOLIC_LINK => Self::SymbolicLink,
            ffi::G_FILE_TYPE_SPECIAL => Self::Special,
            ffi::G_FILE_TYPE_SHORTCUT => Self::Shortcut,
            ffi::G_FILE_TYPE_MOUNTABLE => Self::Mountable,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for FileType {
    #[inline]
    #[doc(alias = "g_file_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_file_type_get_type()) }
    }
}

impl glib::HasParamSpec for FileType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for FileType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for FileType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for FileType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<FileType> for glib::Value {
    #[inline]
    fn from(v: FileType) -> Self {
        ToValue::to_value(&v)
    }
}

/// Indicates a hint from the file system whether files should be
/// previewed in a file manager. Returned as the value of the key
/// [`FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW`][crate::FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GFilesystemPreviewType")]
pub enum FilesystemPreviewType {
    /// Only preview files if user has explicitly requested it.
    #[doc(alias = "G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS")]
    IfAlways,
    /// Preview files if user has requested preview of "local" files.
    #[doc(alias = "G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL")]
    IfLocal,
    /// Never preview files.
    #[doc(alias = "G_FILESYSTEM_PREVIEW_TYPE_NEVER")]
    Never,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for FilesystemPreviewType {
    type GlibType = ffi::GFilesystemPreviewType;

    #[inline]
    fn into_glib(self) -> ffi::GFilesystemPreviewType {
        match self {
            Self::IfAlways => ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS,
            Self::IfLocal => ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL,
            Self::Never => ffi::G_FILESYSTEM_PREVIEW_TYPE_NEVER,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GFilesystemPreviewType> for FilesystemPreviewType {
    #[inline]
    unsafe fn from_glib(value: ffi::GFilesystemPreviewType) -> Self {
        match value {
            ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS => Self::IfAlways,
            ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL => Self::IfLocal,
            ffi::G_FILESYSTEM_PREVIEW_TYPE_NEVER => Self::Never,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for FilesystemPreviewType {
    #[inline]
    #[doc(alias = "g_filesystem_preview_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_filesystem_preview_type_get_type()) }
    }
}

impl glib::HasParamSpec for FilesystemPreviewType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for FilesystemPreviewType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for FilesystemPreviewType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for FilesystemPreviewType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<FilesystemPreviewType> for glib::Value {
    #[inline]
    fn from(v: FilesystemPreviewType) -> Self {
        ToValue::to_value(&v)
    }
}

/// Error codes returned by GIO functions.
///
/// Note that this domain may be extended in future GLib releases. In
/// general, new error codes either only apply to new APIs, or else
/// replace [`Failed`][Self::Failed] in cases that were not explicitly
/// distinguished before. You should therefore avoid writing code like
///
///
/// **⚠️ The following code is in C ⚠️**
///
/// ```C
/// if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED))
///   {
///     // Assume that this is EPRINTERONFIRE
///     ...
///   }
/// ```
/// but should instead treat all unrecognized error codes the same as
/// [`Failed`][Self::Failed].
///
/// See also #GPollableReturn for a cheaper way of returning
/// [`WouldBlock`][Self::WouldBlock] to callers without allocating a #GError.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GIOErrorEnum")]
pub enum IOErrorEnum {
    /// Generic error condition for when an operation fails
    ///     and no more specific #GIOErrorEnum value is defined.
    #[doc(alias = "G_IO_ERROR_FAILED")]
    Failed,
    /// File not found.
    #[doc(alias = "G_IO_ERROR_NOT_FOUND")]
    NotFound,
    /// File already exists.
    #[doc(alias = "G_IO_ERROR_EXISTS")]
    Exists,
    /// File is a directory.
    #[doc(alias = "G_IO_ERROR_IS_DIRECTORY")]
    IsDirectory,
    /// File is not a directory.
    #[doc(alias = "G_IO_ERROR_NOT_DIRECTORY")]
    NotDirectory,
    /// File is a directory that isn't empty.
    #[doc(alias = "G_IO_ERROR_NOT_EMPTY")]
    NotEmpty,
    /// File is not a regular file.
    #[doc(alias = "G_IO_ERROR_NOT_REGULAR_FILE")]
    NotRegularFile,
    /// File is not a symbolic link.
    #[doc(alias = "G_IO_ERROR_NOT_SYMBOLIC_LINK")]
    NotSymbolicLink,
    /// File cannot be mounted.
    #[doc(alias = "G_IO_ERROR_NOT_MOUNTABLE_FILE")]
    NotMountableFile,
    /// Filename is too many characters.
    #[doc(alias = "G_IO_ERROR_FILENAME_TOO_LONG")]
    FilenameTooLong,
    /// Filename is invalid or contains invalid characters.
    #[doc(alias = "G_IO_ERROR_INVALID_FILENAME")]
    InvalidFilename,
    /// File contains too many symbolic links.
    #[doc(alias = "G_IO_ERROR_TOO_MANY_LINKS")]
    TooManyLinks,
    /// No space left on drive.
    #[doc(alias = "G_IO_ERROR_NO_SPACE")]
    NoSpace,
    /// Invalid argument.
    #[doc(alias = "G_IO_ERROR_INVALID_ARGUMENT")]
    InvalidArgument,
    /// Permission denied.
    #[doc(alias = "G_IO_ERROR_PERMISSION_DENIED")]
    PermissionDenied,
    /// Operation (or one of its parameters) not supported
    #[doc(alias = "G_IO_ERROR_NOT_SUPPORTED")]
    NotSupported,
    /// File isn't mounted.
    #[doc(alias = "G_IO_ERROR_NOT_MOUNTED")]
    NotMounted,
    /// File is already mounted.
    #[doc(alias = "G_IO_ERROR_ALREADY_MOUNTED")]
    AlreadyMounted,
    /// File was closed.
    #[doc(alias = "G_IO_ERROR_CLOSED")]
    Closed,
    /// Operation was cancelled. See #GCancellable.
    #[doc(alias = "G_IO_ERROR_CANCELLED")]
    Cancelled,
    /// Operations are still pending.
    #[doc(alias = "G_IO_ERROR_PENDING")]
    Pending,
    /// File is read only.
    #[doc(alias = "G_IO_ERROR_READ_ONLY")]
    ReadOnly,
    /// Backup couldn't be created.
    #[doc(alias = "G_IO_ERROR_CANT_CREATE_BACKUP")]
    CantCreateBackup,
    /// File's Entity Tag was incorrect.
    #[doc(alias = "G_IO_ERROR_WRONG_ETAG")]
    WrongEtag,
    /// Operation timed out.
    #[doc(alias = "G_IO_ERROR_TIMED_OUT")]
    TimedOut,
    /// Operation would be recursive.
    #[doc(alias = "G_IO_ERROR_WOULD_RECURSE")]
    WouldRecurse,
    /// File is busy.
    #[doc(alias = "G_IO_ERROR_BUSY")]
    Busy,
    /// Operation would block.
    #[doc(alias = "G_IO_ERROR_WOULD_BLOCK")]
    WouldBlock,
    /// Host couldn't be found (remote operations).
    #[doc(alias = "G_IO_ERROR_HOST_NOT_FOUND")]
    HostNotFound,
    /// Operation would merge files.
    #[doc(alias = "G_IO_ERROR_WOULD_MERGE")]
    WouldMerge,
    /// Operation failed and a helper program has
    ///     already interacted with the user. Do not display any error dialog.
    #[doc(alias = "G_IO_ERROR_FAILED_HANDLED")]
    FailedHandled,
    /// The current process has too many files
    ///     open and can't open any more. Duplicate descriptors do count toward
    ///     this limit. Since 2.20
    #[doc(alias = "G_IO_ERROR_TOO_MANY_OPEN_FILES")]
    TooManyOpenFiles,
    /// The object has not been initialized. Since 2.22
    #[doc(alias = "G_IO_ERROR_NOT_INITIALIZED")]
    NotInitialized,
    /// The requested address is already in use. Since 2.22
    #[doc(alias = "G_IO_ERROR_ADDRESS_IN_USE")]
    AddressInUse,
    /// Need more input to finish operation. Since 2.24
    #[doc(alias = "G_IO_ERROR_PARTIAL_INPUT")]
    PartialInput,
    /// The input data was invalid. Since 2.24
    #[doc(alias = "G_IO_ERROR_INVALID_DATA")]
    InvalidData,
    /// A remote object generated an error that
    ///     doesn't correspond to a locally registered #GError error
    ///     domain. Use g_dbus_error_get_remote_error() to extract the D-Bus
    ///     error name and g_dbus_error_strip_remote_error() to fix up the
    ///     message so it matches what was received on the wire. Since 2.26.
    #[doc(alias = "G_IO_ERROR_DBUS_ERROR")]
    DbusError,
    /// Host unreachable. Since 2.26
    #[doc(alias = "G_IO_ERROR_HOST_UNREACHABLE")]
    HostUnreachable,
    /// Network unreachable. Since 2.26
    #[doc(alias = "G_IO_ERROR_NETWORK_UNREACHABLE")]
    NetworkUnreachable,
    /// Connection refused. Since 2.26
    #[doc(alias = "G_IO_ERROR_CONNECTION_REFUSED")]
    ConnectionRefused,
    /// Connection to proxy server failed. Since 2.26
    #[doc(alias = "G_IO_ERROR_PROXY_FAILED")]
    ProxyFailed,
    /// Proxy authentication failed. Since 2.26
    #[doc(alias = "G_IO_ERROR_PROXY_AUTH_FAILED")]
    ProxyAuthFailed,
    /// Proxy server needs authentication. Since 2.26
    #[doc(alias = "G_IO_ERROR_PROXY_NEED_AUTH")]
    ProxyNeedAuth,
    /// Proxy connection is not allowed by ruleset.
    ///     Since 2.26
    #[doc(alias = "G_IO_ERROR_PROXY_NOT_ALLOWED")]
    ProxyNotAllowed,
    /// Broken pipe. Since 2.36
    #[doc(alias = "G_IO_ERROR_BROKEN_PIPE")]
    BrokenPipe,
    /// Transport endpoint is not connected. Since 2.44
    #[doc(alias = "G_IO_ERROR_NOT_CONNECTED")]
    NotConnected,
    /// Message too large. Since 2.48.
    #[doc(alias = "G_IO_ERROR_MESSAGE_TOO_LARGE")]
    MessageTooLarge,
    /// No such device found. Since 2.74
    #[cfg(feature = "v2_72")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
    #[doc(alias = "G_IO_ERROR_NO_SUCH_DEVICE")]
    NoSuchDevice,
    /// Destination address unset. Since 2.80
    #[cfg(feature = "v2_80")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_80")))]
    #[doc(alias = "G_IO_ERROR_DESTINATION_UNSET")]
    DestinationUnset,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for IOErrorEnum {
    type GlibType = ffi::GIOErrorEnum;

    fn into_glib(self) -> ffi::GIOErrorEnum {
        match self {
            Self::Failed => ffi::G_IO_ERROR_FAILED,
            Self::NotFound => ffi::G_IO_ERROR_NOT_FOUND,
            Self::Exists => ffi::G_IO_ERROR_EXISTS,
            Self::IsDirectory => ffi::G_IO_ERROR_IS_DIRECTORY,
            Self::NotDirectory => ffi::G_IO_ERROR_NOT_DIRECTORY,
            Self::NotEmpty => ffi::G_IO_ERROR_NOT_EMPTY,
            Self::NotRegularFile => ffi::G_IO_ERROR_NOT_REGULAR_FILE,
            Self::NotSymbolicLink => ffi::G_IO_ERROR_NOT_SYMBOLIC_LINK,
            Self::NotMountableFile => ffi::G_IO_ERROR_NOT_MOUNTABLE_FILE,
            Self::FilenameTooLong => ffi::G_IO_ERROR_FILENAME_TOO_LONG,
            Self::InvalidFilename => ffi::G_IO_ERROR_INVALID_FILENAME,
            Self::TooManyLinks => ffi::G_IO_ERROR_TOO_MANY_LINKS,
            Self::NoSpace => ffi::G_IO_ERROR_NO_SPACE,
            Self::InvalidArgument => ffi::G_IO_ERROR_INVALID_ARGUMENT,
            Self::PermissionDenied => ffi::G_IO_ERROR_PERMISSION_DENIED,
            Self::NotSupported => ffi::G_IO_ERROR_NOT_SUPPORTED,
            Self::NotMounted => ffi::G_IO_ERROR_NOT_MOUNTED,
            Self::AlreadyMounted => ffi::G_IO_ERROR_ALREADY_MOUNTED,
            Self::Closed => ffi::G_IO_ERROR_CLOSED,
            Self::Cancelled => ffi::G_IO_ERROR_CANCELLED,
            Self::Pending => ffi::G_IO_ERROR_PENDING,
            Self::ReadOnly => ffi::G_IO_ERROR_READ_ONLY,
            Self::CantCreateBackup => ffi::G_IO_ERROR_CANT_CREATE_BACKUP,
            Self::WrongEtag => ffi::G_IO_ERROR_WRONG_ETAG,
            Self::TimedOut => ffi::G_IO_ERROR_TIMED_OUT,
            Self::WouldRecurse => ffi::G_IO_ERROR_WOULD_RECURSE,
            Self::Busy => ffi::G_IO_ERROR_BUSY,
            Self::WouldBlock => ffi::G_IO_ERROR_WOULD_BLOCK,
            Self::HostNotFound => ffi::G_IO_ERROR_HOST_NOT_FOUND,
            Self::WouldMerge => ffi::G_IO_ERROR_WOULD_MERGE,
            Self::FailedHandled => ffi::G_IO_ERROR_FAILED_HANDLED,
            Self::TooManyOpenFiles => ffi::G_IO_ERROR_TOO_MANY_OPEN_FILES,
            Self::NotInitialized => ffi::G_IO_ERROR_NOT_INITIALIZED,
            Self::AddressInUse => ffi::G_IO_ERROR_ADDRESS_IN_USE,
            Self::PartialInput => ffi::G_IO_ERROR_PARTIAL_INPUT,
            Self::InvalidData => ffi::G_IO_ERROR_INVALID_DATA,
            Self::DbusError => ffi::G_IO_ERROR_DBUS_ERROR,
            Self::HostUnreachable => ffi::G_IO_ERROR_HOST_UNREACHABLE,
            Self::NetworkUnreachable => ffi::G_IO_ERROR_NETWORK_UNREACHABLE,
            Self::ConnectionRefused => ffi::G_IO_ERROR_CONNECTION_REFUSED,
            Self::ProxyFailed => ffi::G_IO_ERROR_PROXY_FAILED,
            Self::ProxyAuthFailed => ffi::G_IO_ERROR_PROXY_AUTH_FAILED,
            Self::ProxyNeedAuth => ffi::G_IO_ERROR_PROXY_NEED_AUTH,
            Self::ProxyNotAllowed => ffi::G_IO_ERROR_PROXY_NOT_ALLOWED,
            Self::BrokenPipe => ffi::G_IO_ERROR_BROKEN_PIPE,
            Self::NotConnected => ffi::G_IO_ERROR_NOT_CONNECTED,
            Self::MessageTooLarge => ffi::G_IO_ERROR_MESSAGE_TOO_LARGE,
            #[cfg(feature = "v2_72")]
            Self::NoSuchDevice => ffi::G_IO_ERROR_NO_SUCH_DEVICE,
            #[cfg(feature = "v2_80")]
            Self::DestinationUnset => ffi::G_IO_ERROR_DESTINATION_UNSET,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GIOErrorEnum> for IOErrorEnum {
    unsafe fn from_glib(value: ffi::GIOErrorEnum) -> Self {
        match value {
            ffi::G_IO_ERROR_FAILED => Self::Failed,
            ffi::G_IO_ERROR_NOT_FOUND => Self::NotFound,
            ffi::G_IO_ERROR_EXISTS => Self::Exists,
            ffi::G_IO_ERROR_IS_DIRECTORY => Self::IsDirectory,
            ffi::G_IO_ERROR_NOT_DIRECTORY => Self::NotDirectory,
            ffi::G_IO_ERROR_NOT_EMPTY => Self::NotEmpty,
            ffi::G_IO_ERROR_NOT_REGULAR_FILE => Self::NotRegularFile,
            ffi::G_IO_ERROR_NOT_SYMBOLIC_LINK => Self::NotSymbolicLink,
            ffi::G_IO_ERROR_NOT_MOUNTABLE_FILE => Self::NotMountableFile,
            ffi::G_IO_ERROR_FILENAME_TOO_LONG => Self::FilenameTooLong,
            ffi::G_IO_ERROR_INVALID_FILENAME => Self::InvalidFilename,
            ffi::G_IO_ERROR_TOO_MANY_LINKS => Self::TooManyLinks,
            ffi::G_IO_ERROR_NO_SPACE => Self::NoSpace,
            ffi::G_IO_ERROR_INVALID_ARGUMENT => Self::InvalidArgument,
            ffi::G_IO_ERROR_PERMISSION_DENIED => Self::PermissionDenied,
            ffi::G_IO_ERROR_NOT_SUPPORTED => Self::NotSupported,
            ffi::G_IO_ERROR_NOT_MOUNTED => Self::NotMounted,
            ffi::G_IO_ERROR_ALREADY_MOUNTED => Self::AlreadyMounted,
            ffi::G_IO_ERROR_CLOSED => Self::Closed,
            ffi::G_IO_ERROR_CANCELLED => Self::Cancelled,
            ffi::G_IO_ERROR_PENDING => Self::Pending,
            ffi::G_IO_ERROR_READ_ONLY => Self::ReadOnly,
            ffi::G_IO_ERROR_CANT_CREATE_BACKUP => Self::CantCreateBackup,
            ffi::G_IO_ERROR_WRONG_ETAG => Self::WrongEtag,
            ffi::G_IO_ERROR_TIMED_OUT => Self::TimedOut,
            ffi::G_IO_ERROR_WOULD_RECURSE => Self::WouldRecurse,
            ffi::G_IO_ERROR_BUSY => Self::Busy,
            ffi::G_IO_ERROR_WOULD_BLOCK => Self::WouldBlock,
            ffi::G_IO_ERROR_HOST_NOT_FOUND => Self::HostNotFound,
            ffi::G_IO_ERROR_WOULD_MERGE => Self::WouldMerge,
            ffi::G_IO_ERROR_FAILED_HANDLED => Self::FailedHandled,
            ffi::G_IO_ERROR_TOO_MANY_OPEN_FILES => Self::TooManyOpenFiles,
            ffi::G_IO_ERROR_NOT_INITIALIZED => Self::NotInitialized,
            ffi::G_IO_ERROR_ADDRESS_IN_USE => Self::AddressInUse,
            ffi::G_IO_ERROR_PARTIAL_INPUT => Self::PartialInput,
            ffi::G_IO_ERROR_INVALID_DATA => Self::InvalidData,
            ffi::G_IO_ERROR_DBUS_ERROR => Self::DbusError,
            ffi::G_IO_ERROR_HOST_UNREACHABLE => Self::HostUnreachable,
            ffi::G_IO_ERROR_NETWORK_UNREACHABLE => Self::NetworkUnreachable,
            ffi::G_IO_ERROR_CONNECTION_REFUSED => Self::ConnectionRefused,
            ffi::G_IO_ERROR_PROXY_FAILED => Self::ProxyFailed,
            ffi::G_IO_ERROR_PROXY_AUTH_FAILED => Self::ProxyAuthFailed,
            ffi::G_IO_ERROR_PROXY_NEED_AUTH => Self::ProxyNeedAuth,
            ffi::G_IO_ERROR_PROXY_NOT_ALLOWED => Self::ProxyNotAllowed,
            ffi::G_IO_ERROR_BROKEN_PIPE => Self::BrokenPipe,
            ffi::G_IO_ERROR_NOT_CONNECTED => Self::NotConnected,
            ffi::G_IO_ERROR_MESSAGE_TOO_LARGE => Self::MessageTooLarge,
            #[cfg(feature = "v2_72")]
            ffi::G_IO_ERROR_NO_SUCH_DEVICE => Self::NoSuchDevice,
            #[cfg(feature = "v2_80")]
            ffi::G_IO_ERROR_DESTINATION_UNSET => Self::DestinationUnset,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for IOErrorEnum {
    #[inline]
    fn domain() -> glib::Quark {
        unsafe { from_glib(ffi::g_io_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        match unsafe { from_glib(code) } {
            Self::__Unknown(_) => Some(Self::Failed),
            value => Some(value),
        }
    }
}

impl StaticType for IOErrorEnum {
    #[inline]
    #[doc(alias = "g_io_error_enum_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_io_error_enum_get_type()) }
    }
}

impl glib::HasParamSpec for IOErrorEnum {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for IOErrorEnum {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for IOErrorEnum {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for IOErrorEnum {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<IOErrorEnum> for glib::Value {
    #[inline]
    fn from(v: IOErrorEnum) -> Self {
        ToValue::to_value(&v)
    }
}

/// Memory availability warning levels.
///
/// Note that because new values might be added, it is recommended that applications check
/// #GMemoryMonitorWarningLevel as ranges, for example:
///
///
/// **⚠️ The following code is in C ⚠️**
///
/// ```C
/// if (warning_level > G_MEMORY_MONITOR_WARNING_LEVEL_LOW)
///   drop_caches ();
/// ```
#[cfg(feature = "v2_64")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GMemoryMonitorWarningLevel")]
pub enum MemoryMonitorWarningLevel {
    /// Memory on the device is low, processes
    ///   should free up unneeded resources (for example, in-memory caches) so they can
    ///   be used elsewhere.
    #[doc(alias = "G_MEMORY_MONITOR_WARNING_LEVEL_LOW")]
    Low,
    /// Same as @G_MEMORY_MONITOR_WARNING_LEVEL_LOW
    ///   but the device has even less free memory, so processes should try harder to free
    ///   up unneeded resources. If your process does not need to stay running, it is a
    ///   good time for it to quit.
    #[doc(alias = "G_MEMORY_MONITOR_WARNING_LEVEL_MEDIUM")]
    Medium,
    /// The system will soon start terminating
    ///   processes to reclaim memory, including background processes.
    #[doc(alias = "G_MEMORY_MONITOR_WARNING_LEVEL_CRITICAL")]
    Critical,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v2_64")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
#[doc(hidden)]
impl IntoGlib for MemoryMonitorWarningLevel {
    type GlibType = ffi::GMemoryMonitorWarningLevel;

    #[inline]
    fn into_glib(self) -> ffi::GMemoryMonitorWarningLevel {
        match self {
            Self::Low => ffi::G_MEMORY_MONITOR_WARNING_LEVEL_LOW,
            Self::Medium => ffi::G_MEMORY_MONITOR_WARNING_LEVEL_MEDIUM,
            Self::Critical => ffi::G_MEMORY_MONITOR_WARNING_LEVEL_CRITICAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v2_64")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
#[doc(hidden)]
impl FromGlib<ffi::GMemoryMonitorWarningLevel> for MemoryMonitorWarningLevel {
    #[inline]
    unsafe fn from_glib(value: ffi::GMemoryMonitorWarningLevel) -> Self {
        match value {
            ffi::G_MEMORY_MONITOR_WARNING_LEVEL_LOW => Self::Low,
            ffi::G_MEMORY_MONITOR_WARNING_LEVEL_MEDIUM => Self::Medium,
            ffi::G_MEMORY_MONITOR_WARNING_LEVEL_CRITICAL => Self::Critical,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v2_64")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
impl StaticType for MemoryMonitorWarningLevel {
    #[inline]
    #[doc(alias = "g_memory_monitor_warning_level_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_memory_monitor_warning_level_get_type()) }
    }
}

#[cfg(feature = "v2_64")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
impl glib::HasParamSpec for MemoryMonitorWarningLevel {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v2_64")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
impl glib::value::ValueType for MemoryMonitorWarningLevel {
    type Type = Self;
}

#[cfg(feature = "v2_64")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
unsafe impl<'a> glib::value::FromValue<'a> for MemoryMonitorWarningLevel {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v2_64")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
impl ToValue for MemoryMonitorWarningLevel {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v2_64")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
impl From<MemoryMonitorWarningLevel> for glib::Value {
    #[inline]
    fn from(v: MemoryMonitorWarningLevel) -> Self {
        ToValue::to_value(&v)
    }
}

/// #GMountOperationResult is returned as a result when a request for
/// information is send by the mounting operation.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GMountOperationResult")]
pub enum MountOperationResult {
    /// The request was fulfilled and the
    ///     user specified data is now available
    #[doc(alias = "G_MOUNT_OPERATION_HANDLED")]
    Handled,
    /// The user requested the mount operation
    ///     to be aborted
    #[doc(alias = "G_MOUNT_OPERATION_ABORTED")]
    Aborted,
    /// The request was unhandled (i.e. not
    ///     implemented)
    #[doc(alias = "G_MOUNT_OPERATION_UNHANDLED")]
    Unhandled,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for MountOperationResult {
    type GlibType = ffi::GMountOperationResult;

    #[inline]
    fn into_glib(self) -> ffi::GMountOperationResult {
        match self {
            Self::Handled => ffi::G_MOUNT_OPERATION_HANDLED,
            Self::Aborted => ffi::G_MOUNT_OPERATION_ABORTED,
            Self::Unhandled => ffi::G_MOUNT_OPERATION_UNHANDLED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GMountOperationResult> for MountOperationResult {
    #[inline]
    unsafe fn from_glib(value: ffi::GMountOperationResult) -> Self {
        match value {
            ffi::G_MOUNT_OPERATION_HANDLED => Self::Handled,
            ffi::G_MOUNT_OPERATION_ABORTED => Self::Aborted,
            ffi::G_MOUNT_OPERATION_UNHANDLED => Self::Unhandled,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for MountOperationResult {
    #[inline]
    #[doc(alias = "g_mount_operation_result_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_mount_operation_result_get_type()) }
    }
}

impl glib::HasParamSpec for MountOperationResult {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for MountOperationResult {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for MountOperationResult {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for MountOperationResult {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<MountOperationResult> for glib::Value {
    #[inline]
    fn from(v: MountOperationResult) -> Self {
        ToValue::to_value(&v)
    }
}

/// The host's network connectivity state, as reported by #GNetworkMonitor.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GNetworkConnectivity")]
pub enum NetworkConnectivity {
    /// The host is not configured with a
    ///   route to the Internet; it may or may not be connected to a local
    ///   network.
    #[doc(alias = "G_NETWORK_CONNECTIVITY_LOCAL")]
    Local,
    /// The host is connected to a network, but
    ///   does not appear to be able to reach the full Internet, perhaps
    ///   due to upstream network problems.
    #[doc(alias = "G_NETWORK_CONNECTIVITY_LIMITED")]
    Limited,
    /// The host is behind a captive portal and
    ///   cannot reach the full Internet.
    #[doc(alias = "G_NETWORK_CONNECTIVITY_PORTAL")]
    Portal,
    /// The host is connected to a network, and
    ///   appears to be able to reach the full Internet.
    #[doc(alias = "G_NETWORK_CONNECTIVITY_FULL")]
    Full,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for NetworkConnectivity {
    type GlibType = ffi::GNetworkConnectivity;

    #[inline]
    fn into_glib(self) -> ffi::GNetworkConnectivity {
        match self {
            Self::Local => ffi::G_NETWORK_CONNECTIVITY_LOCAL,
            Self::Limited => ffi::G_NETWORK_CONNECTIVITY_LIMITED,
            Self::Portal => ffi::G_NETWORK_CONNECTIVITY_PORTAL,
            Self::Full => ffi::G_NETWORK_CONNECTIVITY_FULL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GNetworkConnectivity> for NetworkConnectivity {
    #[inline]
    unsafe fn from_glib(value: ffi::GNetworkConnectivity) -> Self {
        match value {
            ffi::G_NETWORK_CONNECTIVITY_LOCAL => Self::Local,
            ffi::G_NETWORK_CONNECTIVITY_LIMITED => Self::Limited,
            ffi::G_NETWORK_CONNECTIVITY_PORTAL => Self::Portal,
            ffi::G_NETWORK_CONNECTIVITY_FULL => Self::Full,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for NetworkConnectivity {
    #[inline]
    #[doc(alias = "g_network_connectivity_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_network_connectivity_get_type()) }
    }
}

impl glib::HasParamSpec for NetworkConnectivity {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for NetworkConnectivity {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for NetworkConnectivity {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for NetworkConnectivity {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<NetworkConnectivity> for glib::Value {
    #[inline]
    fn from(v: NetworkConnectivity) -> Self {
        ToValue::to_value(&v)
    }
}

/// Priority levels for #GNotifications.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GNotificationPriority")]
pub enum NotificationPriority {
    /// the default priority, to be used for the
    ///   majority of notifications (for example email messages, software updates,
    ///   completed download/sync operations)
    #[doc(alias = "G_NOTIFICATION_PRIORITY_NORMAL")]
    Normal,
    /// for notifications that do not require
    ///   immediate attention - typically used for contextual background
    ///   information, such as contact birthdays or local weather
    #[doc(alias = "G_NOTIFICATION_PRIORITY_LOW")]
    Low,
    /// for events that require more attention,
    ///   usually because responses are time-sensitive (for example chat and SMS
    ///   messages or alarms)
    #[doc(alias = "G_NOTIFICATION_PRIORITY_HIGH")]
    High,
    /// for urgent notifications, or notifications
    ///   that require a response in a short space of time (for example phone calls
    ///   or emergency warnings)
    #[doc(alias = "G_NOTIFICATION_PRIORITY_URGENT")]
    Urgent,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for NotificationPriority {
    type GlibType = ffi::GNotificationPriority;

    #[inline]
    fn into_glib(self) -> ffi::GNotificationPriority {
        match self {
            Self::Normal => ffi::G_NOTIFICATION_PRIORITY_NORMAL,
            Self::Low => ffi::G_NOTIFICATION_PRIORITY_LOW,
            Self::High => ffi::G_NOTIFICATION_PRIORITY_HIGH,
            Self::Urgent => ffi::G_NOTIFICATION_PRIORITY_URGENT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GNotificationPriority> for NotificationPriority {
    #[inline]
    unsafe fn from_glib(value: ffi::GNotificationPriority) -> Self {
        match value {
            ffi::G_NOTIFICATION_PRIORITY_NORMAL => Self::Normal,
            ffi::G_NOTIFICATION_PRIORITY_LOW => Self::Low,
            ffi::G_NOTIFICATION_PRIORITY_HIGH => Self::High,
            ffi::G_NOTIFICATION_PRIORITY_URGENT => Self::Urgent,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for NotificationPriority {
    #[inline]
    #[doc(alias = "g_notification_priority_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_notification_priority_get_type()) }
    }
}

impl glib::HasParamSpec for NotificationPriority {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for NotificationPriority {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for NotificationPriority {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for NotificationPriority {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<NotificationPriority> for glib::Value {
    #[inline]
    fn from(v: NotificationPriority) -> Self {
        ToValue::to_value(&v)
    }
}

/// #GPasswordSave is used to indicate the lifespan of a saved password.
///
/// #Gvfs stores passwords in the Gnome keyring when this flag allows it
/// to, and later retrieves it again from there.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GPasswordSave")]
pub enum PasswordSave {
    /// never save a password.
    #[doc(alias = "G_PASSWORD_SAVE_NEVER")]
    Never,
    /// save a password for the session.
    #[doc(alias = "G_PASSWORD_SAVE_FOR_SESSION")]
    ForSession,
    /// save a password permanently.
    #[doc(alias = "G_PASSWORD_SAVE_PERMANENTLY")]
    Permanently,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PasswordSave {
    type GlibType = ffi::GPasswordSave;

    #[inline]
    fn into_glib(self) -> ffi::GPasswordSave {
        match self {
            Self::Never => ffi::G_PASSWORD_SAVE_NEVER,
            Self::ForSession => ffi::G_PASSWORD_SAVE_FOR_SESSION,
            Self::Permanently => ffi::G_PASSWORD_SAVE_PERMANENTLY,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GPasswordSave> for PasswordSave {
    #[inline]
    unsafe fn from_glib(value: ffi::GPasswordSave) -> Self {
        match value {
            ffi::G_PASSWORD_SAVE_NEVER => Self::Never,
            ffi::G_PASSWORD_SAVE_FOR_SESSION => Self::ForSession,
            ffi::G_PASSWORD_SAVE_PERMANENTLY => Self::Permanently,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PasswordSave {
    #[inline]
    #[doc(alias = "g_password_save_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_password_save_get_type()) }
    }
}

impl glib::HasParamSpec for PasswordSave {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PasswordSave {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PasswordSave {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PasswordSave {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PasswordSave> for glib::Value {
    #[inline]
    fn from(v: PasswordSave) -> Self {
        ToValue::to_value(&v)
    }
}

/// Return value for various IO operations that signal errors via the
/// return value and not necessarily via a #GError.
///
/// This enum exists to be able to return errors to callers without having to
/// allocate a #GError. Allocating #GErrors can be quite expensive for
/// regularly happening errors like [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock].
///
/// In case of [`Failed`][Self::Failed] a #GError should be set for the
/// operation to give details about the error that happened.
#[cfg(feature = "v2_60")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GPollableReturn")]
pub enum PollableReturn {
    /// Generic error condition for when an operation fails.
    #[doc(alias = "G_POLLABLE_RETURN_FAILED")]
    Failed,
    /// The operation was successfully finished.
    #[doc(alias = "G_POLLABLE_RETURN_OK")]
    Ok,
    /// The operation would block.
    #[doc(alias = "G_POLLABLE_RETURN_WOULD_BLOCK")]
    WouldBlock,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v2_60")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
#[doc(hidden)]
impl IntoGlib for PollableReturn {
    type GlibType = ffi::GPollableReturn;

    #[inline]
    fn into_glib(self) -> ffi::GPollableReturn {
        match self {
            Self::Failed => ffi::G_POLLABLE_RETURN_FAILED,
            Self::Ok => ffi::G_POLLABLE_RETURN_OK,
            Self::WouldBlock => ffi::G_POLLABLE_RETURN_WOULD_BLOCK,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v2_60")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
#[doc(hidden)]
impl FromGlib<ffi::GPollableReturn> for PollableReturn {
    #[inline]
    unsafe fn from_glib(value: ffi::GPollableReturn) -> Self {
        match value {
            ffi::G_POLLABLE_RETURN_FAILED => Self::Failed,
            ffi::G_POLLABLE_RETURN_OK => Self::Ok,
            ffi::G_POLLABLE_RETURN_WOULD_BLOCK => Self::WouldBlock,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v2_60")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
impl StaticType for PollableReturn {
    #[inline]
    #[doc(alias = "g_pollable_return_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_pollable_return_get_type()) }
    }
}

#[cfg(feature = "v2_60")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
impl glib::HasParamSpec for PollableReturn {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v2_60")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
impl glib::value::ValueType for PollableReturn {
    type Type = Self;
}

#[cfg(feature = "v2_60")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
unsafe impl<'a> glib::value::FromValue<'a> for PollableReturn {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v2_60")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
impl ToValue for PollableReturn {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v2_60")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
impl From<PollableReturn> for glib::Value {
    #[inline]
    fn from(v: PollableReturn) -> Self {
        ToValue::to_value(&v)
    }
}

/// An error code used with `G_RESOLVER_ERROR` in a #GError returned
/// from a #GResolver routine.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GResolverError")]
pub enum ResolverError {
    /// the requested name/address/service was not
    ///     found
    #[doc(alias = "G_RESOLVER_ERROR_NOT_FOUND")]
    NotFound,
    /// the requested information could not
    ///     be looked up due to a network error or similar problem
    #[doc(alias = "G_RESOLVER_ERROR_TEMPORARY_FAILURE")]
    TemporaryFailure,
    /// unknown error
    #[doc(alias = "G_RESOLVER_ERROR_INTERNAL")]
    Internal,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ResolverError {
    type GlibType = ffi::GResolverError;

    #[inline]
    fn into_glib(self) -> ffi::GResolverError {
        match self {
            Self::NotFound => ffi::G_RESOLVER_ERROR_NOT_FOUND,
            Self::TemporaryFailure => ffi::G_RESOLVER_ERROR_TEMPORARY_FAILURE,
            Self::Internal => ffi::G_RESOLVER_ERROR_INTERNAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GResolverError> for ResolverError {
    #[inline]
    unsafe fn from_glib(value: ffi::GResolverError) -> Self {
        match value {
            ffi::G_RESOLVER_ERROR_NOT_FOUND => Self::NotFound,
            ffi::G_RESOLVER_ERROR_TEMPORARY_FAILURE => Self::TemporaryFailure,
            ffi::G_RESOLVER_ERROR_INTERNAL => Self::Internal,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for ResolverError {
    #[inline]
    fn domain() -> glib::Quark {
        unsafe { from_glib(ffi::g_resolver_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        match unsafe { from_glib(code) } {
            value => Some(value),
        }
    }
}

impl StaticType for ResolverError {
    #[inline]
    #[doc(alias = "g_resolver_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_resolver_error_get_type()) }
    }
}

impl glib::HasParamSpec for ResolverError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ResolverError {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ResolverError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ResolverError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ResolverError> for glib::Value {
    #[inline]
    fn from(v: ResolverError) -> Self {
        ToValue::to_value(&v)
    }
}

/// The type of record that g_resolver_lookup_records() or
/// g_resolver_lookup_records_async() should retrieve. The records are returned
/// as lists of #GVariant tuples. Each record type has different values in
/// the variant tuples returned.
///
/// [`Srv`][Self::Srv] records are returned as variants with the signature
/// `(qqqs)`, containing a `guint16` with the priority, a `guint16` with the
/// weight, a `guint16` with the port, and a string of the hostname.
///
/// [`Mx`][Self::Mx] records are returned as variants with the signature
/// `(qs)`, representing a `guint16` with the preference, and a string containing
/// the mail exchanger hostname.
///
/// [`Txt`][Self::Txt] records are returned as variants with the signature
/// `(as)`, representing an array of the strings in the text record. Note: Most TXT
/// records only contain a single string, but
/// [RFC 1035](https://tools.ietf.org/html/rfc1035#section-3.3.14) does allow a
/// record to contain multiple strings. The RFC which defines the interpretation
/// of a specific TXT record will likely require concatenation of multiple
/// strings if they are present, as with
/// [RFC 7208](https://tools.ietf.org/html/rfc7208#section-3.3).
///
/// [`Soa`][Self::Soa] records are returned as variants with the signature
/// `(ssuuuuu)`, representing a string containing the primary name server, a
/// string containing the administrator, the serial as a `guint32`, the refresh
/// interval as a `guint32`, the retry interval as a `guint32`, the expire timeout
/// as a `guint32`, and the TTL as a `guint32`.
///
/// [`Ns`][Self::Ns] records are returned as variants with the signature
/// `(s)`, representing a string of the hostname of the name server.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GResolverRecordType")]
pub enum ResolverRecordType {
    /// look up DNS SRV records for a domain
    #[doc(alias = "G_RESOLVER_RECORD_SRV")]
    Srv,
    /// look up DNS MX records for a domain
    #[doc(alias = "G_RESOLVER_RECORD_MX")]
    Mx,
    /// look up DNS TXT records for a name
    #[doc(alias = "G_RESOLVER_RECORD_TXT")]
    Txt,
    /// look up DNS SOA records for a zone
    #[doc(alias = "G_RESOLVER_RECORD_SOA")]
    Soa,
    /// look up DNS NS records for a domain
    #[doc(alias = "G_RESOLVER_RECORD_NS")]
    Ns,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ResolverRecordType {
    type GlibType = ffi::GResolverRecordType;

    #[inline]
    fn into_glib(self) -> ffi::GResolverRecordType {
        match self {
            Self::Srv => ffi::G_RESOLVER_RECORD_SRV,
            Self::Mx => ffi::G_RESOLVER_RECORD_MX,
            Self::Txt => ffi::G_RESOLVER_RECORD_TXT,
            Self::Soa => ffi::G_RESOLVER_RECORD_SOA,
            Self::Ns => ffi::G_RESOLVER_RECORD_NS,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GResolverRecordType> for ResolverRecordType {
    #[inline]
    unsafe fn from_glib(value: ffi::GResolverRecordType) -> Self {
        match value {
            ffi::G_RESOLVER_RECORD_SRV => Self::Srv,
            ffi::G_RESOLVER_RECORD_MX => Self::Mx,
            ffi::G_RESOLVER_RECORD_TXT => Self::Txt,
            ffi::G_RESOLVER_RECORD_SOA => Self::Soa,
            ffi::G_RESOLVER_RECORD_NS => Self::Ns,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ResolverRecordType {
    #[inline]
    #[doc(alias = "g_resolver_record_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_resolver_record_type_get_type()) }
    }
}

impl glib::HasParamSpec for ResolverRecordType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ResolverRecordType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ResolverRecordType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ResolverRecordType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ResolverRecordType> for glib::Value {
    #[inline]
    fn from(v: ResolverRecordType) -> Self {
        ToValue::to_value(&v)
    }
}

/// An error code used with `G_RESOURCE_ERROR` in a #GError returned
/// from a #GResource routine.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GResourceError")]
pub enum ResourceError {
    /// no file was found at the requested path
    #[doc(alias = "G_RESOURCE_ERROR_NOT_FOUND")]
    NotFound,
    /// unknown error
    #[doc(alias = "G_RESOURCE_ERROR_INTERNAL")]
    Internal,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ResourceError {
    type GlibType = ffi::GResourceError;

    #[inline]
    fn into_glib(self) -> ffi::GResourceError {
        match self {
            Self::NotFound => ffi::G_RESOURCE_ERROR_NOT_FOUND,
            Self::Internal => ffi::G_RESOURCE_ERROR_INTERNAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GResourceError> for ResourceError {
    #[inline]
    unsafe fn from_glib(value: ffi::GResourceError) -> Self {
        match value {
            ffi::G_RESOURCE_ERROR_NOT_FOUND => Self::NotFound,
            ffi::G_RESOURCE_ERROR_INTERNAL => Self::Internal,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for ResourceError {
    #[inline]
    fn domain() -> glib::Quark {
        unsafe { from_glib(ffi::g_resource_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        match unsafe { from_glib(code) } {
            value => Some(value),
        }
    }
}

impl StaticType for ResourceError {
    #[inline]
    #[doc(alias = "g_resource_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_resource_error_get_type()) }
    }
}

impl glib::HasParamSpec for ResourceError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ResourceError {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ResourceError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ResourceError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ResourceError> for glib::Value {
    #[inline]
    fn from(v: ResourceError) -> Self {
        ToValue::to_value(&v)
    }
}

/// Describes an event occurring on a #GSocketClient. See the
/// #GSocketClient::event signal for more details.
///
/// Additional values may be added to this type in the future.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GSocketClientEvent")]
pub enum SocketClientEvent {
    /// The client is doing a DNS lookup.
    #[doc(alias = "G_SOCKET_CLIENT_RESOLVING")]
    Resolving,
    /// The client has completed a DNS lookup.
    #[doc(alias = "G_SOCKET_CLIENT_RESOLVED")]
    Resolved,
    /// The client is connecting to a remote
    ///   host (either a proxy or the destination server).
    #[doc(alias = "G_SOCKET_CLIENT_CONNECTING")]
    Connecting,
    /// The client has connected to a remote
    ///   host.
    #[doc(alias = "G_SOCKET_CLIENT_CONNECTED")]
    Connected,
    /// The client is negotiating
    ///   with a proxy to connect to the destination server.
    #[doc(alias = "G_SOCKET_CLIENT_PROXY_NEGOTIATING")]
    ProxyNegotiating,
    /// The client has negotiated
    ///   with the proxy server.
    #[doc(alias = "G_SOCKET_CLIENT_PROXY_NEGOTIATED")]
    ProxyNegotiated,
    /// The client is performing a
    ///   TLS handshake.
    #[doc(alias = "G_SOCKET_CLIENT_TLS_HANDSHAKING")]
    TlsHandshaking,
    /// The client has performed a
    ///   TLS handshake.
    #[doc(alias = "G_SOCKET_CLIENT_TLS_HANDSHAKED")]
    TlsHandshaked,
    /// The client is done with a particular
    ///   #GSocketConnectable.
    #[doc(alias = "G_SOCKET_CLIENT_COMPLETE")]
    Complete,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SocketClientEvent {
    type GlibType = ffi::GSocketClientEvent;

    #[inline]
    fn into_glib(self) -> ffi::GSocketClientEvent {
        match self {
            Self::Resolving => ffi::G_SOCKET_CLIENT_RESOLVING,
            Self::Resolved => ffi::G_SOCKET_CLIENT_RESOLVED,
            Self::Connecting => ffi::G_SOCKET_CLIENT_CONNECTING,
            Self::Connected => ffi::G_SOCKET_CLIENT_CONNECTED,
            Self::ProxyNegotiating => ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATING,
            Self::ProxyNegotiated => ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATED,
            Self::TlsHandshaking => ffi::G_SOCKET_CLIENT_TLS_HANDSHAKING,
            Self::TlsHandshaked => ffi::G_SOCKET_CLIENT_TLS_HANDSHAKED,
            Self::Complete => ffi::G_SOCKET_CLIENT_COMPLETE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GSocketClientEvent> for SocketClientEvent {
    #[inline]
    unsafe fn from_glib(value: ffi::GSocketClientEvent) -> Self {
        match value {
            ffi::G_SOCKET_CLIENT_RESOLVING => Self::Resolving,
            ffi::G_SOCKET_CLIENT_RESOLVED => Self::Resolved,
            ffi::G_SOCKET_CLIENT_CONNECTING => Self::Connecting,
            ffi::G_SOCKET_CLIENT_CONNECTED => Self::Connected,
            ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATING => Self::ProxyNegotiating,
            ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATED => Self::ProxyNegotiated,
            ffi::G_SOCKET_CLIENT_TLS_HANDSHAKING => Self::TlsHandshaking,
            ffi::G_SOCKET_CLIENT_TLS_HANDSHAKED => Self::TlsHandshaked,
            ffi::G_SOCKET_CLIENT_COMPLETE => Self::Complete,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SocketClientEvent {
    #[inline]
    #[doc(alias = "g_socket_client_event_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_socket_client_event_get_type()) }
    }
}

impl glib::HasParamSpec for SocketClientEvent {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for SocketClientEvent {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for SocketClientEvent {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for SocketClientEvent {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SocketClientEvent> for glib::Value {
    #[inline]
    fn from(v: SocketClientEvent) -> Self {
        ToValue::to_value(&v)
    }
}

/// The protocol family of a #GSocketAddress. (These values are
/// identical to the system defines `AF_INET`, `AF_INET6` and `AF_UNIX`,
/// if available.)
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GSocketFamily")]
pub enum SocketFamily {
    /// no address family
    #[doc(alias = "G_SOCKET_FAMILY_INVALID")]
    Invalid,
    /// the UNIX domain family
    #[doc(alias = "G_SOCKET_FAMILY_UNIX")]
    Unix,
    /// the IPv4 family
    #[doc(alias = "G_SOCKET_FAMILY_IPV4")]
    Ipv4,
    /// the IPv6 family
    #[doc(alias = "G_SOCKET_FAMILY_IPV6")]
    Ipv6,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SocketFamily {
    type GlibType = ffi::GSocketFamily;

    #[inline]
    fn into_glib(self) -> ffi::GSocketFamily {
        match self {
            Self::Invalid => ffi::G_SOCKET_FAMILY_INVALID,
            Self::Unix => ffi::G_SOCKET_FAMILY_UNIX,
            Self::Ipv4 => ffi::G_SOCKET_FAMILY_IPV4,
            Self::Ipv6 => ffi::G_SOCKET_FAMILY_IPV6,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GSocketFamily> for SocketFamily {
    #[inline]
    unsafe fn from_glib(value: ffi::GSocketFamily) -> Self {
        match value {
            ffi::G_SOCKET_FAMILY_INVALID => Self::Invalid,
            ffi::G_SOCKET_FAMILY_UNIX => Self::Unix,
            ffi::G_SOCKET_FAMILY_IPV4 => Self::Ipv4,
            ffi::G_SOCKET_FAMILY_IPV6 => Self::Ipv6,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SocketFamily {
    #[inline]
    #[doc(alias = "g_socket_family_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_socket_family_get_type()) }
    }
}

impl glib::HasParamSpec for SocketFamily {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for SocketFamily {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for SocketFamily {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for SocketFamily {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SocketFamily> for glib::Value {
    #[inline]
    fn from(v: SocketFamily) -> Self {
        ToValue::to_value(&v)
    }
}

/// Describes an event occurring on a #GSocketListener. See the
/// #GSocketListener::event signal for more details.
///
/// Additional values may be added to this type in the future.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GSocketListenerEvent")]
pub enum SocketListenerEvent {
    /// The listener is about to bind a socket.
    #[doc(alias = "G_SOCKET_LISTENER_BINDING")]
    Binding,
    /// The listener has bound a socket.
    #[doc(alias = "G_SOCKET_LISTENER_BOUND")]
    Bound,
    /// The listener is about to start
    ///    listening on this socket.
    #[doc(alias = "G_SOCKET_LISTENER_LISTENING")]
    Listening,
    /// The listener is now listening on
    ///   this socket.
    #[doc(alias = "G_SOCKET_LISTENER_LISTENED")]
    Listened,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SocketListenerEvent {
    type GlibType = ffi::GSocketListenerEvent;

    #[inline]
    fn into_glib(self) -> ffi::GSocketListenerEvent {
        match self {
            Self::Binding => ffi::G_SOCKET_LISTENER_BINDING,
            Self::Bound => ffi::G_SOCKET_LISTENER_BOUND,
            Self::Listening => ffi::G_SOCKET_LISTENER_LISTENING,
            Self::Listened => ffi::G_SOCKET_LISTENER_LISTENED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GSocketListenerEvent> for SocketListenerEvent {
    #[inline]
    unsafe fn from_glib(value: ffi::GSocketListenerEvent) -> Self {
        match value {
            ffi::G_SOCKET_LISTENER_BINDING => Self::Binding,
            ffi::G_SOCKET_LISTENER_BOUND => Self::Bound,
            ffi::G_SOCKET_LISTENER_LISTENING => Self::Listening,
            ffi::G_SOCKET_LISTENER_LISTENED => Self::Listened,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SocketListenerEvent {
    #[inline]
    #[doc(alias = "g_socket_listener_event_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_socket_listener_event_get_type()) }
    }
}

impl glib::HasParamSpec for SocketListenerEvent {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for SocketListenerEvent {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for SocketListenerEvent {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for SocketListenerEvent {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SocketListenerEvent> for glib::Value {
    #[inline]
    fn from(v: SocketListenerEvent) -> Self {
        ToValue::to_value(&v)
    }
}

/// A protocol identifier is specified when creating a #GSocket, which is a
/// family/type specific identifier, where 0 means the default protocol for
/// the particular family/type.
///
/// This enum contains a set of commonly available and used protocols. You
/// can also pass any other identifiers handled by the platform in order to
/// use protocols not listed here.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GSocketProtocol")]
pub enum SocketProtocol {
    /// The protocol type is unknown
    #[doc(alias = "G_SOCKET_PROTOCOL_UNKNOWN")]
    Unknown,
    /// The default protocol for the family/type
    #[doc(alias = "G_SOCKET_PROTOCOL_DEFAULT")]
    Default,
    /// TCP over IP
    #[doc(alias = "G_SOCKET_PROTOCOL_TCP")]
    Tcp,
    /// UDP over IP
    #[doc(alias = "G_SOCKET_PROTOCOL_UDP")]
    Udp,
    /// SCTP over IP
    #[doc(alias = "G_SOCKET_PROTOCOL_SCTP")]
    Sctp,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SocketProtocol {
    type GlibType = ffi::GSocketProtocol;

    #[inline]
    fn into_glib(self) -> ffi::GSocketProtocol {
        match self {
            Self::Unknown => ffi::G_SOCKET_PROTOCOL_UNKNOWN,
            Self::Default => ffi::G_SOCKET_PROTOCOL_DEFAULT,
            Self::Tcp => ffi::G_SOCKET_PROTOCOL_TCP,
            Self::Udp => ffi::G_SOCKET_PROTOCOL_UDP,
            Self::Sctp => ffi::G_SOCKET_PROTOCOL_SCTP,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GSocketProtocol> for SocketProtocol {
    #[inline]
    unsafe fn from_glib(value: ffi::GSocketProtocol) -> Self {
        match value {
            ffi::G_SOCKET_PROTOCOL_UNKNOWN => Self::Unknown,
            ffi::G_SOCKET_PROTOCOL_DEFAULT => Self::Default,
            ffi::G_SOCKET_PROTOCOL_TCP => Self::Tcp,
            ffi::G_SOCKET_PROTOCOL_UDP => Self::Udp,
            ffi::G_SOCKET_PROTOCOL_SCTP => Self::Sctp,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SocketProtocol {
    #[inline]
    #[doc(alias = "g_socket_protocol_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_socket_protocol_get_type()) }
    }
}

impl glib::HasParamSpec for SocketProtocol {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for SocketProtocol {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for SocketProtocol {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for SocketProtocol {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SocketProtocol> for glib::Value {
    #[inline]
    fn from(v: SocketProtocol) -> Self {
        ToValue::to_value(&v)
    }
}

/// Flags used when creating a #GSocket. Some protocols may not implement
/// all the socket types.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GSocketType")]
pub enum SocketType {
    /// Type unknown or wrong
    #[doc(alias = "G_SOCKET_TYPE_INVALID")]
    Invalid,
    /// Reliable connection-based byte streams (e.g. TCP).
    #[doc(alias = "G_SOCKET_TYPE_STREAM")]
    Stream,
    /// Connectionless, unreliable datagram passing.
    ///     (e.g. UDP)
    #[doc(alias = "G_SOCKET_TYPE_DATAGRAM")]
    Datagram,
    /// Reliable connection-based passing of datagrams
    ///     of fixed maximum length (e.g. SCTP).
    #[doc(alias = "G_SOCKET_TYPE_SEQPACKET")]
    Seqpacket,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SocketType {
    type GlibType = ffi::GSocketType;

    #[inline]
    fn into_glib(self) -> ffi::GSocketType {
        match self {
            Self::Invalid => ffi::G_SOCKET_TYPE_INVALID,
            Self::Stream => ffi::G_SOCKET_TYPE_STREAM,
            Self::Datagram => ffi::G_SOCKET_TYPE_DATAGRAM,
            Self::Seqpacket => ffi::G_SOCKET_TYPE_SEQPACKET,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GSocketType> for SocketType {
    #[inline]
    unsafe fn from_glib(value: ffi::GSocketType) -> Self {
        match value {
            ffi::G_SOCKET_TYPE_INVALID => Self::Invalid,
            ffi::G_SOCKET_TYPE_STREAM => Self::Stream,
            ffi::G_SOCKET_TYPE_DATAGRAM => Self::Datagram,
            ffi::G_SOCKET_TYPE_SEQPACKET => Self::Seqpacket,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SocketType {
    #[inline]
    #[doc(alias = "g_socket_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_socket_type_get_type()) }
    }
}

impl glib::HasParamSpec for SocketType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for SocketType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for SocketType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for SocketType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SocketType> for glib::Value {
    #[inline]
    fn from(v: SocketType) -> Self {
        ToValue::to_value(&v)
    }
}

/// The client authentication mode for a #GTlsServerConnection.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GTlsAuthenticationMode")]
pub enum TlsAuthenticationMode {
    /// client authentication not required
    #[doc(alias = "G_TLS_AUTHENTICATION_NONE")]
    None,
    /// client authentication is requested
    #[doc(alias = "G_TLS_AUTHENTICATION_REQUESTED")]
    Requested,
    /// client authentication is required
    #[doc(alias = "G_TLS_AUTHENTICATION_REQUIRED")]
    Required,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for TlsAuthenticationMode {
    type GlibType = ffi::GTlsAuthenticationMode;

    #[inline]
    fn into_glib(self) -> ffi::GTlsAuthenticationMode {
        match self {
            Self::None => ffi::G_TLS_AUTHENTICATION_NONE,
            Self::Requested => ffi::G_TLS_AUTHENTICATION_REQUESTED,
            Self::Required => ffi::G_TLS_AUTHENTICATION_REQUIRED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GTlsAuthenticationMode> for TlsAuthenticationMode {
    #[inline]
    unsafe fn from_glib(value: ffi::GTlsAuthenticationMode) -> Self {
        match value {
            ffi::G_TLS_AUTHENTICATION_NONE => Self::None,
            ffi::G_TLS_AUTHENTICATION_REQUESTED => Self::Requested,
            ffi::G_TLS_AUTHENTICATION_REQUIRED => Self::Required,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for TlsAuthenticationMode {
    #[inline]
    #[doc(alias = "g_tls_authentication_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_tls_authentication_mode_get_type()) }
    }
}

impl glib::HasParamSpec for TlsAuthenticationMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for TlsAuthenticationMode {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for TlsAuthenticationMode {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for TlsAuthenticationMode {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<TlsAuthenticationMode> for glib::Value {
    #[inline]
    fn from(v: TlsAuthenticationMode) -> Self {
        ToValue::to_value(&v)
    }
}

/// An error code used with `G_TLS_CHANNEL_BINDING_ERROR` in a #GError to
/// indicate a TLS channel binding retrieval error.
#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GTlsChannelBindingError")]
pub enum TlsChannelBindingError {
    /// Either entire binding
    ///    retrieval facility or specific binding type is not implemented in the
    ///    TLS backend.
    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_NOT_IMPLEMENTED")]
    NotImplemented,
    /// The handshake is not yet
    ///    complete on the connection which is a strong requirement for any existing
    ///    binding type.
    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_INVALID_STATE")]
    InvalidState,
    /// Handshake is complete but
    ///    binding data is not available. That normally indicates the TLS
    ///    implementation failed to provide the binding data. For example, some
    ///    implementations do not provide a peer certificate for resumed connections.
    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_NOT_AVAILABLE")]
    NotAvailable,
    /// Binding type is not supported
    ///    on the current connection. This error could be triggered when requesting
    ///    `tls-server-end-point` binding data for a certificate which has no hash
    ///    function or uses multiple hash functions.
    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_NOT_SUPPORTED")]
    NotSupported,
    /// Any other backend error
    ///    preventing binding data retrieval.
    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_GENERAL_ERROR")]
    GeneralError,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
#[doc(hidden)]
impl IntoGlib for TlsChannelBindingError {
    type GlibType = ffi::GTlsChannelBindingError;

    #[inline]
    fn into_glib(self) -> ffi::GTlsChannelBindingError {
        match self {
            Self::NotImplemented => ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_IMPLEMENTED,
            Self::InvalidState => ffi::G_TLS_CHANNEL_BINDING_ERROR_INVALID_STATE,
            Self::NotAvailable => ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_AVAILABLE,
            Self::NotSupported => ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_SUPPORTED,
            Self::GeneralError => ffi::G_TLS_CHANNEL_BINDING_ERROR_GENERAL_ERROR,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
#[doc(hidden)]
impl FromGlib<ffi::GTlsChannelBindingError> for TlsChannelBindingError {
    #[inline]
    unsafe fn from_glib(value: ffi::GTlsChannelBindingError) -> Self {
        match value {
            ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_IMPLEMENTED => Self::NotImplemented,
            ffi::G_TLS_CHANNEL_BINDING_ERROR_INVALID_STATE => Self::InvalidState,
            ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_AVAILABLE => Self::NotAvailable,
            ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_SUPPORTED => Self::NotSupported,
            ffi::G_TLS_CHANNEL_BINDING_ERROR_GENERAL_ERROR => Self::GeneralError,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
impl glib::error::ErrorDomain for TlsChannelBindingError {
    #[inline]
    fn domain() -> glib::Quark {
        unsafe { from_glib(ffi::g_tls_channel_binding_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        match unsafe { from_glib(code) } {
            value => Some(value),
        }
    }
}

#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
impl StaticType for TlsChannelBindingError {
    #[inline]
    #[doc(alias = "g_tls_channel_binding_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_tls_channel_binding_error_get_type()) }
    }
}

#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
impl glib::HasParamSpec for TlsChannelBindingError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
impl glib::value::ValueType for TlsChannelBindingError {
    type Type = Self;
}

#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
unsafe impl<'a> glib::value::FromValue<'a> for TlsChannelBindingError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
impl ToValue for TlsChannelBindingError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
impl From<TlsChannelBindingError> for glib::Value {
    #[inline]
    fn from(v: TlsChannelBindingError) -> Self {
        ToValue::to_value(&v)
    }
}

/// The type of TLS channel binding data to retrieve from #GTlsConnection
/// or #GDtlsConnection, as documented by RFC 5929 or RFC 9266. The
/// [`tls-unique-for-telnet`](https://tools.ietf.org/html/rfc5929#section-5)
/// binding type is not currently implemented.
#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GTlsChannelBindingType")]
pub enum TlsChannelBindingType {
    /// [`tls-unique`](https://tools.ietf.org/html/rfc5929#section-3) binding
    ///    type
    #[doc(alias = "G_TLS_CHANNEL_BINDING_TLS_UNIQUE")]
    Unique,
    /// [`tls-server-end-point`](https://tools.ietf.org/html/rfc5929#section-4)
    ///    binding type
    #[doc(alias = "G_TLS_CHANNEL_BINDING_TLS_SERVER_END_POINT")]
    ServerEndPoint,
    /// [`tls-exporter`](https://www.rfc-editor.org/rfc/rfc9266.html) binding
    ///    type. Since: 2.74
    #[cfg(feature = "v2_74")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_74")))]
    #[doc(alias = "G_TLS_CHANNEL_BINDING_TLS_EXPORTER")]
    Exporter,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
#[doc(hidden)]
impl IntoGlib for TlsChannelBindingType {
    type GlibType = ffi::GTlsChannelBindingType;

    #[inline]
    fn into_glib(self) -> ffi::GTlsChannelBindingType {
        match self {
            Self::Unique => ffi::G_TLS_CHANNEL_BINDING_TLS_UNIQUE,
            Self::ServerEndPoint => ffi::G_TLS_CHANNEL_BINDING_TLS_SERVER_END_POINT,
            #[cfg(feature = "v2_74")]
            Self::Exporter => ffi::G_TLS_CHANNEL_BINDING_TLS_EXPORTER,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
#[doc(hidden)]
impl FromGlib<ffi::GTlsChannelBindingType> for TlsChannelBindingType {
    #[inline]
    unsafe fn from_glib(value: ffi::GTlsChannelBindingType) -> Self {
        match value {
            ffi::G_TLS_CHANNEL_BINDING_TLS_UNIQUE => Self::Unique,
            ffi::G_TLS_CHANNEL_BINDING_TLS_SERVER_END_POINT => Self::ServerEndPoint,
            #[cfg(feature = "v2_74")]
            ffi::G_TLS_CHANNEL_BINDING_TLS_EXPORTER => Self::Exporter,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
impl StaticType for TlsChannelBindingType {
    #[inline]
    #[doc(alias = "g_tls_channel_binding_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_tls_channel_binding_type_get_type()) }
    }
}

#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
impl glib::HasParamSpec for TlsChannelBindingType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
impl glib::value::ValueType for TlsChannelBindingType {
    type Type = Self;
}

#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
unsafe impl<'a> glib::value::FromValue<'a> for TlsChannelBindingType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
impl ToValue for TlsChannelBindingType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
impl From<TlsChannelBindingType> for glib::Value {
    #[inline]
    fn from(v: TlsChannelBindingType) -> Self {
        ToValue::to_value(&v)
    }
}

/// An error code used with `G_TLS_ERROR` in a #GError returned from a
/// TLS-related routine.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GTlsError")]
pub enum TlsError {
    /// No TLS provider is available
    #[doc(alias = "G_TLS_ERROR_UNAVAILABLE")]
    Unavailable,
    /// Miscellaneous TLS error
    #[doc(alias = "G_TLS_ERROR_MISC")]
    Misc,
    /// The certificate presented could not
    ///   be parsed or failed validation.
    #[doc(alias = "G_TLS_ERROR_BAD_CERTIFICATE")]
    BadCertificate,
    /// The TLS handshake failed because the
    ///   peer does not seem to be a TLS server.
    #[doc(alias = "G_TLS_ERROR_NOT_TLS")]
    NotTls,
    /// The TLS handshake failed because the
    ///   peer's certificate was not acceptable.
    #[doc(alias = "G_TLS_ERROR_HANDSHAKE")]
    Handshake,
    /// The TLS handshake failed because
    ///   the server requested a client-side certificate, but none was
    ///   provided. See g_tls_connection_set_certificate().
    #[doc(alias = "G_TLS_ERROR_CERTIFICATE_REQUIRED")]
    CertificateRequired,
    /// The TLS connection was closed without proper
    ///   notice, which may indicate an attack. See
    ///   g_tls_connection_set_require_close_notify().
    #[doc(alias = "G_TLS_ERROR_EOF")]
    Eof,
    /// The TLS handshake failed
    ///   because the client sent the fallback SCSV, indicating a protocol
    ///   downgrade attack. Since: 2.60
    #[doc(alias = "G_TLS_ERROR_INAPPROPRIATE_FALLBACK")]
    InappropriateFallback,
    /// The certificate failed
    ///   to load because a password was incorrect. Since: 2.72
    #[cfg(feature = "v2_72")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
    #[doc(alias = "G_TLS_ERROR_BAD_CERTIFICATE_PASSWORD")]
    BadCertificatePassword,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for TlsError {
    type GlibType = ffi::GTlsError;

    #[inline]
    fn into_glib(self) -> ffi::GTlsError {
        match self {
            Self::Unavailable => ffi::G_TLS_ERROR_UNAVAILABLE,
            Self::Misc => ffi::G_TLS_ERROR_MISC,
            Self::BadCertificate => ffi::G_TLS_ERROR_BAD_CERTIFICATE,
            Self::NotTls => ffi::G_TLS_ERROR_NOT_TLS,
            Self::Handshake => ffi::G_TLS_ERROR_HANDSHAKE,
            Self::CertificateRequired => ffi::G_TLS_ERROR_CERTIFICATE_REQUIRED,
            Self::Eof => ffi::G_TLS_ERROR_EOF,
            Self::InappropriateFallback => ffi::G_TLS_ERROR_INAPPROPRIATE_FALLBACK,
            #[cfg(feature = "v2_72")]
            Self::BadCertificatePassword => ffi::G_TLS_ERROR_BAD_CERTIFICATE_PASSWORD,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GTlsError> for TlsError {
    #[inline]
    unsafe fn from_glib(value: ffi::GTlsError) -> Self {
        match value {
            ffi::G_TLS_ERROR_UNAVAILABLE => Self::Unavailable,
            ffi::G_TLS_ERROR_MISC => Self::Misc,
            ffi::G_TLS_ERROR_BAD_CERTIFICATE => Self::BadCertificate,
            ffi::G_TLS_ERROR_NOT_TLS => Self::NotTls,
            ffi::G_TLS_ERROR_HANDSHAKE => Self::Handshake,
            ffi::G_TLS_ERROR_CERTIFICATE_REQUIRED => Self::CertificateRequired,
            ffi::G_TLS_ERROR_EOF => Self::Eof,
            ffi::G_TLS_ERROR_INAPPROPRIATE_FALLBACK => Self::InappropriateFallback,
            #[cfg(feature = "v2_72")]
            ffi::G_TLS_ERROR_BAD_CERTIFICATE_PASSWORD => Self::BadCertificatePassword,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for TlsError {
    #[inline]
    fn domain() -> glib::Quark {
        unsafe { from_glib(ffi::g_tls_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        match unsafe { from_glib(code) } {
            value => Some(value),
        }
    }
}

impl StaticType for TlsError {
    #[inline]
    #[doc(alias = "g_tls_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_tls_error_get_type()) }
    }
}

impl glib::HasParamSpec for TlsError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for TlsError {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for TlsError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for TlsError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<TlsError> for glib::Value {
    #[inline]
    fn from(v: TlsError) -> Self {
        ToValue::to_value(&v)
    }
}

/// #GTlsInteractionResult is returned by various functions in #GTlsInteraction
/// when finishing an interaction request.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GTlsInteractionResult")]
pub enum TlsInteractionResult {
    /// The interaction was unhandled (i.e. not
    ///     implemented).
    #[doc(alias = "G_TLS_INTERACTION_UNHANDLED")]
    Unhandled,
    /// The interaction completed, and resulting data
    ///     is available.
    #[doc(alias = "G_TLS_INTERACTION_HANDLED")]
    Handled,
    /// The interaction has failed, or was cancelled.
    ///     and the operation should be aborted.
    #[doc(alias = "G_TLS_INTERACTION_FAILED")]
    Failed,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for TlsInteractionResult {
    type GlibType = ffi::GTlsInteractionResult;

    #[inline]
    fn into_glib(self) -> ffi::GTlsInteractionResult {
        match self {
            Self::Unhandled => ffi::G_TLS_INTERACTION_UNHANDLED,
            Self::Handled => ffi::G_TLS_INTERACTION_HANDLED,
            Self::Failed => ffi::G_TLS_INTERACTION_FAILED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GTlsInteractionResult> for TlsInteractionResult {
    #[inline]
    unsafe fn from_glib(value: ffi::GTlsInteractionResult) -> Self {
        match value {
            ffi::G_TLS_INTERACTION_UNHANDLED => Self::Unhandled,
            ffi::G_TLS_INTERACTION_HANDLED => Self::Handled,
            ffi::G_TLS_INTERACTION_FAILED => Self::Failed,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for TlsInteractionResult {
    #[inline]
    #[doc(alias = "g_tls_interaction_result_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_tls_interaction_result_get_type()) }
    }
}

impl glib::HasParamSpec for TlsInteractionResult {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for TlsInteractionResult {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for TlsInteractionResult {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for TlsInteractionResult {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<TlsInteractionResult> for glib::Value {
    #[inline]
    fn from(v: TlsInteractionResult) -> Self {
        ToValue::to_value(&v)
    }
}

/// The TLS or DTLS protocol version used by a #GTlsConnection or
/// #GDtlsConnection. The integer values of these versions are sequential
/// to ensure newer known protocol versions compare greater than older
/// known versions. Any known DTLS protocol version will compare greater
/// than any SSL or TLS protocol version. The protocol version may be
/// [`Unknown`][Self::Unknown] if the TLS backend supports a newer
/// protocol version that GLib does not yet know about. This means that
/// it's possible for an unknown DTLS protocol version to compare less
/// than the TLS protocol versions.
#[cfg(feature = "v2_70")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GTlsProtocolVersion")]
pub enum TlsProtocolVersion {
    /// No protocol version or unknown protocol version
    #[doc(alias = "G_TLS_PROTOCOL_VERSION_UNKNOWN")]
    Unknown,
    /// SSL 3.0, which is insecure and should not be used
    #[doc(alias = "G_TLS_PROTOCOL_VERSION_SSL_3_0")]
    Ssl30,
    /// TLS 1.0, which is insecure and should not be used
    #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_0")]
    Tls10,
    /// TLS 1.1, which is insecure and should not be used
    #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_1")]
    Tls11,
    /// TLS 1.2, defined by [RFC 5246](https://datatracker.ietf.org/doc/html/rfc5246)
    #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_2")]
    Tls12,
    /// TLS 1.3, defined by [RFC 8446](https://datatracker.ietf.org/doc/html/rfc8446)
    #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_3")]
    Tls13,
    /// DTLS 1.0, which is insecure and should not be used
    #[doc(alias = "G_TLS_PROTOCOL_VERSION_DTLS_1_0")]
    Dtls10,
    /// DTLS 1.2, defined by [RFC 6347](https://datatracker.ietf.org/doc/html/rfc6347)
    #[doc(alias = "G_TLS_PROTOCOL_VERSION_DTLS_1_2")]
    Dtls12,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v2_70")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
#[doc(hidden)]
impl IntoGlib for TlsProtocolVersion {
    type GlibType = ffi::GTlsProtocolVersion;

    #[inline]
    fn into_glib(self) -> ffi::GTlsProtocolVersion {
        match self {
            Self::Unknown => ffi::G_TLS_PROTOCOL_VERSION_UNKNOWN,
            Self::Ssl30 => ffi::G_TLS_PROTOCOL_VERSION_SSL_3_0,
            Self::Tls10 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_0,
            Self::Tls11 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_1,
            Self::Tls12 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_2,
            Self::Tls13 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_3,
            Self::Dtls10 => ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_0,
            Self::Dtls12 => ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_2,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v2_70")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
#[doc(hidden)]
impl FromGlib<ffi::GTlsProtocolVersion> for TlsProtocolVersion {
    #[inline]
    unsafe fn from_glib(value: ffi::GTlsProtocolVersion) -> Self {
        match value {
            ffi::G_TLS_PROTOCOL_VERSION_UNKNOWN => Self::Unknown,
            ffi::G_TLS_PROTOCOL_VERSION_SSL_3_0 => Self::Ssl30,
            ffi::G_TLS_PROTOCOL_VERSION_TLS_1_0 => Self::Tls10,
            ffi::G_TLS_PROTOCOL_VERSION_TLS_1_1 => Self::Tls11,
            ffi::G_TLS_PROTOCOL_VERSION_TLS_1_2 => Self::Tls12,
            ffi::G_TLS_PROTOCOL_VERSION_TLS_1_3 => Self::Tls13,
            ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_0 => Self::Dtls10,
            ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_2 => Self::Dtls12,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v2_70")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
impl StaticType for TlsProtocolVersion {
    #[inline]
    #[doc(alias = "g_tls_protocol_version_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_tls_protocol_version_get_type()) }
    }
}

#[cfg(feature = "v2_70")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
impl glib::HasParamSpec for TlsProtocolVersion {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v2_70")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
impl glib::value::ValueType for TlsProtocolVersion {
    type Type = Self;
}

#[cfg(feature = "v2_70")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
unsafe impl<'a> glib::value::FromValue<'a> for TlsProtocolVersion {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v2_70")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
impl ToValue for TlsProtocolVersion {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v2_70")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
impl From<TlsProtocolVersion> for glib::Value {
    #[inline]
    fn from(v: TlsProtocolVersion) -> Self {
        ToValue::to_value(&v)
    }
}

/// When to allow rehandshaking. See
/// g_tls_connection_set_rehandshake_mode().
///
/// # Deprecated since 2.60
///
/// Changing the rehandshake mode is no longer
///   required for compatibility. Also, rehandshaking has been removed
///   from the TLS protocol in TLS 1.3.
#[cfg_attr(feature = "v2_60", deprecated = "Since 2.60")]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GTlsRehandshakeMode")]
pub enum TlsRehandshakeMode {
    /// Never allow rehandshaking
    #[doc(alias = "G_TLS_REHANDSHAKE_NEVER")]
    Never,
    /// Allow safe rehandshaking only
    #[doc(alias = "G_TLS_REHANDSHAKE_SAFELY")]
    Safely,
    /// Allow unsafe rehandshaking
    #[doc(alias = "G_TLS_REHANDSHAKE_UNSAFELY")]
    Unsafely,
    #[doc(hidden)]
    __Unknown(i32),
}

#[allow(deprecated)]
#[doc(hidden)]
impl IntoGlib for TlsRehandshakeMode {
    type GlibType = ffi::GTlsRehandshakeMode;

    #[inline]
    fn into_glib(self) -> ffi::GTlsRehandshakeMode {
        match self {
            Self::Never => ffi::G_TLS_REHANDSHAKE_NEVER,
            Self::Safely => ffi::G_TLS_REHANDSHAKE_SAFELY,
            Self::Unsafely => ffi::G_TLS_REHANDSHAKE_UNSAFELY,
            Self::__Unknown(value) => value,
        }
    }
}

#[allow(deprecated)]
#[doc(hidden)]
impl FromGlib<ffi::GTlsRehandshakeMode> for TlsRehandshakeMode {
    #[inline]
    unsafe fn from_glib(value: ffi::GTlsRehandshakeMode) -> Self {
        match value {
            ffi::G_TLS_REHANDSHAKE_NEVER => Self::Never,
            ffi::G_TLS_REHANDSHAKE_SAFELY => Self::Safely,
            ffi::G_TLS_REHANDSHAKE_UNSAFELY => Self::Unsafely,
            value => Self::__Unknown(value),
        }
    }
}

#[allow(deprecated)]
impl StaticType for TlsRehandshakeMode {
    #[inline]
    #[doc(alias = "g_tls_rehandshake_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_tls_rehandshake_mode_get_type()) }
    }
}

#[allow(deprecated)]
impl glib::HasParamSpec for TlsRehandshakeMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[allow(deprecated)]
impl glib::value::ValueType for TlsRehandshakeMode {
    type Type = Self;
}

#[allow(deprecated)]
unsafe impl<'a> glib::value::FromValue<'a> for TlsRehandshakeMode {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[allow(deprecated)]
impl ToValue for TlsRehandshakeMode {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[allow(deprecated)]
impl From<TlsRehandshakeMode> for glib::Value {
    #[inline]
    fn from(v: TlsRehandshakeMode) -> Self {
        ToValue::to_value(&v)
    }
}

/// The type of name used by a #GUnixSocketAddress.
/// [`Path`][Self::Path] indicates a traditional unix domain
/// socket bound to a filesystem path. [`Anonymous`][Self::Anonymous]
/// indicates a socket not bound to any name (eg, a client-side socket,
/// or a socket created with socketpair()).
///
/// For abstract sockets, there are two incompatible ways of naming
/// them; the man pages suggest using the entire `struct sockaddr_un`
/// as the name, padding the unused parts of the `sun_path` field with
/// zeroes; this corresponds to [`AbstractPadded`][Self::AbstractPadded].
/// However, many programs instead just use a portion of `sun_path`, and
/// pass an appropriate smaller length to bind() or connect(). This is
/// [`Abstract`][Self::Abstract].
#[cfg(unix)]
#[cfg_attr(docsrs, doc(cfg(unix)))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GUnixSocketAddressType")]
pub enum UnixSocketAddressType {
    /// invalid
    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_INVALID")]
    Invalid,
    /// anonymous
    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_ANONYMOUS")]
    Anonymous,
    /// a filesystem path
    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_PATH")]
    Path,
    /// an abstract name
    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_ABSTRACT")]
    Abstract,
    /// an abstract name, 0-padded
    ///   to the full length of a unix socket name
    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED")]
    AbstractPadded,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(unix)]
#[doc(hidden)]
impl IntoGlib for UnixSocketAddressType {
    type GlibType = ffi::GUnixSocketAddressType;

    #[inline]
    fn into_glib(self) -> ffi::GUnixSocketAddressType {
        match self {
            Self::Invalid => ffi::G_UNIX_SOCKET_ADDRESS_INVALID,
            Self::Anonymous => ffi::G_UNIX_SOCKET_ADDRESS_ANONYMOUS,
            Self::Path => ffi::G_UNIX_SOCKET_ADDRESS_PATH,
            Self::Abstract => ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT,
            Self::AbstractPadded => ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(unix)]
#[doc(hidden)]
impl FromGlib<ffi::GUnixSocketAddressType> for UnixSocketAddressType {
    #[inline]
    unsafe fn from_glib(value: ffi::GUnixSocketAddressType) -> Self {
        match value {
            ffi::G_UNIX_SOCKET_ADDRESS_INVALID => Self::Invalid,
            ffi::G_UNIX_SOCKET_ADDRESS_ANONYMOUS => Self::Anonymous,
            ffi::G_UNIX_SOCKET_ADDRESS_PATH => Self::Path,
            ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT => Self::Abstract,
            ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED => Self::AbstractPadded,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(unix)]
impl StaticType for UnixSocketAddressType {
    #[inline]
    #[doc(alias = "g_unix_socket_address_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_unix_socket_address_type_get_type()) }
    }
}

#[cfg(unix)]
impl glib::HasParamSpec for UnixSocketAddressType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(unix)]
impl glib::value::ValueType for UnixSocketAddressType {
    type Type = Self;
}

#[cfg(unix)]
unsafe impl<'a> glib::value::FromValue<'a> for UnixSocketAddressType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(unix)]
impl ToValue for UnixSocketAddressType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(unix)]
impl From<UnixSocketAddressType> for glib::Value {
    #[inline]
    fn from(v: UnixSocketAddressType) -> Self {
        ToValue::to_value(&v)
    }
}

/// Used to select the type of data format to use for #GZlibDecompressor
/// and #GZlibCompressor.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GZlibCompressorFormat")]
pub enum ZlibCompressorFormat {
    /// deflate compression with zlib header
    #[doc(alias = "G_ZLIB_COMPRESSOR_FORMAT_ZLIB")]
    Zlib,
    /// gzip file format
    #[doc(alias = "G_ZLIB_COMPRESSOR_FORMAT_GZIP")]
    Gzip,
    /// deflate compression with no header
    #[doc(alias = "G_ZLIB_COMPRESSOR_FORMAT_RAW")]
    Raw,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ZlibCompressorFormat {
    type GlibType = ffi::GZlibCompressorFormat;

    #[inline]
    fn into_glib(self) -> ffi::GZlibCompressorFormat {
        match self {
            Self::Zlib => ffi::G_ZLIB_COMPRESSOR_FORMAT_ZLIB,
            Self::Gzip => ffi::G_ZLIB_COMPRESSOR_FORMAT_GZIP,
            Self::Raw => ffi::G_ZLIB_COMPRESSOR_FORMAT_RAW,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GZlibCompressorFormat> for ZlibCompressorFormat {
    #[inline]
    unsafe fn from_glib(value: ffi::GZlibCompressorFormat) -> Self {
        match value {
            ffi::G_ZLIB_COMPRESSOR_FORMAT_ZLIB => Self::Zlib,
            ffi::G_ZLIB_COMPRESSOR_FORMAT_GZIP => Self::Gzip,
            ffi::G_ZLIB_COMPRESSOR_FORMAT_RAW => Self::Raw,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ZlibCompressorFormat {
    #[inline]
    #[doc(alias = "g_zlib_compressor_format_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::g_zlib_compressor_format_get_type()) }
    }
}

impl glib::HasParamSpec for ZlibCompressorFormat {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ZlibCompressorFormat {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ZlibCompressorFormat {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ZlibCompressorFormat {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ZlibCompressorFormat> for glib::Value {
    #[inline]
    fn from(v: ZlibCompressorFormat) -> Self {
        ToValue::to_value(&v)
    }
}