Skip to main content

gio/auto/
enums.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5use crate::ffi;
6use glib::{prelude::*, translate::*};
7
8#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9#[non_exhaustive]
10#[doc(alias = "GBusType")]
11pub enum BusType {
12    #[doc(alias = "G_BUS_TYPE_STARTER")]
13    Starter,
14    #[doc(alias = "G_BUS_TYPE_NONE")]
15    None,
16    #[doc(alias = "G_BUS_TYPE_SYSTEM")]
17    System,
18    #[doc(alias = "G_BUS_TYPE_SESSION")]
19    Session,
20    #[doc(hidden)]
21    __Unknown(i32),
22}
23
24#[doc(hidden)]
25impl IntoGlib for BusType {
26    type GlibType = ffi::GBusType;
27
28    #[inline]
29    fn into_glib(self) -> ffi::GBusType {
30        match self {
31            Self::Starter => ffi::G_BUS_TYPE_STARTER,
32            Self::None => ffi::G_BUS_TYPE_NONE,
33            Self::System => ffi::G_BUS_TYPE_SYSTEM,
34            Self::Session => ffi::G_BUS_TYPE_SESSION,
35            Self::__Unknown(value) => value,
36        }
37    }
38}
39
40#[doc(hidden)]
41impl FromGlib<ffi::GBusType> for BusType {
42    #[inline]
43    unsafe fn from_glib(value: ffi::GBusType) -> Self {
44        match value {
45            ffi::G_BUS_TYPE_STARTER => Self::Starter,
46            ffi::G_BUS_TYPE_NONE => Self::None,
47            ffi::G_BUS_TYPE_SYSTEM => Self::System,
48            ffi::G_BUS_TYPE_SESSION => Self::Session,
49            value => Self::__Unknown(value),
50        }
51    }
52}
53
54impl StaticType for BusType {
55    #[inline]
56    #[doc(alias = "g_bus_type_get_type")]
57    fn static_type() -> glib::Type {
58        unsafe { from_glib(ffi::g_bus_type_get_type()) }
59    }
60}
61
62impl glib::HasParamSpec for BusType {
63    type ParamSpec = glib::ParamSpecEnum;
64    type SetValue = Self;
65    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
66
67    fn param_spec_builder() -> Self::BuilderFn {
68        Self::ParamSpec::builder_with_default
69    }
70}
71
72impl glib::value::ValueType for BusType {
73    type Type = Self;
74}
75
76unsafe impl<'a> glib::value::FromValue<'a> for BusType {
77    type Checker = glib::value::GenericValueTypeChecker<Self>;
78
79    #[inline]
80    unsafe fn from_value(value: &'a glib::Value) -> Self {
81        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
82    }
83}
84
85impl ToValue for BusType {
86    #[inline]
87    fn to_value(&self) -> glib::Value {
88        let mut value = glib::Value::for_value_type::<Self>();
89        unsafe {
90            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
91        }
92        value
93    }
94
95    #[inline]
96    fn value_type(&self) -> glib::Type {
97        Self::static_type()
98    }
99}
100
101impl From<BusType> for glib::Value {
102    #[inline]
103    fn from(v: BusType) -> Self {
104        ToValue::to_value(&v)
105    }
106}
107
108#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
109#[non_exhaustive]
110#[doc(alias = "GConverterResult")]
111pub enum ConverterResult {
112    #[doc(alias = "G_CONVERTER_ERROR")]
113    Error,
114    #[doc(alias = "G_CONVERTER_CONVERTED")]
115    Converted,
116    #[doc(alias = "G_CONVERTER_FINISHED")]
117    Finished,
118    #[doc(alias = "G_CONVERTER_FLUSHED")]
119    Flushed,
120    #[doc(hidden)]
121    __Unknown(i32),
122}
123
124#[doc(hidden)]
125impl IntoGlib for ConverterResult {
126    type GlibType = ffi::GConverterResult;
127
128    #[inline]
129    fn into_glib(self) -> ffi::GConverterResult {
130        match self {
131            Self::Error => ffi::G_CONVERTER_ERROR,
132            Self::Converted => ffi::G_CONVERTER_CONVERTED,
133            Self::Finished => ffi::G_CONVERTER_FINISHED,
134            Self::Flushed => ffi::G_CONVERTER_FLUSHED,
135            Self::__Unknown(value) => value,
136        }
137    }
138}
139
140#[doc(hidden)]
141impl FromGlib<ffi::GConverterResult> for ConverterResult {
142    #[inline]
143    unsafe fn from_glib(value: ffi::GConverterResult) -> Self {
144        match value {
145            ffi::G_CONVERTER_ERROR => Self::Error,
146            ffi::G_CONVERTER_CONVERTED => Self::Converted,
147            ffi::G_CONVERTER_FINISHED => Self::Finished,
148            ffi::G_CONVERTER_FLUSHED => Self::Flushed,
149            value => Self::__Unknown(value),
150        }
151    }
152}
153
154impl StaticType for ConverterResult {
155    #[inline]
156    #[doc(alias = "g_converter_result_get_type")]
157    fn static_type() -> glib::Type {
158        unsafe { from_glib(ffi::g_converter_result_get_type()) }
159    }
160}
161
162impl glib::HasParamSpec for ConverterResult {
163    type ParamSpec = glib::ParamSpecEnum;
164    type SetValue = Self;
165    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
166
167    fn param_spec_builder() -> Self::BuilderFn {
168        Self::ParamSpec::builder_with_default
169    }
170}
171
172impl glib::value::ValueType for ConverterResult {
173    type Type = Self;
174}
175
176unsafe impl<'a> glib::value::FromValue<'a> for ConverterResult {
177    type Checker = glib::value::GenericValueTypeChecker<Self>;
178
179    #[inline]
180    unsafe fn from_value(value: &'a glib::Value) -> Self {
181        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
182    }
183}
184
185impl ToValue for ConverterResult {
186    #[inline]
187    fn to_value(&self) -> glib::Value {
188        let mut value = glib::Value::for_value_type::<Self>();
189        unsafe {
190            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
191        }
192        value
193    }
194
195    #[inline]
196    fn value_type(&self) -> glib::Type {
197        Self::static_type()
198    }
199}
200
201impl From<ConverterResult> for glib::Value {
202    #[inline]
203    fn from(v: ConverterResult) -> Self {
204        ToValue::to_value(&v)
205    }
206}
207
208#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
209#[non_exhaustive]
210#[doc(alias = "GCredentialsType")]
211pub enum CredentialsType {
212    #[doc(alias = "G_CREDENTIALS_TYPE_INVALID")]
213    Invalid,
214    #[doc(alias = "G_CREDENTIALS_TYPE_LINUX_UCRED")]
215    LinuxUcred,
216    #[doc(alias = "G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED")]
217    FreebsdCmsgcred,
218    #[doc(alias = "G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED")]
219    OpenbsdSockpeercred,
220    #[doc(alias = "G_CREDENTIALS_TYPE_SOLARIS_UCRED")]
221    SolarisUcred,
222    #[doc(alias = "G_CREDENTIALS_TYPE_NETBSD_UNPCBID")]
223    NetbsdUnpcbid,
224    #[doc(alias = "G_CREDENTIALS_TYPE_APPLE_XUCRED")]
225    AppleXucred,
226    #[cfg(feature = "v2_72")]
227    #[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
228    #[doc(alias = "G_CREDENTIALS_TYPE_WIN32_PID")]
229    Win32Pid,
230    #[doc(hidden)]
231    __Unknown(i32),
232}
233
234#[doc(hidden)]
235impl IntoGlib for CredentialsType {
236    type GlibType = ffi::GCredentialsType;
237
238    #[inline]
239    fn into_glib(self) -> ffi::GCredentialsType {
240        match self {
241            Self::Invalid => ffi::G_CREDENTIALS_TYPE_INVALID,
242            Self::LinuxUcred => ffi::G_CREDENTIALS_TYPE_LINUX_UCRED,
243            Self::FreebsdCmsgcred => ffi::G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED,
244            Self::OpenbsdSockpeercred => ffi::G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED,
245            Self::SolarisUcred => ffi::G_CREDENTIALS_TYPE_SOLARIS_UCRED,
246            Self::NetbsdUnpcbid => ffi::G_CREDENTIALS_TYPE_NETBSD_UNPCBID,
247            Self::AppleXucred => ffi::G_CREDENTIALS_TYPE_APPLE_XUCRED,
248            #[cfg(feature = "v2_72")]
249            Self::Win32Pid => ffi::G_CREDENTIALS_TYPE_WIN32_PID,
250            Self::__Unknown(value) => value,
251        }
252    }
253}
254
255#[doc(hidden)]
256impl FromGlib<ffi::GCredentialsType> for CredentialsType {
257    #[inline]
258    unsafe fn from_glib(value: ffi::GCredentialsType) -> Self {
259        match value {
260            ffi::G_CREDENTIALS_TYPE_INVALID => Self::Invalid,
261            ffi::G_CREDENTIALS_TYPE_LINUX_UCRED => Self::LinuxUcred,
262            ffi::G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED => Self::FreebsdCmsgcred,
263            ffi::G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED => Self::OpenbsdSockpeercred,
264            ffi::G_CREDENTIALS_TYPE_SOLARIS_UCRED => Self::SolarisUcred,
265            ffi::G_CREDENTIALS_TYPE_NETBSD_UNPCBID => Self::NetbsdUnpcbid,
266            ffi::G_CREDENTIALS_TYPE_APPLE_XUCRED => Self::AppleXucred,
267            #[cfg(feature = "v2_72")]
268            ffi::G_CREDENTIALS_TYPE_WIN32_PID => Self::Win32Pid,
269            value => Self::__Unknown(value),
270        }
271    }
272}
273
274impl StaticType for CredentialsType {
275    #[inline]
276    #[doc(alias = "g_credentials_type_get_type")]
277    fn static_type() -> glib::Type {
278        unsafe { from_glib(ffi::g_credentials_type_get_type()) }
279    }
280}
281
282impl glib::HasParamSpec for CredentialsType {
283    type ParamSpec = glib::ParamSpecEnum;
284    type SetValue = Self;
285    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
286
287    fn param_spec_builder() -> Self::BuilderFn {
288        Self::ParamSpec::builder_with_default
289    }
290}
291
292impl glib::value::ValueType for CredentialsType {
293    type Type = Self;
294}
295
296unsafe impl<'a> glib::value::FromValue<'a> for CredentialsType {
297    type Checker = glib::value::GenericValueTypeChecker<Self>;
298
299    #[inline]
300    unsafe fn from_value(value: &'a glib::Value) -> Self {
301        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
302    }
303}
304
305impl ToValue for CredentialsType {
306    #[inline]
307    fn to_value(&self) -> glib::Value {
308        let mut value = glib::Value::for_value_type::<Self>();
309        unsafe {
310            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
311        }
312        value
313    }
314
315    #[inline]
316    fn value_type(&self) -> glib::Type {
317        Self::static_type()
318    }
319}
320
321impl From<CredentialsType> for glib::Value {
322    #[inline]
323    fn from(v: CredentialsType) -> Self {
324        ToValue::to_value(&v)
325    }
326}
327
328#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
329#[non_exhaustive]
330#[doc(alias = "GDBusError")]
331pub enum DBusError {
332    #[doc(alias = "G_DBUS_ERROR_FAILED")]
333    Failed,
334    #[doc(alias = "G_DBUS_ERROR_NO_MEMORY")]
335    NoMemory,
336    #[doc(alias = "G_DBUS_ERROR_SERVICE_UNKNOWN")]
337    ServiceUnknown,
338    #[doc(alias = "G_DBUS_ERROR_NAME_HAS_NO_OWNER")]
339    NameHasNoOwner,
340    #[doc(alias = "G_DBUS_ERROR_NO_REPLY")]
341    NoReply,
342    #[doc(alias = "G_DBUS_ERROR_IO_ERROR")]
343    IoError,
344    #[doc(alias = "G_DBUS_ERROR_BAD_ADDRESS")]
345    BadAddress,
346    #[doc(alias = "G_DBUS_ERROR_NOT_SUPPORTED")]
347    NotSupported,
348    #[doc(alias = "G_DBUS_ERROR_LIMITS_EXCEEDED")]
349    LimitsExceeded,
350    #[doc(alias = "G_DBUS_ERROR_ACCESS_DENIED")]
351    AccessDenied,
352    #[doc(alias = "G_DBUS_ERROR_AUTH_FAILED")]
353    AuthFailed,
354    #[doc(alias = "G_DBUS_ERROR_NO_SERVER")]
355    NoServer,
356    #[doc(alias = "G_DBUS_ERROR_TIMEOUT")]
357    Timeout,
358    #[doc(alias = "G_DBUS_ERROR_NO_NETWORK")]
359    NoNetwork,
360    #[doc(alias = "G_DBUS_ERROR_ADDRESS_IN_USE")]
361    AddressInUse,
362    #[doc(alias = "G_DBUS_ERROR_DISCONNECTED")]
363    Disconnected,
364    #[doc(alias = "G_DBUS_ERROR_INVALID_ARGS")]
365    InvalidArgs,
366    #[doc(alias = "G_DBUS_ERROR_FILE_NOT_FOUND")]
367    FileNotFound,
368    #[doc(alias = "G_DBUS_ERROR_FILE_EXISTS")]
369    FileExists,
370    #[doc(alias = "G_DBUS_ERROR_UNKNOWN_METHOD")]
371    UnknownMethod,
372    #[doc(alias = "G_DBUS_ERROR_TIMED_OUT")]
373    TimedOut,
374    #[doc(alias = "G_DBUS_ERROR_MATCH_RULE_NOT_FOUND")]
375    MatchRuleNotFound,
376    #[doc(alias = "G_DBUS_ERROR_MATCH_RULE_INVALID")]
377    MatchRuleInvalid,
378    #[doc(alias = "G_DBUS_ERROR_SPAWN_EXEC_FAILED")]
379    SpawnExecFailed,
380    #[doc(alias = "G_DBUS_ERROR_SPAWN_FORK_FAILED")]
381    SpawnForkFailed,
382    #[doc(alias = "G_DBUS_ERROR_SPAWN_CHILD_EXITED")]
383    SpawnChildExited,
384    #[doc(alias = "G_DBUS_ERROR_SPAWN_CHILD_SIGNALED")]
385    SpawnChildSignaled,
386    #[doc(alias = "G_DBUS_ERROR_SPAWN_FAILED")]
387    SpawnFailed,
388    #[doc(alias = "G_DBUS_ERROR_SPAWN_SETUP_FAILED")]
389    SpawnSetupFailed,
390    #[doc(alias = "G_DBUS_ERROR_SPAWN_CONFIG_INVALID")]
391    SpawnConfigInvalid,
392    #[doc(alias = "G_DBUS_ERROR_SPAWN_SERVICE_INVALID")]
393    SpawnServiceInvalid,
394    #[doc(alias = "G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND")]
395    SpawnServiceNotFound,
396    #[doc(alias = "G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID")]
397    SpawnPermissionsInvalid,
398    #[doc(alias = "G_DBUS_ERROR_SPAWN_FILE_INVALID")]
399    SpawnFileInvalid,
400    #[doc(alias = "G_DBUS_ERROR_SPAWN_NO_MEMORY")]
401    SpawnNoMemory,
402    #[doc(alias = "G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN")]
403    UnixProcessIdUnknown,
404    #[doc(alias = "G_DBUS_ERROR_INVALID_SIGNATURE")]
405    InvalidSignature,
406    #[doc(alias = "G_DBUS_ERROR_INVALID_FILE_CONTENT")]
407    InvalidFileContent,
408    #[doc(alias = "G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN")]
409    SelinuxSecurityContextUnknown,
410    #[doc(alias = "G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN")]
411    AdtAuditDataUnknown,
412    #[doc(alias = "G_DBUS_ERROR_OBJECT_PATH_IN_USE")]
413    ObjectPathInUse,
414    #[doc(alias = "G_DBUS_ERROR_UNKNOWN_OBJECT")]
415    UnknownObject,
416    #[doc(alias = "G_DBUS_ERROR_UNKNOWN_INTERFACE")]
417    UnknownInterface,
418    #[doc(alias = "G_DBUS_ERROR_UNKNOWN_PROPERTY")]
419    UnknownProperty,
420    #[doc(alias = "G_DBUS_ERROR_PROPERTY_READ_ONLY")]
421    PropertyReadOnly,
422    #[doc(hidden)]
423    __Unknown(i32),
424}
425
426impl DBusError {
427    #[doc(alias = "g_dbus_error_encode_gerror")]
428    pub fn encode_gerror(error: &glib::Error) -> glib::GString {
429        unsafe { from_glib_full(ffi::g_dbus_error_encode_gerror(error.to_glib_none().0)) }
430    }
431
432    #[doc(alias = "g_dbus_error_get_remote_error")]
433    #[doc(alias = "get_remote_error")]
434    pub fn remote_error(error: &glib::Error) -> Option<glib::GString> {
435        unsafe { from_glib_full(ffi::g_dbus_error_get_remote_error(error.to_glib_none().0)) }
436    }
437
438    #[doc(alias = "g_dbus_error_is_remote_error")]
439    pub fn is_remote_error(error: &glib::Error) -> bool {
440        unsafe { from_glib(ffi::g_dbus_error_is_remote_error(error.to_glib_none().0)) }
441    }
442
443    #[doc(alias = "g_dbus_error_new_for_dbus_error")]
444    pub fn new_for_dbus_error(dbus_error_name: &str, dbus_error_message: &str) -> glib::Error {
445        unsafe {
446            from_glib_full(ffi::g_dbus_error_new_for_dbus_error(
447                dbus_error_name.to_glib_none().0,
448                dbus_error_message.to_glib_none().0,
449            ))
450        }
451    }
452
453    #[doc(alias = "g_dbus_error_register_error")]
454    pub fn register_error(
455        error_domain: glib::Quark,
456        error_code: i32,
457        dbus_error_name: &str,
458    ) -> bool {
459        unsafe {
460            from_glib(ffi::g_dbus_error_register_error(
461                error_domain.into_glib(),
462                error_code,
463                dbus_error_name.to_glib_none().0,
464            ))
465        }
466    }
467
468    //#[doc(alias = "g_dbus_error_register_error_domain")]
469    //pub fn register_error_domain(error_domain_quark_name: &str, entries: /*Ignored*/&[DBusErrorEntry]) -> usize {
470    //    unsafe { TODO: call ffi:g_dbus_error_register_error_domain() }
471    //}
472
473    //#[doc(alias = "g_dbus_error_set_dbus_error")]
474    //pub fn set_dbus_error(dbus_error_name: &str, dbus_error_message: &str, format: Option<&str>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Option<glib::Error> {
475    //    unsafe { TODO: call ffi:g_dbus_error_set_dbus_error() }
476    //}
477
478    //#[doc(alias = "g_dbus_error_set_dbus_error_valist")]
479    //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> {
480    //    unsafe { TODO: call ffi:g_dbus_error_set_dbus_error_valist() }
481    //}
482
483    #[doc(alias = "g_dbus_error_strip_remote_error")]
484    pub fn strip_remote_error(error: &mut glib::Error) -> bool {
485        unsafe {
486            from_glib(ffi::g_dbus_error_strip_remote_error(
487                error.to_glib_none_mut().0,
488            ))
489        }
490    }
491
492    #[doc(alias = "g_dbus_error_unregister_error")]
493    pub fn unregister_error(
494        error_domain: glib::Quark,
495        error_code: i32,
496        dbus_error_name: &str,
497    ) -> bool {
498        unsafe {
499            from_glib(ffi::g_dbus_error_unregister_error(
500                error_domain.into_glib(),
501                error_code,
502                dbus_error_name.to_glib_none().0,
503            ))
504        }
505    }
506}
507
508#[doc(hidden)]
509impl IntoGlib for DBusError {
510    type GlibType = ffi::GDBusError;
511
512    fn into_glib(self) -> ffi::GDBusError {
513        match self {
514            Self::Failed => ffi::G_DBUS_ERROR_FAILED,
515            Self::NoMemory => ffi::G_DBUS_ERROR_NO_MEMORY,
516            Self::ServiceUnknown => ffi::G_DBUS_ERROR_SERVICE_UNKNOWN,
517            Self::NameHasNoOwner => ffi::G_DBUS_ERROR_NAME_HAS_NO_OWNER,
518            Self::NoReply => ffi::G_DBUS_ERROR_NO_REPLY,
519            Self::IoError => ffi::G_DBUS_ERROR_IO_ERROR,
520            Self::BadAddress => ffi::G_DBUS_ERROR_BAD_ADDRESS,
521            Self::NotSupported => ffi::G_DBUS_ERROR_NOT_SUPPORTED,
522            Self::LimitsExceeded => ffi::G_DBUS_ERROR_LIMITS_EXCEEDED,
523            Self::AccessDenied => ffi::G_DBUS_ERROR_ACCESS_DENIED,
524            Self::AuthFailed => ffi::G_DBUS_ERROR_AUTH_FAILED,
525            Self::NoServer => ffi::G_DBUS_ERROR_NO_SERVER,
526            Self::Timeout => ffi::G_DBUS_ERROR_TIMEOUT,
527            Self::NoNetwork => ffi::G_DBUS_ERROR_NO_NETWORK,
528            Self::AddressInUse => ffi::G_DBUS_ERROR_ADDRESS_IN_USE,
529            Self::Disconnected => ffi::G_DBUS_ERROR_DISCONNECTED,
530            Self::InvalidArgs => ffi::G_DBUS_ERROR_INVALID_ARGS,
531            Self::FileNotFound => ffi::G_DBUS_ERROR_FILE_NOT_FOUND,
532            Self::FileExists => ffi::G_DBUS_ERROR_FILE_EXISTS,
533            Self::UnknownMethod => ffi::G_DBUS_ERROR_UNKNOWN_METHOD,
534            Self::TimedOut => ffi::G_DBUS_ERROR_TIMED_OUT,
535            Self::MatchRuleNotFound => ffi::G_DBUS_ERROR_MATCH_RULE_NOT_FOUND,
536            Self::MatchRuleInvalid => ffi::G_DBUS_ERROR_MATCH_RULE_INVALID,
537            Self::SpawnExecFailed => ffi::G_DBUS_ERROR_SPAWN_EXEC_FAILED,
538            Self::SpawnForkFailed => ffi::G_DBUS_ERROR_SPAWN_FORK_FAILED,
539            Self::SpawnChildExited => ffi::G_DBUS_ERROR_SPAWN_CHILD_EXITED,
540            Self::SpawnChildSignaled => ffi::G_DBUS_ERROR_SPAWN_CHILD_SIGNALED,
541            Self::SpawnFailed => ffi::G_DBUS_ERROR_SPAWN_FAILED,
542            Self::SpawnSetupFailed => ffi::G_DBUS_ERROR_SPAWN_SETUP_FAILED,
543            Self::SpawnConfigInvalid => ffi::G_DBUS_ERROR_SPAWN_CONFIG_INVALID,
544            Self::SpawnServiceInvalid => ffi::G_DBUS_ERROR_SPAWN_SERVICE_INVALID,
545            Self::SpawnServiceNotFound => ffi::G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND,
546            Self::SpawnPermissionsInvalid => ffi::G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID,
547            Self::SpawnFileInvalid => ffi::G_DBUS_ERROR_SPAWN_FILE_INVALID,
548            Self::SpawnNoMemory => ffi::G_DBUS_ERROR_SPAWN_NO_MEMORY,
549            Self::UnixProcessIdUnknown => ffi::G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN,
550            Self::InvalidSignature => ffi::G_DBUS_ERROR_INVALID_SIGNATURE,
551            Self::InvalidFileContent => ffi::G_DBUS_ERROR_INVALID_FILE_CONTENT,
552            Self::SelinuxSecurityContextUnknown => {
553                ffi::G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN
554            }
555            Self::AdtAuditDataUnknown => ffi::G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN,
556            Self::ObjectPathInUse => ffi::G_DBUS_ERROR_OBJECT_PATH_IN_USE,
557            Self::UnknownObject => ffi::G_DBUS_ERROR_UNKNOWN_OBJECT,
558            Self::UnknownInterface => ffi::G_DBUS_ERROR_UNKNOWN_INTERFACE,
559            Self::UnknownProperty => ffi::G_DBUS_ERROR_UNKNOWN_PROPERTY,
560            Self::PropertyReadOnly => ffi::G_DBUS_ERROR_PROPERTY_READ_ONLY,
561            Self::__Unknown(value) => value,
562        }
563    }
564}
565
566#[doc(hidden)]
567impl FromGlib<ffi::GDBusError> for DBusError {
568    unsafe fn from_glib(value: ffi::GDBusError) -> Self {
569        match value {
570            ffi::G_DBUS_ERROR_FAILED => Self::Failed,
571            ffi::G_DBUS_ERROR_NO_MEMORY => Self::NoMemory,
572            ffi::G_DBUS_ERROR_SERVICE_UNKNOWN => Self::ServiceUnknown,
573            ffi::G_DBUS_ERROR_NAME_HAS_NO_OWNER => Self::NameHasNoOwner,
574            ffi::G_DBUS_ERROR_NO_REPLY => Self::NoReply,
575            ffi::G_DBUS_ERROR_IO_ERROR => Self::IoError,
576            ffi::G_DBUS_ERROR_BAD_ADDRESS => Self::BadAddress,
577            ffi::G_DBUS_ERROR_NOT_SUPPORTED => Self::NotSupported,
578            ffi::G_DBUS_ERROR_LIMITS_EXCEEDED => Self::LimitsExceeded,
579            ffi::G_DBUS_ERROR_ACCESS_DENIED => Self::AccessDenied,
580            ffi::G_DBUS_ERROR_AUTH_FAILED => Self::AuthFailed,
581            ffi::G_DBUS_ERROR_NO_SERVER => Self::NoServer,
582            ffi::G_DBUS_ERROR_TIMEOUT => Self::Timeout,
583            ffi::G_DBUS_ERROR_NO_NETWORK => Self::NoNetwork,
584            ffi::G_DBUS_ERROR_ADDRESS_IN_USE => Self::AddressInUse,
585            ffi::G_DBUS_ERROR_DISCONNECTED => Self::Disconnected,
586            ffi::G_DBUS_ERROR_INVALID_ARGS => Self::InvalidArgs,
587            ffi::G_DBUS_ERROR_FILE_NOT_FOUND => Self::FileNotFound,
588            ffi::G_DBUS_ERROR_FILE_EXISTS => Self::FileExists,
589            ffi::G_DBUS_ERROR_UNKNOWN_METHOD => Self::UnknownMethod,
590            ffi::G_DBUS_ERROR_TIMED_OUT => Self::TimedOut,
591            ffi::G_DBUS_ERROR_MATCH_RULE_NOT_FOUND => Self::MatchRuleNotFound,
592            ffi::G_DBUS_ERROR_MATCH_RULE_INVALID => Self::MatchRuleInvalid,
593            ffi::G_DBUS_ERROR_SPAWN_EXEC_FAILED => Self::SpawnExecFailed,
594            ffi::G_DBUS_ERROR_SPAWN_FORK_FAILED => Self::SpawnForkFailed,
595            ffi::G_DBUS_ERROR_SPAWN_CHILD_EXITED => Self::SpawnChildExited,
596            ffi::G_DBUS_ERROR_SPAWN_CHILD_SIGNALED => Self::SpawnChildSignaled,
597            ffi::G_DBUS_ERROR_SPAWN_FAILED => Self::SpawnFailed,
598            ffi::G_DBUS_ERROR_SPAWN_SETUP_FAILED => Self::SpawnSetupFailed,
599            ffi::G_DBUS_ERROR_SPAWN_CONFIG_INVALID => Self::SpawnConfigInvalid,
600            ffi::G_DBUS_ERROR_SPAWN_SERVICE_INVALID => Self::SpawnServiceInvalid,
601            ffi::G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND => Self::SpawnServiceNotFound,
602            ffi::G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID => Self::SpawnPermissionsInvalid,
603            ffi::G_DBUS_ERROR_SPAWN_FILE_INVALID => Self::SpawnFileInvalid,
604            ffi::G_DBUS_ERROR_SPAWN_NO_MEMORY => Self::SpawnNoMemory,
605            ffi::G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN => Self::UnixProcessIdUnknown,
606            ffi::G_DBUS_ERROR_INVALID_SIGNATURE => Self::InvalidSignature,
607            ffi::G_DBUS_ERROR_INVALID_FILE_CONTENT => Self::InvalidFileContent,
608            ffi::G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN => {
609                Self::SelinuxSecurityContextUnknown
610            }
611            ffi::G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN => Self::AdtAuditDataUnknown,
612            ffi::G_DBUS_ERROR_OBJECT_PATH_IN_USE => Self::ObjectPathInUse,
613            ffi::G_DBUS_ERROR_UNKNOWN_OBJECT => Self::UnknownObject,
614            ffi::G_DBUS_ERROR_UNKNOWN_INTERFACE => Self::UnknownInterface,
615            ffi::G_DBUS_ERROR_UNKNOWN_PROPERTY => Self::UnknownProperty,
616            ffi::G_DBUS_ERROR_PROPERTY_READ_ONLY => Self::PropertyReadOnly,
617            value => Self::__Unknown(value),
618        }
619    }
620}
621
622impl glib::error::ErrorDomain for DBusError {
623    #[inline]
624    fn domain() -> glib::Quark {
625        unsafe { from_glib(ffi::g_dbus_error_quark()) }
626    }
627
628    #[inline]
629    fn code(self) -> i32 {
630        self.into_glib()
631    }
632
633    #[inline]
634    #[allow(clippy::match_single_binding)]
635    fn from(code: i32) -> Option<Self> {
636        match unsafe { from_glib(code) } {
637            Self::__Unknown(_) => Some(Self::Failed),
638            value => Some(value),
639        }
640    }
641}
642
643impl StaticType for DBusError {
644    #[inline]
645    #[doc(alias = "g_dbus_error_get_type")]
646    fn static_type() -> glib::Type {
647        unsafe { from_glib(ffi::g_dbus_error_get_type()) }
648    }
649}
650
651impl glib::HasParamSpec for DBusError {
652    type ParamSpec = glib::ParamSpecEnum;
653    type SetValue = Self;
654    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
655
656    fn param_spec_builder() -> Self::BuilderFn {
657        Self::ParamSpec::builder_with_default
658    }
659}
660
661impl glib::value::ValueType for DBusError {
662    type Type = Self;
663}
664
665unsafe impl<'a> glib::value::FromValue<'a> for DBusError {
666    type Checker = glib::value::GenericValueTypeChecker<Self>;
667
668    #[inline]
669    unsafe fn from_value(value: &'a glib::Value) -> Self {
670        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
671    }
672}
673
674impl ToValue for DBusError {
675    #[inline]
676    fn to_value(&self) -> glib::Value {
677        let mut value = glib::Value::for_value_type::<Self>();
678        unsafe {
679            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
680        }
681        value
682    }
683
684    #[inline]
685    fn value_type(&self) -> glib::Type {
686        Self::static_type()
687    }
688}
689
690impl From<DBusError> for glib::Value {
691    #[inline]
692    fn from(v: DBusError) -> Self {
693        ToValue::to_value(&v)
694    }
695}
696
697#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
698#[non_exhaustive]
699#[doc(alias = "GDBusMessageByteOrder")]
700pub enum DBusMessageByteOrder {
701    #[doc(alias = "G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN")]
702    BigEndian,
703    #[doc(alias = "G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN")]
704    LittleEndian,
705    #[doc(hidden)]
706    __Unknown(i32),
707}
708
709#[doc(hidden)]
710impl IntoGlib for DBusMessageByteOrder {
711    type GlibType = ffi::GDBusMessageByteOrder;
712
713    #[inline]
714    fn into_glib(self) -> ffi::GDBusMessageByteOrder {
715        match self {
716            Self::BigEndian => ffi::G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN,
717            Self::LittleEndian => ffi::G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN,
718            Self::__Unknown(value) => value,
719        }
720    }
721}
722
723#[doc(hidden)]
724impl FromGlib<ffi::GDBusMessageByteOrder> for DBusMessageByteOrder {
725    #[inline]
726    unsafe fn from_glib(value: ffi::GDBusMessageByteOrder) -> Self {
727        match value {
728            ffi::G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN => Self::BigEndian,
729            ffi::G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN => Self::LittleEndian,
730            value => Self::__Unknown(value),
731        }
732    }
733}
734
735impl StaticType for DBusMessageByteOrder {
736    #[inline]
737    #[doc(alias = "g_dbus_message_byte_order_get_type")]
738    fn static_type() -> glib::Type {
739        unsafe { from_glib(ffi::g_dbus_message_byte_order_get_type()) }
740    }
741}
742
743impl glib::HasParamSpec for DBusMessageByteOrder {
744    type ParamSpec = glib::ParamSpecEnum;
745    type SetValue = Self;
746    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
747
748    fn param_spec_builder() -> Self::BuilderFn {
749        Self::ParamSpec::builder_with_default
750    }
751}
752
753impl glib::value::ValueType for DBusMessageByteOrder {
754    type Type = Self;
755}
756
757unsafe impl<'a> glib::value::FromValue<'a> for DBusMessageByteOrder {
758    type Checker = glib::value::GenericValueTypeChecker<Self>;
759
760    #[inline]
761    unsafe fn from_value(value: &'a glib::Value) -> Self {
762        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
763    }
764}
765
766impl ToValue for DBusMessageByteOrder {
767    #[inline]
768    fn to_value(&self) -> glib::Value {
769        let mut value = glib::Value::for_value_type::<Self>();
770        unsafe {
771            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
772        }
773        value
774    }
775
776    #[inline]
777    fn value_type(&self) -> glib::Type {
778        Self::static_type()
779    }
780}
781
782impl From<DBusMessageByteOrder> for glib::Value {
783    #[inline]
784    fn from(v: DBusMessageByteOrder) -> Self {
785        ToValue::to_value(&v)
786    }
787}
788
789#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
790#[non_exhaustive]
791#[doc(alias = "GDBusMessageHeaderField")]
792pub enum DBusMessageHeaderField {
793    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_INVALID")]
794    Invalid,
795    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_PATH")]
796    Path,
797    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE")]
798    Interface,
799    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_MEMBER")]
800    Member,
801    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME")]
802    ErrorName,
803    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL")]
804    ReplySerial,
805    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION")]
806    Destination,
807    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_SENDER")]
808    Sender,
809    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE")]
810    Signature,
811    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS")]
812    NumUnixFds,
813    #[doc(hidden)]
814    __Unknown(i32),
815}
816
817#[doc(hidden)]
818impl IntoGlib for DBusMessageHeaderField {
819    type GlibType = ffi::GDBusMessageHeaderField;
820
821    #[inline]
822    fn into_glib(self) -> ffi::GDBusMessageHeaderField {
823        match self {
824            Self::Invalid => ffi::G_DBUS_MESSAGE_HEADER_FIELD_INVALID,
825            Self::Path => ffi::G_DBUS_MESSAGE_HEADER_FIELD_PATH,
826            Self::Interface => ffi::G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE,
827            Self::Member => ffi::G_DBUS_MESSAGE_HEADER_FIELD_MEMBER,
828            Self::ErrorName => ffi::G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME,
829            Self::ReplySerial => ffi::G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL,
830            Self::Destination => ffi::G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION,
831            Self::Sender => ffi::G_DBUS_MESSAGE_HEADER_FIELD_SENDER,
832            Self::Signature => ffi::G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE,
833            Self::NumUnixFds => ffi::G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS,
834            Self::__Unknown(value) => value,
835        }
836    }
837}
838
839#[doc(hidden)]
840impl FromGlib<ffi::GDBusMessageHeaderField> for DBusMessageHeaderField {
841    #[inline]
842    unsafe fn from_glib(value: ffi::GDBusMessageHeaderField) -> Self {
843        match value {
844            ffi::G_DBUS_MESSAGE_HEADER_FIELD_INVALID => Self::Invalid,
845            ffi::G_DBUS_MESSAGE_HEADER_FIELD_PATH => Self::Path,
846            ffi::G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE => Self::Interface,
847            ffi::G_DBUS_MESSAGE_HEADER_FIELD_MEMBER => Self::Member,
848            ffi::G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME => Self::ErrorName,
849            ffi::G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL => Self::ReplySerial,
850            ffi::G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION => Self::Destination,
851            ffi::G_DBUS_MESSAGE_HEADER_FIELD_SENDER => Self::Sender,
852            ffi::G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE => Self::Signature,
853            ffi::G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS => Self::NumUnixFds,
854            value => Self::__Unknown(value),
855        }
856    }
857}
858
859impl StaticType for DBusMessageHeaderField {
860    #[inline]
861    #[doc(alias = "g_dbus_message_header_field_get_type")]
862    fn static_type() -> glib::Type {
863        unsafe { from_glib(ffi::g_dbus_message_header_field_get_type()) }
864    }
865}
866
867impl glib::HasParamSpec for DBusMessageHeaderField {
868    type ParamSpec = glib::ParamSpecEnum;
869    type SetValue = Self;
870    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
871
872    fn param_spec_builder() -> Self::BuilderFn {
873        Self::ParamSpec::builder_with_default
874    }
875}
876
877impl glib::value::ValueType for DBusMessageHeaderField {
878    type Type = Self;
879}
880
881unsafe impl<'a> glib::value::FromValue<'a> for DBusMessageHeaderField {
882    type Checker = glib::value::GenericValueTypeChecker<Self>;
883
884    #[inline]
885    unsafe fn from_value(value: &'a glib::Value) -> Self {
886        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
887    }
888}
889
890impl ToValue for DBusMessageHeaderField {
891    #[inline]
892    fn to_value(&self) -> glib::Value {
893        let mut value = glib::Value::for_value_type::<Self>();
894        unsafe {
895            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
896        }
897        value
898    }
899
900    #[inline]
901    fn value_type(&self) -> glib::Type {
902        Self::static_type()
903    }
904}
905
906impl From<DBusMessageHeaderField> for glib::Value {
907    #[inline]
908    fn from(v: DBusMessageHeaderField) -> Self {
909        ToValue::to_value(&v)
910    }
911}
912
913#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
914#[non_exhaustive]
915#[doc(alias = "GDBusMessageType")]
916pub enum DBusMessageType {
917    #[doc(alias = "G_DBUS_MESSAGE_TYPE_INVALID")]
918    Invalid,
919    #[doc(alias = "G_DBUS_MESSAGE_TYPE_METHOD_CALL")]
920    MethodCall,
921    #[doc(alias = "G_DBUS_MESSAGE_TYPE_METHOD_RETURN")]
922    MethodReturn,
923    #[doc(alias = "G_DBUS_MESSAGE_TYPE_ERROR")]
924    Error,
925    #[doc(alias = "G_DBUS_MESSAGE_TYPE_SIGNAL")]
926    Signal,
927    #[doc(hidden)]
928    __Unknown(i32),
929}
930
931#[doc(hidden)]
932impl IntoGlib for DBusMessageType {
933    type GlibType = ffi::GDBusMessageType;
934
935    #[inline]
936    fn into_glib(self) -> ffi::GDBusMessageType {
937        match self {
938            Self::Invalid => ffi::G_DBUS_MESSAGE_TYPE_INVALID,
939            Self::MethodCall => ffi::G_DBUS_MESSAGE_TYPE_METHOD_CALL,
940            Self::MethodReturn => ffi::G_DBUS_MESSAGE_TYPE_METHOD_RETURN,
941            Self::Error => ffi::G_DBUS_MESSAGE_TYPE_ERROR,
942            Self::Signal => ffi::G_DBUS_MESSAGE_TYPE_SIGNAL,
943            Self::__Unknown(value) => value,
944        }
945    }
946}
947
948#[doc(hidden)]
949impl FromGlib<ffi::GDBusMessageType> for DBusMessageType {
950    #[inline]
951    unsafe fn from_glib(value: ffi::GDBusMessageType) -> Self {
952        match value {
953            ffi::G_DBUS_MESSAGE_TYPE_INVALID => Self::Invalid,
954            ffi::G_DBUS_MESSAGE_TYPE_METHOD_CALL => Self::MethodCall,
955            ffi::G_DBUS_MESSAGE_TYPE_METHOD_RETURN => Self::MethodReturn,
956            ffi::G_DBUS_MESSAGE_TYPE_ERROR => Self::Error,
957            ffi::G_DBUS_MESSAGE_TYPE_SIGNAL => Self::Signal,
958            value => Self::__Unknown(value),
959        }
960    }
961}
962
963impl StaticType for DBusMessageType {
964    #[inline]
965    #[doc(alias = "g_dbus_message_type_get_type")]
966    fn static_type() -> glib::Type {
967        unsafe { from_glib(ffi::g_dbus_message_type_get_type()) }
968    }
969}
970
971impl glib::HasParamSpec for DBusMessageType {
972    type ParamSpec = glib::ParamSpecEnum;
973    type SetValue = Self;
974    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
975
976    fn param_spec_builder() -> Self::BuilderFn {
977        Self::ParamSpec::builder_with_default
978    }
979}
980
981impl glib::value::ValueType for DBusMessageType {
982    type Type = Self;
983}
984
985unsafe impl<'a> glib::value::FromValue<'a> for DBusMessageType {
986    type Checker = glib::value::GenericValueTypeChecker<Self>;
987
988    #[inline]
989    unsafe fn from_value(value: &'a glib::Value) -> Self {
990        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
991    }
992}
993
994impl ToValue for DBusMessageType {
995    #[inline]
996    fn to_value(&self) -> glib::Value {
997        let mut value = glib::Value::for_value_type::<Self>();
998        unsafe {
999            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1000        }
1001        value
1002    }
1003
1004    #[inline]
1005    fn value_type(&self) -> glib::Type {
1006        Self::static_type()
1007    }
1008}
1009
1010impl From<DBusMessageType> for glib::Value {
1011    #[inline]
1012    fn from(v: DBusMessageType) -> Self {
1013        ToValue::to_value(&v)
1014    }
1015}
1016
1017#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1018#[non_exhaustive]
1019#[doc(alias = "GDataStreamByteOrder")]
1020pub enum DataStreamByteOrder {
1021    #[doc(alias = "G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN")]
1022    BigEndian,
1023    #[doc(alias = "G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN")]
1024    LittleEndian,
1025    #[doc(alias = "G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN")]
1026    HostEndian,
1027    #[doc(hidden)]
1028    __Unknown(i32),
1029}
1030
1031#[doc(hidden)]
1032impl IntoGlib for DataStreamByteOrder {
1033    type GlibType = ffi::GDataStreamByteOrder;
1034
1035    #[inline]
1036    fn into_glib(self) -> ffi::GDataStreamByteOrder {
1037        match self {
1038            Self::BigEndian => ffi::G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN,
1039            Self::LittleEndian => ffi::G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN,
1040            Self::HostEndian => ffi::G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN,
1041            Self::__Unknown(value) => value,
1042        }
1043    }
1044}
1045
1046#[doc(hidden)]
1047impl FromGlib<ffi::GDataStreamByteOrder> for DataStreamByteOrder {
1048    #[inline]
1049    unsafe fn from_glib(value: ffi::GDataStreamByteOrder) -> Self {
1050        match value {
1051            ffi::G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN => Self::BigEndian,
1052            ffi::G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN => Self::LittleEndian,
1053            ffi::G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN => Self::HostEndian,
1054            value => Self::__Unknown(value),
1055        }
1056    }
1057}
1058
1059impl StaticType for DataStreamByteOrder {
1060    #[inline]
1061    #[doc(alias = "g_data_stream_byte_order_get_type")]
1062    fn static_type() -> glib::Type {
1063        unsafe { from_glib(ffi::g_data_stream_byte_order_get_type()) }
1064    }
1065}
1066
1067impl glib::HasParamSpec for DataStreamByteOrder {
1068    type ParamSpec = glib::ParamSpecEnum;
1069    type SetValue = Self;
1070    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1071
1072    fn param_spec_builder() -> Self::BuilderFn {
1073        Self::ParamSpec::builder_with_default
1074    }
1075}
1076
1077impl glib::value::ValueType for DataStreamByteOrder {
1078    type Type = Self;
1079}
1080
1081unsafe impl<'a> glib::value::FromValue<'a> for DataStreamByteOrder {
1082    type Checker = glib::value::GenericValueTypeChecker<Self>;
1083
1084    #[inline]
1085    unsafe fn from_value(value: &'a glib::Value) -> Self {
1086        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1087    }
1088}
1089
1090impl ToValue for DataStreamByteOrder {
1091    #[inline]
1092    fn to_value(&self) -> glib::Value {
1093        let mut value = glib::Value::for_value_type::<Self>();
1094        unsafe {
1095            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1096        }
1097        value
1098    }
1099
1100    #[inline]
1101    fn value_type(&self) -> glib::Type {
1102        Self::static_type()
1103    }
1104}
1105
1106impl From<DataStreamByteOrder> for glib::Value {
1107    #[inline]
1108    fn from(v: DataStreamByteOrder) -> Self {
1109        ToValue::to_value(&v)
1110    }
1111}
1112
1113#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1114#[non_exhaustive]
1115#[doc(alias = "GDataStreamNewlineType")]
1116pub enum DataStreamNewlineType {
1117    #[doc(alias = "G_DATA_STREAM_NEWLINE_TYPE_LF")]
1118    Lf,
1119    #[doc(alias = "G_DATA_STREAM_NEWLINE_TYPE_CR")]
1120    Cr,
1121    #[doc(alias = "G_DATA_STREAM_NEWLINE_TYPE_CR_LF")]
1122    CrLf,
1123    #[doc(alias = "G_DATA_STREAM_NEWLINE_TYPE_ANY")]
1124    Any,
1125    #[doc(hidden)]
1126    __Unknown(i32),
1127}
1128
1129#[doc(hidden)]
1130impl IntoGlib for DataStreamNewlineType {
1131    type GlibType = ffi::GDataStreamNewlineType;
1132
1133    #[inline]
1134    fn into_glib(self) -> ffi::GDataStreamNewlineType {
1135        match self {
1136            Self::Lf => ffi::G_DATA_STREAM_NEWLINE_TYPE_LF,
1137            Self::Cr => ffi::G_DATA_STREAM_NEWLINE_TYPE_CR,
1138            Self::CrLf => ffi::G_DATA_STREAM_NEWLINE_TYPE_CR_LF,
1139            Self::Any => ffi::G_DATA_STREAM_NEWLINE_TYPE_ANY,
1140            Self::__Unknown(value) => value,
1141        }
1142    }
1143}
1144
1145#[doc(hidden)]
1146impl FromGlib<ffi::GDataStreamNewlineType> for DataStreamNewlineType {
1147    #[inline]
1148    unsafe fn from_glib(value: ffi::GDataStreamNewlineType) -> Self {
1149        match value {
1150            ffi::G_DATA_STREAM_NEWLINE_TYPE_LF => Self::Lf,
1151            ffi::G_DATA_STREAM_NEWLINE_TYPE_CR => Self::Cr,
1152            ffi::G_DATA_STREAM_NEWLINE_TYPE_CR_LF => Self::CrLf,
1153            ffi::G_DATA_STREAM_NEWLINE_TYPE_ANY => Self::Any,
1154            value => Self::__Unknown(value),
1155        }
1156    }
1157}
1158
1159impl StaticType for DataStreamNewlineType {
1160    #[inline]
1161    #[doc(alias = "g_data_stream_newline_type_get_type")]
1162    fn static_type() -> glib::Type {
1163        unsafe { from_glib(ffi::g_data_stream_newline_type_get_type()) }
1164    }
1165}
1166
1167impl glib::HasParamSpec for DataStreamNewlineType {
1168    type ParamSpec = glib::ParamSpecEnum;
1169    type SetValue = Self;
1170    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1171
1172    fn param_spec_builder() -> Self::BuilderFn {
1173        Self::ParamSpec::builder_with_default
1174    }
1175}
1176
1177impl glib::value::ValueType for DataStreamNewlineType {
1178    type Type = Self;
1179}
1180
1181unsafe impl<'a> glib::value::FromValue<'a> for DataStreamNewlineType {
1182    type Checker = glib::value::GenericValueTypeChecker<Self>;
1183
1184    #[inline]
1185    unsafe fn from_value(value: &'a glib::Value) -> Self {
1186        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1187    }
1188}
1189
1190impl ToValue for DataStreamNewlineType {
1191    #[inline]
1192    fn to_value(&self) -> glib::Value {
1193        let mut value = glib::Value::for_value_type::<Self>();
1194        unsafe {
1195            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1196        }
1197        value
1198    }
1199
1200    #[inline]
1201    fn value_type(&self) -> glib::Type {
1202        Self::static_type()
1203    }
1204}
1205
1206impl From<DataStreamNewlineType> for glib::Value {
1207    #[inline]
1208    fn from(v: DataStreamNewlineType) -> Self {
1209        ToValue::to_value(&v)
1210    }
1211}
1212
1213#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1214#[non_exhaustive]
1215#[doc(alias = "GDriveStartStopType")]
1216pub enum DriveStartStopType {
1217    #[doc(alias = "G_DRIVE_START_STOP_TYPE_UNKNOWN")]
1218    Unknown,
1219    #[doc(alias = "G_DRIVE_START_STOP_TYPE_SHUTDOWN")]
1220    Shutdown,
1221    #[doc(alias = "G_DRIVE_START_STOP_TYPE_NETWORK")]
1222    Network,
1223    #[doc(alias = "G_DRIVE_START_STOP_TYPE_MULTIDISK")]
1224    Multidisk,
1225    #[doc(alias = "G_DRIVE_START_STOP_TYPE_PASSWORD")]
1226    Password,
1227    #[doc(hidden)]
1228    __Unknown(i32),
1229}
1230
1231#[doc(hidden)]
1232impl IntoGlib for DriveStartStopType {
1233    type GlibType = ffi::GDriveStartStopType;
1234
1235    #[inline]
1236    fn into_glib(self) -> ffi::GDriveStartStopType {
1237        match self {
1238            Self::Unknown => ffi::G_DRIVE_START_STOP_TYPE_UNKNOWN,
1239            Self::Shutdown => ffi::G_DRIVE_START_STOP_TYPE_SHUTDOWN,
1240            Self::Network => ffi::G_DRIVE_START_STOP_TYPE_NETWORK,
1241            Self::Multidisk => ffi::G_DRIVE_START_STOP_TYPE_MULTIDISK,
1242            Self::Password => ffi::G_DRIVE_START_STOP_TYPE_PASSWORD,
1243            Self::__Unknown(value) => value,
1244        }
1245    }
1246}
1247
1248#[doc(hidden)]
1249impl FromGlib<ffi::GDriveStartStopType> for DriveStartStopType {
1250    #[inline]
1251    unsafe fn from_glib(value: ffi::GDriveStartStopType) -> Self {
1252        match value {
1253            ffi::G_DRIVE_START_STOP_TYPE_UNKNOWN => Self::Unknown,
1254            ffi::G_DRIVE_START_STOP_TYPE_SHUTDOWN => Self::Shutdown,
1255            ffi::G_DRIVE_START_STOP_TYPE_NETWORK => Self::Network,
1256            ffi::G_DRIVE_START_STOP_TYPE_MULTIDISK => Self::Multidisk,
1257            ffi::G_DRIVE_START_STOP_TYPE_PASSWORD => Self::Password,
1258            value => Self::__Unknown(value),
1259        }
1260    }
1261}
1262
1263impl StaticType for DriveStartStopType {
1264    #[inline]
1265    #[doc(alias = "g_drive_start_stop_type_get_type")]
1266    fn static_type() -> glib::Type {
1267        unsafe { from_glib(ffi::g_drive_start_stop_type_get_type()) }
1268    }
1269}
1270
1271impl glib::HasParamSpec for DriveStartStopType {
1272    type ParamSpec = glib::ParamSpecEnum;
1273    type SetValue = Self;
1274    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1275
1276    fn param_spec_builder() -> Self::BuilderFn {
1277        Self::ParamSpec::builder_with_default
1278    }
1279}
1280
1281impl glib::value::ValueType for DriveStartStopType {
1282    type Type = Self;
1283}
1284
1285unsafe impl<'a> glib::value::FromValue<'a> for DriveStartStopType {
1286    type Checker = glib::value::GenericValueTypeChecker<Self>;
1287
1288    #[inline]
1289    unsafe fn from_value(value: &'a glib::Value) -> Self {
1290        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1291    }
1292}
1293
1294impl ToValue for DriveStartStopType {
1295    #[inline]
1296    fn to_value(&self) -> glib::Value {
1297        let mut value = glib::Value::for_value_type::<Self>();
1298        unsafe {
1299            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1300        }
1301        value
1302    }
1303
1304    #[inline]
1305    fn value_type(&self) -> glib::Type {
1306        Self::static_type()
1307    }
1308}
1309
1310impl From<DriveStartStopType> for glib::Value {
1311    #[inline]
1312    fn from(v: DriveStartStopType) -> Self {
1313        ToValue::to_value(&v)
1314    }
1315}
1316
1317#[cfg(feature = "v2_88")]
1318#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1319#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1320#[non_exhaustive]
1321#[doc(alias = "GEcnCodePoint")]
1322pub enum EcnCodePoint {
1323    #[doc(alias = "G_ECN_NO_ECN")]
1324    NoEcn,
1325    #[doc(alias = "G_ECN_ECT_1")]
1326    Ect1,
1327    #[doc(alias = "G_ECN_ECT_0")]
1328    Ect0,
1329    #[doc(alias = "G_ECN_ECT_CE")]
1330    EctCe,
1331    #[doc(hidden)]
1332    __Unknown(i32),
1333}
1334
1335#[cfg(feature = "v2_88")]
1336#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1337#[doc(hidden)]
1338impl IntoGlib for EcnCodePoint {
1339    type GlibType = ffi::GEcnCodePoint;
1340
1341    #[inline]
1342    fn into_glib(self) -> ffi::GEcnCodePoint {
1343        match self {
1344            Self::NoEcn => ffi::G_ECN_NO_ECN,
1345            Self::Ect1 => ffi::G_ECN_ECT_1,
1346            Self::Ect0 => ffi::G_ECN_ECT_0,
1347            Self::EctCe => ffi::G_ECN_ECT_CE,
1348            Self::__Unknown(value) => value,
1349        }
1350    }
1351}
1352
1353#[cfg(feature = "v2_88")]
1354#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1355#[doc(hidden)]
1356impl FromGlib<ffi::GEcnCodePoint> for EcnCodePoint {
1357    #[inline]
1358    unsafe fn from_glib(value: ffi::GEcnCodePoint) -> Self {
1359        match value {
1360            ffi::G_ECN_NO_ECN => Self::NoEcn,
1361            ffi::G_ECN_ECT_1 => Self::Ect1,
1362            ffi::G_ECN_ECT_0 => Self::Ect0,
1363            ffi::G_ECN_ECT_CE => Self::EctCe,
1364            value => Self::__Unknown(value),
1365        }
1366    }
1367}
1368
1369#[cfg(feature = "v2_88")]
1370#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1371impl StaticType for EcnCodePoint {
1372    #[inline]
1373    #[doc(alias = "g_ecn_code_point_get_type")]
1374    fn static_type() -> glib::Type {
1375        unsafe { from_glib(ffi::g_ecn_code_point_get_type()) }
1376    }
1377}
1378
1379#[cfg(feature = "v2_88")]
1380#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1381impl glib::HasParamSpec for EcnCodePoint {
1382    type ParamSpec = glib::ParamSpecEnum;
1383    type SetValue = Self;
1384    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1385
1386    fn param_spec_builder() -> Self::BuilderFn {
1387        Self::ParamSpec::builder_with_default
1388    }
1389}
1390
1391#[cfg(feature = "v2_88")]
1392#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1393impl glib::value::ValueType for EcnCodePoint {
1394    type Type = Self;
1395}
1396
1397#[cfg(feature = "v2_88")]
1398#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1399unsafe impl<'a> glib::value::FromValue<'a> for EcnCodePoint {
1400    type Checker = glib::value::GenericValueTypeChecker<Self>;
1401
1402    #[inline]
1403    unsafe fn from_value(value: &'a glib::Value) -> Self {
1404        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1405    }
1406}
1407
1408#[cfg(feature = "v2_88")]
1409#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1410impl ToValue for EcnCodePoint {
1411    #[inline]
1412    fn to_value(&self) -> glib::Value {
1413        let mut value = glib::Value::for_value_type::<Self>();
1414        unsafe {
1415            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1416        }
1417        value
1418    }
1419
1420    #[inline]
1421    fn value_type(&self) -> glib::Type {
1422        Self::static_type()
1423    }
1424}
1425
1426#[cfg(feature = "v2_88")]
1427#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1428impl From<EcnCodePoint> for glib::Value {
1429    #[inline]
1430    fn from(v: EcnCodePoint) -> Self {
1431        ToValue::to_value(&v)
1432    }
1433}
1434
1435#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1436#[non_exhaustive]
1437#[doc(alias = "GEmblemOrigin")]
1438pub enum EmblemOrigin {
1439    #[doc(alias = "G_EMBLEM_ORIGIN_UNKNOWN")]
1440    Unknown,
1441    #[doc(alias = "G_EMBLEM_ORIGIN_DEVICE")]
1442    Device,
1443    #[doc(alias = "G_EMBLEM_ORIGIN_LIVEMETADATA")]
1444    Livemetadata,
1445    #[doc(alias = "G_EMBLEM_ORIGIN_TAG")]
1446    Tag,
1447    #[doc(hidden)]
1448    __Unknown(i32),
1449}
1450
1451#[doc(hidden)]
1452impl IntoGlib for EmblemOrigin {
1453    type GlibType = ffi::GEmblemOrigin;
1454
1455    #[inline]
1456    fn into_glib(self) -> ffi::GEmblemOrigin {
1457        match self {
1458            Self::Unknown => ffi::G_EMBLEM_ORIGIN_UNKNOWN,
1459            Self::Device => ffi::G_EMBLEM_ORIGIN_DEVICE,
1460            Self::Livemetadata => ffi::G_EMBLEM_ORIGIN_LIVEMETADATA,
1461            Self::Tag => ffi::G_EMBLEM_ORIGIN_TAG,
1462            Self::__Unknown(value) => value,
1463        }
1464    }
1465}
1466
1467#[doc(hidden)]
1468impl FromGlib<ffi::GEmblemOrigin> for EmblemOrigin {
1469    #[inline]
1470    unsafe fn from_glib(value: ffi::GEmblemOrigin) -> Self {
1471        match value {
1472            ffi::G_EMBLEM_ORIGIN_UNKNOWN => Self::Unknown,
1473            ffi::G_EMBLEM_ORIGIN_DEVICE => Self::Device,
1474            ffi::G_EMBLEM_ORIGIN_LIVEMETADATA => Self::Livemetadata,
1475            ffi::G_EMBLEM_ORIGIN_TAG => Self::Tag,
1476            value => Self::__Unknown(value),
1477        }
1478    }
1479}
1480
1481impl StaticType for EmblemOrigin {
1482    #[inline]
1483    #[doc(alias = "g_emblem_origin_get_type")]
1484    fn static_type() -> glib::Type {
1485        unsafe { from_glib(ffi::g_emblem_origin_get_type()) }
1486    }
1487}
1488
1489impl glib::HasParamSpec for EmblemOrigin {
1490    type ParamSpec = glib::ParamSpecEnum;
1491    type SetValue = Self;
1492    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1493
1494    fn param_spec_builder() -> Self::BuilderFn {
1495        Self::ParamSpec::builder_with_default
1496    }
1497}
1498
1499impl glib::value::ValueType for EmblemOrigin {
1500    type Type = Self;
1501}
1502
1503unsafe impl<'a> glib::value::FromValue<'a> for EmblemOrigin {
1504    type Checker = glib::value::GenericValueTypeChecker<Self>;
1505
1506    #[inline]
1507    unsafe fn from_value(value: &'a glib::Value) -> Self {
1508        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1509    }
1510}
1511
1512impl ToValue for EmblemOrigin {
1513    #[inline]
1514    fn to_value(&self) -> glib::Value {
1515        let mut value = glib::Value::for_value_type::<Self>();
1516        unsafe {
1517            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1518        }
1519        value
1520    }
1521
1522    #[inline]
1523    fn value_type(&self) -> glib::Type {
1524        Self::static_type()
1525    }
1526}
1527
1528impl From<EmblemOrigin> for glib::Value {
1529    #[inline]
1530    fn from(v: EmblemOrigin) -> Self {
1531        ToValue::to_value(&v)
1532    }
1533}
1534
1535#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1536#[non_exhaustive]
1537#[doc(alias = "GFileAttributeStatus")]
1538pub enum FileAttributeStatus {
1539    #[doc(alias = "G_FILE_ATTRIBUTE_STATUS_UNSET")]
1540    Unset,
1541    #[doc(alias = "G_FILE_ATTRIBUTE_STATUS_SET")]
1542    Set,
1543    #[doc(alias = "G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING")]
1544    ErrorSetting,
1545    #[doc(hidden)]
1546    __Unknown(i32),
1547}
1548
1549#[doc(hidden)]
1550impl IntoGlib for FileAttributeStatus {
1551    type GlibType = ffi::GFileAttributeStatus;
1552
1553    #[inline]
1554    fn into_glib(self) -> ffi::GFileAttributeStatus {
1555        match self {
1556            Self::Unset => ffi::G_FILE_ATTRIBUTE_STATUS_UNSET,
1557            Self::Set => ffi::G_FILE_ATTRIBUTE_STATUS_SET,
1558            Self::ErrorSetting => ffi::G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING,
1559            Self::__Unknown(value) => value,
1560        }
1561    }
1562}
1563
1564#[doc(hidden)]
1565impl FromGlib<ffi::GFileAttributeStatus> for FileAttributeStatus {
1566    #[inline]
1567    unsafe fn from_glib(value: ffi::GFileAttributeStatus) -> Self {
1568        match value {
1569            ffi::G_FILE_ATTRIBUTE_STATUS_UNSET => Self::Unset,
1570            ffi::G_FILE_ATTRIBUTE_STATUS_SET => Self::Set,
1571            ffi::G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING => Self::ErrorSetting,
1572            value => Self::__Unknown(value),
1573        }
1574    }
1575}
1576
1577impl StaticType for FileAttributeStatus {
1578    #[inline]
1579    #[doc(alias = "g_file_attribute_status_get_type")]
1580    fn static_type() -> glib::Type {
1581        unsafe { from_glib(ffi::g_file_attribute_status_get_type()) }
1582    }
1583}
1584
1585impl glib::HasParamSpec for FileAttributeStatus {
1586    type ParamSpec = glib::ParamSpecEnum;
1587    type SetValue = Self;
1588    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1589
1590    fn param_spec_builder() -> Self::BuilderFn {
1591        Self::ParamSpec::builder_with_default
1592    }
1593}
1594
1595impl glib::value::ValueType for FileAttributeStatus {
1596    type Type = Self;
1597}
1598
1599unsafe impl<'a> glib::value::FromValue<'a> for FileAttributeStatus {
1600    type Checker = glib::value::GenericValueTypeChecker<Self>;
1601
1602    #[inline]
1603    unsafe fn from_value(value: &'a glib::Value) -> Self {
1604        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1605    }
1606}
1607
1608impl ToValue for FileAttributeStatus {
1609    #[inline]
1610    fn to_value(&self) -> glib::Value {
1611        let mut value = glib::Value::for_value_type::<Self>();
1612        unsafe {
1613            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1614        }
1615        value
1616    }
1617
1618    #[inline]
1619    fn value_type(&self) -> glib::Type {
1620        Self::static_type()
1621    }
1622}
1623
1624impl From<FileAttributeStatus> for glib::Value {
1625    #[inline]
1626    fn from(v: FileAttributeStatus) -> Self {
1627        ToValue::to_value(&v)
1628    }
1629}
1630
1631#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1632#[non_exhaustive]
1633#[doc(alias = "GFileAttributeType")]
1634pub enum FileAttributeType {
1635    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_INVALID")]
1636    Invalid,
1637    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_STRING")]
1638    String,
1639    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_BYTE_STRING")]
1640    ByteString,
1641    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_BOOLEAN")]
1642    Boolean,
1643    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_UINT32")]
1644    Uint32,
1645    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_INT32")]
1646    Int32,
1647    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_UINT64")]
1648    Uint64,
1649    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_INT64")]
1650    Int64,
1651    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_OBJECT")]
1652    Object,
1653    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_STRINGV")]
1654    Stringv,
1655    #[doc(hidden)]
1656    __Unknown(i32),
1657}
1658
1659#[doc(hidden)]
1660impl IntoGlib for FileAttributeType {
1661    type GlibType = ffi::GFileAttributeType;
1662
1663    #[inline]
1664    fn into_glib(self) -> ffi::GFileAttributeType {
1665        match self {
1666            Self::Invalid => ffi::G_FILE_ATTRIBUTE_TYPE_INVALID,
1667            Self::String => ffi::G_FILE_ATTRIBUTE_TYPE_STRING,
1668            Self::ByteString => ffi::G_FILE_ATTRIBUTE_TYPE_BYTE_STRING,
1669            Self::Boolean => ffi::G_FILE_ATTRIBUTE_TYPE_BOOLEAN,
1670            Self::Uint32 => ffi::G_FILE_ATTRIBUTE_TYPE_UINT32,
1671            Self::Int32 => ffi::G_FILE_ATTRIBUTE_TYPE_INT32,
1672            Self::Uint64 => ffi::G_FILE_ATTRIBUTE_TYPE_UINT64,
1673            Self::Int64 => ffi::G_FILE_ATTRIBUTE_TYPE_INT64,
1674            Self::Object => ffi::G_FILE_ATTRIBUTE_TYPE_OBJECT,
1675            Self::Stringv => ffi::G_FILE_ATTRIBUTE_TYPE_STRINGV,
1676            Self::__Unknown(value) => value,
1677        }
1678    }
1679}
1680
1681#[doc(hidden)]
1682impl FromGlib<ffi::GFileAttributeType> for FileAttributeType {
1683    #[inline]
1684    unsafe fn from_glib(value: ffi::GFileAttributeType) -> Self {
1685        match value {
1686            ffi::G_FILE_ATTRIBUTE_TYPE_INVALID => Self::Invalid,
1687            ffi::G_FILE_ATTRIBUTE_TYPE_STRING => Self::String,
1688            ffi::G_FILE_ATTRIBUTE_TYPE_BYTE_STRING => Self::ByteString,
1689            ffi::G_FILE_ATTRIBUTE_TYPE_BOOLEAN => Self::Boolean,
1690            ffi::G_FILE_ATTRIBUTE_TYPE_UINT32 => Self::Uint32,
1691            ffi::G_FILE_ATTRIBUTE_TYPE_INT32 => Self::Int32,
1692            ffi::G_FILE_ATTRIBUTE_TYPE_UINT64 => Self::Uint64,
1693            ffi::G_FILE_ATTRIBUTE_TYPE_INT64 => Self::Int64,
1694            ffi::G_FILE_ATTRIBUTE_TYPE_OBJECT => Self::Object,
1695            ffi::G_FILE_ATTRIBUTE_TYPE_STRINGV => Self::Stringv,
1696            value => Self::__Unknown(value),
1697        }
1698    }
1699}
1700
1701impl StaticType for FileAttributeType {
1702    #[inline]
1703    #[doc(alias = "g_file_attribute_type_get_type")]
1704    fn static_type() -> glib::Type {
1705        unsafe { from_glib(ffi::g_file_attribute_type_get_type()) }
1706    }
1707}
1708
1709impl glib::HasParamSpec for FileAttributeType {
1710    type ParamSpec = glib::ParamSpecEnum;
1711    type SetValue = Self;
1712    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1713
1714    fn param_spec_builder() -> Self::BuilderFn {
1715        Self::ParamSpec::builder_with_default
1716    }
1717}
1718
1719impl glib::value::ValueType for FileAttributeType {
1720    type Type = Self;
1721}
1722
1723unsafe impl<'a> glib::value::FromValue<'a> for FileAttributeType {
1724    type Checker = glib::value::GenericValueTypeChecker<Self>;
1725
1726    #[inline]
1727    unsafe fn from_value(value: &'a glib::Value) -> Self {
1728        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1729    }
1730}
1731
1732impl ToValue for FileAttributeType {
1733    #[inline]
1734    fn to_value(&self) -> glib::Value {
1735        let mut value = glib::Value::for_value_type::<Self>();
1736        unsafe {
1737            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1738        }
1739        value
1740    }
1741
1742    #[inline]
1743    fn value_type(&self) -> glib::Type {
1744        Self::static_type()
1745    }
1746}
1747
1748impl From<FileAttributeType> for glib::Value {
1749    #[inline]
1750    fn from(v: FileAttributeType) -> Self {
1751        ToValue::to_value(&v)
1752    }
1753}
1754
1755#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1756#[non_exhaustive]
1757#[doc(alias = "GFileMonitorEvent")]
1758pub enum FileMonitorEvent {
1759    #[doc(alias = "G_FILE_MONITOR_EVENT_CHANGED")]
1760    Changed,
1761    #[doc(alias = "G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT")]
1762    ChangesDoneHint,
1763    #[doc(alias = "G_FILE_MONITOR_EVENT_DELETED")]
1764    Deleted,
1765    #[doc(alias = "G_FILE_MONITOR_EVENT_CREATED")]
1766    Created,
1767    #[doc(alias = "G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED")]
1768    AttributeChanged,
1769    #[doc(alias = "G_FILE_MONITOR_EVENT_PRE_UNMOUNT")]
1770    PreUnmount,
1771    #[doc(alias = "G_FILE_MONITOR_EVENT_UNMOUNTED")]
1772    Unmounted,
1773    #[doc(alias = "G_FILE_MONITOR_EVENT_MOVED")]
1774    Moved,
1775    #[doc(alias = "G_FILE_MONITOR_EVENT_RENAMED")]
1776    Renamed,
1777    #[doc(alias = "G_FILE_MONITOR_EVENT_MOVED_IN")]
1778    MovedIn,
1779    #[doc(alias = "G_FILE_MONITOR_EVENT_MOVED_OUT")]
1780    MovedOut,
1781    #[doc(hidden)]
1782    __Unknown(i32),
1783}
1784
1785#[doc(hidden)]
1786impl IntoGlib for FileMonitorEvent {
1787    type GlibType = ffi::GFileMonitorEvent;
1788
1789    #[inline]
1790    fn into_glib(self) -> ffi::GFileMonitorEvent {
1791        match self {
1792            Self::Changed => ffi::G_FILE_MONITOR_EVENT_CHANGED,
1793            Self::ChangesDoneHint => ffi::G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT,
1794            Self::Deleted => ffi::G_FILE_MONITOR_EVENT_DELETED,
1795            Self::Created => ffi::G_FILE_MONITOR_EVENT_CREATED,
1796            Self::AttributeChanged => ffi::G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED,
1797            Self::PreUnmount => ffi::G_FILE_MONITOR_EVENT_PRE_UNMOUNT,
1798            Self::Unmounted => ffi::G_FILE_MONITOR_EVENT_UNMOUNTED,
1799            Self::Moved => ffi::G_FILE_MONITOR_EVENT_MOVED,
1800            Self::Renamed => ffi::G_FILE_MONITOR_EVENT_RENAMED,
1801            Self::MovedIn => ffi::G_FILE_MONITOR_EVENT_MOVED_IN,
1802            Self::MovedOut => ffi::G_FILE_MONITOR_EVENT_MOVED_OUT,
1803            Self::__Unknown(value) => value,
1804        }
1805    }
1806}
1807
1808#[doc(hidden)]
1809impl FromGlib<ffi::GFileMonitorEvent> for FileMonitorEvent {
1810    #[inline]
1811    unsafe fn from_glib(value: ffi::GFileMonitorEvent) -> Self {
1812        match value {
1813            ffi::G_FILE_MONITOR_EVENT_CHANGED => Self::Changed,
1814            ffi::G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT => Self::ChangesDoneHint,
1815            ffi::G_FILE_MONITOR_EVENT_DELETED => Self::Deleted,
1816            ffi::G_FILE_MONITOR_EVENT_CREATED => Self::Created,
1817            ffi::G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED => Self::AttributeChanged,
1818            ffi::G_FILE_MONITOR_EVENT_PRE_UNMOUNT => Self::PreUnmount,
1819            ffi::G_FILE_MONITOR_EVENT_UNMOUNTED => Self::Unmounted,
1820            ffi::G_FILE_MONITOR_EVENT_MOVED => Self::Moved,
1821            ffi::G_FILE_MONITOR_EVENT_RENAMED => Self::Renamed,
1822            ffi::G_FILE_MONITOR_EVENT_MOVED_IN => Self::MovedIn,
1823            ffi::G_FILE_MONITOR_EVENT_MOVED_OUT => Self::MovedOut,
1824            value => Self::__Unknown(value),
1825        }
1826    }
1827}
1828
1829impl StaticType for FileMonitorEvent {
1830    #[inline]
1831    #[doc(alias = "g_file_monitor_event_get_type")]
1832    fn static_type() -> glib::Type {
1833        unsafe { from_glib(ffi::g_file_monitor_event_get_type()) }
1834    }
1835}
1836
1837impl glib::HasParamSpec for FileMonitorEvent {
1838    type ParamSpec = glib::ParamSpecEnum;
1839    type SetValue = Self;
1840    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1841
1842    fn param_spec_builder() -> Self::BuilderFn {
1843        Self::ParamSpec::builder_with_default
1844    }
1845}
1846
1847impl glib::value::ValueType for FileMonitorEvent {
1848    type Type = Self;
1849}
1850
1851unsafe impl<'a> glib::value::FromValue<'a> for FileMonitorEvent {
1852    type Checker = glib::value::GenericValueTypeChecker<Self>;
1853
1854    #[inline]
1855    unsafe fn from_value(value: &'a glib::Value) -> Self {
1856        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1857    }
1858}
1859
1860impl ToValue for FileMonitorEvent {
1861    #[inline]
1862    fn to_value(&self) -> glib::Value {
1863        let mut value = glib::Value::for_value_type::<Self>();
1864        unsafe {
1865            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1866        }
1867        value
1868    }
1869
1870    #[inline]
1871    fn value_type(&self) -> glib::Type {
1872        Self::static_type()
1873    }
1874}
1875
1876impl From<FileMonitorEvent> for glib::Value {
1877    #[inline]
1878    fn from(v: FileMonitorEvent) -> Self {
1879        ToValue::to_value(&v)
1880    }
1881}
1882
1883#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1884#[non_exhaustive]
1885#[doc(alias = "GFileType")]
1886pub enum FileType {
1887    #[doc(alias = "G_FILE_TYPE_UNKNOWN")]
1888    Unknown,
1889    #[doc(alias = "G_FILE_TYPE_REGULAR")]
1890    Regular,
1891    #[doc(alias = "G_FILE_TYPE_DIRECTORY")]
1892    Directory,
1893    #[doc(alias = "G_FILE_TYPE_SYMBOLIC_LINK")]
1894    SymbolicLink,
1895    #[doc(alias = "G_FILE_TYPE_SPECIAL")]
1896    Special,
1897    #[doc(alias = "G_FILE_TYPE_SHORTCUT")]
1898    Shortcut,
1899    #[doc(alias = "G_FILE_TYPE_MOUNTABLE")]
1900    Mountable,
1901    #[doc(hidden)]
1902    __Unknown(i32),
1903}
1904
1905#[doc(hidden)]
1906impl IntoGlib for FileType {
1907    type GlibType = ffi::GFileType;
1908
1909    #[inline]
1910    fn into_glib(self) -> ffi::GFileType {
1911        match self {
1912            Self::Unknown => ffi::G_FILE_TYPE_UNKNOWN,
1913            Self::Regular => ffi::G_FILE_TYPE_REGULAR,
1914            Self::Directory => ffi::G_FILE_TYPE_DIRECTORY,
1915            Self::SymbolicLink => ffi::G_FILE_TYPE_SYMBOLIC_LINK,
1916            Self::Special => ffi::G_FILE_TYPE_SPECIAL,
1917            Self::Shortcut => ffi::G_FILE_TYPE_SHORTCUT,
1918            Self::Mountable => ffi::G_FILE_TYPE_MOUNTABLE,
1919            Self::__Unknown(value) => value,
1920        }
1921    }
1922}
1923
1924#[doc(hidden)]
1925impl FromGlib<ffi::GFileType> for FileType {
1926    #[inline]
1927    unsafe fn from_glib(value: ffi::GFileType) -> Self {
1928        match value {
1929            ffi::G_FILE_TYPE_UNKNOWN => Self::Unknown,
1930            ffi::G_FILE_TYPE_REGULAR => Self::Regular,
1931            ffi::G_FILE_TYPE_DIRECTORY => Self::Directory,
1932            ffi::G_FILE_TYPE_SYMBOLIC_LINK => Self::SymbolicLink,
1933            ffi::G_FILE_TYPE_SPECIAL => Self::Special,
1934            ffi::G_FILE_TYPE_SHORTCUT => Self::Shortcut,
1935            ffi::G_FILE_TYPE_MOUNTABLE => Self::Mountable,
1936            value => Self::__Unknown(value),
1937        }
1938    }
1939}
1940
1941impl StaticType for FileType {
1942    #[inline]
1943    #[doc(alias = "g_file_type_get_type")]
1944    fn static_type() -> glib::Type {
1945        unsafe { from_glib(ffi::g_file_type_get_type()) }
1946    }
1947}
1948
1949impl glib::HasParamSpec for FileType {
1950    type ParamSpec = glib::ParamSpecEnum;
1951    type SetValue = Self;
1952    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1953
1954    fn param_spec_builder() -> Self::BuilderFn {
1955        Self::ParamSpec::builder_with_default
1956    }
1957}
1958
1959impl glib::value::ValueType for FileType {
1960    type Type = Self;
1961}
1962
1963unsafe impl<'a> glib::value::FromValue<'a> for FileType {
1964    type Checker = glib::value::GenericValueTypeChecker<Self>;
1965
1966    #[inline]
1967    unsafe fn from_value(value: &'a glib::Value) -> Self {
1968        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1969    }
1970}
1971
1972impl ToValue for FileType {
1973    #[inline]
1974    fn to_value(&self) -> glib::Value {
1975        let mut value = glib::Value::for_value_type::<Self>();
1976        unsafe {
1977            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1978        }
1979        value
1980    }
1981
1982    #[inline]
1983    fn value_type(&self) -> glib::Type {
1984        Self::static_type()
1985    }
1986}
1987
1988impl From<FileType> for glib::Value {
1989    #[inline]
1990    fn from(v: FileType) -> Self {
1991        ToValue::to_value(&v)
1992    }
1993}
1994
1995#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1996#[non_exhaustive]
1997#[doc(alias = "GFilesystemPreviewType")]
1998pub enum FilesystemPreviewType {
1999    #[doc(alias = "G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS")]
2000    IfAlways,
2001    #[doc(alias = "G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL")]
2002    IfLocal,
2003    #[doc(alias = "G_FILESYSTEM_PREVIEW_TYPE_NEVER")]
2004    Never,
2005    #[doc(hidden)]
2006    __Unknown(i32),
2007}
2008
2009#[doc(hidden)]
2010impl IntoGlib for FilesystemPreviewType {
2011    type GlibType = ffi::GFilesystemPreviewType;
2012
2013    #[inline]
2014    fn into_glib(self) -> ffi::GFilesystemPreviewType {
2015        match self {
2016            Self::IfAlways => ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS,
2017            Self::IfLocal => ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL,
2018            Self::Never => ffi::G_FILESYSTEM_PREVIEW_TYPE_NEVER,
2019            Self::__Unknown(value) => value,
2020        }
2021    }
2022}
2023
2024#[doc(hidden)]
2025impl FromGlib<ffi::GFilesystemPreviewType> for FilesystemPreviewType {
2026    #[inline]
2027    unsafe fn from_glib(value: ffi::GFilesystemPreviewType) -> Self {
2028        match value {
2029            ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS => Self::IfAlways,
2030            ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL => Self::IfLocal,
2031            ffi::G_FILESYSTEM_PREVIEW_TYPE_NEVER => Self::Never,
2032            value => Self::__Unknown(value),
2033        }
2034    }
2035}
2036
2037impl StaticType for FilesystemPreviewType {
2038    #[inline]
2039    #[doc(alias = "g_filesystem_preview_type_get_type")]
2040    fn static_type() -> glib::Type {
2041        unsafe { from_glib(ffi::g_filesystem_preview_type_get_type()) }
2042    }
2043}
2044
2045impl glib::HasParamSpec for FilesystemPreviewType {
2046    type ParamSpec = glib::ParamSpecEnum;
2047    type SetValue = Self;
2048    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2049
2050    fn param_spec_builder() -> Self::BuilderFn {
2051        Self::ParamSpec::builder_with_default
2052    }
2053}
2054
2055impl glib::value::ValueType for FilesystemPreviewType {
2056    type Type = Self;
2057}
2058
2059unsafe impl<'a> glib::value::FromValue<'a> for FilesystemPreviewType {
2060    type Checker = glib::value::GenericValueTypeChecker<Self>;
2061
2062    #[inline]
2063    unsafe fn from_value(value: &'a glib::Value) -> Self {
2064        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2065    }
2066}
2067
2068impl ToValue for FilesystemPreviewType {
2069    #[inline]
2070    fn to_value(&self) -> glib::Value {
2071        let mut value = glib::Value::for_value_type::<Self>();
2072        unsafe {
2073            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2074        }
2075        value
2076    }
2077
2078    #[inline]
2079    fn value_type(&self) -> glib::Type {
2080        Self::static_type()
2081    }
2082}
2083
2084impl From<FilesystemPreviewType> for glib::Value {
2085    #[inline]
2086    fn from(v: FilesystemPreviewType) -> Self {
2087        ToValue::to_value(&v)
2088    }
2089}
2090
2091#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2092#[non_exhaustive]
2093#[doc(alias = "GIOErrorEnum")]
2094pub enum IOErrorEnum {
2095    #[doc(alias = "G_IO_ERROR_FAILED")]
2096    Failed,
2097    #[doc(alias = "G_IO_ERROR_NOT_FOUND")]
2098    NotFound,
2099    #[doc(alias = "G_IO_ERROR_EXISTS")]
2100    Exists,
2101    #[doc(alias = "G_IO_ERROR_IS_DIRECTORY")]
2102    IsDirectory,
2103    #[doc(alias = "G_IO_ERROR_NOT_DIRECTORY")]
2104    NotDirectory,
2105    #[doc(alias = "G_IO_ERROR_NOT_EMPTY")]
2106    NotEmpty,
2107    #[doc(alias = "G_IO_ERROR_NOT_REGULAR_FILE")]
2108    NotRegularFile,
2109    #[doc(alias = "G_IO_ERROR_NOT_SYMBOLIC_LINK")]
2110    NotSymbolicLink,
2111    #[doc(alias = "G_IO_ERROR_NOT_MOUNTABLE_FILE")]
2112    NotMountableFile,
2113    #[doc(alias = "G_IO_ERROR_FILENAME_TOO_LONG")]
2114    FilenameTooLong,
2115    #[doc(alias = "G_IO_ERROR_INVALID_FILENAME")]
2116    InvalidFilename,
2117    #[doc(alias = "G_IO_ERROR_TOO_MANY_LINKS")]
2118    TooManyLinks,
2119    #[doc(alias = "G_IO_ERROR_NO_SPACE")]
2120    NoSpace,
2121    #[doc(alias = "G_IO_ERROR_INVALID_ARGUMENT")]
2122    InvalidArgument,
2123    #[doc(alias = "G_IO_ERROR_PERMISSION_DENIED")]
2124    PermissionDenied,
2125    #[doc(alias = "G_IO_ERROR_NOT_SUPPORTED")]
2126    NotSupported,
2127    #[doc(alias = "G_IO_ERROR_NOT_MOUNTED")]
2128    NotMounted,
2129    #[doc(alias = "G_IO_ERROR_ALREADY_MOUNTED")]
2130    AlreadyMounted,
2131    #[doc(alias = "G_IO_ERROR_CLOSED")]
2132    Closed,
2133    #[doc(alias = "G_IO_ERROR_CANCELLED")]
2134    Cancelled,
2135    #[doc(alias = "G_IO_ERROR_PENDING")]
2136    Pending,
2137    #[doc(alias = "G_IO_ERROR_READ_ONLY")]
2138    ReadOnly,
2139    #[doc(alias = "G_IO_ERROR_CANT_CREATE_BACKUP")]
2140    CantCreateBackup,
2141    #[doc(alias = "G_IO_ERROR_WRONG_ETAG")]
2142    WrongEtag,
2143    #[doc(alias = "G_IO_ERROR_TIMED_OUT")]
2144    TimedOut,
2145    #[doc(alias = "G_IO_ERROR_WOULD_RECURSE")]
2146    WouldRecurse,
2147    #[doc(alias = "G_IO_ERROR_BUSY")]
2148    Busy,
2149    #[doc(alias = "G_IO_ERROR_WOULD_BLOCK")]
2150    WouldBlock,
2151    #[doc(alias = "G_IO_ERROR_HOST_NOT_FOUND")]
2152    HostNotFound,
2153    #[doc(alias = "G_IO_ERROR_WOULD_MERGE")]
2154    WouldMerge,
2155    #[doc(alias = "G_IO_ERROR_FAILED_HANDLED")]
2156    FailedHandled,
2157    #[doc(alias = "G_IO_ERROR_TOO_MANY_OPEN_FILES")]
2158    TooManyOpenFiles,
2159    #[doc(alias = "G_IO_ERROR_NOT_INITIALIZED")]
2160    NotInitialized,
2161    #[doc(alias = "G_IO_ERROR_ADDRESS_IN_USE")]
2162    AddressInUse,
2163    #[doc(alias = "G_IO_ERROR_PARTIAL_INPUT")]
2164    PartialInput,
2165    #[doc(alias = "G_IO_ERROR_INVALID_DATA")]
2166    InvalidData,
2167    #[doc(alias = "G_IO_ERROR_DBUS_ERROR")]
2168    DbusError,
2169    #[doc(alias = "G_IO_ERROR_HOST_UNREACHABLE")]
2170    HostUnreachable,
2171    #[doc(alias = "G_IO_ERROR_NETWORK_UNREACHABLE")]
2172    NetworkUnreachable,
2173    #[doc(alias = "G_IO_ERROR_CONNECTION_REFUSED")]
2174    ConnectionRefused,
2175    #[doc(alias = "G_IO_ERROR_PROXY_FAILED")]
2176    ProxyFailed,
2177    #[doc(alias = "G_IO_ERROR_PROXY_AUTH_FAILED")]
2178    ProxyAuthFailed,
2179    #[doc(alias = "G_IO_ERROR_PROXY_NEED_AUTH")]
2180    ProxyNeedAuth,
2181    #[doc(alias = "G_IO_ERROR_PROXY_NOT_ALLOWED")]
2182    ProxyNotAllowed,
2183    #[doc(alias = "G_IO_ERROR_BROKEN_PIPE")]
2184    BrokenPipe,
2185    #[doc(alias = "G_IO_ERROR_NOT_CONNECTED")]
2186    NotConnected,
2187    #[doc(alias = "G_IO_ERROR_MESSAGE_TOO_LARGE")]
2188    MessageTooLarge,
2189    #[cfg(feature = "v2_72")]
2190    #[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
2191    #[doc(alias = "G_IO_ERROR_NO_SUCH_DEVICE")]
2192    NoSuchDevice,
2193    #[cfg(feature = "v2_80")]
2194    #[cfg_attr(docsrs, doc(cfg(feature = "v2_80")))]
2195    #[doc(alias = "G_IO_ERROR_DESTINATION_UNSET")]
2196    DestinationUnset,
2197    #[doc(hidden)]
2198    __Unknown(i32),
2199}
2200
2201#[doc(hidden)]
2202impl IntoGlib for IOErrorEnum {
2203    type GlibType = ffi::GIOErrorEnum;
2204
2205    fn into_glib(self) -> ffi::GIOErrorEnum {
2206        match self {
2207            Self::Failed => ffi::G_IO_ERROR_FAILED,
2208            Self::NotFound => ffi::G_IO_ERROR_NOT_FOUND,
2209            Self::Exists => ffi::G_IO_ERROR_EXISTS,
2210            Self::IsDirectory => ffi::G_IO_ERROR_IS_DIRECTORY,
2211            Self::NotDirectory => ffi::G_IO_ERROR_NOT_DIRECTORY,
2212            Self::NotEmpty => ffi::G_IO_ERROR_NOT_EMPTY,
2213            Self::NotRegularFile => ffi::G_IO_ERROR_NOT_REGULAR_FILE,
2214            Self::NotSymbolicLink => ffi::G_IO_ERROR_NOT_SYMBOLIC_LINK,
2215            Self::NotMountableFile => ffi::G_IO_ERROR_NOT_MOUNTABLE_FILE,
2216            Self::FilenameTooLong => ffi::G_IO_ERROR_FILENAME_TOO_LONG,
2217            Self::InvalidFilename => ffi::G_IO_ERROR_INVALID_FILENAME,
2218            Self::TooManyLinks => ffi::G_IO_ERROR_TOO_MANY_LINKS,
2219            Self::NoSpace => ffi::G_IO_ERROR_NO_SPACE,
2220            Self::InvalidArgument => ffi::G_IO_ERROR_INVALID_ARGUMENT,
2221            Self::PermissionDenied => ffi::G_IO_ERROR_PERMISSION_DENIED,
2222            Self::NotSupported => ffi::G_IO_ERROR_NOT_SUPPORTED,
2223            Self::NotMounted => ffi::G_IO_ERROR_NOT_MOUNTED,
2224            Self::AlreadyMounted => ffi::G_IO_ERROR_ALREADY_MOUNTED,
2225            Self::Closed => ffi::G_IO_ERROR_CLOSED,
2226            Self::Cancelled => ffi::G_IO_ERROR_CANCELLED,
2227            Self::Pending => ffi::G_IO_ERROR_PENDING,
2228            Self::ReadOnly => ffi::G_IO_ERROR_READ_ONLY,
2229            Self::CantCreateBackup => ffi::G_IO_ERROR_CANT_CREATE_BACKUP,
2230            Self::WrongEtag => ffi::G_IO_ERROR_WRONG_ETAG,
2231            Self::TimedOut => ffi::G_IO_ERROR_TIMED_OUT,
2232            Self::WouldRecurse => ffi::G_IO_ERROR_WOULD_RECURSE,
2233            Self::Busy => ffi::G_IO_ERROR_BUSY,
2234            Self::WouldBlock => ffi::G_IO_ERROR_WOULD_BLOCK,
2235            Self::HostNotFound => ffi::G_IO_ERROR_HOST_NOT_FOUND,
2236            Self::WouldMerge => ffi::G_IO_ERROR_WOULD_MERGE,
2237            Self::FailedHandled => ffi::G_IO_ERROR_FAILED_HANDLED,
2238            Self::TooManyOpenFiles => ffi::G_IO_ERROR_TOO_MANY_OPEN_FILES,
2239            Self::NotInitialized => ffi::G_IO_ERROR_NOT_INITIALIZED,
2240            Self::AddressInUse => ffi::G_IO_ERROR_ADDRESS_IN_USE,
2241            Self::PartialInput => ffi::G_IO_ERROR_PARTIAL_INPUT,
2242            Self::InvalidData => ffi::G_IO_ERROR_INVALID_DATA,
2243            Self::DbusError => ffi::G_IO_ERROR_DBUS_ERROR,
2244            Self::HostUnreachable => ffi::G_IO_ERROR_HOST_UNREACHABLE,
2245            Self::NetworkUnreachable => ffi::G_IO_ERROR_NETWORK_UNREACHABLE,
2246            Self::ConnectionRefused => ffi::G_IO_ERROR_CONNECTION_REFUSED,
2247            Self::ProxyFailed => ffi::G_IO_ERROR_PROXY_FAILED,
2248            Self::ProxyAuthFailed => ffi::G_IO_ERROR_PROXY_AUTH_FAILED,
2249            Self::ProxyNeedAuth => ffi::G_IO_ERROR_PROXY_NEED_AUTH,
2250            Self::ProxyNotAllowed => ffi::G_IO_ERROR_PROXY_NOT_ALLOWED,
2251            Self::BrokenPipe => ffi::G_IO_ERROR_BROKEN_PIPE,
2252            Self::NotConnected => ffi::G_IO_ERROR_NOT_CONNECTED,
2253            Self::MessageTooLarge => ffi::G_IO_ERROR_MESSAGE_TOO_LARGE,
2254            #[cfg(feature = "v2_72")]
2255            Self::NoSuchDevice => ffi::G_IO_ERROR_NO_SUCH_DEVICE,
2256            #[cfg(feature = "v2_80")]
2257            Self::DestinationUnset => ffi::G_IO_ERROR_DESTINATION_UNSET,
2258            Self::__Unknown(value) => value,
2259        }
2260    }
2261}
2262
2263#[doc(hidden)]
2264impl FromGlib<ffi::GIOErrorEnum> for IOErrorEnum {
2265    unsafe fn from_glib(value: ffi::GIOErrorEnum) -> Self {
2266        match value {
2267            ffi::G_IO_ERROR_FAILED => Self::Failed,
2268            ffi::G_IO_ERROR_NOT_FOUND => Self::NotFound,
2269            ffi::G_IO_ERROR_EXISTS => Self::Exists,
2270            ffi::G_IO_ERROR_IS_DIRECTORY => Self::IsDirectory,
2271            ffi::G_IO_ERROR_NOT_DIRECTORY => Self::NotDirectory,
2272            ffi::G_IO_ERROR_NOT_EMPTY => Self::NotEmpty,
2273            ffi::G_IO_ERROR_NOT_REGULAR_FILE => Self::NotRegularFile,
2274            ffi::G_IO_ERROR_NOT_SYMBOLIC_LINK => Self::NotSymbolicLink,
2275            ffi::G_IO_ERROR_NOT_MOUNTABLE_FILE => Self::NotMountableFile,
2276            ffi::G_IO_ERROR_FILENAME_TOO_LONG => Self::FilenameTooLong,
2277            ffi::G_IO_ERROR_INVALID_FILENAME => Self::InvalidFilename,
2278            ffi::G_IO_ERROR_TOO_MANY_LINKS => Self::TooManyLinks,
2279            ffi::G_IO_ERROR_NO_SPACE => Self::NoSpace,
2280            ffi::G_IO_ERROR_INVALID_ARGUMENT => Self::InvalidArgument,
2281            ffi::G_IO_ERROR_PERMISSION_DENIED => Self::PermissionDenied,
2282            ffi::G_IO_ERROR_NOT_SUPPORTED => Self::NotSupported,
2283            ffi::G_IO_ERROR_NOT_MOUNTED => Self::NotMounted,
2284            ffi::G_IO_ERROR_ALREADY_MOUNTED => Self::AlreadyMounted,
2285            ffi::G_IO_ERROR_CLOSED => Self::Closed,
2286            ffi::G_IO_ERROR_CANCELLED => Self::Cancelled,
2287            ffi::G_IO_ERROR_PENDING => Self::Pending,
2288            ffi::G_IO_ERROR_READ_ONLY => Self::ReadOnly,
2289            ffi::G_IO_ERROR_CANT_CREATE_BACKUP => Self::CantCreateBackup,
2290            ffi::G_IO_ERROR_WRONG_ETAG => Self::WrongEtag,
2291            ffi::G_IO_ERROR_TIMED_OUT => Self::TimedOut,
2292            ffi::G_IO_ERROR_WOULD_RECURSE => Self::WouldRecurse,
2293            ffi::G_IO_ERROR_BUSY => Self::Busy,
2294            ffi::G_IO_ERROR_WOULD_BLOCK => Self::WouldBlock,
2295            ffi::G_IO_ERROR_HOST_NOT_FOUND => Self::HostNotFound,
2296            ffi::G_IO_ERROR_WOULD_MERGE => Self::WouldMerge,
2297            ffi::G_IO_ERROR_FAILED_HANDLED => Self::FailedHandled,
2298            ffi::G_IO_ERROR_TOO_MANY_OPEN_FILES => Self::TooManyOpenFiles,
2299            ffi::G_IO_ERROR_NOT_INITIALIZED => Self::NotInitialized,
2300            ffi::G_IO_ERROR_ADDRESS_IN_USE => Self::AddressInUse,
2301            ffi::G_IO_ERROR_PARTIAL_INPUT => Self::PartialInput,
2302            ffi::G_IO_ERROR_INVALID_DATA => Self::InvalidData,
2303            ffi::G_IO_ERROR_DBUS_ERROR => Self::DbusError,
2304            ffi::G_IO_ERROR_HOST_UNREACHABLE => Self::HostUnreachable,
2305            ffi::G_IO_ERROR_NETWORK_UNREACHABLE => Self::NetworkUnreachable,
2306            ffi::G_IO_ERROR_CONNECTION_REFUSED => Self::ConnectionRefused,
2307            ffi::G_IO_ERROR_PROXY_FAILED => Self::ProxyFailed,
2308            ffi::G_IO_ERROR_PROXY_AUTH_FAILED => Self::ProxyAuthFailed,
2309            ffi::G_IO_ERROR_PROXY_NEED_AUTH => Self::ProxyNeedAuth,
2310            ffi::G_IO_ERROR_PROXY_NOT_ALLOWED => Self::ProxyNotAllowed,
2311            ffi::G_IO_ERROR_BROKEN_PIPE => Self::BrokenPipe,
2312            ffi::G_IO_ERROR_NOT_CONNECTED => Self::NotConnected,
2313            ffi::G_IO_ERROR_MESSAGE_TOO_LARGE => Self::MessageTooLarge,
2314            #[cfg(feature = "v2_72")]
2315            ffi::G_IO_ERROR_NO_SUCH_DEVICE => Self::NoSuchDevice,
2316            #[cfg(feature = "v2_80")]
2317            ffi::G_IO_ERROR_DESTINATION_UNSET => Self::DestinationUnset,
2318            value => Self::__Unknown(value),
2319        }
2320    }
2321}
2322
2323impl glib::error::ErrorDomain for IOErrorEnum {
2324    #[inline]
2325    fn domain() -> glib::Quark {
2326        unsafe { from_glib(ffi::g_io_error_quark()) }
2327    }
2328
2329    #[inline]
2330    fn code(self) -> i32 {
2331        self.into_glib()
2332    }
2333
2334    #[inline]
2335    #[allow(clippy::match_single_binding)]
2336    fn from(code: i32) -> Option<Self> {
2337        match unsafe { from_glib(code) } {
2338            Self::__Unknown(_) => Some(Self::Failed),
2339            value => Some(value),
2340        }
2341    }
2342}
2343
2344impl StaticType for IOErrorEnum {
2345    #[inline]
2346    #[doc(alias = "g_io_error_enum_get_type")]
2347    fn static_type() -> glib::Type {
2348        unsafe { from_glib(ffi::g_io_error_enum_get_type()) }
2349    }
2350}
2351
2352impl glib::HasParamSpec for IOErrorEnum {
2353    type ParamSpec = glib::ParamSpecEnum;
2354    type SetValue = Self;
2355    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2356
2357    fn param_spec_builder() -> Self::BuilderFn {
2358        Self::ParamSpec::builder_with_default
2359    }
2360}
2361
2362impl glib::value::ValueType for IOErrorEnum {
2363    type Type = Self;
2364}
2365
2366unsafe impl<'a> glib::value::FromValue<'a> for IOErrorEnum {
2367    type Checker = glib::value::GenericValueTypeChecker<Self>;
2368
2369    #[inline]
2370    unsafe fn from_value(value: &'a glib::Value) -> Self {
2371        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2372    }
2373}
2374
2375impl ToValue for IOErrorEnum {
2376    #[inline]
2377    fn to_value(&self) -> glib::Value {
2378        let mut value = glib::Value::for_value_type::<Self>();
2379        unsafe {
2380            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2381        }
2382        value
2383    }
2384
2385    #[inline]
2386    fn value_type(&self) -> glib::Type {
2387        Self::static_type()
2388    }
2389}
2390
2391impl From<IOErrorEnum> for glib::Value {
2392    #[inline]
2393    fn from(v: IOErrorEnum) -> Self {
2394        ToValue::to_value(&v)
2395    }
2396}
2397
2398#[cfg(feature = "v2_64")]
2399#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2400#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2401#[non_exhaustive]
2402#[doc(alias = "GMemoryMonitorWarningLevel")]
2403pub enum MemoryMonitorWarningLevel {
2404    #[doc(alias = "G_MEMORY_MONITOR_WARNING_LEVEL_LOW")]
2405    Low,
2406    #[doc(alias = "G_MEMORY_MONITOR_WARNING_LEVEL_MEDIUM")]
2407    Medium,
2408    #[doc(alias = "G_MEMORY_MONITOR_WARNING_LEVEL_CRITICAL")]
2409    Critical,
2410    #[doc(hidden)]
2411    __Unknown(i32),
2412}
2413
2414#[cfg(feature = "v2_64")]
2415#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2416#[doc(hidden)]
2417impl IntoGlib for MemoryMonitorWarningLevel {
2418    type GlibType = ffi::GMemoryMonitorWarningLevel;
2419
2420    #[inline]
2421    fn into_glib(self) -> ffi::GMemoryMonitorWarningLevel {
2422        match self {
2423            Self::Low => ffi::G_MEMORY_MONITOR_WARNING_LEVEL_LOW,
2424            Self::Medium => ffi::G_MEMORY_MONITOR_WARNING_LEVEL_MEDIUM,
2425            Self::Critical => ffi::G_MEMORY_MONITOR_WARNING_LEVEL_CRITICAL,
2426            Self::__Unknown(value) => value,
2427        }
2428    }
2429}
2430
2431#[cfg(feature = "v2_64")]
2432#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2433#[doc(hidden)]
2434impl FromGlib<ffi::GMemoryMonitorWarningLevel> for MemoryMonitorWarningLevel {
2435    #[inline]
2436    unsafe fn from_glib(value: ffi::GMemoryMonitorWarningLevel) -> Self {
2437        match value {
2438            ffi::G_MEMORY_MONITOR_WARNING_LEVEL_LOW => Self::Low,
2439            ffi::G_MEMORY_MONITOR_WARNING_LEVEL_MEDIUM => Self::Medium,
2440            ffi::G_MEMORY_MONITOR_WARNING_LEVEL_CRITICAL => Self::Critical,
2441            value => Self::__Unknown(value),
2442        }
2443    }
2444}
2445
2446#[cfg(feature = "v2_64")]
2447#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2448impl StaticType for MemoryMonitorWarningLevel {
2449    #[inline]
2450    #[doc(alias = "g_memory_monitor_warning_level_get_type")]
2451    fn static_type() -> glib::Type {
2452        unsafe { from_glib(ffi::g_memory_monitor_warning_level_get_type()) }
2453    }
2454}
2455
2456#[cfg(feature = "v2_64")]
2457#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2458impl glib::HasParamSpec for MemoryMonitorWarningLevel {
2459    type ParamSpec = glib::ParamSpecEnum;
2460    type SetValue = Self;
2461    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2462
2463    fn param_spec_builder() -> Self::BuilderFn {
2464        Self::ParamSpec::builder_with_default
2465    }
2466}
2467
2468#[cfg(feature = "v2_64")]
2469#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2470impl glib::value::ValueType for MemoryMonitorWarningLevel {
2471    type Type = Self;
2472}
2473
2474#[cfg(feature = "v2_64")]
2475#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2476unsafe impl<'a> glib::value::FromValue<'a> for MemoryMonitorWarningLevel {
2477    type Checker = glib::value::GenericValueTypeChecker<Self>;
2478
2479    #[inline]
2480    unsafe fn from_value(value: &'a glib::Value) -> Self {
2481        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2482    }
2483}
2484
2485#[cfg(feature = "v2_64")]
2486#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2487impl ToValue for MemoryMonitorWarningLevel {
2488    #[inline]
2489    fn to_value(&self) -> glib::Value {
2490        let mut value = glib::Value::for_value_type::<Self>();
2491        unsafe {
2492            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2493        }
2494        value
2495    }
2496
2497    #[inline]
2498    fn value_type(&self) -> glib::Type {
2499        Self::static_type()
2500    }
2501}
2502
2503#[cfg(feature = "v2_64")]
2504#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2505impl From<MemoryMonitorWarningLevel> for glib::Value {
2506    #[inline]
2507    fn from(v: MemoryMonitorWarningLevel) -> Self {
2508        ToValue::to_value(&v)
2509    }
2510}
2511
2512#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2513#[non_exhaustive]
2514#[doc(alias = "GMountOperationResult")]
2515pub enum MountOperationResult {
2516    #[doc(alias = "G_MOUNT_OPERATION_HANDLED")]
2517    Handled,
2518    #[doc(alias = "G_MOUNT_OPERATION_ABORTED")]
2519    Aborted,
2520    #[doc(alias = "G_MOUNT_OPERATION_UNHANDLED")]
2521    Unhandled,
2522    #[doc(hidden)]
2523    __Unknown(i32),
2524}
2525
2526#[doc(hidden)]
2527impl IntoGlib for MountOperationResult {
2528    type GlibType = ffi::GMountOperationResult;
2529
2530    #[inline]
2531    fn into_glib(self) -> ffi::GMountOperationResult {
2532        match self {
2533            Self::Handled => ffi::G_MOUNT_OPERATION_HANDLED,
2534            Self::Aborted => ffi::G_MOUNT_OPERATION_ABORTED,
2535            Self::Unhandled => ffi::G_MOUNT_OPERATION_UNHANDLED,
2536            Self::__Unknown(value) => value,
2537        }
2538    }
2539}
2540
2541#[doc(hidden)]
2542impl FromGlib<ffi::GMountOperationResult> for MountOperationResult {
2543    #[inline]
2544    unsafe fn from_glib(value: ffi::GMountOperationResult) -> Self {
2545        match value {
2546            ffi::G_MOUNT_OPERATION_HANDLED => Self::Handled,
2547            ffi::G_MOUNT_OPERATION_ABORTED => Self::Aborted,
2548            ffi::G_MOUNT_OPERATION_UNHANDLED => Self::Unhandled,
2549            value => Self::__Unknown(value),
2550        }
2551    }
2552}
2553
2554impl StaticType for MountOperationResult {
2555    #[inline]
2556    #[doc(alias = "g_mount_operation_result_get_type")]
2557    fn static_type() -> glib::Type {
2558        unsafe { from_glib(ffi::g_mount_operation_result_get_type()) }
2559    }
2560}
2561
2562impl glib::HasParamSpec for MountOperationResult {
2563    type ParamSpec = glib::ParamSpecEnum;
2564    type SetValue = Self;
2565    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2566
2567    fn param_spec_builder() -> Self::BuilderFn {
2568        Self::ParamSpec::builder_with_default
2569    }
2570}
2571
2572impl glib::value::ValueType for MountOperationResult {
2573    type Type = Self;
2574}
2575
2576unsafe impl<'a> glib::value::FromValue<'a> for MountOperationResult {
2577    type Checker = glib::value::GenericValueTypeChecker<Self>;
2578
2579    #[inline]
2580    unsafe fn from_value(value: &'a glib::Value) -> Self {
2581        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2582    }
2583}
2584
2585impl ToValue for MountOperationResult {
2586    #[inline]
2587    fn to_value(&self) -> glib::Value {
2588        let mut value = glib::Value::for_value_type::<Self>();
2589        unsafe {
2590            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2591        }
2592        value
2593    }
2594
2595    #[inline]
2596    fn value_type(&self) -> glib::Type {
2597        Self::static_type()
2598    }
2599}
2600
2601impl From<MountOperationResult> for glib::Value {
2602    #[inline]
2603    fn from(v: MountOperationResult) -> Self {
2604        ToValue::to_value(&v)
2605    }
2606}
2607
2608#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2609#[non_exhaustive]
2610#[doc(alias = "GNetworkConnectivity")]
2611pub enum NetworkConnectivity {
2612    #[doc(alias = "G_NETWORK_CONNECTIVITY_LOCAL")]
2613    Local,
2614    #[doc(alias = "G_NETWORK_CONNECTIVITY_LIMITED")]
2615    Limited,
2616    #[doc(alias = "G_NETWORK_CONNECTIVITY_PORTAL")]
2617    Portal,
2618    #[doc(alias = "G_NETWORK_CONNECTIVITY_FULL")]
2619    Full,
2620    #[doc(hidden)]
2621    __Unknown(i32),
2622}
2623
2624#[doc(hidden)]
2625impl IntoGlib for NetworkConnectivity {
2626    type GlibType = ffi::GNetworkConnectivity;
2627
2628    #[inline]
2629    fn into_glib(self) -> ffi::GNetworkConnectivity {
2630        match self {
2631            Self::Local => ffi::G_NETWORK_CONNECTIVITY_LOCAL,
2632            Self::Limited => ffi::G_NETWORK_CONNECTIVITY_LIMITED,
2633            Self::Portal => ffi::G_NETWORK_CONNECTIVITY_PORTAL,
2634            Self::Full => ffi::G_NETWORK_CONNECTIVITY_FULL,
2635            Self::__Unknown(value) => value,
2636        }
2637    }
2638}
2639
2640#[doc(hidden)]
2641impl FromGlib<ffi::GNetworkConnectivity> for NetworkConnectivity {
2642    #[inline]
2643    unsafe fn from_glib(value: ffi::GNetworkConnectivity) -> Self {
2644        match value {
2645            ffi::G_NETWORK_CONNECTIVITY_LOCAL => Self::Local,
2646            ffi::G_NETWORK_CONNECTIVITY_LIMITED => Self::Limited,
2647            ffi::G_NETWORK_CONNECTIVITY_PORTAL => Self::Portal,
2648            ffi::G_NETWORK_CONNECTIVITY_FULL => Self::Full,
2649            value => Self::__Unknown(value),
2650        }
2651    }
2652}
2653
2654impl StaticType for NetworkConnectivity {
2655    #[inline]
2656    #[doc(alias = "g_network_connectivity_get_type")]
2657    fn static_type() -> glib::Type {
2658        unsafe { from_glib(ffi::g_network_connectivity_get_type()) }
2659    }
2660}
2661
2662impl glib::HasParamSpec for NetworkConnectivity {
2663    type ParamSpec = glib::ParamSpecEnum;
2664    type SetValue = Self;
2665    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2666
2667    fn param_spec_builder() -> Self::BuilderFn {
2668        Self::ParamSpec::builder_with_default
2669    }
2670}
2671
2672impl glib::value::ValueType for NetworkConnectivity {
2673    type Type = Self;
2674}
2675
2676unsafe impl<'a> glib::value::FromValue<'a> for NetworkConnectivity {
2677    type Checker = glib::value::GenericValueTypeChecker<Self>;
2678
2679    #[inline]
2680    unsafe fn from_value(value: &'a glib::Value) -> Self {
2681        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2682    }
2683}
2684
2685impl ToValue for NetworkConnectivity {
2686    #[inline]
2687    fn to_value(&self) -> glib::Value {
2688        let mut value = glib::Value::for_value_type::<Self>();
2689        unsafe {
2690            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2691        }
2692        value
2693    }
2694
2695    #[inline]
2696    fn value_type(&self) -> glib::Type {
2697        Self::static_type()
2698    }
2699}
2700
2701impl From<NetworkConnectivity> for glib::Value {
2702    #[inline]
2703    fn from(v: NetworkConnectivity) -> Self {
2704        ToValue::to_value(&v)
2705    }
2706}
2707
2708#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2709#[non_exhaustive]
2710#[doc(alias = "GNotificationPriority")]
2711pub enum NotificationPriority {
2712    #[doc(alias = "G_NOTIFICATION_PRIORITY_NORMAL")]
2713    Normal,
2714    #[doc(alias = "G_NOTIFICATION_PRIORITY_LOW")]
2715    Low,
2716    #[doc(alias = "G_NOTIFICATION_PRIORITY_HIGH")]
2717    High,
2718    #[doc(alias = "G_NOTIFICATION_PRIORITY_URGENT")]
2719    Urgent,
2720    #[doc(hidden)]
2721    __Unknown(i32),
2722}
2723
2724#[doc(hidden)]
2725impl IntoGlib for NotificationPriority {
2726    type GlibType = ffi::GNotificationPriority;
2727
2728    #[inline]
2729    fn into_glib(self) -> ffi::GNotificationPriority {
2730        match self {
2731            Self::Normal => ffi::G_NOTIFICATION_PRIORITY_NORMAL,
2732            Self::Low => ffi::G_NOTIFICATION_PRIORITY_LOW,
2733            Self::High => ffi::G_NOTIFICATION_PRIORITY_HIGH,
2734            Self::Urgent => ffi::G_NOTIFICATION_PRIORITY_URGENT,
2735            Self::__Unknown(value) => value,
2736        }
2737    }
2738}
2739
2740#[doc(hidden)]
2741impl FromGlib<ffi::GNotificationPriority> for NotificationPriority {
2742    #[inline]
2743    unsafe fn from_glib(value: ffi::GNotificationPriority) -> Self {
2744        match value {
2745            ffi::G_NOTIFICATION_PRIORITY_NORMAL => Self::Normal,
2746            ffi::G_NOTIFICATION_PRIORITY_LOW => Self::Low,
2747            ffi::G_NOTIFICATION_PRIORITY_HIGH => Self::High,
2748            ffi::G_NOTIFICATION_PRIORITY_URGENT => Self::Urgent,
2749            value => Self::__Unknown(value),
2750        }
2751    }
2752}
2753
2754impl StaticType for NotificationPriority {
2755    #[inline]
2756    #[doc(alias = "g_notification_priority_get_type")]
2757    fn static_type() -> glib::Type {
2758        unsafe { from_glib(ffi::g_notification_priority_get_type()) }
2759    }
2760}
2761
2762impl glib::HasParamSpec for NotificationPriority {
2763    type ParamSpec = glib::ParamSpecEnum;
2764    type SetValue = Self;
2765    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2766
2767    fn param_spec_builder() -> Self::BuilderFn {
2768        Self::ParamSpec::builder_with_default
2769    }
2770}
2771
2772impl glib::value::ValueType for NotificationPriority {
2773    type Type = Self;
2774}
2775
2776unsafe impl<'a> glib::value::FromValue<'a> for NotificationPriority {
2777    type Checker = glib::value::GenericValueTypeChecker<Self>;
2778
2779    #[inline]
2780    unsafe fn from_value(value: &'a glib::Value) -> Self {
2781        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2782    }
2783}
2784
2785impl ToValue for NotificationPriority {
2786    #[inline]
2787    fn to_value(&self) -> glib::Value {
2788        let mut value = glib::Value::for_value_type::<Self>();
2789        unsafe {
2790            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2791        }
2792        value
2793    }
2794
2795    #[inline]
2796    fn value_type(&self) -> glib::Type {
2797        Self::static_type()
2798    }
2799}
2800
2801impl From<NotificationPriority> for glib::Value {
2802    #[inline]
2803    fn from(v: NotificationPriority) -> Self {
2804        ToValue::to_value(&v)
2805    }
2806}
2807
2808#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2809#[non_exhaustive]
2810#[doc(alias = "GPasswordSave")]
2811pub enum PasswordSave {
2812    #[doc(alias = "G_PASSWORD_SAVE_NEVER")]
2813    Never,
2814    #[doc(alias = "G_PASSWORD_SAVE_FOR_SESSION")]
2815    ForSession,
2816    #[doc(alias = "G_PASSWORD_SAVE_PERMANENTLY")]
2817    Permanently,
2818    #[doc(hidden)]
2819    __Unknown(i32),
2820}
2821
2822#[doc(hidden)]
2823impl IntoGlib for PasswordSave {
2824    type GlibType = ffi::GPasswordSave;
2825
2826    #[inline]
2827    fn into_glib(self) -> ffi::GPasswordSave {
2828        match self {
2829            Self::Never => ffi::G_PASSWORD_SAVE_NEVER,
2830            Self::ForSession => ffi::G_PASSWORD_SAVE_FOR_SESSION,
2831            Self::Permanently => ffi::G_PASSWORD_SAVE_PERMANENTLY,
2832            Self::__Unknown(value) => value,
2833        }
2834    }
2835}
2836
2837#[doc(hidden)]
2838impl FromGlib<ffi::GPasswordSave> for PasswordSave {
2839    #[inline]
2840    unsafe fn from_glib(value: ffi::GPasswordSave) -> Self {
2841        match value {
2842            ffi::G_PASSWORD_SAVE_NEVER => Self::Never,
2843            ffi::G_PASSWORD_SAVE_FOR_SESSION => Self::ForSession,
2844            ffi::G_PASSWORD_SAVE_PERMANENTLY => Self::Permanently,
2845            value => Self::__Unknown(value),
2846        }
2847    }
2848}
2849
2850impl StaticType for PasswordSave {
2851    #[inline]
2852    #[doc(alias = "g_password_save_get_type")]
2853    fn static_type() -> glib::Type {
2854        unsafe { from_glib(ffi::g_password_save_get_type()) }
2855    }
2856}
2857
2858impl glib::HasParamSpec for PasswordSave {
2859    type ParamSpec = glib::ParamSpecEnum;
2860    type SetValue = Self;
2861    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2862
2863    fn param_spec_builder() -> Self::BuilderFn {
2864        Self::ParamSpec::builder_with_default
2865    }
2866}
2867
2868impl glib::value::ValueType for PasswordSave {
2869    type Type = Self;
2870}
2871
2872unsafe impl<'a> glib::value::FromValue<'a> for PasswordSave {
2873    type Checker = glib::value::GenericValueTypeChecker<Self>;
2874
2875    #[inline]
2876    unsafe fn from_value(value: &'a glib::Value) -> Self {
2877        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2878    }
2879}
2880
2881impl ToValue for PasswordSave {
2882    #[inline]
2883    fn to_value(&self) -> glib::Value {
2884        let mut value = glib::Value::for_value_type::<Self>();
2885        unsafe {
2886            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2887        }
2888        value
2889    }
2890
2891    #[inline]
2892    fn value_type(&self) -> glib::Type {
2893        Self::static_type()
2894    }
2895}
2896
2897impl From<PasswordSave> for glib::Value {
2898    #[inline]
2899    fn from(v: PasswordSave) -> Self {
2900        ToValue::to_value(&v)
2901    }
2902}
2903
2904#[cfg(feature = "v2_60")]
2905#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2906#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2907#[non_exhaustive]
2908#[doc(alias = "GPollableReturn")]
2909pub enum PollableReturn {
2910    #[doc(alias = "G_POLLABLE_RETURN_FAILED")]
2911    Failed,
2912    #[doc(alias = "G_POLLABLE_RETURN_OK")]
2913    Ok,
2914    #[doc(alias = "G_POLLABLE_RETURN_WOULD_BLOCK")]
2915    WouldBlock,
2916    #[doc(hidden)]
2917    __Unknown(i32),
2918}
2919
2920#[cfg(feature = "v2_60")]
2921#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2922#[doc(hidden)]
2923impl IntoGlib for PollableReturn {
2924    type GlibType = ffi::GPollableReturn;
2925
2926    #[inline]
2927    fn into_glib(self) -> ffi::GPollableReturn {
2928        match self {
2929            Self::Failed => ffi::G_POLLABLE_RETURN_FAILED,
2930            Self::Ok => ffi::G_POLLABLE_RETURN_OK,
2931            Self::WouldBlock => ffi::G_POLLABLE_RETURN_WOULD_BLOCK,
2932            Self::__Unknown(value) => value,
2933        }
2934    }
2935}
2936
2937#[cfg(feature = "v2_60")]
2938#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2939#[doc(hidden)]
2940impl FromGlib<ffi::GPollableReturn> for PollableReturn {
2941    #[inline]
2942    unsafe fn from_glib(value: ffi::GPollableReturn) -> Self {
2943        match value {
2944            ffi::G_POLLABLE_RETURN_FAILED => Self::Failed,
2945            ffi::G_POLLABLE_RETURN_OK => Self::Ok,
2946            ffi::G_POLLABLE_RETURN_WOULD_BLOCK => Self::WouldBlock,
2947            value => Self::__Unknown(value),
2948        }
2949    }
2950}
2951
2952#[cfg(feature = "v2_60")]
2953#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2954impl StaticType for PollableReturn {
2955    #[inline]
2956    #[doc(alias = "g_pollable_return_get_type")]
2957    fn static_type() -> glib::Type {
2958        unsafe { from_glib(ffi::g_pollable_return_get_type()) }
2959    }
2960}
2961
2962#[cfg(feature = "v2_60")]
2963#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2964impl glib::HasParamSpec for PollableReturn {
2965    type ParamSpec = glib::ParamSpecEnum;
2966    type SetValue = Self;
2967    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2968
2969    fn param_spec_builder() -> Self::BuilderFn {
2970        Self::ParamSpec::builder_with_default
2971    }
2972}
2973
2974#[cfg(feature = "v2_60")]
2975#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2976impl glib::value::ValueType for PollableReturn {
2977    type Type = Self;
2978}
2979
2980#[cfg(feature = "v2_60")]
2981#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2982unsafe impl<'a> glib::value::FromValue<'a> for PollableReturn {
2983    type Checker = glib::value::GenericValueTypeChecker<Self>;
2984
2985    #[inline]
2986    unsafe fn from_value(value: &'a glib::Value) -> Self {
2987        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2988    }
2989}
2990
2991#[cfg(feature = "v2_60")]
2992#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2993impl ToValue for PollableReturn {
2994    #[inline]
2995    fn to_value(&self) -> glib::Value {
2996        let mut value = glib::Value::for_value_type::<Self>();
2997        unsafe {
2998            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2999        }
3000        value
3001    }
3002
3003    #[inline]
3004    fn value_type(&self) -> glib::Type {
3005        Self::static_type()
3006    }
3007}
3008
3009#[cfg(feature = "v2_60")]
3010#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3011impl From<PollableReturn> for glib::Value {
3012    #[inline]
3013    fn from(v: PollableReturn) -> Self {
3014        ToValue::to_value(&v)
3015    }
3016}
3017
3018#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3019#[non_exhaustive]
3020#[doc(alias = "GResolverError")]
3021pub enum ResolverError {
3022    #[doc(alias = "G_RESOLVER_ERROR_NOT_FOUND")]
3023    NotFound,
3024    #[doc(alias = "G_RESOLVER_ERROR_TEMPORARY_FAILURE")]
3025    TemporaryFailure,
3026    #[doc(alias = "G_RESOLVER_ERROR_INTERNAL")]
3027    Internal,
3028    #[doc(hidden)]
3029    __Unknown(i32),
3030}
3031
3032#[doc(hidden)]
3033impl IntoGlib for ResolverError {
3034    type GlibType = ffi::GResolverError;
3035
3036    #[inline]
3037    fn into_glib(self) -> ffi::GResolverError {
3038        match self {
3039            Self::NotFound => ffi::G_RESOLVER_ERROR_NOT_FOUND,
3040            Self::TemporaryFailure => ffi::G_RESOLVER_ERROR_TEMPORARY_FAILURE,
3041            Self::Internal => ffi::G_RESOLVER_ERROR_INTERNAL,
3042            Self::__Unknown(value) => value,
3043        }
3044    }
3045}
3046
3047#[doc(hidden)]
3048impl FromGlib<ffi::GResolverError> for ResolverError {
3049    #[inline]
3050    unsafe fn from_glib(value: ffi::GResolverError) -> Self {
3051        match value {
3052            ffi::G_RESOLVER_ERROR_NOT_FOUND => Self::NotFound,
3053            ffi::G_RESOLVER_ERROR_TEMPORARY_FAILURE => Self::TemporaryFailure,
3054            ffi::G_RESOLVER_ERROR_INTERNAL => Self::Internal,
3055            value => Self::__Unknown(value),
3056        }
3057    }
3058}
3059
3060impl glib::error::ErrorDomain for ResolverError {
3061    #[inline]
3062    fn domain() -> glib::Quark {
3063        unsafe { from_glib(ffi::g_resolver_error_quark()) }
3064    }
3065
3066    #[inline]
3067    fn code(self) -> i32 {
3068        self.into_glib()
3069    }
3070
3071    #[inline]
3072    #[allow(clippy::match_single_binding)]
3073    fn from(code: i32) -> Option<Self> {
3074        match unsafe { from_glib(code) } {
3075            value => Some(value),
3076        }
3077    }
3078}
3079
3080impl StaticType for ResolverError {
3081    #[inline]
3082    #[doc(alias = "g_resolver_error_get_type")]
3083    fn static_type() -> glib::Type {
3084        unsafe { from_glib(ffi::g_resolver_error_get_type()) }
3085    }
3086}
3087
3088impl glib::HasParamSpec for ResolverError {
3089    type ParamSpec = glib::ParamSpecEnum;
3090    type SetValue = Self;
3091    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3092
3093    fn param_spec_builder() -> Self::BuilderFn {
3094        Self::ParamSpec::builder_with_default
3095    }
3096}
3097
3098impl glib::value::ValueType for ResolverError {
3099    type Type = Self;
3100}
3101
3102unsafe impl<'a> glib::value::FromValue<'a> for ResolverError {
3103    type Checker = glib::value::GenericValueTypeChecker<Self>;
3104
3105    #[inline]
3106    unsafe fn from_value(value: &'a glib::Value) -> Self {
3107        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3108    }
3109}
3110
3111impl ToValue for ResolverError {
3112    #[inline]
3113    fn to_value(&self) -> glib::Value {
3114        let mut value = glib::Value::for_value_type::<Self>();
3115        unsafe {
3116            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3117        }
3118        value
3119    }
3120
3121    #[inline]
3122    fn value_type(&self) -> glib::Type {
3123        Self::static_type()
3124    }
3125}
3126
3127impl From<ResolverError> for glib::Value {
3128    #[inline]
3129    fn from(v: ResolverError) -> Self {
3130        ToValue::to_value(&v)
3131    }
3132}
3133
3134#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3135#[non_exhaustive]
3136#[doc(alias = "GResolverRecordType")]
3137pub enum ResolverRecordType {
3138    #[doc(alias = "G_RESOLVER_RECORD_SRV")]
3139    Srv,
3140    #[doc(alias = "G_RESOLVER_RECORD_MX")]
3141    Mx,
3142    #[doc(alias = "G_RESOLVER_RECORD_TXT")]
3143    Txt,
3144    #[doc(alias = "G_RESOLVER_RECORD_SOA")]
3145    Soa,
3146    #[doc(alias = "G_RESOLVER_RECORD_NS")]
3147    Ns,
3148    #[doc(hidden)]
3149    __Unknown(i32),
3150}
3151
3152#[doc(hidden)]
3153impl IntoGlib for ResolverRecordType {
3154    type GlibType = ffi::GResolverRecordType;
3155
3156    #[inline]
3157    fn into_glib(self) -> ffi::GResolverRecordType {
3158        match self {
3159            Self::Srv => ffi::G_RESOLVER_RECORD_SRV,
3160            Self::Mx => ffi::G_RESOLVER_RECORD_MX,
3161            Self::Txt => ffi::G_RESOLVER_RECORD_TXT,
3162            Self::Soa => ffi::G_RESOLVER_RECORD_SOA,
3163            Self::Ns => ffi::G_RESOLVER_RECORD_NS,
3164            Self::__Unknown(value) => value,
3165        }
3166    }
3167}
3168
3169#[doc(hidden)]
3170impl FromGlib<ffi::GResolverRecordType> for ResolverRecordType {
3171    #[inline]
3172    unsafe fn from_glib(value: ffi::GResolverRecordType) -> Self {
3173        match value {
3174            ffi::G_RESOLVER_RECORD_SRV => Self::Srv,
3175            ffi::G_RESOLVER_RECORD_MX => Self::Mx,
3176            ffi::G_RESOLVER_RECORD_TXT => Self::Txt,
3177            ffi::G_RESOLVER_RECORD_SOA => Self::Soa,
3178            ffi::G_RESOLVER_RECORD_NS => Self::Ns,
3179            value => Self::__Unknown(value),
3180        }
3181    }
3182}
3183
3184impl StaticType for ResolverRecordType {
3185    #[inline]
3186    #[doc(alias = "g_resolver_record_type_get_type")]
3187    fn static_type() -> glib::Type {
3188        unsafe { from_glib(ffi::g_resolver_record_type_get_type()) }
3189    }
3190}
3191
3192impl glib::HasParamSpec for ResolverRecordType {
3193    type ParamSpec = glib::ParamSpecEnum;
3194    type SetValue = Self;
3195    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3196
3197    fn param_spec_builder() -> Self::BuilderFn {
3198        Self::ParamSpec::builder_with_default
3199    }
3200}
3201
3202impl glib::value::ValueType for ResolverRecordType {
3203    type Type = Self;
3204}
3205
3206unsafe impl<'a> glib::value::FromValue<'a> for ResolverRecordType {
3207    type Checker = glib::value::GenericValueTypeChecker<Self>;
3208
3209    #[inline]
3210    unsafe fn from_value(value: &'a glib::Value) -> Self {
3211        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3212    }
3213}
3214
3215impl ToValue for ResolverRecordType {
3216    #[inline]
3217    fn to_value(&self) -> glib::Value {
3218        let mut value = glib::Value::for_value_type::<Self>();
3219        unsafe {
3220            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3221        }
3222        value
3223    }
3224
3225    #[inline]
3226    fn value_type(&self) -> glib::Type {
3227        Self::static_type()
3228    }
3229}
3230
3231impl From<ResolverRecordType> for glib::Value {
3232    #[inline]
3233    fn from(v: ResolverRecordType) -> Self {
3234        ToValue::to_value(&v)
3235    }
3236}
3237
3238#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3239#[non_exhaustive]
3240#[doc(alias = "GResourceError")]
3241pub enum ResourceError {
3242    #[doc(alias = "G_RESOURCE_ERROR_NOT_FOUND")]
3243    NotFound,
3244    #[doc(alias = "G_RESOURCE_ERROR_INTERNAL")]
3245    Internal,
3246    #[doc(hidden)]
3247    __Unknown(i32),
3248}
3249
3250#[doc(hidden)]
3251impl IntoGlib for ResourceError {
3252    type GlibType = ffi::GResourceError;
3253
3254    #[inline]
3255    fn into_glib(self) -> ffi::GResourceError {
3256        match self {
3257            Self::NotFound => ffi::G_RESOURCE_ERROR_NOT_FOUND,
3258            Self::Internal => ffi::G_RESOURCE_ERROR_INTERNAL,
3259            Self::__Unknown(value) => value,
3260        }
3261    }
3262}
3263
3264#[doc(hidden)]
3265impl FromGlib<ffi::GResourceError> for ResourceError {
3266    #[inline]
3267    unsafe fn from_glib(value: ffi::GResourceError) -> Self {
3268        match value {
3269            ffi::G_RESOURCE_ERROR_NOT_FOUND => Self::NotFound,
3270            ffi::G_RESOURCE_ERROR_INTERNAL => Self::Internal,
3271            value => Self::__Unknown(value),
3272        }
3273    }
3274}
3275
3276impl glib::error::ErrorDomain for ResourceError {
3277    #[inline]
3278    fn domain() -> glib::Quark {
3279        unsafe { from_glib(ffi::g_resource_error_quark()) }
3280    }
3281
3282    #[inline]
3283    fn code(self) -> i32 {
3284        self.into_glib()
3285    }
3286
3287    #[inline]
3288    #[allow(clippy::match_single_binding)]
3289    fn from(code: i32) -> Option<Self> {
3290        match unsafe { from_glib(code) } {
3291            value => Some(value),
3292        }
3293    }
3294}
3295
3296impl StaticType for ResourceError {
3297    #[inline]
3298    #[doc(alias = "g_resource_error_get_type")]
3299    fn static_type() -> glib::Type {
3300        unsafe { from_glib(ffi::g_resource_error_get_type()) }
3301    }
3302}
3303
3304impl glib::HasParamSpec for ResourceError {
3305    type ParamSpec = glib::ParamSpecEnum;
3306    type SetValue = Self;
3307    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3308
3309    fn param_spec_builder() -> Self::BuilderFn {
3310        Self::ParamSpec::builder_with_default
3311    }
3312}
3313
3314impl glib::value::ValueType for ResourceError {
3315    type Type = Self;
3316}
3317
3318unsafe impl<'a> glib::value::FromValue<'a> for ResourceError {
3319    type Checker = glib::value::GenericValueTypeChecker<Self>;
3320
3321    #[inline]
3322    unsafe fn from_value(value: &'a glib::Value) -> Self {
3323        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3324    }
3325}
3326
3327impl ToValue for ResourceError {
3328    #[inline]
3329    fn to_value(&self) -> glib::Value {
3330        let mut value = glib::Value::for_value_type::<Self>();
3331        unsafe {
3332            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3333        }
3334        value
3335    }
3336
3337    #[inline]
3338    fn value_type(&self) -> glib::Type {
3339        Self::static_type()
3340    }
3341}
3342
3343impl From<ResourceError> for glib::Value {
3344    #[inline]
3345    fn from(v: ResourceError) -> Self {
3346        ToValue::to_value(&v)
3347    }
3348}
3349
3350#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3351#[non_exhaustive]
3352#[doc(alias = "GSocketClientEvent")]
3353pub enum SocketClientEvent {
3354    #[doc(alias = "G_SOCKET_CLIENT_RESOLVING")]
3355    Resolving,
3356    #[doc(alias = "G_SOCKET_CLIENT_RESOLVED")]
3357    Resolved,
3358    #[doc(alias = "G_SOCKET_CLIENT_CONNECTING")]
3359    Connecting,
3360    #[doc(alias = "G_SOCKET_CLIENT_CONNECTED")]
3361    Connected,
3362    #[doc(alias = "G_SOCKET_CLIENT_PROXY_NEGOTIATING")]
3363    ProxyNegotiating,
3364    #[doc(alias = "G_SOCKET_CLIENT_PROXY_NEGOTIATED")]
3365    ProxyNegotiated,
3366    #[doc(alias = "G_SOCKET_CLIENT_TLS_HANDSHAKING")]
3367    TlsHandshaking,
3368    #[doc(alias = "G_SOCKET_CLIENT_TLS_HANDSHAKED")]
3369    TlsHandshaked,
3370    #[doc(alias = "G_SOCKET_CLIENT_COMPLETE")]
3371    Complete,
3372    #[doc(hidden)]
3373    __Unknown(i32),
3374}
3375
3376#[doc(hidden)]
3377impl IntoGlib for SocketClientEvent {
3378    type GlibType = ffi::GSocketClientEvent;
3379
3380    #[inline]
3381    fn into_glib(self) -> ffi::GSocketClientEvent {
3382        match self {
3383            Self::Resolving => ffi::G_SOCKET_CLIENT_RESOLVING,
3384            Self::Resolved => ffi::G_SOCKET_CLIENT_RESOLVED,
3385            Self::Connecting => ffi::G_SOCKET_CLIENT_CONNECTING,
3386            Self::Connected => ffi::G_SOCKET_CLIENT_CONNECTED,
3387            Self::ProxyNegotiating => ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATING,
3388            Self::ProxyNegotiated => ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATED,
3389            Self::TlsHandshaking => ffi::G_SOCKET_CLIENT_TLS_HANDSHAKING,
3390            Self::TlsHandshaked => ffi::G_SOCKET_CLIENT_TLS_HANDSHAKED,
3391            Self::Complete => ffi::G_SOCKET_CLIENT_COMPLETE,
3392            Self::__Unknown(value) => value,
3393        }
3394    }
3395}
3396
3397#[doc(hidden)]
3398impl FromGlib<ffi::GSocketClientEvent> for SocketClientEvent {
3399    #[inline]
3400    unsafe fn from_glib(value: ffi::GSocketClientEvent) -> Self {
3401        match value {
3402            ffi::G_SOCKET_CLIENT_RESOLVING => Self::Resolving,
3403            ffi::G_SOCKET_CLIENT_RESOLVED => Self::Resolved,
3404            ffi::G_SOCKET_CLIENT_CONNECTING => Self::Connecting,
3405            ffi::G_SOCKET_CLIENT_CONNECTED => Self::Connected,
3406            ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATING => Self::ProxyNegotiating,
3407            ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATED => Self::ProxyNegotiated,
3408            ffi::G_SOCKET_CLIENT_TLS_HANDSHAKING => Self::TlsHandshaking,
3409            ffi::G_SOCKET_CLIENT_TLS_HANDSHAKED => Self::TlsHandshaked,
3410            ffi::G_SOCKET_CLIENT_COMPLETE => Self::Complete,
3411            value => Self::__Unknown(value),
3412        }
3413    }
3414}
3415
3416impl StaticType for SocketClientEvent {
3417    #[inline]
3418    #[doc(alias = "g_socket_client_event_get_type")]
3419    fn static_type() -> glib::Type {
3420        unsafe { from_glib(ffi::g_socket_client_event_get_type()) }
3421    }
3422}
3423
3424impl glib::HasParamSpec for SocketClientEvent {
3425    type ParamSpec = glib::ParamSpecEnum;
3426    type SetValue = Self;
3427    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3428
3429    fn param_spec_builder() -> Self::BuilderFn {
3430        Self::ParamSpec::builder_with_default
3431    }
3432}
3433
3434impl glib::value::ValueType for SocketClientEvent {
3435    type Type = Self;
3436}
3437
3438unsafe impl<'a> glib::value::FromValue<'a> for SocketClientEvent {
3439    type Checker = glib::value::GenericValueTypeChecker<Self>;
3440
3441    #[inline]
3442    unsafe fn from_value(value: &'a glib::Value) -> Self {
3443        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3444    }
3445}
3446
3447impl ToValue for SocketClientEvent {
3448    #[inline]
3449    fn to_value(&self) -> glib::Value {
3450        let mut value = glib::Value::for_value_type::<Self>();
3451        unsafe {
3452            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3453        }
3454        value
3455    }
3456
3457    #[inline]
3458    fn value_type(&self) -> glib::Type {
3459        Self::static_type()
3460    }
3461}
3462
3463impl From<SocketClientEvent> for glib::Value {
3464    #[inline]
3465    fn from(v: SocketClientEvent) -> Self {
3466        ToValue::to_value(&v)
3467    }
3468}
3469
3470#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3471#[non_exhaustive]
3472#[doc(alias = "GSocketFamily")]
3473pub enum SocketFamily {
3474    #[doc(alias = "G_SOCKET_FAMILY_INVALID")]
3475    Invalid,
3476    #[doc(alias = "G_SOCKET_FAMILY_UNIX")]
3477    Unix,
3478    #[doc(alias = "G_SOCKET_FAMILY_IPV4")]
3479    Ipv4,
3480    #[doc(alias = "G_SOCKET_FAMILY_IPV6")]
3481    Ipv6,
3482    #[doc(hidden)]
3483    __Unknown(i32),
3484}
3485
3486#[doc(hidden)]
3487impl IntoGlib for SocketFamily {
3488    type GlibType = ffi::GSocketFamily;
3489
3490    #[inline]
3491    fn into_glib(self) -> ffi::GSocketFamily {
3492        match self {
3493            Self::Invalid => ffi::G_SOCKET_FAMILY_INVALID,
3494            Self::Unix => ffi::G_SOCKET_FAMILY_UNIX,
3495            Self::Ipv4 => ffi::G_SOCKET_FAMILY_IPV4,
3496            Self::Ipv6 => ffi::G_SOCKET_FAMILY_IPV6,
3497            Self::__Unknown(value) => value,
3498        }
3499    }
3500}
3501
3502#[doc(hidden)]
3503impl FromGlib<ffi::GSocketFamily> for SocketFamily {
3504    #[inline]
3505    unsafe fn from_glib(value: ffi::GSocketFamily) -> Self {
3506        match value {
3507            ffi::G_SOCKET_FAMILY_INVALID => Self::Invalid,
3508            ffi::G_SOCKET_FAMILY_UNIX => Self::Unix,
3509            ffi::G_SOCKET_FAMILY_IPV4 => Self::Ipv4,
3510            ffi::G_SOCKET_FAMILY_IPV6 => Self::Ipv6,
3511            value => Self::__Unknown(value),
3512        }
3513    }
3514}
3515
3516impl StaticType for SocketFamily {
3517    #[inline]
3518    #[doc(alias = "g_socket_family_get_type")]
3519    fn static_type() -> glib::Type {
3520        unsafe { from_glib(ffi::g_socket_family_get_type()) }
3521    }
3522}
3523
3524impl glib::HasParamSpec for SocketFamily {
3525    type ParamSpec = glib::ParamSpecEnum;
3526    type SetValue = Self;
3527    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3528
3529    fn param_spec_builder() -> Self::BuilderFn {
3530        Self::ParamSpec::builder_with_default
3531    }
3532}
3533
3534impl glib::value::ValueType for SocketFamily {
3535    type Type = Self;
3536}
3537
3538unsafe impl<'a> glib::value::FromValue<'a> for SocketFamily {
3539    type Checker = glib::value::GenericValueTypeChecker<Self>;
3540
3541    #[inline]
3542    unsafe fn from_value(value: &'a glib::Value) -> Self {
3543        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3544    }
3545}
3546
3547impl ToValue for SocketFamily {
3548    #[inline]
3549    fn to_value(&self) -> glib::Value {
3550        let mut value = glib::Value::for_value_type::<Self>();
3551        unsafe {
3552            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3553        }
3554        value
3555    }
3556
3557    #[inline]
3558    fn value_type(&self) -> glib::Type {
3559        Self::static_type()
3560    }
3561}
3562
3563impl From<SocketFamily> for glib::Value {
3564    #[inline]
3565    fn from(v: SocketFamily) -> Self {
3566        ToValue::to_value(&v)
3567    }
3568}
3569
3570#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3571#[non_exhaustive]
3572#[doc(alias = "GSocketListenerEvent")]
3573pub enum SocketListenerEvent {
3574    #[doc(alias = "G_SOCKET_LISTENER_BINDING")]
3575    Binding,
3576    #[doc(alias = "G_SOCKET_LISTENER_BOUND")]
3577    Bound,
3578    #[doc(alias = "G_SOCKET_LISTENER_LISTENING")]
3579    Listening,
3580    #[doc(alias = "G_SOCKET_LISTENER_LISTENED")]
3581    Listened,
3582    #[doc(hidden)]
3583    __Unknown(i32),
3584}
3585
3586#[doc(hidden)]
3587impl IntoGlib for SocketListenerEvent {
3588    type GlibType = ffi::GSocketListenerEvent;
3589
3590    #[inline]
3591    fn into_glib(self) -> ffi::GSocketListenerEvent {
3592        match self {
3593            Self::Binding => ffi::G_SOCKET_LISTENER_BINDING,
3594            Self::Bound => ffi::G_SOCKET_LISTENER_BOUND,
3595            Self::Listening => ffi::G_SOCKET_LISTENER_LISTENING,
3596            Self::Listened => ffi::G_SOCKET_LISTENER_LISTENED,
3597            Self::__Unknown(value) => value,
3598        }
3599    }
3600}
3601
3602#[doc(hidden)]
3603impl FromGlib<ffi::GSocketListenerEvent> for SocketListenerEvent {
3604    #[inline]
3605    unsafe fn from_glib(value: ffi::GSocketListenerEvent) -> Self {
3606        match value {
3607            ffi::G_SOCKET_LISTENER_BINDING => Self::Binding,
3608            ffi::G_SOCKET_LISTENER_BOUND => Self::Bound,
3609            ffi::G_SOCKET_LISTENER_LISTENING => Self::Listening,
3610            ffi::G_SOCKET_LISTENER_LISTENED => Self::Listened,
3611            value => Self::__Unknown(value),
3612        }
3613    }
3614}
3615
3616impl StaticType for SocketListenerEvent {
3617    #[inline]
3618    #[doc(alias = "g_socket_listener_event_get_type")]
3619    fn static_type() -> glib::Type {
3620        unsafe { from_glib(ffi::g_socket_listener_event_get_type()) }
3621    }
3622}
3623
3624impl glib::HasParamSpec for SocketListenerEvent {
3625    type ParamSpec = glib::ParamSpecEnum;
3626    type SetValue = Self;
3627    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3628
3629    fn param_spec_builder() -> Self::BuilderFn {
3630        Self::ParamSpec::builder_with_default
3631    }
3632}
3633
3634impl glib::value::ValueType for SocketListenerEvent {
3635    type Type = Self;
3636}
3637
3638unsafe impl<'a> glib::value::FromValue<'a> for SocketListenerEvent {
3639    type Checker = glib::value::GenericValueTypeChecker<Self>;
3640
3641    #[inline]
3642    unsafe fn from_value(value: &'a glib::Value) -> Self {
3643        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3644    }
3645}
3646
3647impl ToValue for SocketListenerEvent {
3648    #[inline]
3649    fn to_value(&self) -> glib::Value {
3650        let mut value = glib::Value::for_value_type::<Self>();
3651        unsafe {
3652            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3653        }
3654        value
3655    }
3656
3657    #[inline]
3658    fn value_type(&self) -> glib::Type {
3659        Self::static_type()
3660    }
3661}
3662
3663impl From<SocketListenerEvent> for glib::Value {
3664    #[inline]
3665    fn from(v: SocketListenerEvent) -> Self {
3666        ToValue::to_value(&v)
3667    }
3668}
3669
3670#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3671#[non_exhaustive]
3672#[doc(alias = "GSocketProtocol")]
3673pub enum SocketProtocol {
3674    #[doc(alias = "G_SOCKET_PROTOCOL_UNKNOWN")]
3675    Unknown,
3676    #[doc(alias = "G_SOCKET_PROTOCOL_DEFAULT")]
3677    Default,
3678    #[doc(alias = "G_SOCKET_PROTOCOL_TCP")]
3679    Tcp,
3680    #[doc(alias = "G_SOCKET_PROTOCOL_UDP")]
3681    Udp,
3682    #[doc(alias = "G_SOCKET_PROTOCOL_SCTP")]
3683    Sctp,
3684    #[doc(hidden)]
3685    __Unknown(i32),
3686}
3687
3688#[doc(hidden)]
3689impl IntoGlib for SocketProtocol {
3690    type GlibType = ffi::GSocketProtocol;
3691
3692    #[inline]
3693    fn into_glib(self) -> ffi::GSocketProtocol {
3694        match self {
3695            Self::Unknown => ffi::G_SOCKET_PROTOCOL_UNKNOWN,
3696            Self::Default => ffi::G_SOCKET_PROTOCOL_DEFAULT,
3697            Self::Tcp => ffi::G_SOCKET_PROTOCOL_TCP,
3698            Self::Udp => ffi::G_SOCKET_PROTOCOL_UDP,
3699            Self::Sctp => ffi::G_SOCKET_PROTOCOL_SCTP,
3700            Self::__Unknown(value) => value,
3701        }
3702    }
3703}
3704
3705#[doc(hidden)]
3706impl FromGlib<ffi::GSocketProtocol> for SocketProtocol {
3707    #[inline]
3708    unsafe fn from_glib(value: ffi::GSocketProtocol) -> Self {
3709        match value {
3710            ffi::G_SOCKET_PROTOCOL_UNKNOWN => Self::Unknown,
3711            ffi::G_SOCKET_PROTOCOL_DEFAULT => Self::Default,
3712            ffi::G_SOCKET_PROTOCOL_TCP => Self::Tcp,
3713            ffi::G_SOCKET_PROTOCOL_UDP => Self::Udp,
3714            ffi::G_SOCKET_PROTOCOL_SCTP => Self::Sctp,
3715            value => Self::__Unknown(value),
3716        }
3717    }
3718}
3719
3720impl StaticType for SocketProtocol {
3721    #[inline]
3722    #[doc(alias = "g_socket_protocol_get_type")]
3723    fn static_type() -> glib::Type {
3724        unsafe { from_glib(ffi::g_socket_protocol_get_type()) }
3725    }
3726}
3727
3728impl glib::HasParamSpec for SocketProtocol {
3729    type ParamSpec = glib::ParamSpecEnum;
3730    type SetValue = Self;
3731    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3732
3733    fn param_spec_builder() -> Self::BuilderFn {
3734        Self::ParamSpec::builder_with_default
3735    }
3736}
3737
3738impl glib::value::ValueType for SocketProtocol {
3739    type Type = Self;
3740}
3741
3742unsafe impl<'a> glib::value::FromValue<'a> for SocketProtocol {
3743    type Checker = glib::value::GenericValueTypeChecker<Self>;
3744
3745    #[inline]
3746    unsafe fn from_value(value: &'a glib::Value) -> Self {
3747        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3748    }
3749}
3750
3751impl ToValue for SocketProtocol {
3752    #[inline]
3753    fn to_value(&self) -> glib::Value {
3754        let mut value = glib::Value::for_value_type::<Self>();
3755        unsafe {
3756            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3757        }
3758        value
3759    }
3760
3761    #[inline]
3762    fn value_type(&self) -> glib::Type {
3763        Self::static_type()
3764    }
3765}
3766
3767impl From<SocketProtocol> for glib::Value {
3768    #[inline]
3769    fn from(v: SocketProtocol) -> Self {
3770        ToValue::to_value(&v)
3771    }
3772}
3773
3774#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3775#[non_exhaustive]
3776#[doc(alias = "GSocketType")]
3777pub enum SocketType {
3778    #[doc(alias = "G_SOCKET_TYPE_INVALID")]
3779    Invalid,
3780    #[doc(alias = "G_SOCKET_TYPE_STREAM")]
3781    Stream,
3782    #[doc(alias = "G_SOCKET_TYPE_DATAGRAM")]
3783    Datagram,
3784    #[doc(alias = "G_SOCKET_TYPE_SEQPACKET")]
3785    Seqpacket,
3786    #[doc(hidden)]
3787    __Unknown(i32),
3788}
3789
3790#[doc(hidden)]
3791impl IntoGlib for SocketType {
3792    type GlibType = ffi::GSocketType;
3793
3794    #[inline]
3795    fn into_glib(self) -> ffi::GSocketType {
3796        match self {
3797            Self::Invalid => ffi::G_SOCKET_TYPE_INVALID,
3798            Self::Stream => ffi::G_SOCKET_TYPE_STREAM,
3799            Self::Datagram => ffi::G_SOCKET_TYPE_DATAGRAM,
3800            Self::Seqpacket => ffi::G_SOCKET_TYPE_SEQPACKET,
3801            Self::__Unknown(value) => value,
3802        }
3803    }
3804}
3805
3806#[doc(hidden)]
3807impl FromGlib<ffi::GSocketType> for SocketType {
3808    #[inline]
3809    unsafe fn from_glib(value: ffi::GSocketType) -> Self {
3810        match value {
3811            ffi::G_SOCKET_TYPE_INVALID => Self::Invalid,
3812            ffi::G_SOCKET_TYPE_STREAM => Self::Stream,
3813            ffi::G_SOCKET_TYPE_DATAGRAM => Self::Datagram,
3814            ffi::G_SOCKET_TYPE_SEQPACKET => Self::Seqpacket,
3815            value => Self::__Unknown(value),
3816        }
3817    }
3818}
3819
3820impl StaticType for SocketType {
3821    #[inline]
3822    #[doc(alias = "g_socket_type_get_type")]
3823    fn static_type() -> glib::Type {
3824        unsafe { from_glib(ffi::g_socket_type_get_type()) }
3825    }
3826}
3827
3828impl glib::HasParamSpec for SocketType {
3829    type ParamSpec = glib::ParamSpecEnum;
3830    type SetValue = Self;
3831    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3832
3833    fn param_spec_builder() -> Self::BuilderFn {
3834        Self::ParamSpec::builder_with_default
3835    }
3836}
3837
3838impl glib::value::ValueType for SocketType {
3839    type Type = Self;
3840}
3841
3842unsafe impl<'a> glib::value::FromValue<'a> for SocketType {
3843    type Checker = glib::value::GenericValueTypeChecker<Self>;
3844
3845    #[inline]
3846    unsafe fn from_value(value: &'a glib::Value) -> Self {
3847        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3848    }
3849}
3850
3851impl ToValue for SocketType {
3852    #[inline]
3853    fn to_value(&self) -> glib::Value {
3854        let mut value = glib::Value::for_value_type::<Self>();
3855        unsafe {
3856            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3857        }
3858        value
3859    }
3860
3861    #[inline]
3862    fn value_type(&self) -> glib::Type {
3863        Self::static_type()
3864    }
3865}
3866
3867impl From<SocketType> for glib::Value {
3868    #[inline]
3869    fn from(v: SocketType) -> Self {
3870        ToValue::to_value(&v)
3871    }
3872}
3873
3874#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3875#[non_exhaustive]
3876#[doc(alias = "GTlsAuthenticationMode")]
3877pub enum TlsAuthenticationMode {
3878    #[doc(alias = "G_TLS_AUTHENTICATION_NONE")]
3879    None,
3880    #[doc(alias = "G_TLS_AUTHENTICATION_REQUESTED")]
3881    Requested,
3882    #[doc(alias = "G_TLS_AUTHENTICATION_REQUIRED")]
3883    Required,
3884    #[doc(hidden)]
3885    __Unknown(i32),
3886}
3887
3888#[doc(hidden)]
3889impl IntoGlib for TlsAuthenticationMode {
3890    type GlibType = ffi::GTlsAuthenticationMode;
3891
3892    #[inline]
3893    fn into_glib(self) -> ffi::GTlsAuthenticationMode {
3894        match self {
3895            Self::None => ffi::G_TLS_AUTHENTICATION_NONE,
3896            Self::Requested => ffi::G_TLS_AUTHENTICATION_REQUESTED,
3897            Self::Required => ffi::G_TLS_AUTHENTICATION_REQUIRED,
3898            Self::__Unknown(value) => value,
3899        }
3900    }
3901}
3902
3903#[doc(hidden)]
3904impl FromGlib<ffi::GTlsAuthenticationMode> for TlsAuthenticationMode {
3905    #[inline]
3906    unsafe fn from_glib(value: ffi::GTlsAuthenticationMode) -> Self {
3907        match value {
3908            ffi::G_TLS_AUTHENTICATION_NONE => Self::None,
3909            ffi::G_TLS_AUTHENTICATION_REQUESTED => Self::Requested,
3910            ffi::G_TLS_AUTHENTICATION_REQUIRED => Self::Required,
3911            value => Self::__Unknown(value),
3912        }
3913    }
3914}
3915
3916impl StaticType for TlsAuthenticationMode {
3917    #[inline]
3918    #[doc(alias = "g_tls_authentication_mode_get_type")]
3919    fn static_type() -> glib::Type {
3920        unsafe { from_glib(ffi::g_tls_authentication_mode_get_type()) }
3921    }
3922}
3923
3924impl glib::HasParamSpec for TlsAuthenticationMode {
3925    type ParamSpec = glib::ParamSpecEnum;
3926    type SetValue = Self;
3927    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3928
3929    fn param_spec_builder() -> Self::BuilderFn {
3930        Self::ParamSpec::builder_with_default
3931    }
3932}
3933
3934impl glib::value::ValueType for TlsAuthenticationMode {
3935    type Type = Self;
3936}
3937
3938unsafe impl<'a> glib::value::FromValue<'a> for TlsAuthenticationMode {
3939    type Checker = glib::value::GenericValueTypeChecker<Self>;
3940
3941    #[inline]
3942    unsafe fn from_value(value: &'a glib::Value) -> Self {
3943        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3944    }
3945}
3946
3947impl ToValue for TlsAuthenticationMode {
3948    #[inline]
3949    fn to_value(&self) -> glib::Value {
3950        let mut value = glib::Value::for_value_type::<Self>();
3951        unsafe {
3952            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3953        }
3954        value
3955    }
3956
3957    #[inline]
3958    fn value_type(&self) -> glib::Type {
3959        Self::static_type()
3960    }
3961}
3962
3963impl From<TlsAuthenticationMode> for glib::Value {
3964    #[inline]
3965    fn from(v: TlsAuthenticationMode) -> Self {
3966        ToValue::to_value(&v)
3967    }
3968}
3969
3970#[cfg(feature = "v2_66")]
3971#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
3972#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3973#[non_exhaustive]
3974#[doc(alias = "GTlsChannelBindingError")]
3975pub enum TlsChannelBindingError {
3976    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_NOT_IMPLEMENTED")]
3977    NotImplemented,
3978    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_INVALID_STATE")]
3979    InvalidState,
3980    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_NOT_AVAILABLE")]
3981    NotAvailable,
3982    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_NOT_SUPPORTED")]
3983    NotSupported,
3984    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_GENERAL_ERROR")]
3985    GeneralError,
3986    #[doc(hidden)]
3987    __Unknown(i32),
3988}
3989
3990#[cfg(feature = "v2_66")]
3991#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
3992#[doc(hidden)]
3993impl IntoGlib for TlsChannelBindingError {
3994    type GlibType = ffi::GTlsChannelBindingError;
3995
3996    #[inline]
3997    fn into_glib(self) -> ffi::GTlsChannelBindingError {
3998        match self {
3999            Self::NotImplemented => ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_IMPLEMENTED,
4000            Self::InvalidState => ffi::G_TLS_CHANNEL_BINDING_ERROR_INVALID_STATE,
4001            Self::NotAvailable => ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_AVAILABLE,
4002            Self::NotSupported => ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_SUPPORTED,
4003            Self::GeneralError => ffi::G_TLS_CHANNEL_BINDING_ERROR_GENERAL_ERROR,
4004            Self::__Unknown(value) => value,
4005        }
4006    }
4007}
4008
4009#[cfg(feature = "v2_66")]
4010#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4011#[doc(hidden)]
4012impl FromGlib<ffi::GTlsChannelBindingError> for TlsChannelBindingError {
4013    #[inline]
4014    unsafe fn from_glib(value: ffi::GTlsChannelBindingError) -> Self {
4015        match value {
4016            ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_IMPLEMENTED => Self::NotImplemented,
4017            ffi::G_TLS_CHANNEL_BINDING_ERROR_INVALID_STATE => Self::InvalidState,
4018            ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_AVAILABLE => Self::NotAvailable,
4019            ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_SUPPORTED => Self::NotSupported,
4020            ffi::G_TLS_CHANNEL_BINDING_ERROR_GENERAL_ERROR => Self::GeneralError,
4021            value => Self::__Unknown(value),
4022        }
4023    }
4024}
4025
4026#[cfg(feature = "v2_66")]
4027#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4028impl glib::error::ErrorDomain for TlsChannelBindingError {
4029    #[inline]
4030    fn domain() -> glib::Quark {
4031        unsafe { from_glib(ffi::g_tls_channel_binding_error_quark()) }
4032    }
4033
4034    #[inline]
4035    fn code(self) -> i32 {
4036        self.into_glib()
4037    }
4038
4039    #[inline]
4040    #[allow(clippy::match_single_binding)]
4041    fn from(code: i32) -> Option<Self> {
4042        match unsafe { from_glib(code) } {
4043            value => Some(value),
4044        }
4045    }
4046}
4047
4048#[cfg(feature = "v2_66")]
4049#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4050impl StaticType for TlsChannelBindingError {
4051    #[inline]
4052    #[doc(alias = "g_tls_channel_binding_error_get_type")]
4053    fn static_type() -> glib::Type {
4054        unsafe { from_glib(ffi::g_tls_channel_binding_error_get_type()) }
4055    }
4056}
4057
4058#[cfg(feature = "v2_66")]
4059#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4060impl glib::HasParamSpec for TlsChannelBindingError {
4061    type ParamSpec = glib::ParamSpecEnum;
4062    type SetValue = Self;
4063    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4064
4065    fn param_spec_builder() -> Self::BuilderFn {
4066        Self::ParamSpec::builder_with_default
4067    }
4068}
4069
4070#[cfg(feature = "v2_66")]
4071#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4072impl glib::value::ValueType for TlsChannelBindingError {
4073    type Type = Self;
4074}
4075
4076#[cfg(feature = "v2_66")]
4077#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4078unsafe impl<'a> glib::value::FromValue<'a> for TlsChannelBindingError {
4079    type Checker = glib::value::GenericValueTypeChecker<Self>;
4080
4081    #[inline]
4082    unsafe fn from_value(value: &'a glib::Value) -> Self {
4083        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4084    }
4085}
4086
4087#[cfg(feature = "v2_66")]
4088#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4089impl ToValue for TlsChannelBindingError {
4090    #[inline]
4091    fn to_value(&self) -> glib::Value {
4092        let mut value = glib::Value::for_value_type::<Self>();
4093        unsafe {
4094            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4095        }
4096        value
4097    }
4098
4099    #[inline]
4100    fn value_type(&self) -> glib::Type {
4101        Self::static_type()
4102    }
4103}
4104
4105#[cfg(feature = "v2_66")]
4106#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4107impl From<TlsChannelBindingError> for glib::Value {
4108    #[inline]
4109    fn from(v: TlsChannelBindingError) -> Self {
4110        ToValue::to_value(&v)
4111    }
4112}
4113
4114#[cfg(feature = "v2_66")]
4115#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4116#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4117#[non_exhaustive]
4118#[doc(alias = "GTlsChannelBindingType")]
4119pub enum TlsChannelBindingType {
4120    #[doc(alias = "G_TLS_CHANNEL_BINDING_TLS_UNIQUE")]
4121    Unique,
4122    #[doc(alias = "G_TLS_CHANNEL_BINDING_TLS_SERVER_END_POINT")]
4123    ServerEndPoint,
4124    #[cfg(feature = "v2_74")]
4125    #[cfg_attr(docsrs, doc(cfg(feature = "v2_74")))]
4126    #[doc(alias = "G_TLS_CHANNEL_BINDING_TLS_EXPORTER")]
4127    Exporter,
4128    #[doc(hidden)]
4129    __Unknown(i32),
4130}
4131
4132#[cfg(feature = "v2_66")]
4133#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4134#[doc(hidden)]
4135impl IntoGlib for TlsChannelBindingType {
4136    type GlibType = ffi::GTlsChannelBindingType;
4137
4138    #[inline]
4139    fn into_glib(self) -> ffi::GTlsChannelBindingType {
4140        match self {
4141            Self::Unique => ffi::G_TLS_CHANNEL_BINDING_TLS_UNIQUE,
4142            Self::ServerEndPoint => ffi::G_TLS_CHANNEL_BINDING_TLS_SERVER_END_POINT,
4143            #[cfg(feature = "v2_74")]
4144            Self::Exporter => ffi::G_TLS_CHANNEL_BINDING_TLS_EXPORTER,
4145            Self::__Unknown(value) => value,
4146        }
4147    }
4148}
4149
4150#[cfg(feature = "v2_66")]
4151#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4152#[doc(hidden)]
4153impl FromGlib<ffi::GTlsChannelBindingType> for TlsChannelBindingType {
4154    #[inline]
4155    unsafe fn from_glib(value: ffi::GTlsChannelBindingType) -> Self {
4156        match value {
4157            ffi::G_TLS_CHANNEL_BINDING_TLS_UNIQUE => Self::Unique,
4158            ffi::G_TLS_CHANNEL_BINDING_TLS_SERVER_END_POINT => Self::ServerEndPoint,
4159            #[cfg(feature = "v2_74")]
4160            ffi::G_TLS_CHANNEL_BINDING_TLS_EXPORTER => Self::Exporter,
4161            value => Self::__Unknown(value),
4162        }
4163    }
4164}
4165
4166#[cfg(feature = "v2_66")]
4167#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4168impl StaticType for TlsChannelBindingType {
4169    #[inline]
4170    #[doc(alias = "g_tls_channel_binding_type_get_type")]
4171    fn static_type() -> glib::Type {
4172        unsafe { from_glib(ffi::g_tls_channel_binding_type_get_type()) }
4173    }
4174}
4175
4176#[cfg(feature = "v2_66")]
4177#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4178impl glib::HasParamSpec for TlsChannelBindingType {
4179    type ParamSpec = glib::ParamSpecEnum;
4180    type SetValue = Self;
4181    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4182
4183    fn param_spec_builder() -> Self::BuilderFn {
4184        Self::ParamSpec::builder_with_default
4185    }
4186}
4187
4188#[cfg(feature = "v2_66")]
4189#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4190impl glib::value::ValueType for TlsChannelBindingType {
4191    type Type = Self;
4192}
4193
4194#[cfg(feature = "v2_66")]
4195#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4196unsafe impl<'a> glib::value::FromValue<'a> for TlsChannelBindingType {
4197    type Checker = glib::value::GenericValueTypeChecker<Self>;
4198
4199    #[inline]
4200    unsafe fn from_value(value: &'a glib::Value) -> Self {
4201        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4202    }
4203}
4204
4205#[cfg(feature = "v2_66")]
4206#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4207impl ToValue for TlsChannelBindingType {
4208    #[inline]
4209    fn to_value(&self) -> glib::Value {
4210        let mut value = glib::Value::for_value_type::<Self>();
4211        unsafe {
4212            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4213        }
4214        value
4215    }
4216
4217    #[inline]
4218    fn value_type(&self) -> glib::Type {
4219        Self::static_type()
4220    }
4221}
4222
4223#[cfg(feature = "v2_66")]
4224#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4225impl From<TlsChannelBindingType> for glib::Value {
4226    #[inline]
4227    fn from(v: TlsChannelBindingType) -> Self {
4228        ToValue::to_value(&v)
4229    }
4230}
4231
4232#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4233#[non_exhaustive]
4234#[doc(alias = "GTlsError")]
4235pub enum TlsError {
4236    #[doc(alias = "G_TLS_ERROR_UNAVAILABLE")]
4237    Unavailable,
4238    #[doc(alias = "G_TLS_ERROR_MISC")]
4239    Misc,
4240    #[doc(alias = "G_TLS_ERROR_BAD_CERTIFICATE")]
4241    BadCertificate,
4242    #[doc(alias = "G_TLS_ERROR_NOT_TLS")]
4243    NotTls,
4244    #[doc(alias = "G_TLS_ERROR_HANDSHAKE")]
4245    Handshake,
4246    #[doc(alias = "G_TLS_ERROR_CERTIFICATE_REQUIRED")]
4247    CertificateRequired,
4248    #[doc(alias = "G_TLS_ERROR_EOF")]
4249    Eof,
4250    #[doc(alias = "G_TLS_ERROR_INAPPROPRIATE_FALLBACK")]
4251    InappropriateFallback,
4252    #[cfg(feature = "v2_72")]
4253    #[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
4254    #[doc(alias = "G_TLS_ERROR_BAD_CERTIFICATE_PASSWORD")]
4255    BadCertificatePassword,
4256    #[doc(hidden)]
4257    __Unknown(i32),
4258}
4259
4260#[doc(hidden)]
4261impl IntoGlib for TlsError {
4262    type GlibType = ffi::GTlsError;
4263
4264    #[inline]
4265    fn into_glib(self) -> ffi::GTlsError {
4266        match self {
4267            Self::Unavailable => ffi::G_TLS_ERROR_UNAVAILABLE,
4268            Self::Misc => ffi::G_TLS_ERROR_MISC,
4269            Self::BadCertificate => ffi::G_TLS_ERROR_BAD_CERTIFICATE,
4270            Self::NotTls => ffi::G_TLS_ERROR_NOT_TLS,
4271            Self::Handshake => ffi::G_TLS_ERROR_HANDSHAKE,
4272            Self::CertificateRequired => ffi::G_TLS_ERROR_CERTIFICATE_REQUIRED,
4273            Self::Eof => ffi::G_TLS_ERROR_EOF,
4274            Self::InappropriateFallback => ffi::G_TLS_ERROR_INAPPROPRIATE_FALLBACK,
4275            #[cfg(feature = "v2_72")]
4276            Self::BadCertificatePassword => ffi::G_TLS_ERROR_BAD_CERTIFICATE_PASSWORD,
4277            Self::__Unknown(value) => value,
4278        }
4279    }
4280}
4281
4282#[doc(hidden)]
4283impl FromGlib<ffi::GTlsError> for TlsError {
4284    #[inline]
4285    unsafe fn from_glib(value: ffi::GTlsError) -> Self {
4286        match value {
4287            ffi::G_TLS_ERROR_UNAVAILABLE => Self::Unavailable,
4288            ffi::G_TLS_ERROR_MISC => Self::Misc,
4289            ffi::G_TLS_ERROR_BAD_CERTIFICATE => Self::BadCertificate,
4290            ffi::G_TLS_ERROR_NOT_TLS => Self::NotTls,
4291            ffi::G_TLS_ERROR_HANDSHAKE => Self::Handshake,
4292            ffi::G_TLS_ERROR_CERTIFICATE_REQUIRED => Self::CertificateRequired,
4293            ffi::G_TLS_ERROR_EOF => Self::Eof,
4294            ffi::G_TLS_ERROR_INAPPROPRIATE_FALLBACK => Self::InappropriateFallback,
4295            #[cfg(feature = "v2_72")]
4296            ffi::G_TLS_ERROR_BAD_CERTIFICATE_PASSWORD => Self::BadCertificatePassword,
4297            value => Self::__Unknown(value),
4298        }
4299    }
4300}
4301
4302impl glib::error::ErrorDomain for TlsError {
4303    #[inline]
4304    fn domain() -> glib::Quark {
4305        unsafe { from_glib(ffi::g_tls_error_quark()) }
4306    }
4307
4308    #[inline]
4309    fn code(self) -> i32 {
4310        self.into_glib()
4311    }
4312
4313    #[inline]
4314    #[allow(clippy::match_single_binding)]
4315    fn from(code: i32) -> Option<Self> {
4316        match unsafe { from_glib(code) } {
4317            value => Some(value),
4318        }
4319    }
4320}
4321
4322impl StaticType for TlsError {
4323    #[inline]
4324    #[doc(alias = "g_tls_error_get_type")]
4325    fn static_type() -> glib::Type {
4326        unsafe { from_glib(ffi::g_tls_error_get_type()) }
4327    }
4328}
4329
4330impl glib::HasParamSpec for TlsError {
4331    type ParamSpec = glib::ParamSpecEnum;
4332    type SetValue = Self;
4333    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4334
4335    fn param_spec_builder() -> Self::BuilderFn {
4336        Self::ParamSpec::builder_with_default
4337    }
4338}
4339
4340impl glib::value::ValueType for TlsError {
4341    type Type = Self;
4342}
4343
4344unsafe impl<'a> glib::value::FromValue<'a> for TlsError {
4345    type Checker = glib::value::GenericValueTypeChecker<Self>;
4346
4347    #[inline]
4348    unsafe fn from_value(value: &'a glib::Value) -> Self {
4349        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4350    }
4351}
4352
4353impl ToValue for TlsError {
4354    #[inline]
4355    fn to_value(&self) -> glib::Value {
4356        let mut value = glib::Value::for_value_type::<Self>();
4357        unsafe {
4358            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4359        }
4360        value
4361    }
4362
4363    #[inline]
4364    fn value_type(&self) -> glib::Type {
4365        Self::static_type()
4366    }
4367}
4368
4369impl From<TlsError> for glib::Value {
4370    #[inline]
4371    fn from(v: TlsError) -> Self {
4372        ToValue::to_value(&v)
4373    }
4374}
4375
4376#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4377#[non_exhaustive]
4378#[doc(alias = "GTlsInteractionResult")]
4379pub enum TlsInteractionResult {
4380    #[doc(alias = "G_TLS_INTERACTION_UNHANDLED")]
4381    Unhandled,
4382    #[doc(alias = "G_TLS_INTERACTION_HANDLED")]
4383    Handled,
4384    #[doc(alias = "G_TLS_INTERACTION_FAILED")]
4385    Failed,
4386    #[doc(hidden)]
4387    __Unknown(i32),
4388}
4389
4390#[doc(hidden)]
4391impl IntoGlib for TlsInteractionResult {
4392    type GlibType = ffi::GTlsInteractionResult;
4393
4394    #[inline]
4395    fn into_glib(self) -> ffi::GTlsInteractionResult {
4396        match self {
4397            Self::Unhandled => ffi::G_TLS_INTERACTION_UNHANDLED,
4398            Self::Handled => ffi::G_TLS_INTERACTION_HANDLED,
4399            Self::Failed => ffi::G_TLS_INTERACTION_FAILED,
4400            Self::__Unknown(value) => value,
4401        }
4402    }
4403}
4404
4405#[doc(hidden)]
4406impl FromGlib<ffi::GTlsInteractionResult> for TlsInteractionResult {
4407    #[inline]
4408    unsafe fn from_glib(value: ffi::GTlsInteractionResult) -> Self {
4409        match value {
4410            ffi::G_TLS_INTERACTION_UNHANDLED => Self::Unhandled,
4411            ffi::G_TLS_INTERACTION_HANDLED => Self::Handled,
4412            ffi::G_TLS_INTERACTION_FAILED => Self::Failed,
4413            value => Self::__Unknown(value),
4414        }
4415    }
4416}
4417
4418impl StaticType for TlsInteractionResult {
4419    #[inline]
4420    #[doc(alias = "g_tls_interaction_result_get_type")]
4421    fn static_type() -> glib::Type {
4422        unsafe { from_glib(ffi::g_tls_interaction_result_get_type()) }
4423    }
4424}
4425
4426impl glib::HasParamSpec for TlsInteractionResult {
4427    type ParamSpec = glib::ParamSpecEnum;
4428    type SetValue = Self;
4429    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4430
4431    fn param_spec_builder() -> Self::BuilderFn {
4432        Self::ParamSpec::builder_with_default
4433    }
4434}
4435
4436impl glib::value::ValueType for TlsInteractionResult {
4437    type Type = Self;
4438}
4439
4440unsafe impl<'a> glib::value::FromValue<'a> for TlsInteractionResult {
4441    type Checker = glib::value::GenericValueTypeChecker<Self>;
4442
4443    #[inline]
4444    unsafe fn from_value(value: &'a glib::Value) -> Self {
4445        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4446    }
4447}
4448
4449impl ToValue for TlsInteractionResult {
4450    #[inline]
4451    fn to_value(&self) -> glib::Value {
4452        let mut value = glib::Value::for_value_type::<Self>();
4453        unsafe {
4454            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4455        }
4456        value
4457    }
4458
4459    #[inline]
4460    fn value_type(&self) -> glib::Type {
4461        Self::static_type()
4462    }
4463}
4464
4465impl From<TlsInteractionResult> for glib::Value {
4466    #[inline]
4467    fn from(v: TlsInteractionResult) -> Self {
4468        ToValue::to_value(&v)
4469    }
4470}
4471
4472#[cfg(feature = "v2_70")]
4473#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
4474#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4475#[non_exhaustive]
4476#[doc(alias = "GTlsProtocolVersion")]
4477pub enum TlsProtocolVersion {
4478    #[doc(alias = "G_TLS_PROTOCOL_VERSION_UNKNOWN")]
4479    Unknown,
4480    #[doc(alias = "G_TLS_PROTOCOL_VERSION_SSL_3_0")]
4481    Ssl30,
4482    #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_0")]
4483    Tls10,
4484    #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_1")]
4485    Tls11,
4486    #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_2")]
4487    Tls12,
4488    #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_3")]
4489    Tls13,
4490    #[doc(alias = "G_TLS_PROTOCOL_VERSION_DTLS_1_0")]
4491    Dtls10,
4492    #[doc(alias = "G_TLS_PROTOCOL_VERSION_DTLS_1_2")]
4493    Dtls12,
4494    #[doc(hidden)]
4495    __Unknown(i32),
4496}
4497
4498#[cfg(feature = "v2_70")]
4499#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
4500#[doc(hidden)]
4501impl IntoGlib for TlsProtocolVersion {
4502    type GlibType = ffi::GTlsProtocolVersion;
4503
4504    #[inline]
4505    fn into_glib(self) -> ffi::GTlsProtocolVersion {
4506        match self {
4507            Self::Unknown => ffi::G_TLS_PROTOCOL_VERSION_UNKNOWN,
4508            Self::Ssl30 => ffi::G_TLS_PROTOCOL_VERSION_SSL_3_0,
4509            Self::Tls10 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_0,
4510            Self::Tls11 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_1,
4511            Self::Tls12 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_2,
4512            Self::Tls13 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_3,
4513            Self::Dtls10 => ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_0,
4514            Self::Dtls12 => ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_2,
4515            Self::__Unknown(value) => value,
4516        }
4517    }
4518}
4519
4520#[cfg(feature = "v2_70")]
4521#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
4522#[doc(hidden)]
4523impl FromGlib<ffi::GTlsProtocolVersion> for TlsProtocolVersion {
4524    #[inline]
4525    unsafe fn from_glib(value: ffi::GTlsProtocolVersion) -> Self {
4526        match value {
4527            ffi::G_TLS_PROTOCOL_VERSION_UNKNOWN => Self::Unknown,
4528            ffi::G_TLS_PROTOCOL_VERSION_SSL_3_0 => Self::Ssl30,
4529            ffi::G_TLS_PROTOCOL_VERSION_TLS_1_0 => Self::Tls10,
4530            ffi::G_TLS_PROTOCOL_VERSION_TLS_1_1 => Self::Tls11,
4531            ffi::G_TLS_PROTOCOL_VERSION_TLS_1_2 => Self::Tls12,
4532            ffi::G_TLS_PROTOCOL_VERSION_TLS_1_3 => Self::Tls13,
4533            ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_0 => Self::Dtls10,
4534            ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_2 => Self::Dtls12,
4535            value => Self::__Unknown(value),
4536        }
4537    }
4538}
4539
4540#[cfg(feature = "v2_70")]
4541#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
4542impl StaticType for TlsProtocolVersion {
4543    #[inline]
4544    #[doc(alias = "g_tls_protocol_version_get_type")]
4545    fn static_type() -> glib::Type {
4546        unsafe { from_glib(ffi::g_tls_protocol_version_get_type()) }
4547    }
4548}
4549
4550#[cfg(feature = "v2_70")]
4551#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
4552impl glib::HasParamSpec for TlsProtocolVersion {
4553    type ParamSpec = glib::ParamSpecEnum;
4554    type SetValue = Self;
4555    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4556
4557    fn param_spec_builder() -> Self::BuilderFn {
4558        Self::ParamSpec::builder_with_default
4559    }
4560}
4561
4562#[cfg(feature = "v2_70")]
4563#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
4564impl glib::value::ValueType for TlsProtocolVersion {
4565    type Type = Self;
4566}
4567
4568#[cfg(feature = "v2_70")]
4569#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
4570unsafe impl<'a> glib::value::FromValue<'a> for TlsProtocolVersion {
4571    type Checker = glib::value::GenericValueTypeChecker<Self>;
4572
4573    #[inline]
4574    unsafe fn from_value(value: &'a glib::Value) -> Self {
4575        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4576    }
4577}
4578
4579#[cfg(feature = "v2_70")]
4580#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
4581impl ToValue for TlsProtocolVersion {
4582    #[inline]
4583    fn to_value(&self) -> glib::Value {
4584        let mut value = glib::Value::for_value_type::<Self>();
4585        unsafe {
4586            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4587        }
4588        value
4589    }
4590
4591    #[inline]
4592    fn value_type(&self) -> glib::Type {
4593        Self::static_type()
4594    }
4595}
4596
4597#[cfg(feature = "v2_70")]
4598#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
4599impl From<TlsProtocolVersion> for glib::Value {
4600    #[inline]
4601    fn from(v: TlsProtocolVersion) -> Self {
4602        ToValue::to_value(&v)
4603    }
4604}
4605
4606#[cfg_attr(feature = "v2_60", deprecated = "Since 2.60")]
4607#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4608#[non_exhaustive]
4609#[doc(alias = "GTlsRehandshakeMode")]
4610pub enum TlsRehandshakeMode {
4611    #[doc(alias = "G_TLS_REHANDSHAKE_NEVER")]
4612    Never,
4613    #[doc(alias = "G_TLS_REHANDSHAKE_SAFELY")]
4614    Safely,
4615    #[doc(alias = "G_TLS_REHANDSHAKE_UNSAFELY")]
4616    Unsafely,
4617    #[doc(hidden)]
4618    __Unknown(i32),
4619}
4620
4621#[allow(deprecated)]
4622#[doc(hidden)]
4623impl IntoGlib for TlsRehandshakeMode {
4624    type GlibType = ffi::GTlsRehandshakeMode;
4625
4626    #[inline]
4627    fn into_glib(self) -> ffi::GTlsRehandshakeMode {
4628        match self {
4629            Self::Never => ffi::G_TLS_REHANDSHAKE_NEVER,
4630            Self::Safely => ffi::G_TLS_REHANDSHAKE_SAFELY,
4631            Self::Unsafely => ffi::G_TLS_REHANDSHAKE_UNSAFELY,
4632            Self::__Unknown(value) => value,
4633        }
4634    }
4635}
4636
4637#[allow(deprecated)]
4638#[doc(hidden)]
4639impl FromGlib<ffi::GTlsRehandshakeMode> for TlsRehandshakeMode {
4640    #[inline]
4641    unsafe fn from_glib(value: ffi::GTlsRehandshakeMode) -> Self {
4642        match value {
4643            ffi::G_TLS_REHANDSHAKE_NEVER => Self::Never,
4644            ffi::G_TLS_REHANDSHAKE_SAFELY => Self::Safely,
4645            ffi::G_TLS_REHANDSHAKE_UNSAFELY => Self::Unsafely,
4646            value => Self::__Unknown(value),
4647        }
4648    }
4649}
4650
4651#[allow(deprecated)]
4652impl StaticType for TlsRehandshakeMode {
4653    #[inline]
4654    #[doc(alias = "g_tls_rehandshake_mode_get_type")]
4655    fn static_type() -> glib::Type {
4656        unsafe { from_glib(ffi::g_tls_rehandshake_mode_get_type()) }
4657    }
4658}
4659
4660#[allow(deprecated)]
4661impl glib::HasParamSpec for TlsRehandshakeMode {
4662    type ParamSpec = glib::ParamSpecEnum;
4663    type SetValue = Self;
4664    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4665
4666    fn param_spec_builder() -> Self::BuilderFn {
4667        Self::ParamSpec::builder_with_default
4668    }
4669}
4670
4671#[allow(deprecated)]
4672impl glib::value::ValueType for TlsRehandshakeMode {
4673    type Type = Self;
4674}
4675
4676#[allow(deprecated)]
4677unsafe impl<'a> glib::value::FromValue<'a> for TlsRehandshakeMode {
4678    type Checker = glib::value::GenericValueTypeChecker<Self>;
4679
4680    #[inline]
4681    unsafe fn from_value(value: &'a glib::Value) -> Self {
4682        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4683    }
4684}
4685
4686#[allow(deprecated)]
4687impl ToValue for TlsRehandshakeMode {
4688    #[inline]
4689    fn to_value(&self) -> glib::Value {
4690        let mut value = glib::Value::for_value_type::<Self>();
4691        unsafe {
4692            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4693        }
4694        value
4695    }
4696
4697    #[inline]
4698    fn value_type(&self) -> glib::Type {
4699        Self::static_type()
4700    }
4701}
4702
4703#[allow(deprecated)]
4704impl From<TlsRehandshakeMode> for glib::Value {
4705    #[inline]
4706    fn from(v: TlsRehandshakeMode) -> Self {
4707        ToValue::to_value(&v)
4708    }
4709}
4710
4711#[cfg(unix)]
4712#[cfg_attr(docsrs, doc(cfg(unix)))]
4713#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4714#[non_exhaustive]
4715#[doc(alias = "GUnixSocketAddressType")]
4716pub enum UnixSocketAddressType {
4717    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_INVALID")]
4718    Invalid,
4719    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_ANONYMOUS")]
4720    Anonymous,
4721    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_PATH")]
4722    Path,
4723    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_ABSTRACT")]
4724    Abstract,
4725    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED")]
4726    AbstractPadded,
4727    #[doc(hidden)]
4728    __Unknown(i32),
4729}
4730
4731#[cfg(unix)]
4732#[doc(hidden)]
4733impl IntoGlib for UnixSocketAddressType {
4734    type GlibType = ffi::GUnixSocketAddressType;
4735
4736    #[inline]
4737    fn into_glib(self) -> ffi::GUnixSocketAddressType {
4738        match self {
4739            Self::Invalid => ffi::G_UNIX_SOCKET_ADDRESS_INVALID,
4740            Self::Anonymous => ffi::G_UNIX_SOCKET_ADDRESS_ANONYMOUS,
4741            Self::Path => ffi::G_UNIX_SOCKET_ADDRESS_PATH,
4742            Self::Abstract => ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT,
4743            Self::AbstractPadded => ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED,
4744            Self::__Unknown(value) => value,
4745        }
4746    }
4747}
4748
4749#[cfg(unix)]
4750#[doc(hidden)]
4751impl FromGlib<ffi::GUnixSocketAddressType> for UnixSocketAddressType {
4752    #[inline]
4753    unsafe fn from_glib(value: ffi::GUnixSocketAddressType) -> Self {
4754        match value {
4755            ffi::G_UNIX_SOCKET_ADDRESS_INVALID => Self::Invalid,
4756            ffi::G_UNIX_SOCKET_ADDRESS_ANONYMOUS => Self::Anonymous,
4757            ffi::G_UNIX_SOCKET_ADDRESS_PATH => Self::Path,
4758            ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT => Self::Abstract,
4759            ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED => Self::AbstractPadded,
4760            value => Self::__Unknown(value),
4761        }
4762    }
4763}
4764
4765#[cfg(unix)]
4766impl StaticType for UnixSocketAddressType {
4767    #[inline]
4768    #[doc(alias = "g_unix_socket_address_type_get_type")]
4769    fn static_type() -> glib::Type {
4770        unsafe { from_glib(ffi::g_unix_socket_address_type_get_type()) }
4771    }
4772}
4773
4774#[cfg(unix)]
4775impl glib::HasParamSpec for UnixSocketAddressType {
4776    type ParamSpec = glib::ParamSpecEnum;
4777    type SetValue = Self;
4778    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4779
4780    fn param_spec_builder() -> Self::BuilderFn {
4781        Self::ParamSpec::builder_with_default
4782    }
4783}
4784
4785#[cfg(unix)]
4786impl glib::value::ValueType for UnixSocketAddressType {
4787    type Type = Self;
4788}
4789
4790#[cfg(unix)]
4791unsafe impl<'a> glib::value::FromValue<'a> for UnixSocketAddressType {
4792    type Checker = glib::value::GenericValueTypeChecker<Self>;
4793
4794    #[inline]
4795    unsafe fn from_value(value: &'a glib::Value) -> Self {
4796        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4797    }
4798}
4799
4800#[cfg(unix)]
4801impl ToValue for UnixSocketAddressType {
4802    #[inline]
4803    fn to_value(&self) -> glib::Value {
4804        let mut value = glib::Value::for_value_type::<Self>();
4805        unsafe {
4806            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4807        }
4808        value
4809    }
4810
4811    #[inline]
4812    fn value_type(&self) -> glib::Type {
4813        Self::static_type()
4814    }
4815}
4816
4817#[cfg(unix)]
4818impl From<UnixSocketAddressType> for glib::Value {
4819    #[inline]
4820    fn from(v: UnixSocketAddressType) -> Self {
4821        ToValue::to_value(&v)
4822    }
4823}
4824
4825#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4826#[non_exhaustive]
4827#[doc(alias = "GZlibCompressorFormat")]
4828pub enum ZlibCompressorFormat {
4829    #[doc(alias = "G_ZLIB_COMPRESSOR_FORMAT_ZLIB")]
4830    Zlib,
4831    #[doc(alias = "G_ZLIB_COMPRESSOR_FORMAT_GZIP")]
4832    Gzip,
4833    #[doc(alias = "G_ZLIB_COMPRESSOR_FORMAT_RAW")]
4834    Raw,
4835    #[doc(hidden)]
4836    __Unknown(i32),
4837}
4838
4839#[doc(hidden)]
4840impl IntoGlib for ZlibCompressorFormat {
4841    type GlibType = ffi::GZlibCompressorFormat;
4842
4843    #[inline]
4844    fn into_glib(self) -> ffi::GZlibCompressorFormat {
4845        match self {
4846            Self::Zlib => ffi::G_ZLIB_COMPRESSOR_FORMAT_ZLIB,
4847            Self::Gzip => ffi::G_ZLIB_COMPRESSOR_FORMAT_GZIP,
4848            Self::Raw => ffi::G_ZLIB_COMPRESSOR_FORMAT_RAW,
4849            Self::__Unknown(value) => value,
4850        }
4851    }
4852}
4853
4854#[doc(hidden)]
4855impl FromGlib<ffi::GZlibCompressorFormat> for ZlibCompressorFormat {
4856    #[inline]
4857    unsafe fn from_glib(value: ffi::GZlibCompressorFormat) -> Self {
4858        match value {
4859            ffi::G_ZLIB_COMPRESSOR_FORMAT_ZLIB => Self::Zlib,
4860            ffi::G_ZLIB_COMPRESSOR_FORMAT_GZIP => Self::Gzip,
4861            ffi::G_ZLIB_COMPRESSOR_FORMAT_RAW => Self::Raw,
4862            value => Self::__Unknown(value),
4863        }
4864    }
4865}
4866
4867impl StaticType for ZlibCompressorFormat {
4868    #[inline]
4869    #[doc(alias = "g_zlib_compressor_format_get_type")]
4870    fn static_type() -> glib::Type {
4871        unsafe { from_glib(ffi::g_zlib_compressor_format_get_type()) }
4872    }
4873}
4874
4875impl glib::HasParamSpec for ZlibCompressorFormat {
4876    type ParamSpec = glib::ParamSpecEnum;
4877    type SetValue = Self;
4878    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4879
4880    fn param_spec_builder() -> Self::BuilderFn {
4881        Self::ParamSpec::builder_with_default
4882    }
4883}
4884
4885impl glib::value::ValueType for ZlibCompressorFormat {
4886    type Type = Self;
4887}
4888
4889unsafe impl<'a> glib::value::FromValue<'a> for ZlibCompressorFormat {
4890    type Checker = glib::value::GenericValueTypeChecker<Self>;
4891
4892    #[inline]
4893    unsafe fn from_value(value: &'a glib::Value) -> Self {
4894        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4895    }
4896}
4897
4898impl ToValue for ZlibCompressorFormat {
4899    #[inline]
4900    fn to_value(&self) -> glib::Value {
4901        let mut value = glib::Value::for_value_type::<Self>();
4902        unsafe {
4903            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4904        }
4905        value
4906    }
4907
4908    #[inline]
4909    fn value_type(&self) -> glib::Type {
4910        Self::static_type()
4911    }
4912}
4913
4914impl From<ZlibCompressorFormat> for glib::Value {
4915    #[inline]
4916    fn from(v: ZlibCompressorFormat) -> Self {
4917        ToValue::to_value(&v)
4918    }
4919}