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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsAgreementKind")]
pub enum AgreementKind {
    #[doc(alias = "AS_AGREEMENT_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_AGREEMENT_KIND_GENERIC")]
    Generic,
    #[doc(alias = "AS_AGREEMENT_KIND_EULA")]
    Eula,
    #[doc(alias = "AS_AGREEMENT_KIND_PRIVACY")]
    Privacy,
    #[doc(hidden)]
    __Unknown(i32),
}

impl AgreementKind {
    #[doc(alias = "as_agreement_kind_from_string")]
    pub fn from_string(value: &str) -> AgreementKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_agreement_kind_from_string(value.to_glib_none().0)) }
    }

    #[doc(alias = "as_agreement_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_agreement_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsAgreementKind {
        match self {
            Self::Unknown => ffi::AS_AGREEMENT_KIND_UNKNOWN,
            Self::Generic => ffi::AS_AGREEMENT_KIND_GENERIC,
            Self::Eula => ffi::AS_AGREEMENT_KIND_EULA,
            Self::Privacy => ffi::AS_AGREEMENT_KIND_PRIVACY,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsAgreementKind> for AgreementKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsAgreementKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_AGREEMENT_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_AGREEMENT_KIND_GENERIC => Self::Generic,
            ffi::AS_AGREEMENT_KIND_EULA => Self::Eula,
            ffi::AS_AGREEMENT_KIND_PRIVACY => Self::Privacy,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsArtifactKind")]
pub enum ArtifactKind {
    #[doc(alias = "AS_ARTIFACT_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_ARTIFACT_KIND_SOURCE")]
    Source,
    #[doc(alias = "AS_ARTIFACT_KIND_BINARY")]
    Binary,
    #[doc(hidden)]
    __Unknown(i32),
}

impl ArtifactKind {
    #[doc(alias = "as_artifact_kind_from_string")]
    pub fn from_string(kind: &str) -> ArtifactKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_artifact_kind_from_string(kind.to_glib_none().0)) }
    }

    #[doc(alias = "as_artifact_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_artifact_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsArtifactKind {
        match self {
            Self::Unknown => ffi::AS_ARTIFACT_KIND_UNKNOWN,
            Self::Source => ffi::AS_ARTIFACT_KIND_SOURCE,
            Self::Binary => ffi::AS_ARTIFACT_KIND_BINARY,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsArtifactKind> for ArtifactKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsArtifactKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_ARTIFACT_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_ARTIFACT_KIND_SOURCE => Self::Source,
            ffi::AS_ARTIFACT_KIND_BINARY => Self::Binary,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsBundleKind")]
pub enum BundleKind {
    #[doc(alias = "AS_BUNDLE_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_BUNDLE_KIND_PACKAGE")]
    Package,
    #[doc(alias = "AS_BUNDLE_KIND_LIMBA")]
    Limba,
    #[doc(alias = "AS_BUNDLE_KIND_FLATPAK")]
    Flatpak,
    #[doc(alias = "AS_BUNDLE_KIND_APPIMAGE")]
    Appimage,
    #[doc(alias = "AS_BUNDLE_KIND_SNAP")]
    Snap,
    #[doc(alias = "AS_BUNDLE_KIND_TARBALL")]
    Tarball,
    #[doc(alias = "AS_BUNDLE_KIND_CABINET")]
    Cabinet,
    #[doc(alias = "AS_BUNDLE_KIND_LINGLONG")]
    Linglong,
    #[doc(hidden)]
    __Unknown(i32),
}

impl BundleKind {
    #[doc(alias = "as_bundle_kind_from_string")]
    pub fn from_string(bundle_str: &str) -> BundleKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_bundle_kind_from_string(bundle_str.to_glib_none().0)) }
    }

    #[doc(alias = "as_bundle_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_bundle_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsBundleKind {
        match self {
            Self::Unknown => ffi::AS_BUNDLE_KIND_UNKNOWN,
            Self::Package => ffi::AS_BUNDLE_KIND_PACKAGE,
            Self::Limba => ffi::AS_BUNDLE_KIND_LIMBA,
            Self::Flatpak => ffi::AS_BUNDLE_KIND_FLATPAK,
            Self::Appimage => ffi::AS_BUNDLE_KIND_APPIMAGE,
            Self::Snap => ffi::AS_BUNDLE_KIND_SNAP,
            Self::Tarball => ffi::AS_BUNDLE_KIND_TARBALL,
            Self::Cabinet => ffi::AS_BUNDLE_KIND_CABINET,
            Self::Linglong => ffi::AS_BUNDLE_KIND_LINGLONG,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsBundleKind> for BundleKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsBundleKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_BUNDLE_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_BUNDLE_KIND_PACKAGE => Self::Package,
            ffi::AS_BUNDLE_KIND_LIMBA => Self::Limba,
            ffi::AS_BUNDLE_KIND_FLATPAK => Self::Flatpak,
            ffi::AS_BUNDLE_KIND_APPIMAGE => Self::Appimage,
            ffi::AS_BUNDLE_KIND_SNAP => Self::Snap,
            ffi::AS_BUNDLE_KIND_TARBALL => Self::Tarball,
            ffi::AS_BUNDLE_KIND_CABINET => Self::Cabinet,
            ffi::AS_BUNDLE_KIND_LINGLONG => Self::Linglong,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsChecksumKind")]
pub enum ChecksumKind {
    #[doc(alias = "AS_CHECKSUM_KIND_NONE")]
    None,
    #[doc(alias = "AS_CHECKSUM_KIND_SHA1")]
    Sha1,
    #[doc(alias = "AS_CHECKSUM_KIND_SHA256")]
    Sha256,
    #[doc(alias = "AS_CHECKSUM_KIND_SHA512")]
    Sha512,
    #[doc(alias = "AS_CHECKSUM_KIND_BLAKE2B")]
    Blake2b,
    #[doc(alias = "AS_CHECKSUM_KIND_BLAKE3")]
    Blake3,
    #[doc(hidden)]
    __Unknown(i32),
}

impl ChecksumKind {
    #[doc(alias = "as_checksum_kind_from_string")]
    pub fn from_string(kind_str: &str) -> ChecksumKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_checksum_kind_from_string(kind_str.to_glib_none().0)) }
    }

    #[doc(alias = "as_checksum_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_checksum_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsChecksumKind {
        match self {
            Self::None => ffi::AS_CHECKSUM_KIND_NONE,
            Self::Sha1 => ffi::AS_CHECKSUM_KIND_SHA1,
            Self::Sha256 => ffi::AS_CHECKSUM_KIND_SHA256,
            Self::Sha512 => ffi::AS_CHECKSUM_KIND_SHA512,
            Self::Blake2b => ffi::AS_CHECKSUM_KIND_BLAKE2B,
            Self::Blake3 => ffi::AS_CHECKSUM_KIND_BLAKE3,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsChecksumKind> for ChecksumKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsChecksumKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_CHECKSUM_KIND_NONE => Self::None,
            ffi::AS_CHECKSUM_KIND_SHA1 => Self::Sha1,
            ffi::AS_CHECKSUM_KIND_SHA256 => Self::Sha256,
            ffi::AS_CHECKSUM_KIND_SHA512 => Self::Sha512,
            ffi::AS_CHECKSUM_KIND_BLAKE2B => Self::Blake2b,
            ffi::AS_CHECKSUM_KIND_BLAKE3 => Self::Blake3,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsColorKind")]
pub enum ColorKind {
    #[doc(alias = "AS_COLOR_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_COLOR_KIND_PRIMARY")]
    Primary,
    #[doc(hidden)]
    __Unknown(i32),
}

impl ColorKind {
    #[doc(alias = "as_color_kind_from_string")]
    pub fn from_string(str: &str) -> ColorKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_color_kind_from_string(str.to_glib_none().0)) }
    }

    #[doc(alias = "as_color_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_color_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsColorKind {
        match self {
            Self::Unknown => ffi::AS_COLOR_KIND_UNKNOWN,
            Self::Primary => ffi::AS_COLOR_KIND_PRIMARY,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsColorKind> for ColorKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsColorKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_COLOR_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_COLOR_KIND_PRIMARY => Self::Primary,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsColorSchemeKind")]
pub enum ColorSchemeKind {
    #[doc(alias = "AS_COLOR_SCHEME_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_COLOR_SCHEME_KIND_LIGHT")]
    Light,
    #[doc(alias = "AS_COLOR_SCHEME_KIND_DARK")]
    Dark,
    #[doc(hidden)]
    __Unknown(i32),
}

impl ColorSchemeKind {
    #[doc(alias = "as_color_scheme_kind_from_string")]
    pub fn from_string(str: &str) -> ColorSchemeKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_color_scheme_kind_from_string(str.to_glib_none().0)) }
    }

    #[doc(alias = "as_color_scheme_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_color_scheme_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsColorSchemeKind {
        match self {
            Self::Unknown => ffi::AS_COLOR_SCHEME_KIND_UNKNOWN,
            Self::Light => ffi::AS_COLOR_SCHEME_KIND_LIGHT,
            Self::Dark => ffi::AS_COLOR_SCHEME_KIND_DARK,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsColorSchemeKind> for ColorSchemeKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsColorSchemeKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_COLOR_SCHEME_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_COLOR_SCHEME_KIND_LIGHT => Self::Light,
            ffi::AS_COLOR_SCHEME_KIND_DARK => Self::Dark,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsComponentKind")]
pub enum ComponentKind {
    #[doc(alias = "AS_COMPONENT_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_COMPONENT_KIND_GENERIC")]
    Generic,
    #[doc(alias = "AS_COMPONENT_KIND_DESKTOP_APP")]
    DesktopApp,
    #[doc(alias = "AS_COMPONENT_KIND_CONSOLE_APP")]
    ConsoleApp,
    #[doc(alias = "AS_COMPONENT_KIND_WEB_APP")]
    WebApp,
    #[doc(alias = "AS_COMPONENT_KIND_SERVICE")]
    Service,
    #[doc(alias = "AS_COMPONENT_KIND_ADDON")]
    Addon,
    #[doc(alias = "AS_COMPONENT_KIND_RUNTIME")]
    Runtime,
    #[doc(alias = "AS_COMPONENT_KIND_FONT")]
    Font,
    #[doc(alias = "AS_COMPONENT_KIND_CODEC")]
    Codec,
    #[doc(alias = "AS_COMPONENT_KIND_INPUT_METHOD")]
    InputMethod,
    #[doc(alias = "AS_COMPONENT_KIND_OPERATING_SYSTEM")]
    OperatingSystem,
    #[doc(alias = "AS_COMPONENT_KIND_FIRMWARE")]
    Firmware,
    #[doc(alias = "AS_COMPONENT_KIND_DRIVER")]
    Driver,
    #[doc(alias = "AS_COMPONENT_KIND_LOCALIZATION")]
    Localization,
    #[doc(alias = "AS_COMPONENT_KIND_REPOSITORY")]
    Repository,
    #[doc(alias = "AS_COMPONENT_KIND_ICON_THEME")]
    IconTheme,
    #[doc(hidden)]
    __Unknown(i32),
}

impl ComponentKind {
    #[doc(alias = "as_component_kind_from_string")]
    pub fn from_string(kind_str: &str) -> ComponentKind {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::as_component_kind_from_string(
                kind_str.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_component_kind_to_string(self.into_glib())) }
    }
}

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

    fn into_glib(self) -> ffi::AsComponentKind {
        match self {
            Self::Unknown => ffi::AS_COMPONENT_KIND_UNKNOWN,
            Self::Generic => ffi::AS_COMPONENT_KIND_GENERIC,
            Self::DesktopApp => ffi::AS_COMPONENT_KIND_DESKTOP_APP,
            Self::ConsoleApp => ffi::AS_COMPONENT_KIND_CONSOLE_APP,
            Self::WebApp => ffi::AS_COMPONENT_KIND_WEB_APP,
            Self::Service => ffi::AS_COMPONENT_KIND_SERVICE,
            Self::Addon => ffi::AS_COMPONENT_KIND_ADDON,
            Self::Runtime => ffi::AS_COMPONENT_KIND_RUNTIME,
            Self::Font => ffi::AS_COMPONENT_KIND_FONT,
            Self::Codec => ffi::AS_COMPONENT_KIND_CODEC,
            Self::InputMethod => ffi::AS_COMPONENT_KIND_INPUT_METHOD,
            Self::OperatingSystem => ffi::AS_COMPONENT_KIND_OPERATING_SYSTEM,
            Self::Firmware => ffi::AS_COMPONENT_KIND_FIRMWARE,
            Self::Driver => ffi::AS_COMPONENT_KIND_DRIVER,
            Self::Localization => ffi::AS_COMPONENT_KIND_LOCALIZATION,
            Self::Repository => ffi::AS_COMPONENT_KIND_REPOSITORY,
            Self::IconTheme => ffi::AS_COMPONENT_KIND_ICON_THEME,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsComponentKind> for ComponentKind {
    unsafe fn from_glib(value: ffi::AsComponentKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_COMPONENT_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_COMPONENT_KIND_GENERIC => Self::Generic,
            ffi::AS_COMPONENT_KIND_DESKTOP_APP => Self::DesktopApp,
            ffi::AS_COMPONENT_KIND_CONSOLE_APP => Self::ConsoleApp,
            ffi::AS_COMPONENT_KIND_WEB_APP => Self::WebApp,
            ffi::AS_COMPONENT_KIND_SERVICE => Self::Service,
            ffi::AS_COMPONENT_KIND_ADDON => Self::Addon,
            ffi::AS_COMPONENT_KIND_RUNTIME => Self::Runtime,
            ffi::AS_COMPONENT_KIND_FONT => Self::Font,
            ffi::AS_COMPONENT_KIND_CODEC => Self::Codec,
            ffi::AS_COMPONENT_KIND_INPUT_METHOD => Self::InputMethod,
            ffi::AS_COMPONENT_KIND_OPERATING_SYSTEM => Self::OperatingSystem,
            ffi::AS_COMPONENT_KIND_FIRMWARE => Self::Firmware,
            ffi::AS_COMPONENT_KIND_DRIVER => Self::Driver,
            ffi::AS_COMPONENT_KIND_LOCALIZATION => Self::Localization,
            ffi::AS_COMPONENT_KIND_REPOSITORY => Self::Repository,
            ffi::AS_COMPONENT_KIND_ICON_THEME => Self::IconTheme,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsComponentScope")]
pub enum ComponentScope {
    #[doc(alias = "AS_COMPONENT_SCOPE_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_COMPONENT_SCOPE_SYSTEM")]
    System,
    #[doc(alias = "AS_COMPONENT_SCOPE_USER")]
    User,
    #[doc(hidden)]
    __Unknown(i32),
}

impl ComponentScope {
    #[doc(alias = "as_component_scope_from_string")]
    pub fn from_string(scope_str: &str) -> ComponentScope {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::as_component_scope_from_string(
                scope_str.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_scope_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_component_scope_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsComponentScope {
        match self {
            Self::Unknown => ffi::AS_COMPONENT_SCOPE_UNKNOWN,
            Self::System => ffi::AS_COMPONENT_SCOPE_SYSTEM,
            Self::User => ffi::AS_COMPONENT_SCOPE_USER,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsComponentScope> for ComponentScope {
    #[inline]
    unsafe fn from_glib(value: ffi::AsComponentScope) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_COMPONENT_SCOPE_UNKNOWN => Self::Unknown,
            ffi::AS_COMPONENT_SCOPE_SYSTEM => Self::System,
            ffi::AS_COMPONENT_SCOPE_USER => Self::User,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsContentRatingSystem")]
pub enum ContentRatingSystem {
    #[doc(alias = "AS_CONTENT_RATING_SYSTEM_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_CONTENT_RATING_SYSTEM_INCAA")]
    Incaa,
    #[doc(alias = "AS_CONTENT_RATING_SYSTEM_ACB")]
    Acb,
    #[doc(alias = "AS_CONTENT_RATING_SYSTEM_DJCTQ")]
    Djctq,
    #[doc(alias = "AS_CONTENT_RATING_SYSTEM_GSRR")]
    Gsrr,
    #[doc(alias = "AS_CONTENT_RATING_SYSTEM_PEGI")]
    Pegi,
    #[doc(alias = "AS_CONTENT_RATING_SYSTEM_KAVI")]
    Kavi,
    #[doc(alias = "AS_CONTENT_RATING_SYSTEM_USK")]
    Usk,
    #[doc(alias = "AS_CONTENT_RATING_SYSTEM_ESRA")]
    Esra,
    #[doc(alias = "AS_CONTENT_RATING_SYSTEM_CERO")]
    Cero,
    #[doc(alias = "AS_CONTENT_RATING_SYSTEM_OFLCNZ")]
    Oflcnz,
    #[doc(alias = "AS_CONTENT_RATING_SYSTEM_RUSSIA")]
    Russia,
    #[doc(alias = "AS_CONTENT_RATING_SYSTEM_MDA")]
    Mda,
    #[doc(alias = "AS_CONTENT_RATING_SYSTEM_GRAC")]
    Grac,
    #[doc(alias = "AS_CONTENT_RATING_SYSTEM_ESRB")]
    Esrb,
    #[doc(alias = "AS_CONTENT_RATING_SYSTEM_IARC")]
    Iarc,
    #[doc(hidden)]
    __Unknown(i32),
}

impl ContentRatingSystem {
    #[doc(alias = "as_content_rating_system_format_age")]
    pub fn format_age(self, age: u32) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::as_content_rating_system_format_age(
                self.into_glib(),
                age,
            ))
        }
    }

    #[doc(alias = "as_content_rating_system_from_locale")]
    pub fn from_locale(locale: &str) -> ContentRatingSystem {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::as_content_rating_system_from_locale(
                locale.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_content_rating_system_get_csm_ages")]
    #[doc(alias = "get_csm_ages")]
    pub fn csm_ages(self) -> Vec<u32> {
        assert_initialized_main_thread!();
        unsafe {
            let mut length_out = std::mem::MaybeUninit::uninit();
            let ret = FromGlibContainer::from_glib_container_num(
                ffi::as_content_rating_system_get_csm_ages(
                    self.into_glib(),
                    length_out.as_mut_ptr(),
                ),
                length_out.assume_init() as _,
            );
            ret
        }
    }

    #[doc(alias = "as_content_rating_system_get_formatted_ages")]
    #[doc(alias = "get_formatted_ages")]
    pub fn formatted_ages(self) -> Vec<glib::GString> {
        assert_initialized_main_thread!();
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::as_content_rating_system_get_formatted_ages(
                self.into_glib(),
            ))
        }
    }

    #[doc(alias = "as_content_rating_system_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_content_rating_system_to_string(self.into_glib())) }
    }
}

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

    fn into_glib(self) -> ffi::AsContentRatingSystem {
        match self {
            Self::Unknown => ffi::AS_CONTENT_RATING_SYSTEM_UNKNOWN,
            Self::Incaa => ffi::AS_CONTENT_RATING_SYSTEM_INCAA,
            Self::Acb => ffi::AS_CONTENT_RATING_SYSTEM_ACB,
            Self::Djctq => ffi::AS_CONTENT_RATING_SYSTEM_DJCTQ,
            Self::Gsrr => ffi::AS_CONTENT_RATING_SYSTEM_GSRR,
            Self::Pegi => ffi::AS_CONTENT_RATING_SYSTEM_PEGI,
            Self::Kavi => ffi::AS_CONTENT_RATING_SYSTEM_KAVI,
            Self::Usk => ffi::AS_CONTENT_RATING_SYSTEM_USK,
            Self::Esra => ffi::AS_CONTENT_RATING_SYSTEM_ESRA,
            Self::Cero => ffi::AS_CONTENT_RATING_SYSTEM_CERO,
            Self::Oflcnz => ffi::AS_CONTENT_RATING_SYSTEM_OFLCNZ,
            Self::Russia => ffi::AS_CONTENT_RATING_SYSTEM_RUSSIA,
            Self::Mda => ffi::AS_CONTENT_RATING_SYSTEM_MDA,
            Self::Grac => ffi::AS_CONTENT_RATING_SYSTEM_GRAC,
            Self::Esrb => ffi::AS_CONTENT_RATING_SYSTEM_ESRB,
            Self::Iarc => ffi::AS_CONTENT_RATING_SYSTEM_IARC,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsContentRatingSystem> for ContentRatingSystem {
    unsafe fn from_glib(value: ffi::AsContentRatingSystem) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_CONTENT_RATING_SYSTEM_UNKNOWN => Self::Unknown,
            ffi::AS_CONTENT_RATING_SYSTEM_INCAA => Self::Incaa,
            ffi::AS_CONTENT_RATING_SYSTEM_ACB => Self::Acb,
            ffi::AS_CONTENT_RATING_SYSTEM_DJCTQ => Self::Djctq,
            ffi::AS_CONTENT_RATING_SYSTEM_GSRR => Self::Gsrr,
            ffi::AS_CONTENT_RATING_SYSTEM_PEGI => Self::Pegi,
            ffi::AS_CONTENT_RATING_SYSTEM_KAVI => Self::Kavi,
            ffi::AS_CONTENT_RATING_SYSTEM_USK => Self::Usk,
            ffi::AS_CONTENT_RATING_SYSTEM_ESRA => Self::Esra,
            ffi::AS_CONTENT_RATING_SYSTEM_CERO => Self::Cero,
            ffi::AS_CONTENT_RATING_SYSTEM_OFLCNZ => Self::Oflcnz,
            ffi::AS_CONTENT_RATING_SYSTEM_RUSSIA => Self::Russia,
            ffi::AS_CONTENT_RATING_SYSTEM_MDA => Self::Mda,
            ffi::AS_CONTENT_RATING_SYSTEM_GRAC => Self::Grac,
            ffi::AS_CONTENT_RATING_SYSTEM_ESRB => Self::Esrb,
            ffi::AS_CONTENT_RATING_SYSTEM_IARC => Self::Iarc,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsContentRatingValue")]
pub enum ContentRatingValue {
    #[doc(alias = "AS_CONTENT_RATING_VALUE_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_CONTENT_RATING_VALUE_NONE")]
    None,
    #[doc(alias = "AS_CONTENT_RATING_VALUE_MILD")]
    Mild,
    #[doc(alias = "AS_CONTENT_RATING_VALUE_MODERATE")]
    Moderate,
    #[doc(alias = "AS_CONTENT_RATING_VALUE_INTENSE")]
    Intense,
    #[doc(hidden)]
    __Unknown(i32),
}

impl ContentRatingValue {
    #[doc(alias = "as_content_rating_value_from_string")]
    pub fn from_string(value: &str) -> ContentRatingValue {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::as_content_rating_value_from_string(
                value.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_content_rating_value_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_content_rating_value_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsContentRatingValue {
        match self {
            Self::Unknown => ffi::AS_CONTENT_RATING_VALUE_UNKNOWN,
            Self::None => ffi::AS_CONTENT_RATING_VALUE_NONE,
            Self::Mild => ffi::AS_CONTENT_RATING_VALUE_MILD,
            Self::Moderate => ffi::AS_CONTENT_RATING_VALUE_MODERATE,
            Self::Intense => ffi::AS_CONTENT_RATING_VALUE_INTENSE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsContentRatingValue> for ContentRatingValue {
    #[inline]
    unsafe fn from_glib(value: ffi::AsContentRatingValue) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_CONTENT_RATING_VALUE_UNKNOWN => Self::Unknown,
            ffi::AS_CONTENT_RATING_VALUE_NONE => Self::None,
            ffi::AS_CONTENT_RATING_VALUE_MILD => Self::Mild,
            ffi::AS_CONTENT_RATING_VALUE_MODERATE => Self::Moderate,
            ffi::AS_CONTENT_RATING_VALUE_INTENSE => Self::Intense,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsControlKind")]
pub enum ControlKind {
    #[doc(alias = "AS_CONTROL_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_CONTROL_KIND_POINTING")]
    Pointing,
    #[doc(alias = "AS_CONTROL_KIND_KEYBOARD")]
    Keyboard,
    #[doc(alias = "AS_CONTROL_KIND_CONSOLE")]
    Console,
    #[doc(alias = "AS_CONTROL_KIND_TOUCH")]
    Touch,
    #[doc(alias = "AS_CONTROL_KIND_GAMEPAD")]
    Gamepad,
    #[doc(alias = "AS_CONTROL_KIND_VOICE")]
    Voice,
    #[doc(alias = "AS_CONTROL_KIND_VISION")]
    Vision,
    #[doc(alias = "AS_CONTROL_KIND_TV_REMOTE")]
    TvRemote,
    #[doc(alias = "AS_CONTROL_KIND_TABLET")]
    Tablet,
    #[doc(hidden)]
    __Unknown(i32),
}

impl ControlKind {
    #[doc(alias = "as_control_kind_from_string")]
    pub fn from_string(kind_str: &str) -> ControlKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_control_kind_from_string(kind_str.to_glib_none().0)) }
    }

    #[doc(alias = "as_control_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_control_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsControlKind {
        match self {
            Self::Unknown => ffi::AS_CONTROL_KIND_UNKNOWN,
            Self::Pointing => ffi::AS_CONTROL_KIND_POINTING,
            Self::Keyboard => ffi::AS_CONTROL_KIND_KEYBOARD,
            Self::Console => ffi::AS_CONTROL_KIND_CONSOLE,
            Self::Touch => ffi::AS_CONTROL_KIND_TOUCH,
            Self::Gamepad => ffi::AS_CONTROL_KIND_GAMEPAD,
            Self::Voice => ffi::AS_CONTROL_KIND_VOICE,
            Self::Vision => ffi::AS_CONTROL_KIND_VISION,
            Self::TvRemote => ffi::AS_CONTROL_KIND_TV_REMOTE,
            Self::Tablet => ffi::AS_CONTROL_KIND_TABLET,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsControlKind> for ControlKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsControlKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_CONTROL_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_CONTROL_KIND_POINTING => Self::Pointing,
            ffi::AS_CONTROL_KIND_KEYBOARD => Self::Keyboard,
            ffi::AS_CONTROL_KIND_CONSOLE => Self::Console,
            ffi::AS_CONTROL_KIND_TOUCH => Self::Touch,
            ffi::AS_CONTROL_KIND_GAMEPAD => Self::Gamepad,
            ffi::AS_CONTROL_KIND_VOICE => Self::Voice,
            ffi::AS_CONTROL_KIND_VISION => Self::Vision,
            ffi::AS_CONTROL_KIND_TV_REMOTE => Self::TvRemote,
            ffi::AS_CONTROL_KIND_TABLET => Self::Tablet,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsDisplaySideKind")]
pub enum DisplaySideKind {
    #[doc(alias = "AS_DISPLAY_SIDE_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_DISPLAY_SIDE_KIND_SHORTEST")]
    Shortest,
    #[doc(alias = "AS_DISPLAY_SIDE_KIND_LONGEST")]
    Longest,
    #[doc(hidden)]
    __Unknown(i32),
}

impl DisplaySideKind {
    #[doc(alias = "as_display_side_kind_from_string")]
    pub fn from_string(kind_str: &str) -> DisplaySideKind {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::as_display_side_kind_from_string(
                kind_str.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_display_side_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_display_side_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsDisplaySideKind {
        match self {
            Self::Unknown => ffi::AS_DISPLAY_SIDE_KIND_UNKNOWN,
            Self::Shortest => ffi::AS_DISPLAY_SIDE_KIND_SHORTEST,
            Self::Longest => ffi::AS_DISPLAY_SIDE_KIND_LONGEST,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsDisplaySideKind> for DisplaySideKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsDisplaySideKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_DISPLAY_SIDE_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_DISPLAY_SIDE_KIND_SHORTEST => Self::Shortest,
            ffi::AS_DISPLAY_SIDE_KIND_LONGEST => Self::Longest,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsFormatKind")]
pub enum FormatKind {
    #[doc(alias = "AS_FORMAT_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_FORMAT_KIND_XML")]
    Xml,
    #[doc(alias = "AS_FORMAT_KIND_YAML")]
    Yaml,
    #[doc(alias = "AS_FORMAT_KIND_DESKTOP_ENTRY")]
    DesktopEntry,
    #[doc(hidden)]
    __Unknown(i32),
}

impl FormatKind {
    #[doc(alias = "as_format_kind_from_string")]
    pub fn from_string(kind_str: &str) -> FormatKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_format_kind_from_string(kind_str.to_glib_none().0)) }
    }

    #[doc(alias = "as_format_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_format_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsFormatKind {
        match self {
            Self::Unknown => ffi::AS_FORMAT_KIND_UNKNOWN,
            Self::Xml => ffi::AS_FORMAT_KIND_XML,
            Self::Yaml => ffi::AS_FORMAT_KIND_YAML,
            Self::DesktopEntry => ffi::AS_FORMAT_KIND_DESKTOP_ENTRY,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsFormatKind> for FormatKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsFormatKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_FORMAT_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_FORMAT_KIND_XML => Self::Xml,
            ffi::AS_FORMAT_KIND_YAML => Self::Yaml,
            ffi::AS_FORMAT_KIND_DESKTOP_ENTRY => Self::DesktopEntry,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsFormatStyle")]
pub enum FormatStyle {
    #[doc(alias = "AS_FORMAT_STYLE_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_FORMAT_STYLE_METAINFO")]
    Metainfo,
    #[doc(alias = "AS_FORMAT_STYLE_CATALOG")]
    Catalog,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsFormatStyle {
        match self {
            Self::Unknown => ffi::AS_FORMAT_STYLE_UNKNOWN,
            Self::Metainfo => ffi::AS_FORMAT_STYLE_METAINFO,
            Self::Catalog => ffi::AS_FORMAT_STYLE_CATALOG,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsFormatStyle> for FormatStyle {
    #[inline]
    unsafe fn from_glib(value: ffi::AsFormatStyle) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_FORMAT_STYLE_UNKNOWN => Self::Unknown,
            ffi::AS_FORMAT_STYLE_METAINFO => Self::Metainfo,
            ffi::AS_FORMAT_STYLE_CATALOG => Self::Catalog,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsFormatVersion")]
pub enum FormatVersion {
    #[doc(alias = "AS_FORMAT_VERSION_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_FORMAT_VERSION_V1_0")]
    V10,
    #[doc(hidden)]
    __Unknown(i32),
}

impl FormatVersion {
    #[doc(alias = "as_format_version_from_string")]
    pub fn from_string(version_str: &str) -> FormatVersion {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::as_format_version_from_string(
                version_str.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_format_version_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_format_version_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsFormatVersion {
        match self {
            Self::Unknown => ffi::AS_FORMAT_VERSION_UNKNOWN,
            Self::V10 => ffi::AS_FORMAT_VERSION_V1_0,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsFormatVersion> for FormatVersion {
    #[inline]
    unsafe fn from_glib(value: ffi::AsFormatVersion) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_FORMAT_VERSION_UNKNOWN => Self::Unknown,
            ffi::AS_FORMAT_VERSION_V1_0 => Self::V10,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsIconKind")]
pub enum IconKind {
    #[doc(alias = "AS_ICON_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_ICON_KIND_STOCK")]
    Stock,
    #[doc(alias = "AS_ICON_KIND_CACHED")]
    Cached,
    #[doc(alias = "AS_ICON_KIND_LOCAL")]
    Local,
    #[doc(alias = "AS_ICON_KIND_REMOTE")]
    Remote,
    #[doc(hidden)]
    __Unknown(i32),
}

impl IconKind {
    #[doc(alias = "as_icon_kind_from_string")]
    pub fn from_string(kind_str: &str) -> IconKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_icon_kind_from_string(kind_str.to_glib_none().0)) }
    }

    #[doc(alias = "as_icon_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_icon_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsIconKind {
        match self {
            Self::Unknown => ffi::AS_ICON_KIND_UNKNOWN,
            Self::Stock => ffi::AS_ICON_KIND_STOCK,
            Self::Cached => ffi::AS_ICON_KIND_CACHED,
            Self::Local => ffi::AS_ICON_KIND_LOCAL,
            Self::Remote => ffi::AS_ICON_KIND_REMOTE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsIconKind> for IconKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsIconKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_ICON_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_ICON_KIND_STOCK => Self::Stock,
            ffi::AS_ICON_KIND_CACHED => Self::Cached,
            ffi::AS_ICON_KIND_LOCAL => Self::Local,
            ffi::AS_ICON_KIND_REMOTE => Self::Remote,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsImageKind")]
pub enum ImageKind {
    #[doc(alias = "AS_IMAGE_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_IMAGE_KIND_SOURCE")]
    Source,
    #[doc(alias = "AS_IMAGE_KIND_THUMBNAIL")]
    Thumbnail,
    #[doc(hidden)]
    __Unknown(i32),
}

impl ImageKind {
    #[doc(alias = "as_image_kind_from_string")]
    pub fn from_string(kind: &str) -> ImageKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_image_kind_from_string(kind.to_glib_none().0)) }
    }

    #[doc(alias = "as_image_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_image_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsImageKind {
        match self {
            Self::Unknown => ffi::AS_IMAGE_KIND_UNKNOWN,
            Self::Source => ffi::AS_IMAGE_KIND_SOURCE,
            Self::Thumbnail => ffi::AS_IMAGE_KIND_THUMBNAIL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsImageKind> for ImageKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsImageKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_IMAGE_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_IMAGE_KIND_SOURCE => Self::Source,
            ffi::AS_IMAGE_KIND_THUMBNAIL => Self::Thumbnail,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsIssueKind")]
pub enum IssueKind {
    #[doc(alias = "AS_ISSUE_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_ISSUE_KIND_GENERIC")]
    Generic,
    #[doc(alias = "AS_ISSUE_KIND_CVE")]
    Cve,
    #[doc(hidden)]
    __Unknown(i32),
}

impl IssueKind {
    #[doc(alias = "as_issue_kind_from_string")]
    pub fn from_string(kind_str: &str) -> IssueKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_issue_kind_from_string(kind_str.to_glib_none().0)) }
    }

    #[doc(alias = "as_issue_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_issue_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsIssueKind {
        match self {
            Self::Unknown => ffi::AS_ISSUE_KIND_UNKNOWN,
            Self::Generic => ffi::AS_ISSUE_KIND_GENERIC,
            Self::Cve => ffi::AS_ISSUE_KIND_CVE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsIssueKind> for IssueKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsIssueKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_ISSUE_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_ISSUE_KIND_GENERIC => Self::Generic,
            ffi::AS_ISSUE_KIND_CVE => Self::Cve,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsIssueSeverity")]
pub enum IssueSeverity {
    #[doc(alias = "AS_ISSUE_SEVERITY_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_ISSUE_SEVERITY_PEDANTIC")]
    Pedantic,
    #[doc(alias = "AS_ISSUE_SEVERITY_INFO")]
    Info,
    #[doc(alias = "AS_ISSUE_SEVERITY_WARNING")]
    Warning,
    #[doc(alias = "AS_ISSUE_SEVERITY_ERROR")]
    Error,
    #[doc(hidden)]
    __Unknown(i32),
}

impl IssueSeverity {
    #[doc(alias = "as_issue_severity_from_string")]
    pub fn from_string(str: &str) -> IssueSeverity {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_issue_severity_from_string(str.to_glib_none().0)) }
    }

    #[doc(alias = "as_issue_severity_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_issue_severity_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsIssueSeverity {
        match self {
            Self::Unknown => ffi::AS_ISSUE_SEVERITY_UNKNOWN,
            Self::Pedantic => ffi::AS_ISSUE_SEVERITY_PEDANTIC,
            Self::Info => ffi::AS_ISSUE_SEVERITY_INFO,
            Self::Warning => ffi::AS_ISSUE_SEVERITY_WARNING,
            Self::Error => ffi::AS_ISSUE_SEVERITY_ERROR,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsIssueSeverity> for IssueSeverity {
    #[inline]
    unsafe fn from_glib(value: ffi::AsIssueSeverity) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_ISSUE_SEVERITY_UNKNOWN => Self::Unknown,
            ffi::AS_ISSUE_SEVERITY_PEDANTIC => Self::Pedantic,
            ffi::AS_ISSUE_SEVERITY_INFO => Self::Info,
            ffi::AS_ISSUE_SEVERITY_WARNING => Self::Warning,
            ffi::AS_ISSUE_SEVERITY_ERROR => Self::Error,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsLaunchableKind")]
pub enum LaunchableKind {
    #[doc(alias = "AS_LAUNCHABLE_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_LAUNCHABLE_KIND_DESKTOP_ID")]
    DesktopId,
    #[doc(alias = "AS_LAUNCHABLE_KIND_SERVICE")]
    Service,
    #[doc(alias = "AS_LAUNCHABLE_KIND_COCKPIT_MANIFEST")]
    CockpitManifest,
    #[doc(alias = "AS_LAUNCHABLE_KIND_URL")]
    Url,
    #[doc(hidden)]
    __Unknown(i32),
}

impl LaunchableKind {
    #[doc(alias = "as_launchable_kind_from_string")]
    pub fn from_string(kind_str: &str) -> LaunchableKind {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::as_launchable_kind_from_string(
                kind_str.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_launchable_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_launchable_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsLaunchableKind {
        match self {
            Self::Unknown => ffi::AS_LAUNCHABLE_KIND_UNKNOWN,
            Self::DesktopId => ffi::AS_LAUNCHABLE_KIND_DESKTOP_ID,
            Self::Service => ffi::AS_LAUNCHABLE_KIND_SERVICE,
            Self::CockpitManifest => ffi::AS_LAUNCHABLE_KIND_COCKPIT_MANIFEST,
            Self::Url => ffi::AS_LAUNCHABLE_KIND_URL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsLaunchableKind> for LaunchableKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsLaunchableKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_LAUNCHABLE_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_LAUNCHABLE_KIND_DESKTOP_ID => Self::DesktopId,
            ffi::AS_LAUNCHABLE_KIND_SERVICE => Self::Service,
            ffi::AS_LAUNCHABLE_KIND_COCKPIT_MANIFEST => Self::CockpitManifest,
            ffi::AS_LAUNCHABLE_KIND_URL => Self::Url,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsMergeKind")]
pub enum MergeKind {
    #[doc(alias = "AS_MERGE_KIND_NONE")]
    None,
    #[doc(alias = "AS_MERGE_KIND_REPLACE")]
    Replace,
    #[doc(alias = "AS_MERGE_KIND_APPEND")]
    Append,
    #[doc(alias = "AS_MERGE_KIND_REMOVE_COMPONENT")]
    RemoveComponent,
    #[doc(hidden)]
    __Unknown(i32),
}

impl MergeKind {
    #[doc(alias = "as_merge_kind_from_string")]
    pub fn from_string(kind_str: &str) -> MergeKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_merge_kind_from_string(kind_str.to_glib_none().0)) }
    }

    #[doc(alias = "as_merge_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_merge_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsMergeKind {
        match self {
            Self::None => ffi::AS_MERGE_KIND_NONE,
            Self::Replace => ffi::AS_MERGE_KIND_REPLACE,
            Self::Append => ffi::AS_MERGE_KIND_APPEND,
            Self::RemoveComponent => ffi::AS_MERGE_KIND_REMOVE_COMPONENT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsMergeKind> for MergeKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsMergeKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_MERGE_KIND_NONE => Self::None,
            ffi::AS_MERGE_KIND_REPLACE => Self::Replace,
            ffi::AS_MERGE_KIND_APPEND => Self::Append,
            ffi::AS_MERGE_KIND_REMOVE_COMPONENT => Self::RemoveComponent,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsMetadataError")]
pub enum MetadataError {
    #[doc(alias = "AS_METADATA_ERROR_FAILED")]
    Failed,
    #[doc(alias = "AS_METADATA_ERROR_PARSE")]
    Parse,
    #[doc(alias = "AS_METADATA_ERROR_FORMAT_UNEXPECTED")]
    FormatUnexpected,
    #[doc(alias = "AS_METADATA_ERROR_NO_COMPONENT")]
    NoComponent,
    #[doc(alias = "AS_METADATA_ERROR_VALUE_MISSING")]
    ValueMissing,
    #[doc(hidden)]
    __Unknown(i32),
}

impl MetadataError {
    #[doc(alias = "as_metadata_error_quark")]
    pub fn quark() -> glib::Quark {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_metadata_error_quark()) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsMetadataError {
        match self {
            Self::Failed => ffi::AS_METADATA_ERROR_FAILED,
            Self::Parse => ffi::AS_METADATA_ERROR_PARSE,
            Self::FormatUnexpected => ffi::AS_METADATA_ERROR_FORMAT_UNEXPECTED,
            Self::NoComponent => ffi::AS_METADATA_ERROR_NO_COMPONENT,
            Self::ValueMissing => ffi::AS_METADATA_ERROR_VALUE_MISSING,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsMetadataError> for MetadataError {
    #[inline]
    unsafe fn from_glib(value: ffi::AsMetadataError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_METADATA_ERROR_FAILED => Self::Failed,
            ffi::AS_METADATA_ERROR_PARSE => Self::Parse,
            ffi::AS_METADATA_ERROR_FORMAT_UNEXPECTED => Self::FormatUnexpected,
            ffi::AS_METADATA_ERROR_NO_COMPONENT => Self::NoComponent,
            ffi::AS_METADATA_ERROR_VALUE_MISSING => Self::ValueMissing,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for MetadataError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        static QUARK: ::std::sync::OnceLock<glib::ffi::GQuark> = ::std::sync::OnceLock::new();
        let quark = *QUARK.get_or_init(|| unsafe {
            glib::ffi::g_quark_from_static_string(b"AsMetadataError\0".as_ptr() as *const _)
        });
        unsafe { from_glib(quark) }
    }

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

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

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsMetadataLocation")]
pub enum MetadataLocation {
    #[doc(alias = "AS_METADATA_LOCATION_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_METADATA_LOCATION_SHARED")]
    Shared,
    #[doc(alias = "AS_METADATA_LOCATION_STATE")]
    State,
    #[doc(alias = "AS_METADATA_LOCATION_CACHE")]
    Cache,
    #[doc(alias = "AS_METADATA_LOCATION_USER")]
    User,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsMetadataLocation {
        match self {
            Self::Unknown => ffi::AS_METADATA_LOCATION_UNKNOWN,
            Self::Shared => ffi::AS_METADATA_LOCATION_SHARED,
            Self::State => ffi::AS_METADATA_LOCATION_STATE,
            Self::Cache => ffi::AS_METADATA_LOCATION_CACHE,
            Self::User => ffi::AS_METADATA_LOCATION_USER,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsMetadataLocation> for MetadataLocation {
    #[inline]
    unsafe fn from_glib(value: ffi::AsMetadataLocation) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_METADATA_LOCATION_UNKNOWN => Self::Unknown,
            ffi::AS_METADATA_LOCATION_SHARED => Self::Shared,
            ffi::AS_METADATA_LOCATION_STATE => Self::State,
            ffi::AS_METADATA_LOCATION_CACHE => Self::Cache,
            ffi::AS_METADATA_LOCATION_USER => Self::User,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsPoolError")]
pub enum PoolError {
    #[doc(alias = "AS_POOL_ERROR_FAILED")]
    Failed,
    #[doc(alias = "AS_POOL_ERROR_INCOMPLETE")]
    Incomplete,
    #[doc(alias = "AS_POOL_ERROR_COLLISION")]
    Collision,
    #[doc(alias = "AS_POOL_ERROR_CACHE_WRITE_FAILED")]
    CacheWriteFailed,
    #[doc(alias = "AS_POOL_ERROR_CACHE_DAMAGED")]
    CacheDamaged,
    #[doc(hidden)]
    __Unknown(i32),
}

impl PoolError {
    #[doc(alias = "as_pool_error_quark")]
    pub fn quark() -> glib::Quark {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_pool_error_quark()) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsPoolError {
        match self {
            Self::Failed => ffi::AS_POOL_ERROR_FAILED,
            Self::Incomplete => ffi::AS_POOL_ERROR_INCOMPLETE,
            Self::Collision => ffi::AS_POOL_ERROR_COLLISION,
            Self::CacheWriteFailed => ffi::AS_POOL_ERROR_CACHE_WRITE_FAILED,
            Self::CacheDamaged => ffi::AS_POOL_ERROR_CACHE_DAMAGED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsPoolError> for PoolError {
    #[inline]
    unsafe fn from_glib(value: ffi::AsPoolError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_POOL_ERROR_FAILED => Self::Failed,
            ffi::AS_POOL_ERROR_INCOMPLETE => Self::Incomplete,
            ffi::AS_POOL_ERROR_COLLISION => Self::Collision,
            ffi::AS_POOL_ERROR_CACHE_WRITE_FAILED => Self::CacheWriteFailed,
            ffi::AS_POOL_ERROR_CACHE_DAMAGED => Self::CacheDamaged,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for PoolError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        static QUARK: ::std::sync::OnceLock<glib::ffi::GQuark> = ::std::sync::OnceLock::new();
        let quark = *QUARK.get_or_init(|| unsafe {
            glib::ffi::g_quark_from_static_string(b"AsPool\0".as_ptr() as *const _)
        });
        unsafe { from_glib(quark) }
    }

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

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

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsProvidedKind")]
pub enum ProvidedKind {
    #[doc(alias = "AS_PROVIDED_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_PROVIDED_KIND_LIBRARY")]
    Library,
    #[doc(alias = "AS_PROVIDED_KIND_BINARY")]
    Binary,
    #[doc(alias = "AS_PROVIDED_KIND_MEDIATYPE")]
    Mediatype,
    #[doc(alias = "AS_PROVIDED_KIND_FONT")]
    Font,
    #[doc(alias = "AS_PROVIDED_KIND_MODALIAS")]
    Modalias,
    #[doc(alias = "AS_PROVIDED_KIND_PYTHON")]
    Python,
    #[doc(alias = "AS_PROVIDED_KIND_DBUS_SYSTEM")]
    DbusSystem,
    #[doc(alias = "AS_PROVIDED_KIND_DBUS_USER")]
    DbusUser,
    #[doc(alias = "AS_PROVIDED_KIND_FIRMWARE_RUNTIME")]
    FirmwareRuntime,
    #[doc(alias = "AS_PROVIDED_KIND_FIRMWARE_FLASHED")]
    FirmwareFlashed,
    #[doc(alias = "AS_PROVIDED_KIND_ID")]
    Id,
    #[doc(hidden)]
    __Unknown(i32),
}

impl ProvidedKind {
    #[doc(alias = "as_provided_kind_from_string")]
    pub fn from_string(kind_str: &str) -> ProvidedKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_provided_kind_from_string(kind_str.to_glib_none().0)) }
    }

    #[doc(alias = "as_provided_kind_to_l10n_string")]
    pub fn to_l10n_string(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_provided_kind_to_l10n_string(self.into_glib())) }
    }

    #[doc(alias = "as_provided_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_provided_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsProvidedKind {
        match self {
            Self::Unknown => ffi::AS_PROVIDED_KIND_UNKNOWN,
            Self::Library => ffi::AS_PROVIDED_KIND_LIBRARY,
            Self::Binary => ffi::AS_PROVIDED_KIND_BINARY,
            Self::Mediatype => ffi::AS_PROVIDED_KIND_MEDIATYPE,
            Self::Font => ffi::AS_PROVIDED_KIND_FONT,
            Self::Modalias => ffi::AS_PROVIDED_KIND_MODALIAS,
            Self::Python => ffi::AS_PROVIDED_KIND_PYTHON,
            Self::DbusSystem => ffi::AS_PROVIDED_KIND_DBUS_SYSTEM,
            Self::DbusUser => ffi::AS_PROVIDED_KIND_DBUS_USER,
            Self::FirmwareRuntime => ffi::AS_PROVIDED_KIND_FIRMWARE_RUNTIME,
            Self::FirmwareFlashed => ffi::AS_PROVIDED_KIND_FIRMWARE_FLASHED,
            Self::Id => ffi::AS_PROVIDED_KIND_ID,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsProvidedKind> for ProvidedKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsProvidedKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_PROVIDED_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_PROVIDED_KIND_LIBRARY => Self::Library,
            ffi::AS_PROVIDED_KIND_BINARY => Self::Binary,
            ffi::AS_PROVIDED_KIND_MEDIATYPE => Self::Mediatype,
            ffi::AS_PROVIDED_KIND_FONT => Self::Font,
            ffi::AS_PROVIDED_KIND_MODALIAS => Self::Modalias,
            ffi::AS_PROVIDED_KIND_PYTHON => Self::Python,
            ffi::AS_PROVIDED_KIND_DBUS_SYSTEM => Self::DbusSystem,
            ffi::AS_PROVIDED_KIND_DBUS_USER => Self::DbusUser,
            ffi::AS_PROVIDED_KIND_FIRMWARE_RUNTIME => Self::FirmwareRuntime,
            ffi::AS_PROVIDED_KIND_FIRMWARE_FLASHED => Self::FirmwareFlashed,
            ffi::AS_PROVIDED_KIND_ID => Self::Id,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsRelationCompare")]
pub enum RelationCompare {
    #[doc(alias = "AS_RELATION_COMPARE_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_RELATION_COMPARE_EQ")]
    Eq,
    #[doc(alias = "AS_RELATION_COMPARE_NE")]
    Ne,
    #[doc(alias = "AS_RELATION_COMPARE_LT")]
    Lt,
    #[doc(alias = "AS_RELATION_COMPARE_GT")]
    Gt,
    #[doc(alias = "AS_RELATION_COMPARE_LE")]
    Le,
    #[doc(alias = "AS_RELATION_COMPARE_GE")]
    Ge,
    #[doc(hidden)]
    __Unknown(i32),
}

impl RelationCompare {
    #[doc(alias = "as_relation_compare_from_string")]
    pub fn from_string(compare_str: &str) -> RelationCompare {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::as_relation_compare_from_string(
                compare_str.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_relation_compare_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_relation_compare_to_string(self.into_glib())) }
    }

    #[doc(alias = "as_relation_compare_to_symbols_string")]
    pub fn to_symbols_string(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_relation_compare_to_symbols_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsRelationCompare {
        match self {
            Self::Unknown => ffi::AS_RELATION_COMPARE_UNKNOWN,
            Self::Eq => ffi::AS_RELATION_COMPARE_EQ,
            Self::Ne => ffi::AS_RELATION_COMPARE_NE,
            Self::Lt => ffi::AS_RELATION_COMPARE_LT,
            Self::Gt => ffi::AS_RELATION_COMPARE_GT,
            Self::Le => ffi::AS_RELATION_COMPARE_LE,
            Self::Ge => ffi::AS_RELATION_COMPARE_GE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsRelationCompare> for RelationCompare {
    #[inline]
    unsafe fn from_glib(value: ffi::AsRelationCompare) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_RELATION_COMPARE_UNKNOWN => Self::Unknown,
            ffi::AS_RELATION_COMPARE_EQ => Self::Eq,
            ffi::AS_RELATION_COMPARE_NE => Self::Ne,
            ffi::AS_RELATION_COMPARE_LT => Self::Lt,
            ffi::AS_RELATION_COMPARE_GT => Self::Gt,
            ffi::AS_RELATION_COMPARE_LE => Self::Le,
            ffi::AS_RELATION_COMPARE_GE => Self::Ge,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsRelationItemKind")]
pub enum RelationItemKind {
    #[doc(alias = "AS_RELATION_ITEM_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_RELATION_ITEM_KIND_ID")]
    Id,
    #[doc(alias = "AS_RELATION_ITEM_KIND_MODALIAS")]
    Modalias,
    #[doc(alias = "AS_RELATION_ITEM_KIND_KERNEL")]
    Kernel,
    #[doc(alias = "AS_RELATION_ITEM_KIND_MEMORY")]
    Memory,
    #[doc(alias = "AS_RELATION_ITEM_KIND_FIRMWARE")]
    Firmware,
    #[doc(alias = "AS_RELATION_ITEM_KIND_CONTROL")]
    Control,
    #[doc(alias = "AS_RELATION_ITEM_KIND_DISPLAY_LENGTH")]
    DisplayLength,
    #[doc(alias = "AS_RELATION_ITEM_KIND_HARDWARE")]
    Hardware,
    #[doc(alias = "AS_RELATION_ITEM_KIND_INTERNET")]
    Internet,
    #[doc(hidden)]
    __Unknown(i32),
}

impl RelationItemKind {
    #[doc(alias = "as_relation_item_kind_from_string")]
    pub fn from_string(kind_str: &str) -> RelationItemKind {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::as_relation_item_kind_from_string(
                kind_str.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_relation_item_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_relation_item_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsRelationItemKind {
        match self {
            Self::Unknown => ffi::AS_RELATION_ITEM_KIND_UNKNOWN,
            Self::Id => ffi::AS_RELATION_ITEM_KIND_ID,
            Self::Modalias => ffi::AS_RELATION_ITEM_KIND_MODALIAS,
            Self::Kernel => ffi::AS_RELATION_ITEM_KIND_KERNEL,
            Self::Memory => ffi::AS_RELATION_ITEM_KIND_MEMORY,
            Self::Firmware => ffi::AS_RELATION_ITEM_KIND_FIRMWARE,
            Self::Control => ffi::AS_RELATION_ITEM_KIND_CONTROL,
            Self::DisplayLength => ffi::AS_RELATION_ITEM_KIND_DISPLAY_LENGTH,
            Self::Hardware => ffi::AS_RELATION_ITEM_KIND_HARDWARE,
            Self::Internet => ffi::AS_RELATION_ITEM_KIND_INTERNET,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsRelationItemKind> for RelationItemKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsRelationItemKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_RELATION_ITEM_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_RELATION_ITEM_KIND_ID => Self::Id,
            ffi::AS_RELATION_ITEM_KIND_MODALIAS => Self::Modalias,
            ffi::AS_RELATION_ITEM_KIND_KERNEL => Self::Kernel,
            ffi::AS_RELATION_ITEM_KIND_MEMORY => Self::Memory,
            ffi::AS_RELATION_ITEM_KIND_FIRMWARE => Self::Firmware,
            ffi::AS_RELATION_ITEM_KIND_CONTROL => Self::Control,
            ffi::AS_RELATION_ITEM_KIND_DISPLAY_LENGTH => Self::DisplayLength,
            ffi::AS_RELATION_ITEM_KIND_HARDWARE => Self::Hardware,
            ffi::AS_RELATION_ITEM_KIND_INTERNET => Self::Internet,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsRelationKind")]
pub enum RelationKind {
    #[doc(alias = "AS_RELATION_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_RELATION_KIND_REQUIRES")]
    Requires,
    #[doc(alias = "AS_RELATION_KIND_RECOMMENDS")]
    Recommends,
    #[doc(alias = "AS_RELATION_KIND_SUPPORTS")]
    Supports,
    #[doc(hidden)]
    __Unknown(i32),
}

impl RelationKind {
    #[doc(alias = "as_relation_kind_from_string")]
    pub fn from_string(kind_str: &str) -> RelationKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_relation_kind_from_string(kind_str.to_glib_none().0)) }
    }

    #[doc(alias = "as_relation_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_relation_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsRelationKind {
        match self {
            Self::Unknown => ffi::AS_RELATION_KIND_UNKNOWN,
            Self::Requires => ffi::AS_RELATION_KIND_REQUIRES,
            Self::Recommends => ffi::AS_RELATION_KIND_RECOMMENDS,
            Self::Supports => ffi::AS_RELATION_KIND_SUPPORTS,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsRelationKind> for RelationKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsRelationKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_RELATION_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_RELATION_KIND_REQUIRES => Self::Requires,
            ffi::AS_RELATION_KIND_RECOMMENDS => Self::Recommends,
            ffi::AS_RELATION_KIND_SUPPORTS => Self::Supports,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsReleaseKind")]
pub enum ReleaseKind {
    #[doc(alias = "AS_RELEASE_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_RELEASE_KIND_STABLE")]
    Stable,
    #[doc(alias = "AS_RELEASE_KIND_DEVELOPMENT")]
    Development,
    #[doc(alias = "AS_RELEASE_KIND_SNAPSHOT")]
    Snapshot,
    #[doc(hidden)]
    __Unknown(i32),
}

impl ReleaseKind {
    #[doc(alias = "as_release_kind_from_string")]
    pub fn from_string(kind_str: &str) -> ReleaseKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_release_kind_from_string(kind_str.to_glib_none().0)) }
    }

    #[doc(alias = "as_release_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_release_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsReleaseKind {
        match self {
            Self::Unknown => ffi::AS_RELEASE_KIND_UNKNOWN,
            Self::Stable => ffi::AS_RELEASE_KIND_STABLE,
            Self::Development => ffi::AS_RELEASE_KIND_DEVELOPMENT,
            Self::Snapshot => ffi::AS_RELEASE_KIND_SNAPSHOT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsReleaseKind> for ReleaseKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsReleaseKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_RELEASE_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_RELEASE_KIND_STABLE => Self::Stable,
            ffi::AS_RELEASE_KIND_DEVELOPMENT => Self::Development,
            ffi::AS_RELEASE_KIND_SNAPSHOT => Self::Snapshot,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsReleaseUrlKind")]
pub enum ReleaseUrlKind {
    #[doc(alias = "AS_RELEASE_URL_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_RELEASE_URL_KIND_DETAILS")]
    Details,
    #[doc(hidden)]
    __Unknown(i32),
}

impl ReleaseUrlKind {
    #[doc(alias = "as_release_url_kind_from_string")]
    pub fn from_string(kind_str: &str) -> ReleaseUrlKind {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::as_release_url_kind_from_string(
                kind_str.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_release_url_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_release_url_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsReleaseUrlKind {
        match self {
            Self::Unknown => ffi::AS_RELEASE_URL_KIND_UNKNOWN,
            Self::Details => ffi::AS_RELEASE_URL_KIND_DETAILS,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsReleaseUrlKind> for ReleaseUrlKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsReleaseUrlKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_RELEASE_URL_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_RELEASE_URL_KIND_DETAILS => Self::Details,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsScreenshotKind")]
pub enum ScreenshotKind {
    #[doc(alias = "AS_SCREENSHOT_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_SCREENSHOT_KIND_DEFAULT")]
    Default,
    #[doc(alias = "AS_SCREENSHOT_KIND_EXTRA")]
    Extra,
    #[doc(hidden)]
    __Unknown(i32),
}

impl ScreenshotKind {
    #[doc(alias = "as_screenshot_kind_from_string")]
    pub fn from_string(kind: &str) -> ScreenshotKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_screenshot_kind_from_string(kind.to_glib_none().0)) }
    }

    #[doc(alias = "as_screenshot_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_screenshot_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsScreenshotKind {
        match self {
            Self::Unknown => ffi::AS_SCREENSHOT_KIND_UNKNOWN,
            Self::Default => ffi::AS_SCREENSHOT_KIND_DEFAULT,
            Self::Extra => ffi::AS_SCREENSHOT_KIND_EXTRA,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsScreenshotKind> for ScreenshotKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsScreenshotKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_SCREENSHOT_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_SCREENSHOT_KIND_DEFAULT => Self::Default,
            ffi::AS_SCREENSHOT_KIND_EXTRA => Self::Extra,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsScreenshotMediaKind")]
pub enum ScreenshotMediaKind {
    #[doc(alias = "AS_SCREENSHOT_MEDIA_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_SCREENSHOT_MEDIA_KIND_IMAGE")]
    Image,
    #[doc(alias = "AS_SCREENSHOT_MEDIA_KIND_VIDEO")]
    Video,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsScreenshotMediaKind {
        match self {
            Self::Unknown => ffi::AS_SCREENSHOT_MEDIA_KIND_UNKNOWN,
            Self::Image => ffi::AS_SCREENSHOT_MEDIA_KIND_IMAGE,
            Self::Video => ffi::AS_SCREENSHOT_MEDIA_KIND_VIDEO,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsScreenshotMediaKind> for ScreenshotMediaKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsScreenshotMediaKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_SCREENSHOT_MEDIA_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_SCREENSHOT_MEDIA_KIND_IMAGE => Self::Image,
            ffi::AS_SCREENSHOT_MEDIA_KIND_VIDEO => Self::Video,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsSizeKind")]
pub enum SizeKind {
    #[doc(alias = "AS_SIZE_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_SIZE_KIND_DOWNLOAD")]
    Download,
    #[doc(alias = "AS_SIZE_KIND_INSTALLED")]
    Installed,
    #[doc(hidden)]
    __Unknown(i32),
}

impl SizeKind {
    #[doc(alias = "as_size_kind_from_string")]
    pub fn from_string(size_kind: &str) -> SizeKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_size_kind_from_string(size_kind.to_glib_none().0)) }
    }

    #[doc(alias = "as_size_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_size_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsSizeKind {
        match self {
            Self::Unknown => ffi::AS_SIZE_KIND_UNKNOWN,
            Self::Download => ffi::AS_SIZE_KIND_DOWNLOAD,
            Self::Installed => ffi::AS_SIZE_KIND_INSTALLED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsSizeKind> for SizeKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsSizeKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_SIZE_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_SIZE_KIND_DOWNLOAD => Self::Download,
            ffi::AS_SIZE_KIND_INSTALLED => Self::Installed,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsSuggestedKind")]
pub enum SuggestedKind {
    #[doc(alias = "AS_SUGGESTED_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_SUGGESTED_KIND_UPSTREAM")]
    Upstream,
    #[doc(alias = "AS_SUGGESTED_KIND_HEURISTIC")]
    Heuristic,
    #[doc(hidden)]
    __Unknown(i32),
}

impl SuggestedKind {
    #[doc(alias = "as_suggested_kind_from_string")]
    pub fn from_string(kind_str: &str) -> SuggestedKind {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::as_suggested_kind_from_string(
                kind_str.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_suggested_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_suggested_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsSuggestedKind {
        match self {
            Self::Unknown => ffi::AS_SUGGESTED_KIND_UNKNOWN,
            Self::Upstream => ffi::AS_SUGGESTED_KIND_UPSTREAM,
            Self::Heuristic => ffi::AS_SUGGESTED_KIND_HEURISTIC,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsSuggestedKind> for SuggestedKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsSuggestedKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_SUGGESTED_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_SUGGESTED_KIND_UPSTREAM => Self::Upstream,
            ffi::AS_SUGGESTED_KIND_HEURISTIC => Self::Heuristic,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsTranslationKind")]
pub enum TranslationKind {
    #[doc(alias = "AS_TRANSLATION_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_TRANSLATION_KIND_GETTEXT")]
    Gettext,
    #[doc(alias = "AS_TRANSLATION_KIND_QT")]
    Qt,
    #[doc(hidden)]
    __Unknown(i32),
}

impl TranslationKind {
    #[doc(alias = "as_translation_kind_from_string")]
    pub fn from_string(kind_str: &str) -> TranslationKind {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::as_translation_kind_from_string(
                kind_str.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_translation_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_translation_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsTranslationKind {
        match self {
            Self::Unknown => ffi::AS_TRANSLATION_KIND_UNKNOWN,
            Self::Gettext => ffi::AS_TRANSLATION_KIND_GETTEXT,
            Self::Qt => ffi::AS_TRANSLATION_KIND_QT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsTranslationKind> for TranslationKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsTranslationKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_TRANSLATION_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_TRANSLATION_KIND_GETTEXT => Self::Gettext,
            ffi::AS_TRANSLATION_KIND_QT => Self::Qt,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsUrgencyKind")]
pub enum UrgencyKind {
    #[doc(alias = "AS_URGENCY_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_URGENCY_KIND_LOW")]
    Low,
    #[doc(alias = "AS_URGENCY_KIND_MEDIUM")]
    Medium,
    #[doc(alias = "AS_URGENCY_KIND_HIGH")]
    High,
    #[doc(alias = "AS_URGENCY_KIND_CRITICAL")]
    Critical,
    #[doc(hidden)]
    __Unknown(i32),
}

impl UrgencyKind {
    #[doc(alias = "as_urgency_kind_from_string")]
    pub fn from_string(urgency_kind: &str) -> UrgencyKind {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::as_urgency_kind_from_string(
                urgency_kind.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_urgency_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_urgency_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsUrgencyKind {
        match self {
            Self::Unknown => ffi::AS_URGENCY_KIND_UNKNOWN,
            Self::Low => ffi::AS_URGENCY_KIND_LOW,
            Self::Medium => ffi::AS_URGENCY_KIND_MEDIUM,
            Self::High => ffi::AS_URGENCY_KIND_HIGH,
            Self::Critical => ffi::AS_URGENCY_KIND_CRITICAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsUrgencyKind> for UrgencyKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsUrgencyKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_URGENCY_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_URGENCY_KIND_LOW => Self::Low,
            ffi::AS_URGENCY_KIND_MEDIUM => Self::Medium,
            ffi::AS_URGENCY_KIND_HIGH => Self::High,
            ffi::AS_URGENCY_KIND_CRITICAL => Self::Critical,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsUrlKind")]
pub enum UrlKind {
    #[doc(alias = "AS_URL_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_URL_KIND_HOMEPAGE")]
    Homepage,
    #[doc(alias = "AS_URL_KIND_BUGTRACKER")]
    Bugtracker,
    #[doc(alias = "AS_URL_KIND_FAQ")]
    Faq,
    #[doc(alias = "AS_URL_KIND_HELP")]
    Help,
    #[doc(alias = "AS_URL_KIND_DONATION")]
    Donation,
    #[doc(alias = "AS_URL_KIND_TRANSLATE")]
    Translate,
    #[doc(alias = "AS_URL_KIND_CONTACT")]
    Contact,
    #[doc(alias = "AS_URL_KIND_VCS_BROWSER")]
    VcsBrowser,
    #[doc(alias = "AS_URL_KIND_CONTRIBUTE")]
    Contribute,
    #[doc(hidden)]
    __Unknown(i32),
}

impl UrlKind {
    #[doc(alias = "as_url_kind_from_string")]
    pub fn from_string(url_kind: &str) -> UrlKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_url_kind_from_string(url_kind.to_glib_none().0)) }
    }

    #[doc(alias = "as_url_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_url_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsUrlKind {
        match self {
            Self::Unknown => ffi::AS_URL_KIND_UNKNOWN,
            Self::Homepage => ffi::AS_URL_KIND_HOMEPAGE,
            Self::Bugtracker => ffi::AS_URL_KIND_BUGTRACKER,
            Self::Faq => ffi::AS_URL_KIND_FAQ,
            Self::Help => ffi::AS_URL_KIND_HELP,
            Self::Donation => ffi::AS_URL_KIND_DONATION,
            Self::Translate => ffi::AS_URL_KIND_TRANSLATE,
            Self::Contact => ffi::AS_URL_KIND_CONTACT,
            Self::VcsBrowser => ffi::AS_URL_KIND_VCS_BROWSER,
            Self::Contribute => ffi::AS_URL_KIND_CONTRIBUTE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsUrlKind> for UrlKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsUrlKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_URL_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_URL_KIND_HOMEPAGE => Self::Homepage,
            ffi::AS_URL_KIND_BUGTRACKER => Self::Bugtracker,
            ffi::AS_URL_KIND_FAQ => Self::Faq,
            ffi::AS_URL_KIND_HELP => Self::Help,
            ffi::AS_URL_KIND_DONATION => Self::Donation,
            ffi::AS_URL_KIND_TRANSLATE => Self::Translate,
            ffi::AS_URL_KIND_CONTACT => Self::Contact,
            ffi::AS_URL_KIND_VCS_BROWSER => Self::VcsBrowser,
            ffi::AS_URL_KIND_CONTRIBUTE => Self::Contribute,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsUtilsError")]
pub enum UtilsError {
    #[doc(alias = "AS_UTILS_ERROR_FAILED")]
    Failed,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsUtilsError {
        match self {
            Self::Failed => ffi::AS_UTILS_ERROR_FAILED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsUtilsError> for UtilsError {
    #[inline]
    unsafe fn from_glib(value: ffi::AsUtilsError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_UTILS_ERROR_FAILED => Self::Failed,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for UtilsError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::as_utils_error_quark()) }
    }

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

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

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsVideoCodecKind")]
pub enum VideoCodecKind {
    #[doc(alias = "AS_VIDEO_CODEC_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_VIDEO_CODEC_KIND_VP9")]
    Vp9,
    #[doc(alias = "AS_VIDEO_CODEC_KIND_AV1")]
    Av1,
    #[doc(hidden)]
    __Unknown(i32),
}

impl VideoCodecKind {
    #[doc(alias = "as_video_codec_kind_from_string")]
    pub fn from_string(str: &str) -> VideoCodecKind {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_video_codec_kind_from_string(str.to_glib_none().0)) }
    }

    #[doc(alias = "as_video_codec_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_video_codec_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsVideoCodecKind {
        match self {
            Self::Unknown => ffi::AS_VIDEO_CODEC_KIND_UNKNOWN,
            Self::Vp9 => ffi::AS_VIDEO_CODEC_KIND_VP9,
            Self::Av1 => ffi::AS_VIDEO_CODEC_KIND_AV1,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsVideoCodecKind> for VideoCodecKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsVideoCodecKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_VIDEO_CODEC_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_VIDEO_CODEC_KIND_VP9 => Self::Vp9,
            ffi::AS_VIDEO_CODEC_KIND_AV1 => Self::Av1,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AsVideoContainerKind")]
pub enum VideoContainerKind {
    #[doc(alias = "AS_VIDEO_CONTAINER_KIND_UNKNOWN")]
    Unknown,
    #[doc(alias = "AS_VIDEO_CONTAINER_KIND_MKV")]
    Mkv,
    #[doc(alias = "AS_VIDEO_CONTAINER_KIND_WEBM")]
    Webm,
    #[doc(hidden)]
    __Unknown(i32),
}

impl VideoContainerKind {
    #[doc(alias = "as_video_container_kind_from_string")]
    pub fn from_string(str: &str) -> VideoContainerKind {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::as_video_container_kind_from_string(
                str.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_video_container_kind_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::as_video_container_kind_to_string(self.into_glib())) }
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::AsVideoContainerKind {
        match self {
            Self::Unknown => ffi::AS_VIDEO_CONTAINER_KIND_UNKNOWN,
            Self::Mkv => ffi::AS_VIDEO_CONTAINER_KIND_MKV,
            Self::Webm => ffi::AS_VIDEO_CONTAINER_KIND_WEBM,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::AsVideoContainerKind> for VideoContainerKind {
    #[inline]
    unsafe fn from_glib(value: ffi::AsVideoContainerKind) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::AS_VIDEO_CONTAINER_KIND_UNKNOWN => Self::Unknown,
            ffi::AS_VIDEO_CONTAINER_KIND_MKV => Self::Mkv,
            ffi::AS_VIDEO_CONTAINER_KIND_WEBM => Self::Webm,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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