// 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
#![allow(deprecated)]

#[cfg(feature = "v1_3_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3_3")))]
use crate::QueryFlags;
use crate::{ffi, InstalledRef, Ref, RefKind, RelatedRef, Remote, RemoteRef, StorageType};
use glib::{prelude::*, translate::*};

glib::wrapper! {
    ///
    ///
    /// # Implements
    ///
    /// [`InstallationExt`][trait@crate::prelude::InstallationExt], [`InstallationExtManual`][trait@crate::prelude::InstallationExtManual]
    #[doc(alias = "FlatpakInstallation")]
    pub struct Installation(Object<ffi::FlatpakInstallation, ffi::FlatpakInstallationClass>);

    match fn {
        type_ => || ffi::flatpak_installation_get_type(),
    }
}

impl Installation {
    pub const NONE: Option<&'static Installation> = None;

    /// Creates a new [`Installation`][crate::Installation] for the installation at the given `path`.
    /// ## `path`
    /// a [`gio::File`][crate::gio::File]
    /// ## `user`
    /// whether this is a user-specific location
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a new [`Installation`][crate::Installation]
    #[doc(alias = "flatpak_installation_new_for_path")]
    #[doc(alias = "new_for_path")]
    pub fn for_path(
        path: &impl IsA<gio::File>,
        user: bool,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Installation, glib::Error> {
        assert_initialized_main_thread!();
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_new_for_path(
                path.as_ref().to_glib_none().0,
                user.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Creates a new [`Installation`][crate::Installation] for the default system-wide installation.
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a new [`Installation`][crate::Installation]
    #[doc(alias = "flatpak_installation_new_system")]
    pub fn new_system(
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Installation, glib::Error> {
        assert_initialized_main_thread!();
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_new_system(
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Creates a new [`Installation`][crate::Installation] for the system-wide installation `id`.
    /// ## `id`
    /// the ID of the system-wide installation
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a new [`Installation`][crate::Installation]
    #[doc(alias = "flatpak_installation_new_system_with_id")]
    pub fn new_system_with_id(
        id: Option<&str>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Installation, glib::Error> {
        assert_initialized_main_thread!();
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_new_system_with_id(
                id.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Creates a new [`Installation`][crate::Installation] for the per-user installation.
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a new [`Installation`][crate::Installation]
    #[doc(alias = "flatpak_installation_new_user")]
    pub fn new_user(
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Installation, glib::Error> {
        assert_initialized_main_thread!();
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_new_user(
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }
}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::Installation>> Sealed for T {}
}

/// Trait containing all [`struct@Installation`] methods.
///
/// # Implementors
///
/// [`Installation`][struct@crate::Installation]
pub trait InstallationExt: IsA<Installation> + sealed::Sealed + 'static {
    /// Adds a new `remote` object to the set of remotes. This is similar
    /// to [`modify_remote()`][Self::modify_remote()] for non-existing remote
    /// names. However, if the named remote already exists then instead of
    /// modifying it it fails with [`Error::AlreadyInstalled`][crate::Error::AlreadyInstalled], or if
    /// `if_needed` is true it silently succeeds without doing anything.
    ///
    /// As an exception to the last, if the local config has a filter defined,
    /// but the new remote unsets the filter (for example, it comes from an
    /// unfiltered .flatpakref via [`Remote::from_file()`][crate::Remote::from_file()]) the the local
    /// remote filter gets reset. This is to allow the setup where there is a
    /// default setup of a filtered remote, yet you can still use the standard
    /// flatpakref file to get the full contents without getting two remotes.
    /// ## `remote`
    /// the new [`Remote`][crate::Remote]
    /// ## `if_needed`
    /// if [`true`], only add if it doesn't exists
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// [`true`] if the modifications have been committed successfully
    #[cfg(feature = "v1_3_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3_4")))]
    #[doc(alias = "flatpak_installation_add_remote")]
    fn add_remote(
        &self,
        remote: &impl IsA<Remote>,
        if_needed: bool,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::flatpak_installation_add_remote(
                self.as_ref().to_glib_none().0,
                remote.as_ref().to_glib_none().0,
                if_needed.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Remove all OSTree refs from the local flatpak repository which are not
    /// in a deployed state. The next time the underlying OSTree repo is pruned,
    /// objects which were attached to that ref will be removed. This is useful if
    /// you pulled a flatpak refs using [`InstallationExtManual::install_full()`][crate::prelude::InstallationExtManual::install_full()] and
    /// specified [`InstallFlags::NO_DEPLOY`][crate::InstallFlags::NO_DEPLOY] but then decided not to
    /// deploy the refs later on and want to remove the local refs to prevent them
    /// from taking up disk space. Note that this will not remove the objects
    /// referred to by `ref_` from the underlying OSTree repo, you should use
    /// [`prune_local_repo()`][Self::prune_local_repo()] to do that.
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// [`true`] on success
    #[doc(alias = "flatpak_installation_cleanup_local_refs_sync")]
    fn cleanup_local_refs_sync(
        &self,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::flatpak_installation_cleanup_local_refs_sync(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Gets monitor object for the installation. The returned file monitor will
    /// emit the [`changed`][struct@crate::gio::FileMonitor#changed] signal whenever an application or runtime
    /// was installed, uninstalled or updated.
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a new [`gio::FileMonitor`][crate::gio::FileMonitor] instance, or [`None`] on error
    #[doc(alias = "flatpak_installation_create_monitor")]
    fn create_monitor(
        &self,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<gio::FileMonitor, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_create_monitor(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Drops all internal (in-memory) caches. For instance, this may be needed to pick up new or changed
    /// remotes configured outside this installation instance.
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error
    #[doc(alias = "flatpak_installation_drop_caches")]
    fn drop_caches(
        &self,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::flatpak_installation_drop_caches(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Obtains the metadata file from a commit.
    ///
    /// NOTE: Since 0.11.4 this information is accessible in FlatpakRemoteRef, so this
    /// function is not very useful anymore.
    /// ## `remote_name`
    /// the name of the remote
    /// ## `ref_`
    /// the ref
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a [`glib::Bytes`][crate::glib::Bytes] containing the flatpak metadata file,
    ///  or [`None`] if an error occurred
    #[doc(alias = "flatpak_installation_fetch_remote_metadata_sync")]
    fn fetch_remote_metadata_sync(
        &self,
        remote_name: &str,
        ref_: &impl IsA<Ref>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<glib::Bytes, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_fetch_remote_metadata_sync(
                self.as_ref().to_glib_none().0,
                remote_name.to_glib_none().0,
                ref_.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Gets the current remote branch of a ref in the remote.
    /// ## `remote_name`
    /// the name of the remote
    /// ## `kind`
    /// what this ref contains (an [`RefKind`][crate::RefKind])
    /// ## `name`
    /// name of the app/runtime to fetch
    /// ## `arch`
    /// which architecture to fetch (default: current architecture)
    /// ## `branch`
    /// which branch to fetch (default: 'master')
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a [`RemoteRef`][crate::RemoteRef] instance, or [`None`]
    #[doc(alias = "flatpak_installation_fetch_remote_ref_sync")]
    fn fetch_remote_ref_sync(
        &self,
        remote_name: &str,
        kind: RefKind,
        name: &str,
        arch: Option<&str>,
        branch: Option<&str>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<RemoteRef, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_fetch_remote_ref_sync(
                self.as_ref().to_glib_none().0,
                remote_name.to_glib_none().0,
                kind.into_glib(),
                name.to_glib_none().0,
                arch.to_glib_none().0,
                branch.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Gets the current remote branch of a ref in the remote.
    /// ## `remote_name`
    /// the name of the remote
    /// ## `kind`
    /// what this ref contains (an [`RefKind`][crate::RefKind])
    /// ## `name`
    /// name of the app/runtime to fetch
    /// ## `arch`
    /// which architecture to fetch (default: current architecture)
    /// ## `branch`
    /// which branch to fetch (default: 'master')
    /// ## `flags`
    /// set of [`QueryFlags`][crate::QueryFlags]
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a [`RemoteRef`][crate::RemoteRef] instance, or [`None`]
    #[cfg(feature = "v1_3_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3_3")))]
    #[doc(alias = "flatpak_installation_fetch_remote_ref_sync_full")]
    fn fetch_remote_ref_sync_full(
        &self,
        remote_name: &str,
        kind: RefKind,
        name: &str,
        arch: Option<&str>,
        branch: Option<&str>,
        flags: QueryFlags,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<RemoteRef, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_fetch_remote_ref_sync_full(
                self.as_ref().to_glib_none().0,
                remote_name.to_glib_none().0,
                kind.into_glib(),
                name.to_glib_none().0,
                arch.to_glib_none().0,
                branch.to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Gets information about the maximum amount of data that needs to be transferred
    /// to pull the ref from a remote repository, and about the amount of
    /// local disk space that is required to check out this commit.
    ///
    /// Note that if there are locally available data that are in the ref, which is common
    /// for instance if you're doing an update then the real download size may be smaller
    /// than what is returned here.
    ///
    /// NOTE: Since 0.11.4 this information is accessible in FlatpakRemoteRef, so this
    /// function is not very useful anymore.
    /// ## `remote_name`
    /// the name of the remote
    /// ## `ref_`
    /// the ref
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// [`true`], unless an error occurred
    ///
    /// ## `download_size`
    /// return location for the (maximum) download size
    ///
    /// ## `installed_size`
    /// return location for the installed size
    #[doc(alias = "flatpak_installation_fetch_remote_size_sync")]
    fn fetch_remote_size_sync(
        &self,
        remote_name: &str,
        ref_: &impl IsA<Ref>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(u64, u64), glib::Error> {
        unsafe {
            let mut download_size = std::mem::MaybeUninit::uninit();
            let mut installed_size = std::mem::MaybeUninit::uninit();
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::flatpak_installation_fetch_remote_size_sync(
                self.as_ref().to_glib_none().0,
                remote_name.to_glib_none().0,
                ref_.as_ref().to_glib_none().0,
                download_size.as_mut_ptr(),
                installed_size.as_mut_ptr(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok((download_size.assume_init(), installed_size.assume_init()))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Get a global configuration option for the installation, see
    /// [`set_config_sync()`][Self::set_config_sync()] for supported keys.
    /// ## `key`
    /// the name of the key to get
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// The (newly allocated) value, or [`None`] on error (`G_KEY_FILE_ERROR_KEY_NOT_FOUND` error if key is not set)
    #[doc(alias = "flatpak_installation_get_config")]
    #[doc(alias = "get_config")]
    fn config(
        &self,
        key: &str,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<glib::GString, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_get_config(
                self.as_ref().to_glib_none().0,
                key.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Get the last build of reference `name` that was installed with
    /// [`InstallationExtManual::install()`][crate::prelude::InstallationExtManual::install()], or [`None`] if the reference has
    /// never been installed locally.
    /// ## `name`
    /// the name of the app
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// an [`InstalledRef`][crate::InstalledRef]
    #[doc(alias = "flatpak_installation_get_current_installed_app")]
    #[doc(alias = "get_current_installed_app")]
    fn current_installed_app(
        &self,
        name: &str,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<InstalledRef, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_get_current_installed_app(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Get the default languages used by the installation to decide which
    /// subpaths to install of locale extensions. This list may also be used
    /// by frontends like GNOME Software to decide which language-specific apps
    /// to display. An empty array means that all languages should be installed.
    ///
    /// # Returns
    ///
    ///
    ///  A possibly empty array of strings, or [`None`] on error.
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    #[doc(alias = "flatpak_installation_get_default_languages")]
    #[doc(alias = "get_default_languages")]
    fn default_languages(&self) -> Result<Vec<glib::GString>, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_get_default_languages(
                self.as_ref().to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Like [`default_languages()`][Self::default_languages()] but includes territory
    /// information (e.g. `en_US` rather than `en`) which may be included in the
    /// `extra-languages` configuration.
    ///
    /// Strings returned by this function are in the format specified by
    /// [``setlocale()``](man:setlocale): `language[_territory][.codeset][`modifier`]`.
    ///
    /// # Returns
    ///
    ///
    ///  A possibly empty array of locale strings, or [`None`] on error.
    #[cfg(feature = "v1_5_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5_1")))]
    #[doc(alias = "flatpak_installation_get_default_locales")]
    #[doc(alias = "get_default_locales")]
    fn default_locales(&self) -> Result<Vec<glib::GString>, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_get_default_locales(
                self.as_ref().to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Returns the display name of the installation for `self`.
    ///
    /// Note that this function may return [`None`] if the installation
    /// does not have a display name.
    ///
    /// # Returns
    ///
    /// a string with the installation's display name
    #[doc(alias = "flatpak_installation_get_display_name")]
    #[doc(alias = "get_display_name")]
    fn display_name(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::flatpak_installation_get_display_name(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the ID of the installation for `self`.
    ///
    /// The ID for the default system installation is "default".
    /// The ID for the user installation is "user".
    ///
    /// # Returns
    ///
    /// a string with the installation's ID
    #[doc(alias = "flatpak_installation_get_id")]
    #[doc(alias = "get_id")]
    fn id(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::flatpak_installation_get_id(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "flatpak_installation_get_installed_ref")]
    #[doc(alias = "get_installed_ref")]
    fn installed_ref(
        &self,
        kind: RefKind,
        name: &str,
        arch: Option<&str>,
        branch: Option<&str>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<InstalledRef, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_get_installed_ref(
                self.as_ref().to_glib_none().0,
                kind.into_glib(),
                name.to_glib_none().0,
                arch.to_glib_none().0,
                branch.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Returns whether the installation is for a user-specific location.
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is a per-user installation
    #[doc(alias = "flatpak_installation_get_is_user")]
    #[doc(alias = "get_is_user")]
    fn is_user(&self) -> bool {
        unsafe {
            from_glib(ffi::flatpak_installation_get_is_user(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the min-free-space config value from the OSTree repository of this installation.
    ///
    /// Applications can use this value, together with information about the available
    /// disk space and the size of pending updates or installs, to estimate whether a
    /// pull operation will fail due to running out of disk space.
    ///
    /// # Returns
    ///
    /// [`true`] on success, or [`false`] on error.
    ///
    /// ## `out_bytes`
    /// Location to store the result
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    #[doc(alias = "flatpak_installation_get_min_free_space_bytes")]
    #[doc(alias = "get_min_free_space_bytes")]
    fn min_free_space_bytes(&self) -> Result<u64, glib::Error> {
        unsafe {
            let mut out_bytes = std::mem::MaybeUninit::uninit();
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::flatpak_installation_get_min_free_space_bytes(
                self.as_ref().to_glib_none().0,
                out_bytes.as_mut_ptr(),
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(out_bytes.assume_init())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Returns the value set with [`set_no_interaction()`][Self::set_no_interaction()].
    ///
    /// # Returns
    ///
    /// [`true`] if interactive authorization dialogs are not allowed
    #[cfg(feature = "v1_1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1_1")))]
    #[doc(alias = "flatpak_installation_get_no_interaction")]
    #[doc(alias = "get_no_interaction")]
    fn is_no_interaction(&self) -> bool {
        unsafe {
            from_glib(ffi::flatpak_installation_get_no_interaction(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the installation location for `self`.
    ///
    /// # Returns
    ///
    /// an [`gio::File`][crate::gio::File]
    #[doc(alias = "flatpak_installation_get_path")]
    #[doc(alias = "get_path")]
    fn path(&self) -> Option<gio::File> {
        unsafe {
            from_glib_full(ffi::flatpak_installation_get_path(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the numeric priority of the installation for `self`.
    ///
    /// # Returns
    ///
    /// an integer with the configured priority value
    #[doc(alias = "flatpak_installation_get_priority")]
    #[doc(alias = "get_priority")]
    fn priority(&self) -> i32 {
        unsafe { ffi::flatpak_installation_get_priority(self.as_ref().to_glib_none().0) }
    }

    /// Looks up a remote by name.
    /// ## `name`
    /// a remote name
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a [`Remote`][crate::Remote] instance, or [`None`] with `error`
    ///  set
    #[doc(alias = "flatpak_installation_get_remote_by_name")]
    #[doc(alias = "get_remote_by_name")]
    fn remote_by_name(
        &self,
        name: &str,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Remote, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_get_remote_by_name(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Returns the type of storage of the installation for `self`.
    ///
    /// # Returns
    ///
    /// a [`StorageType`][crate::StorageType]
    #[doc(alias = "flatpak_installation_get_storage_type")]
    #[doc(alias = "get_storage_type")]
    fn storage_type(&self) -> StorageType {
        unsafe {
            from_glib(ffi::flatpak_installation_get_storage_type(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// This is an old deprecated function, you should use
    /// [`Transaction`][crate::Transaction] and [`TransactionExt::add_install_flatpakref()`][crate::prelude::TransactionExt::add_install_flatpakref()]
    /// instead. It has a lot more interesting features.
    ///
    /// Creates a remote based on the passed in .flatpakref file contents
    /// in `ref_file_data` and returns the [`RemoteRef`][crate::RemoteRef] that can be used
    /// to install it.
    ///
    /// Note, the [`RemoteRef`][crate::RemoteRef] will not have the commit field set, or other details, to
    /// avoid unnecessary roundtrips. If you need that you have to resolve it
    /// explicitly with flatpak_installation_fetch_remote_ref_sync ().
    ///
    /// # Deprecated since 1.7
    ///
    /// Use [`TransactionExt::add_install_flatpakref()`][crate::prelude::TransactionExt::add_install_flatpakref()] instead.
    /// ## `ref_file_data`
    /// The ref file contents
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a [`RemoteRef`][crate::RemoteRef] if the remote has been added successfully, [`None`]
    /// on error.
    #[cfg_attr(feature = "v1_7", deprecated = "Since 1.7")]
    #[allow(deprecated)]
    #[doc(alias = "flatpak_installation_install_ref_file")]
    fn install_ref_file(
        &self,
        ref_file_data: &glib::Bytes,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<RemoteRef, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_install_ref_file(
                self.as_ref().to_glib_none().0,
                ref_file_data.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Launch an installed application.
    ///
    /// You can use `flatpak_installation_get_installed_ref()` or
    /// [`current_installed_app()`][Self::current_installed_app()] to find out what builds
    /// are available, in order to get a value for `commit`.
    /// ## `name`
    /// name of the app to launch
    /// ## `arch`
    /// which architecture to launch (default: current architecture)
    /// ## `branch`
    /// which branch of the application (default: "master")
    /// ## `commit`
    /// the commit of `branch` to launch
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// [`true`], unless an error occurred
    #[doc(alias = "flatpak_installation_launch")]
    fn launch(
        &self,
        name: &str,
        arch: Option<&str>,
        branch: Option<&str>,
        commit: Option<&str>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::flatpak_installation_launch(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
                arch.to_glib_none().0,
                branch.to_glib_none().0,
                commit.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Lists the installed references.
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a GPtrArray of
    ///  [`InstalledRef`][crate::InstalledRef] instances
    #[doc(alias = "flatpak_installation_list_installed_refs")]
    fn list_installed_refs(
        &self,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Vec<InstalledRef>, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_list_installed_refs(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_container(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Lists the installed references of a specific kind.
    /// ## `kind`
    /// the kind of installation
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a GPtrArray of
    ///  [`InstalledRef`][crate::InstalledRef] instances
    #[doc(alias = "flatpak_installation_list_installed_refs_by_kind")]
    fn list_installed_refs_by_kind(
        &self,
        kind: RefKind,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Vec<InstalledRef>, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_list_installed_refs_by_kind(
                self.as_ref().to_glib_none().0,
                kind.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_container(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Lists the installed apps and runtimes that have an update available, either
    /// from the configured remote or locally available but not deployed (see
    /// [`TransactionExt::set_no_deploy()`][crate::prelude::TransactionExt::set_no_deploy()]).
    ///
    /// This also checks if any of [`InstalledRef`][crate::InstalledRef] has a missing [`RelatedRef`][crate::RelatedRef]
    /// (which has `should-download` set to [`true`]) or runtime. If so, it adds the
    /// ref to the returning [`glib::PtrArray`][crate::glib::PtrArray] to pull in the [`RelatedRef`][crate::RelatedRef] or runtime
    /// again via an update operation in [`Transaction`][crate::Transaction].
    ///
    /// In case more than one app needs an update of the same runtime or extension,
    /// this function will return all of those apps.
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a GPtrArray of
    ///  [`InstalledRef`][crate::InstalledRef] instances, or [`None`] on error
    #[doc(alias = "flatpak_installation_list_installed_refs_for_update")]
    fn list_installed_refs_for_update(
        &self,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Vec<InstalledRef>, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_list_installed_refs_for_update(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_container(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Lists all the locally installed refs that are related to `ref_`. These are
    /// things that are interesting to install, update, or uninstall together with
    /// `ref_`. For instance, locale data or debug information.
    ///
    /// Note that while the related refs are usually installed from the same remote
    /// as `ref_` (`remote_name`), it is possible they were installed from another
    /// remote.
    ///
    /// This function is similar to flatpak_installation_list_remote_related_refs_sync,
    /// but instead of looking at what is available on the remote, it only looks
    /// at the locally installed refs. This is useful for instance when you're
    /// looking for related refs to uninstall, or when you're planning to use
    /// FLATPAK_UPDATE_FLAGS_NO_PULL to install previously pulled refs.
    /// ## `remote_name`
    /// the name of the remote providing `ref_`
    /// ## `ref_`
    /// the ref
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a GPtrArray of
    ///  [`RelatedRef`][crate::RelatedRef] instances
    #[doc(alias = "flatpak_installation_list_installed_related_refs_sync")]
    fn list_installed_related_refs_sync(
        &self,
        remote_name: &str,
        ref_: &str,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Vec<RelatedRef>, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_list_installed_related_refs_sync(
                self.as_ref().to_glib_none().0,
                remote_name.to_glib_none().0,
                ref_.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_container(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Lists the installed references that are pinned, meaning they will not be
    /// returned by [`list_unused_refs()`][Self::list_unused_refs()] and won't be removed
    /// unless explicitly specified for removal.
    ///
    /// Refs appear here either because they have been pinned automatically by
    /// Flatpak or because the user pinned them; see flatpak-pin(1).
    /// ## `arch`
    /// if non-[`None`], the architecture of refs to collect
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a GPtrArray of
    ///  [`InstalledRef`][crate::InstalledRef] instances
    #[cfg(feature = "v1_9_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9_1")))]
    #[doc(alias = "flatpak_installation_list_pinned_refs")]
    fn list_pinned_refs(
        &self,
        arch: Option<&str>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Vec<InstalledRef>, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_list_pinned_refs(
                self.as_ref().to_glib_none().0,
                arch.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_container(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Lists all the applications and runtimes in a remote.
    /// ## `remote_or_uri`
    /// the name or URI of the remote
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a GPtrArray of
    ///  [`RemoteRef`][crate::RemoteRef] instances
    #[doc(alias = "flatpak_installation_list_remote_refs_sync")]
    fn list_remote_refs_sync(
        &self,
        remote_or_uri: &str,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Vec<RemoteRef>, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_list_remote_refs_sync(
                self.as_ref().to_glib_none().0,
                remote_or_uri.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_container(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Lists all the applications and runtimes in a remote.
    /// ## `remote_or_uri`
    /// the name or URI of the remote
    /// ## `flags`
    /// set of [`QueryFlags`][crate::QueryFlags]
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a GPtrArray of
    ///  [`RemoteRef`][crate::RemoteRef] instances
    #[cfg(feature = "v1_3_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3_3")))]
    #[doc(alias = "flatpak_installation_list_remote_refs_sync_full")]
    fn list_remote_refs_sync_full(
        &self,
        remote_or_uri: &str,
        flags: QueryFlags,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Vec<RemoteRef>, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_list_remote_refs_sync_full(
                self.as_ref().to_glib_none().0,
                remote_or_uri.to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_container(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Lists all the available refs on `remote_name` that are related to `ref_`, and
    /// which are appropriate for the installed version of `ref_`. For example if the
    /// installed version of org.videolan.VLC has a related ref of
    /// org.videolan.VLC.Plugin.bdj//3-19.08 and the remote version of VLC has a
    /// related ref of org.videolan.VLC.Plugin.bdj//3-20.08, this function will only
    /// return the 3-19.08 branch.
    ///
    /// See also the related functions
    /// [`list_remote_related_refs_sync()`][Self::list_remote_related_refs_sync()] and
    /// [`list_installed_related_refs_sync()`][Self::list_installed_related_refs_sync()].
    ///
    /// The returned list contains all available related refs, but not
    /// every one should always be installed. For example,
    /// [`RelatedRefExt::should_download()`][crate::prelude::RelatedRefExt::should_download()] returns [`true`] if the
    /// reference should be installed/updated with the app, and
    /// [`RelatedRefExt::should_delete()`][crate::prelude::RelatedRefExt::should_delete()] returns [`true`] if it
    /// should be uninstalled with the main ref.
    ///
    /// The commit property of each [`RelatedRef`][crate::RelatedRef] is not guaranteed to be
    /// non-[`None`].
    /// ## `remote_name`
    /// the name of the remote
    /// ## `ref_`
    /// the ref
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a GPtrArray of
    ///  [`RelatedRef`][crate::RelatedRef] instances
    #[cfg(feature = "v1_11_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_11_1")))]
    #[doc(alias = "flatpak_installation_list_remote_related_refs_for_installed_sync")]
    fn list_remote_related_refs_for_installed_sync(
        &self,
        remote_name: &str,
        ref_: &str,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Vec<RelatedRef>, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_list_remote_related_refs_for_installed_sync(
                self.as_ref().to_glib_none().0,
                remote_name.to_glib_none().0,
                ref_.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_container(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Lists all the available refs on `remote_name` that are related to
    /// `ref_`, and the subpaths to use. These are things that are
    /// interesting to install, update, or uninstall together with
    /// `ref_`. For instance, locale data or debug information.
    ///
    /// The returned list contains all available related refs, but not
    /// every one should always be installed. For example,
    /// [`RelatedRefExt::should_download()`][crate::prelude::RelatedRefExt::should_download()] returns [`true`] if the
    /// reference should be installed/updated with the app, and
    /// [`RelatedRefExt::should_delete()`][crate::prelude::RelatedRefExt::should_delete()] returns [`true`] if it
    /// should be uninstalled with the main ref.
    ///
    /// The commit property of each [`RelatedRef`][crate::RelatedRef] is not guaranteed to be
    /// non-[`None`].
    /// ## `remote_name`
    /// the name of the remote
    /// ## `ref_`
    /// the ref
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a GPtrArray of
    ///  [`RelatedRef`][crate::RelatedRef] instances
    #[doc(alias = "flatpak_installation_list_remote_related_refs_sync")]
    fn list_remote_related_refs_sync(
        &self,
        remote_name: &str,
        ref_: &str,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Vec<RelatedRef>, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_list_remote_related_refs_sync(
                self.as_ref().to_glib_none().0,
                remote_name.to_glib_none().0,
                ref_.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_container(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Lists the static remotes, in priority (highest first) order. For same
    /// priority, an earlier added remote comes before a later added one.
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a GPtrArray of
    ///  [`Remote`][crate::Remote] instances
    #[doc(alias = "flatpak_installation_list_remotes")]
    fn list_remotes(
        &self,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Vec<Remote>, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_list_remotes(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_container(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    //#[doc(alias = "flatpak_installation_list_remotes_by_type")]
    //fn list_remotes_by_type(&self, types: /*Unimplemented*/&CArray TypeId { ns_id: 1, id: 17 }, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Vec<Remote>, glib::Error> {
    //    unsafe { TODO: call ffi:flatpak_installation_list_remotes_by_type() }
    //}

    /// Lists the installed references that are not 'used'.
    ///
    /// A reference is used if it is either an application,
    /// or the runtime or sdk of a used ref, or an extension of a used ref.
    /// Pinned runtimes are also considered used; see flatpak-pin(1) and
    /// [`list_pinned_refs()`][Self::list_pinned_refs()].
    /// ## `arch`
    /// if non-[`None`], the architecture of refs to collect
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// a GPtrArray of
    ///  [`InstalledRef`][crate::InstalledRef] instances
    #[cfg(feature = "v1_1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1_2")))]
    #[doc(alias = "flatpak_installation_list_unused_refs")]
    fn list_unused_refs(
        &self,
        arch: Option<&str>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Vec<InstalledRef>, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_list_unused_refs(
                self.as_ref().to_glib_none().0,
                arch.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_container(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    //#[cfg(feature = "v1_9_1")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_9_1")))]
    //#[doc(alias = "flatpak_installation_list_unused_refs_with_options")]
    //fn list_unused_refs_with_options(&self, arch: Option<&str>, metadata_injection: /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 25 }/TypeId { ns_id: 0, id: 25 }, options: Option<&glib::Variant>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Vec<InstalledRef>, glib::Error> {
    //    unsafe { TODO: call ffi:flatpak_installation_list_unused_refs_with_options() }
    //}

    /// Loads the metadata overrides file for an application.
    /// ## `app_id`
    /// an application id
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// the contents of the overrides files,
    ///  or [`None`] if an error occurred
    #[doc(alias = "flatpak_installation_load_app_overrides")]
    fn load_app_overrides(
        &self,
        app_id: &str,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<glib::GString, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::flatpak_installation_load_app_overrides(
                self.as_ref().to_glib_none().0,
                app_id.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Saves changes in the `remote` object.
    /// ## `remote`
    /// the modified [`Remote`][crate::Remote]
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// [`true`] if the modifications have been committed successfully
    #[doc(alias = "flatpak_installation_modify_remote")]
    fn modify_remote(
        &self,
        remote: &impl IsA<Remote>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::flatpak_installation_modify_remote(
                self.as_ref().to_glib_none().0,
                remote.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Remove all orphaned OSTree objects from the underlying OSTree repo in
    /// `self`.
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// [`true`] on success
    #[doc(alias = "flatpak_installation_prune_local_repo")]
    fn prune_local_repo(
        &self,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::flatpak_installation_prune_local_repo(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Remove the OSTree ref given by `remote_name`:`ref_` from the local flatpak
    /// repository. The next time the underlying OSTree repo is pruned, objects
    /// which were attached to that ref will be removed. This is useful if you
    /// pulled a flatpak ref using [`InstallationExtManual::install_full()`][crate::prelude::InstallationExtManual::install_full()] and
    /// specified [`InstallFlags::NO_DEPLOY`][crate::InstallFlags::NO_DEPLOY] but then decided not to
    /// deploy the ref later on and want to remove the local ref to prevent it
    /// from taking up disk space. Note that this will not remove the objects
    /// referred to by `ref_` from the underlying OSTree repo, you should use
    /// [`prune_local_repo()`][Self::prune_local_repo()] to do that.
    /// ## `remote_name`
    /// the name of the remote
    /// ## `ref_`
    /// the ref
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// [`true`] on success
    #[doc(alias = "flatpak_installation_remove_local_ref_sync")]
    fn remove_local_ref_sync(
        &self,
        remote_name: &str,
        ref_: &str,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::flatpak_installation_remove_local_ref_sync(
                self.as_ref().to_glib_none().0,
                remote_name.to_glib_none().0,
                ref_.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Removes the remote with the given name from the installation.
    /// ## `name`
    /// the name of the remote to remove
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// [`true`] if the remote has been removed successfully
    #[doc(alias = "flatpak_installation_remove_remote")]
    fn remove_remote(
        &self,
        name: &str,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::flatpak_installation_remove_remote(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Run the trigger commands to update the files exported by the apps in
    /// `self`. Should be used after one or more app install, upgrade or
    /// uninstall operations with the [`InstallFlags::NO_TRIGGERS`][crate::InstallFlags::NO_TRIGGERS],
    /// [`UpdateFlags::NO_TRIGGERS`][crate::UpdateFlags::NO_TRIGGERS] or [`UninstallFlags::NO_TRIGGERS`][crate::UninstallFlags::NO_TRIGGERS]
    /// flags set.
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// [`true`] on success
    #[cfg(feature = "v1_0_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_0_3")))]
    #[doc(alias = "flatpak_installation_run_triggers")]
    fn run_triggers(
        &self,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::flatpak_installation_run_triggers(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Set a global configuration option for the installation, currently
    /// the only supported keys are `languages`, which is a semicolon-separated
    /// list of language codes like `"sv;en;pl"`, or `""` to mean all languages,
    /// and `extra-languages`, which is a semicolon-separated list of locale
    /// identifiers like `"en;en_DK;zh_HK.big5hkscs;uz_UZ.utf8`cyrillic`"`.
    /// ## `key`
    /// the name of the key to set
    /// ## `value`
    /// the new value, or [`None`] to unset
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// [`true`] if the option was set correctly
    #[doc(alias = "flatpak_installation_set_config_sync")]
    fn set_config_sync(
        &self,
        key: &str,
        value: &str,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::flatpak_installation_set_config_sync(
                self.as_ref().to_glib_none().0,
                key.to_glib_none().0,
                value.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// This method can be used to prevent interactive authorization dialogs to appear
    /// for operations on `self`. This is useful for background operations that are not
    /// directly triggered by a user action.
    ///
    /// By default, interaction is allowed.
    /// ## `no_interaction`
    /// Whether to disallow interactive authorization for operations
    #[cfg(feature = "v1_1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1_1")))]
    #[doc(alias = "flatpak_installation_set_no_interaction")]
    fn set_no_interaction(&self, no_interaction: bool) {
        unsafe {
            ffi::flatpak_installation_set_no_interaction(
                self.as_ref().to_glib_none().0,
                no_interaction.into_glib(),
            );
        }
    }

    /// Updates the local configuration of a remote repository by fetching
    /// the related information from the summary file in the remote OSTree
    /// repository and committing the changes to the local installation.
    /// ## `name`
    /// the name of the remote to update
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable]
    ///
    /// # Returns
    ///
    /// [`true`] if the remote has been updated successfully
    #[doc(alias = "flatpak_installation_update_remote_sync")]
    fn update_remote_sync(
        &self,
        name: &str,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::flatpak_installation_update_remote_sync(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }
}

impl<O: IsA<Installation>> InstallationExt for O {}