// 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 crate::ffi;
use glib::{prelude::*, translate::*};

/// Error codes for library functions.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "FlatpakError")]
pub enum Error {
    /// App/runtime/remote is already installed
    #[doc(alias = "FLATPAK_ERROR_ALREADY_INSTALLED")]
    AlreadyInstalled,
    /// App/runtime is not installed
    #[doc(alias = "FLATPAK_ERROR_NOT_INSTALLED")]
    NotInstalled,
    /// App/runtime was only pulled into the local
    ///  repository but not installed.
    #[doc(alias = "FLATPAK_ERROR_ONLY_PULLED")]
    OnlyPulled,
    /// The App/Runtime is already installed, but from a different remote.
    #[doc(alias = "FLATPAK_ERROR_DIFFERENT_REMOTE")]
    DifferentRemote,
    /// The transaction was aborted (returned [`true`] in operation-error signal).
    #[doc(alias = "FLATPAK_ERROR_ABORTED")]
    Aborted,
    /// The App/Runtime install was skipped due to earlier errors.
    #[doc(alias = "FLATPAK_ERROR_SKIPPED")]
    Skipped,
    /// The App/Runtime needs a more recent version of flatpak.
    #[doc(alias = "FLATPAK_ERROR_NEED_NEW_FLATPAK")]
    NeedNewFlatpak,
    /// The specified remote was not found.
    #[doc(alias = "FLATPAK_ERROR_REMOTE_NOT_FOUND")]
    RemoteNotFound,
    /// A runtime needed for the app was not found.
    #[doc(alias = "FLATPAK_ERROR_RUNTIME_NOT_FOUND")]
    RuntimeNotFound,
    /// The pulled commit is a downgrade, and a downgrade wasn't
    ///  specifically allowed. (Since: 1.0)
    #[doc(alias = "FLATPAK_ERROR_DOWNGRADE")]
    Downgrade,
    /// A ref could not be parsed. (Since: 1.0.3)
    #[doc(alias = "FLATPAK_ERROR_INVALID_REF")]
    InvalidRef,
    /// Invalid data. (Since: 1.0.3)
    #[doc(alias = "FLATPAK_ERROR_INVALID_DATA")]
    InvalidData,
    /// Missing GPG key or signature. (Since: 1.0.3)
    #[doc(alias = "FLATPAK_ERROR_UNTRUSTED")]
    Untrusted,
    /// Sandbox setup failed. (Since: 1.0.3)
    #[doc(alias = "FLATPAK_ERROR_SETUP_FAILED")]
    SetupFailed,
    /// Exporting data failed. (Since: 1.0.3)
    #[doc(alias = "FLATPAK_ERROR_EXPORT_FAILED")]
    ExportFailed,
    /// Remote can't be uninstalled. (Since: 1.0.3)
    #[doc(alias = "FLATPAK_ERROR_REMOTE_USED")]
    RemoteUsed,
    /// Runtime can't be uninstalled. (Since: 1.0.3)
    #[doc(alias = "FLATPAK_ERROR_RUNTIME_USED")]
    RuntimeUsed,
    /// Application, runtime or remote name is invalid. (Since: 1.0.3)
    #[doc(alias = "FLATPAK_ERROR_INVALID_NAME")]
    InvalidName,
    /// More disk space needed. (Since: 1.2.0)
    #[doc(alias = "FLATPAK_ERROR_OUT_OF_SPACE")]
    OutOfSpace,
    /// An operation is being attempted by the wrong user (such as
    ///  root operating on a user installation). (Since: 1.2.0)
    #[doc(alias = "FLATPAK_ERROR_WRONG_USER")]
    WrongUser,
    /// Cached data was requested, but it was not available. (Since: 1.4.0)
    #[doc(alias = "FLATPAK_ERROR_NOT_CACHED")]
    NotCached,
    /// The specified ref was not found. (Since: 1.4.0)
    #[doc(alias = "FLATPAK_ERROR_REF_NOT_FOUND")]
    RefNotFound,
    /// An operation was not allowed by the administrative policy.
    ///  For example, an app is not allowed to be installed due
    ///  to not complying with the parental controls policy. (Since: 1.5.1)
    #[doc(alias = "FLATPAK_ERROR_PERMISSION_DENIED")]
    PermissionDenied,
    /// An authentication operation failed, for example, no
    ///  correct password was supplied. (Since: 1.7.3)
    #[doc(alias = "FLATPAK_ERROR_AUTHENTICATION_FAILED")]
    AuthenticationFailed,
    /// An operation tried to access a ref, or information about it that it
    ///  was not authorized. For example, when succesfully authenticating with a
    ///  server but the user doesn't have permissions for a private ref. (Since: 1.7.3)
    #[doc(alias = "FLATPAK_ERROR_NOT_AUTHORIZED")]
    NotAuthorized,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::FlatpakError {
        match self {
            Self::AlreadyInstalled => ffi::FLATPAK_ERROR_ALREADY_INSTALLED,
            Self::NotInstalled => ffi::FLATPAK_ERROR_NOT_INSTALLED,
            Self::OnlyPulled => ffi::FLATPAK_ERROR_ONLY_PULLED,
            Self::DifferentRemote => ffi::FLATPAK_ERROR_DIFFERENT_REMOTE,
            Self::Aborted => ffi::FLATPAK_ERROR_ABORTED,
            Self::Skipped => ffi::FLATPAK_ERROR_SKIPPED,
            Self::NeedNewFlatpak => ffi::FLATPAK_ERROR_NEED_NEW_FLATPAK,
            Self::RemoteNotFound => ffi::FLATPAK_ERROR_REMOTE_NOT_FOUND,
            Self::RuntimeNotFound => ffi::FLATPAK_ERROR_RUNTIME_NOT_FOUND,
            Self::Downgrade => ffi::FLATPAK_ERROR_DOWNGRADE,
            Self::InvalidRef => ffi::FLATPAK_ERROR_INVALID_REF,
            Self::InvalidData => ffi::FLATPAK_ERROR_INVALID_DATA,
            Self::Untrusted => ffi::FLATPAK_ERROR_UNTRUSTED,
            Self::SetupFailed => ffi::FLATPAK_ERROR_SETUP_FAILED,
            Self::ExportFailed => ffi::FLATPAK_ERROR_EXPORT_FAILED,
            Self::RemoteUsed => ffi::FLATPAK_ERROR_REMOTE_USED,
            Self::RuntimeUsed => ffi::FLATPAK_ERROR_RUNTIME_USED,
            Self::InvalidName => ffi::FLATPAK_ERROR_INVALID_NAME,
            Self::OutOfSpace => ffi::FLATPAK_ERROR_OUT_OF_SPACE,
            Self::WrongUser => ffi::FLATPAK_ERROR_WRONG_USER,
            Self::NotCached => ffi::FLATPAK_ERROR_NOT_CACHED,
            Self::RefNotFound => ffi::FLATPAK_ERROR_REF_NOT_FOUND,
            Self::PermissionDenied => ffi::FLATPAK_ERROR_PERMISSION_DENIED,
            Self::AuthenticationFailed => ffi::FLATPAK_ERROR_AUTHENTICATION_FAILED,
            Self::NotAuthorized => ffi::FLATPAK_ERROR_NOT_AUTHORIZED,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::FLATPAK_ERROR_ALREADY_INSTALLED => Self::AlreadyInstalled,
            ffi::FLATPAK_ERROR_NOT_INSTALLED => Self::NotInstalled,
            ffi::FLATPAK_ERROR_ONLY_PULLED => Self::OnlyPulled,
            ffi::FLATPAK_ERROR_DIFFERENT_REMOTE => Self::DifferentRemote,
            ffi::FLATPAK_ERROR_ABORTED => Self::Aborted,
            ffi::FLATPAK_ERROR_SKIPPED => Self::Skipped,
            ffi::FLATPAK_ERROR_NEED_NEW_FLATPAK => Self::NeedNewFlatpak,
            ffi::FLATPAK_ERROR_REMOTE_NOT_FOUND => Self::RemoteNotFound,
            ffi::FLATPAK_ERROR_RUNTIME_NOT_FOUND => Self::RuntimeNotFound,
            ffi::FLATPAK_ERROR_DOWNGRADE => Self::Downgrade,
            ffi::FLATPAK_ERROR_INVALID_REF => Self::InvalidRef,
            ffi::FLATPAK_ERROR_INVALID_DATA => Self::InvalidData,
            ffi::FLATPAK_ERROR_UNTRUSTED => Self::Untrusted,
            ffi::FLATPAK_ERROR_SETUP_FAILED => Self::SetupFailed,
            ffi::FLATPAK_ERROR_EXPORT_FAILED => Self::ExportFailed,
            ffi::FLATPAK_ERROR_REMOTE_USED => Self::RemoteUsed,
            ffi::FLATPAK_ERROR_RUNTIME_USED => Self::RuntimeUsed,
            ffi::FLATPAK_ERROR_INVALID_NAME => Self::InvalidName,
            ffi::FLATPAK_ERROR_OUT_OF_SPACE => Self::OutOfSpace,
            ffi::FLATPAK_ERROR_WRONG_USER => Self::WrongUser,
            ffi::FLATPAK_ERROR_NOT_CACHED => Self::NotCached,
            ffi::FLATPAK_ERROR_REF_NOT_FOUND => Self::RefNotFound,
            ffi::FLATPAK_ERROR_PERMISSION_DENIED => Self::PermissionDenied,
            ffi::FLATPAK_ERROR_AUTHENTICATION_FAILED => Self::AuthenticationFailed,
            ffi::FLATPAK_ERROR_NOT_AUTHORIZED => Self::NotAuthorized,
            value => Self::__Unknown(value),
        }
    }
}

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

        unsafe { from_glib(ffi::flatpak_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) } {
            value => Some(value),
        }
    }
}

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

impl glib::HasParamSpec for Error {
    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 Error {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for Error {
    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 Error {
    #[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<Error> for glib::Value {
    #[inline]
    fn from(v: Error) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Error codes returned by portal calls.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "FlatpakPortalError")]
pub enum PortalError {
    /// General portal failure
    #[doc(alias = "FLATPAK_PORTAL_ERROR_FAILED")]
    Failed,
    /// An argument was invalid
    #[doc(alias = "FLATPAK_PORTAL_ERROR_INVALID_ARGUMENT")]
    InvalidArgument,
    /// The object was not found
    #[doc(alias = "FLATPAK_PORTAL_ERROR_NOT_FOUND")]
    NotFound,
    /// The object already exists
    #[doc(alias = "FLATPAK_PORTAL_ERROR_EXISTS")]
    Exists,
    /// The call was not allowed
    #[doc(alias = "FLATPAK_PORTAL_ERROR_NOT_ALLOWED")]
    NotAllowed,
    /// The call was cancelled by the user
    #[doc(alias = "FLATPAK_PORTAL_ERROR_CANCELLED")]
    Cancelled,
    /// The window was destroyed by the user
    #[doc(alias = "FLATPAK_PORTAL_ERROR_WINDOW_DESTROYED")]
    WindowDestroyed,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::FlatpakPortalError {
        match self {
            Self::Failed => ffi::FLATPAK_PORTAL_ERROR_FAILED,
            Self::InvalidArgument => ffi::FLATPAK_PORTAL_ERROR_INVALID_ARGUMENT,
            Self::NotFound => ffi::FLATPAK_PORTAL_ERROR_NOT_FOUND,
            Self::Exists => ffi::FLATPAK_PORTAL_ERROR_EXISTS,
            Self::NotAllowed => ffi::FLATPAK_PORTAL_ERROR_NOT_ALLOWED,
            Self::Cancelled => ffi::FLATPAK_PORTAL_ERROR_CANCELLED,
            Self::WindowDestroyed => ffi::FLATPAK_PORTAL_ERROR_WINDOW_DESTROYED,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::FLATPAK_PORTAL_ERROR_FAILED => Self::Failed,
            ffi::FLATPAK_PORTAL_ERROR_INVALID_ARGUMENT => Self::InvalidArgument,
            ffi::FLATPAK_PORTAL_ERROR_NOT_FOUND => Self::NotFound,
            ffi::FLATPAK_PORTAL_ERROR_EXISTS => Self::Exists,
            ffi::FLATPAK_PORTAL_ERROR_NOT_ALLOWED => Self::NotAllowed,
            ffi::FLATPAK_PORTAL_ERROR_CANCELLED => Self::Cancelled,
            ffi::FLATPAK_PORTAL_ERROR_WINDOW_DESTROYED => Self::WindowDestroyed,
            value => Self::__Unknown(value),
        }
    }
}

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

        unsafe { from_glib(ffi::flatpak_portal_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 PortalError {
    #[inline]
    #[doc(alias = "flatpak_portal_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::flatpak_portal_error_get_type()) }
    }
}

impl glib::HasParamSpec for PortalError {
    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 PortalError {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PortalError {
    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 PortalError {
    #[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<PortalError> for glib::Value {
    #[inline]
    fn from(v: PortalError) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The kind of artifact that a FlatpakRef refers to.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "FlatpakRefKind")]
pub enum RefKind {
    /// An application
    #[doc(alias = "FLATPAK_REF_KIND_APP")]
    App,
    /// A runtime that applications can use.
    #[doc(alias = "FLATPAK_REF_KIND_RUNTIME")]
    Runtime,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::FlatpakRefKind {
        match self {
            Self::App => ffi::FLATPAK_REF_KIND_APP,
            Self::Runtime => ffi::FLATPAK_REF_KIND_RUNTIME,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::FLATPAK_REF_KIND_APP => Self::App,
            ffi::FLATPAK_REF_KIND_RUNTIME => Self::Runtime,
            value => Self::__Unknown(value),
        }
    }
}

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

impl glib::HasParamSpec for RefKind {
    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 RefKind {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for RefKind {
    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 RefKind {
    #[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<RefKind> for glib::Value {
    #[inline]
    fn from(v: RefKind) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Different types of [`Remote`][crate::Remote].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "FlatpakRemoteType")]
pub enum RemoteType {
    /// Statically configured remote
    #[doc(alias = "FLATPAK_REMOTE_TYPE_STATIC")]
    Static,
    /// Dynamically detected local pathname remote
    #[doc(alias = "FLATPAK_REMOTE_TYPE_USB")]
    Usb,
    /// Dynamically detected network remote
    #[doc(alias = "FLATPAK_REMOTE_TYPE_LAN")]
    Lan,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::FlatpakRemoteType {
        match self {
            Self::Static => ffi::FLATPAK_REMOTE_TYPE_STATIC,
            Self::Usb => ffi::FLATPAK_REMOTE_TYPE_USB,
            Self::Lan => ffi::FLATPAK_REMOTE_TYPE_LAN,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::FLATPAK_REMOTE_TYPE_STATIC => Self::Static,
            ffi::FLATPAK_REMOTE_TYPE_USB => Self::Usb,
            ffi::FLATPAK_REMOTE_TYPE_LAN => Self::Lan,
            value => Self::__Unknown(value),
        }
    }
}

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

impl glib::HasParamSpec for RemoteType {
    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 RemoteType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for RemoteType {
    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 RemoteType {
    #[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<RemoteType> for glib::Value {
    #[inline]
    fn from(v: RemoteType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Information about the storage of an installation.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "FlatpakStorageType")]
pub enum StorageType {
    /// default
    #[doc(alias = "FLATPAK_STORAGE_TYPE_DEFAULT")]
    Default,
    /// installation is on a hard disk
    #[doc(alias = "FLATPAK_STORAGE_TYPE_HARD_DISK")]
    HardDisk,
    /// installation is on a SD card
    #[doc(alias = "FLATPAK_STORAGE_TYPE_SDCARD")]
    Sdcard,
    /// installation is on an MMC
    #[doc(alias = "FLATPAK_STORAGE_TYPE_MMC")]
    Mmc,
    /// installation is on the network
    #[doc(alias = "FLATPAK_STORAGE_TYPE_NETWORK")]
    Network,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::FlatpakStorageType {
        match self {
            Self::Default => ffi::FLATPAK_STORAGE_TYPE_DEFAULT,
            Self::HardDisk => ffi::FLATPAK_STORAGE_TYPE_HARD_DISK,
            Self::Sdcard => ffi::FLATPAK_STORAGE_TYPE_SDCARD,
            Self::Mmc => ffi::FLATPAK_STORAGE_TYPE_MMC,
            Self::Network => ffi::FLATPAK_STORAGE_TYPE_NETWORK,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::FLATPAK_STORAGE_TYPE_DEFAULT => Self::Default,
            ffi::FLATPAK_STORAGE_TYPE_HARD_DISK => Self::HardDisk,
            ffi::FLATPAK_STORAGE_TYPE_SDCARD => Self::Sdcard,
            ffi::FLATPAK_STORAGE_TYPE_MMC => Self::Mmc,
            ffi::FLATPAK_STORAGE_TYPE_NETWORK => Self::Network,
            value => Self::__Unknown(value),
        }
    }
}

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

impl glib::HasParamSpec for StorageType {
    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 StorageType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for StorageType {
    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 StorageType {
    #[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<StorageType> for glib::Value {
    #[inline]
    fn from(v: StorageType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The type of a [`TransactionOperation`][crate::TransactionOperation].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "FlatpakTransactionOperationType")]
pub enum TransactionOperationType {
    /// Install a ref from a remote
    #[doc(alias = "FLATPAK_TRANSACTION_OPERATION_INSTALL")]
    Install,
    /// Update an installed ref
    #[doc(alias = "FLATPAK_TRANSACTION_OPERATION_UPDATE")]
    Update,
    /// Install a bundle from a file
    #[doc(alias = "FLATPAK_TRANSACTION_OPERATION_INSTALL_BUNDLE")]
    InstallBundle,
    /// Uninstall a ref
    #[doc(alias = "FLATPAK_TRANSACTION_OPERATION_UNINSTALL")]
    Uninstall,
    /// The (currently) last operation type
    #[doc(alias = "FLATPAK_TRANSACTION_OPERATION_LAST_TYPE")]
    LastType,
    #[doc(hidden)]
    __Unknown(i32),
}

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

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

    #[inline]
    fn into_glib(self) -> ffi::FlatpakTransactionOperationType {
        match self {
            Self::Install => ffi::FLATPAK_TRANSACTION_OPERATION_INSTALL,
            Self::Update => ffi::FLATPAK_TRANSACTION_OPERATION_UPDATE,
            Self::InstallBundle => ffi::FLATPAK_TRANSACTION_OPERATION_INSTALL_BUNDLE,
            Self::Uninstall => ffi::FLATPAK_TRANSACTION_OPERATION_UNINSTALL,
            Self::LastType => ffi::FLATPAK_TRANSACTION_OPERATION_LAST_TYPE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::FLATPAK_TRANSACTION_OPERATION_INSTALL => Self::Install,
            ffi::FLATPAK_TRANSACTION_OPERATION_UPDATE => Self::Update,
            ffi::FLATPAK_TRANSACTION_OPERATION_INSTALL_BUNDLE => Self::InstallBundle,
            ffi::FLATPAK_TRANSACTION_OPERATION_UNINSTALL => Self::Uninstall,
            ffi::FLATPAK_TRANSACTION_OPERATION_LAST_TYPE => Self::LastType,
            value => Self::__Unknown(value),
        }
    }
}

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

impl glib::HasParamSpec for TransactionOperationType {
    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 TransactionOperationType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for TransactionOperationType {
    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 TransactionOperationType {
    #[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<TransactionOperationType> for glib::Value {
    #[inline]
    fn from(v: TransactionOperationType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The reason for [`add-new-remote`][struct@crate::Transaction#add-new-remote].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "FlatpakTransactionRemoteReason")]
pub enum TransactionRemoteReason {
    /// The remote specified in the flatpakref has other apps too
    #[doc(alias = "FLATPAK_TRANSACTION_REMOTE_GENERIC_REPO")]
    GenericRepo,
    /// The remote has runtimes needed for the app
    #[doc(alias = "FLATPAK_TRANSACTION_REMOTE_RUNTIME_DEPS")]
    RuntimeDeps,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::FlatpakTransactionRemoteReason {
        match self {
            Self::GenericRepo => ffi::FLATPAK_TRANSACTION_REMOTE_GENERIC_REPO,
            Self::RuntimeDeps => ffi::FLATPAK_TRANSACTION_REMOTE_RUNTIME_DEPS,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::FLATPAK_TRANSACTION_REMOTE_GENERIC_REPO => Self::GenericRepo,
            ffi::FLATPAK_TRANSACTION_REMOTE_RUNTIME_DEPS => Self::RuntimeDeps,
            value => Self::__Unknown(value),
        }
    }
}

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

impl glib::HasParamSpec for TransactionRemoteReason {
    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 TransactionRemoteReason {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for TransactionRemoteReason {
    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 TransactionRemoteReason {
    #[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<TransactionRemoteReason> for glib::Value {
    #[inline]
    fn from(v: TransactionRemoteReason) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}