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

use crate::AsyncResult;
use crate::BusType;
use crate::Cancellable;
use crate::DBusConnection;
use crate::File;
use crate::IOErrorEnum;
use crate::IOStream;
use crate::Icon;
use crate::InputStream;
use crate::Resource;
use crate::ResourceLookupFlags;
use crate::SettingsBackend;
use glib::object::IsA;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::mem;
use std::pin::Pin;
use std::ptr;

/// Asynchronously connects to the message bus specified by `bus_type`.
///
/// When the operation is finished, `callback` will be invoked. You can
/// then call `g_bus_get_finish()` to get the result of the operation.
///
/// This is an asynchronous failable function. See [`bus_get_sync()`][crate::bus_get_sync()] for
/// the synchronous version.
/// ## `bus_type`
/// a [`BusType`][crate::BusType]
/// ## `cancellable`
/// a [`Cancellable`][crate::Cancellable] or [`None`]
/// ## `callback`
/// a `GAsyncReadyCallback` to call when the request is satisfied
#[doc(alias = "g_bus_get")]
pub fn bus_get<P: FnOnce(Result<DBusConnection, glib::Error>) + 'static>(
    bus_type: BusType,
    cancellable: Option<&impl IsA<Cancellable>>,
    callback: P,
) {
    let main_context = glib::MainContext::ref_thread_default();
    let is_main_context_owner = main_context.is_owner();
    let has_acquired_main_context = (!is_main_context_owner)
        .then(|| main_context.acquire().ok())
        .flatten();
    assert!(
        is_main_context_owner || has_acquired_main_context.is_some(),
        "Async operations only allowed if the thread is owning the MainContext"
    );

    let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
        Box_::new(glib::thread_guard::ThreadGuard::new(callback));
    unsafe extern "C" fn bus_get_trampoline<
        P: FnOnce(Result<DBusConnection, glib::Error>) + 'static,
    >(
        _source_object: *mut glib::gobject_ffi::GObject,
        res: *mut crate::ffi::GAsyncResult,
        user_data: glib::ffi::gpointer,
    ) {
        let mut error = ptr::null_mut();
        let ret = ffi::g_bus_get_finish(res, &mut error);
        let result = if error.is_null() {
            Ok(from_glib_full(ret))
        } else {
            Err(from_glib_full(error))
        };
        let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::from_raw(user_data as *mut _);
        let callback: P = callback.into_inner();
        callback(result);
    }
    let callback = bus_get_trampoline::<P>;
    unsafe {
        ffi::g_bus_get(
            bus_type.into_glib(),
            cancellable.map(|p| p.as_ref()).to_glib_none().0,
            Some(callback),
            Box_::into_raw(user_data) as *mut _,
        );
    }
}

pub fn bus_get_future(
    bus_type: BusType,
) -> Pin<Box_<dyn std::future::Future<Output = Result<DBusConnection, glib::Error>> + 'static>> {
    Box_::pin(crate::GioFuture::new(
        &(),
        move |_obj, cancellable, send| {
            bus_get(bus_type, Some(cancellable), move |res| {
                send.resolve(res);
            });
        },
    ))
}

/// Synchronously connects to the message bus specified by `bus_type`.
/// Note that the returned object may shared with other callers,
/// e.g. if two separate parts of a process calls this function with
/// the same `bus_type`, they will share the same object.
///
/// This is a synchronous failable function. See [`bus_get()`][crate::bus_get()] and
/// `g_bus_get_finish()` for the asynchronous version.
///
/// The returned object is a singleton, that is, shared with other
/// callers of [`bus_get()`][crate::bus_get()] and [`bus_get_sync()`][crate::bus_get_sync()] for `bus_type`. In the
/// event that you need a private message bus connection, use
/// [`dbus_address_get_for_bus_sync()`][crate::dbus_address_get_for_bus_sync()] and
/// [`DBusConnection::for_address()`][crate::DBusConnection::for_address()] with
/// G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT and
/// G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION flags.
///
/// Note that the returned [`DBusConnection`][crate::DBusConnection] object will (usually) have
/// the `property::DBusConnection::exit-on-close` property set to [`true`].
/// ## `bus_type`
/// a [`BusType`][crate::BusType]
/// ## `cancellable`
/// a [`Cancellable`][crate::Cancellable] or [`None`]
///
/// # Returns
///
/// a [`DBusConnection`][crate::DBusConnection] or [`None`] if `error` is set.
///  Free with `g_object_unref()`.
#[doc(alias = "g_bus_get_sync")]
pub fn bus_get_sync(
    bus_type: BusType,
    cancellable: Option<&impl IsA<Cancellable>>,
) -> Result<DBusConnection, glib::Error> {
    unsafe {
        let mut error = ptr::null_mut();
        let ret = ffi::g_bus_get_sync(
            bus_type.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))
        }
    }
}

//#[doc(alias = "g_bus_own_name")]
//pub fn bus_own_name(bus_type: BusType, name: &str, flags: BusNameOwnerFlags, bus_acquired_handler: Option<Box_<dyn Fn(&DBusConnection, &str) + 'static>>, name_acquired_handler: Option<Box_<dyn Fn(&DBusConnection, &str) + 'static>>, name_lost_handler: Option<Box_<dyn Fn(&DBusConnection, &str) + 'static>>) -> u32 {
//    unsafe { TODO: call ffi:g_bus_own_name() }
//}

//#[doc(alias = "g_bus_own_name_on_connection")]
//pub fn bus_own_name_on_connection(connection: &DBusConnection, name: &str, flags: BusNameOwnerFlags, name_acquired_handler: Option<Box_<dyn Fn(&DBusConnection, &str) + 'static>>, name_lost_handler: Option<Box_<dyn Fn(&DBusConnection, &str) + 'static>>) -> u32 {
//    unsafe { TODO: call ffi:g_bus_own_name_on_connection() }
//}

//#[doc(alias = "g_bus_watch_name")]
//pub fn bus_watch_name(bus_type: BusType, name: &str, flags: BusNameWatcherFlags, name_appeared_handler: Option<Box_<dyn Fn(&DBusConnection, &str, &str) + 'static>>, name_vanished_handler: Option<Box_<dyn Fn(&DBusConnection, &str) + 'static>>) -> u32 {
//    unsafe { TODO: call ffi:g_bus_watch_name() }
//}

//#[doc(alias = "g_bus_watch_name_on_connection")]
//pub fn bus_watch_name_on_connection(connection: &DBusConnection, name: &str, flags: BusNameWatcherFlags, name_appeared_handler: Option<Box_<dyn Fn(&DBusConnection, &str, &str) + 'static>>, name_vanished_handler: Option<Box_<dyn Fn(&DBusConnection, &str) + 'static>>) -> u32 {
//    unsafe { TODO: call ffi:g_bus_watch_name_on_connection() }
//}

/// Checks if a content type can be executable. Note that for instance
/// things like text files can be executables (i.e. scripts and batch files).
/// ## `type_`
/// a content type string
///
/// # Returns
///
/// [`true`] if the file type corresponds to a type that
///  can be executable, [`false`] otherwise.
#[doc(alias = "g_content_type_can_be_executable")]
pub fn content_type_can_be_executable(type_: &str) -> bool {
    unsafe {
        from_glib(ffi::g_content_type_can_be_executable(
            type_.to_glib_none().0,
        ))
    }
}

/// Compares two content types for equality.
/// ## `type1`
/// a content type string
/// ## `type2`
/// a content type string
///
/// # Returns
///
/// [`true`] if the two strings are identical or equivalent,
///  [`false`] otherwise.
#[doc(alias = "g_content_type_equals")]
pub fn content_type_equals(type1: &str, type2: &str) -> bool {
    unsafe {
        from_glib(ffi::g_content_type_equals(
            type1.to_glib_none().0,
            type2.to_glib_none().0,
        ))
    }
}

/// Tries to find a content type based on the mime type name.
/// ## `mime_type`
/// a mime type string
///
/// # Returns
///
/// Newly allocated string with content type or
///  [`None`]. Free with `g_free()`
#[doc(alias = "g_content_type_from_mime_type")]
pub fn content_type_from_mime_type(mime_type: &str) -> Option<glib::GString> {
    unsafe {
        from_glib_full(ffi::g_content_type_from_mime_type(
            mime_type.to_glib_none().0,
        ))
    }
}

/// Gets the human readable description of the content type.
/// ## `type_`
/// a content type string
///
/// # Returns
///
/// a short description of the content type `type_`. Free the
///  returned string with `g_free()`
#[doc(alias = "g_content_type_get_description")]
pub fn content_type_get_description(type_: &str) -> glib::GString {
    unsafe { from_glib_full(ffi::g_content_type_get_description(type_.to_glib_none().0)) }
}

/// Gets the generic icon name for a content type.
///
/// See the
/// [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
/// specification for more on the generic icon name.
/// ## `type_`
/// a content type string
///
/// # Returns
///
/// the registered generic icon name for the given `type_`,
///  or [`None`] if unknown. Free with `g_free()`
#[doc(alias = "g_content_type_get_generic_icon_name")]
pub fn content_type_get_generic_icon_name(type_: &str) -> Option<glib::GString> {
    unsafe {
        from_glib_full(ffi::g_content_type_get_generic_icon_name(
            type_.to_glib_none().0,
        ))
    }
}

/// Gets the icon for a content type.
/// ## `type_`
/// a content type string
///
/// # Returns
///
/// [`Icon`][crate::Icon] corresponding to the content type. Free the returned
///  object with `g_object_unref()`
#[doc(alias = "g_content_type_get_icon")]
pub fn content_type_get_icon(type_: &str) -> Icon {
    unsafe { from_glib_full(ffi::g_content_type_get_icon(type_.to_glib_none().0)) }
}

/// Get the list of directories which MIME data is loaded from. See
/// [`content_type_set_mime_dirs()`][crate::content_type_set_mime_dirs()] for details.
///
/// # Returns
///
/// [`None`]-terminated list of
///  directories to load MIME data from, including any `mime/` subdirectory,
///  and with the first directory to try listed first
#[cfg(any(feature = "v2_60", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_60")))]
#[doc(alias = "g_content_type_get_mime_dirs")]
pub fn content_type_get_mime_dirs() -> Vec<glib::GString> {
    unsafe { FromGlibPtrContainer::from_glib_none(ffi::g_content_type_get_mime_dirs()) }
}

/// Gets the mime type for the content type, if one is registered.
/// ## `type_`
/// a content type string
///
/// # Returns
///
/// the registered mime type for the
///  given `type_`, or [`None`] if unknown; free with `g_free()`.
#[doc(alias = "g_content_type_get_mime_type")]
pub fn content_type_get_mime_type(type_: &str) -> Option<glib::GString> {
    unsafe { from_glib_full(ffi::g_content_type_get_mime_type(type_.to_glib_none().0)) }
}

/// Gets the symbolic icon for a content type.
/// ## `type_`
/// a content type string
///
/// # Returns
///
/// symbolic [`Icon`][crate::Icon] corresponding to the content type.
///  Free the returned object with `g_object_unref()`
#[doc(alias = "g_content_type_get_symbolic_icon")]
pub fn content_type_get_symbolic_icon(type_: &str) -> Icon {
    unsafe {
        from_glib_full(ffi::g_content_type_get_symbolic_icon(
            type_.to_glib_none().0,
        ))
    }
}

/// Guesses the content type based on example data. If the function is
/// uncertain, `result_uncertain` will be set to [`true`]. Either `filename`
/// or `data` may be [`None`], in which case the guess will be based solely
/// on the other argument.
/// ## `filename`
/// a path, or [`None`]
/// ## `data`
/// a stream of data, or [`None`]
///
/// # Returns
///
/// a string indicating a guessed content type for the
///  given data. Free with `g_free()`
///
/// ## `result_uncertain`
/// return location for the certainty
///  of the result, or [`None`]
#[doc(alias = "g_content_type_guess")]
pub fn content_type_guess(
    filename: Option<impl AsRef<std::path::Path>>,
    data: &[u8],
) -> (glib::GString, bool) {
    let data_size = data.len() as usize;
    unsafe {
        let mut result_uncertain = mem::MaybeUninit::uninit();
        let ret = from_glib_full(ffi::g_content_type_guess(
            filename.as_ref().map(|p| p.as_ref()).to_glib_none().0,
            data.to_glib_none().0,
            data_size,
            result_uncertain.as_mut_ptr(),
        ));
        (ret, from_glib(result_uncertain.assume_init()))
    }
}

/// Tries to guess the type of the tree with root `root`, by
/// looking at the files it contains. The result is an array
/// of content types, with the best guess coming first.
///
/// The types returned all have the form x-content/foo, e.g.
/// x-content/audio-cdda (for audio CDs) or x-content/image-dcf
/// (for a camera memory card). See the
/// [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
/// specification for more on x-content types.
///
/// This function is useful in the implementation of
/// [`MountExt::guess_content_type()`][crate::prelude::MountExt::guess_content_type()].
/// ## `root`
/// the root of the tree to guess a type for
///
/// # Returns
///
/// an [`None`]-terminated
///  array of zero or more content types. Free with `g_strfreev()`
#[doc(alias = "g_content_type_guess_for_tree")]
pub fn content_type_guess_for_tree(root: &impl IsA<File>) -> Vec<glib::GString> {
    unsafe {
        FromGlibPtrContainer::from_glib_full(ffi::g_content_type_guess_for_tree(
            root.as_ref().to_glib_none().0,
        ))
    }
}

/// Determines if `type_` is a subset of `supertype`.
/// ## `type_`
/// a content type string
/// ## `supertype`
/// a content type string
///
/// # Returns
///
/// [`true`] if `type_` is a kind of `supertype`,
///  [`false`] otherwise.
#[doc(alias = "g_content_type_is_a")]
pub fn content_type_is_a(type_: &str, supertype: &str) -> bool {
    unsafe {
        from_glib(ffi::g_content_type_is_a(
            type_.to_glib_none().0,
            supertype.to_glib_none().0,
        ))
    }
}

/// Determines if `type_` is a subset of `mime_type`.
/// Convenience wrapper around [`content_type_is_a()`][crate::content_type_is_a()].
/// ## `type_`
/// a content type string
/// ## `mime_type`
/// a mime type string
///
/// # Returns
///
/// [`true`] if `type_` is a kind of `mime_type`,
///  [`false`] otherwise.
#[doc(alias = "g_content_type_is_mime_type")]
pub fn content_type_is_mime_type(type_: &str, mime_type: &str) -> bool {
    unsafe {
        from_glib(ffi::g_content_type_is_mime_type(
            type_.to_glib_none().0,
            mime_type.to_glib_none().0,
        ))
    }
}

/// Checks if the content type is the generic "unknown" type.
/// On UNIX this is the "application/octet-stream" mimetype,
/// while on win32 it is "*" and on OSX it is a dynamic type
/// or octet-stream.
/// ## `type_`
/// a content type string
///
/// # Returns
///
/// [`true`] if the type is the unknown type.
#[doc(alias = "g_content_type_is_unknown")]
pub fn content_type_is_unknown(type_: &str) -> bool {
    unsafe { from_glib(ffi::g_content_type_is_unknown(type_.to_glib_none().0)) }
}

/// Set the list of directories used by GIO to load the MIME database.
/// If `dirs` is [`None`], the directories used are the default:
///
///  - the `mime` subdirectory of the directory in `$XDG_DATA_HOME`
///  - the `mime` subdirectory of every directory in `$XDG_DATA_DIRS`
///
/// This function is intended to be used when writing tests that depend on
/// information stored in the MIME database, in order to control the data.
///
/// Typically, in case your tests use `G_TEST_OPTION_ISOLATE_DIRS`, but they
/// depend on the system’s MIME database, you should call this function
/// with `dirs` set to [`None`] before calling `g_test_init()`, for instance:
///
///
///
/// **⚠️ The following code is in C ⚠️**
///
/// ```C
///   // Load MIME data from the system
///   g_content_type_set_mime_dirs (NULL);
///   // Isolate the environment
///   g_test_init (&argc, &argv, G_TEST_OPTION_ISOLATE_DIRS, NULL);
///
///   …
///
///   return g_test_run ();
/// ```
/// ## `dirs`
/// [`None`]-terminated list of
///  directories to load MIME data from, including any `mime/` subdirectory,
///  and with the first directory to try listed first
#[cfg(any(feature = "v2_60", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_60")))]
#[doc(alias = "g_content_type_set_mime_dirs")]
pub fn content_type_set_mime_dirs(dirs: &[&str]) {
    unsafe {
        ffi::g_content_type_set_mime_dirs(dirs.to_glib_none().0);
    }
}

/// Gets a list of strings containing all the registered content types
/// known to the system. The list and its data should be freed using
/// `g_list_free_full (list, g_free)`.
///
/// # Returns
///
/// list of the registered
///  content types
#[doc(alias = "g_content_types_get_registered")]
pub fn content_types_get_registered() -> Vec<glib::GString> {
    unsafe { FromGlibPtrContainer::from_glib_full(ffi::g_content_types_get_registered()) }
}

/// Escape `string` so it can appear in a D-Bus address as the value
/// part of a key-value pair.
///
/// For instance, if `string` is `/run/bus-for-:0`,
/// this function would return `/run/bus-for-`3A0``,
/// which could be used in a D-Bus address like
/// `unix:nonce-tcp:host=127.0.0.1,port=42,noncefile=/run/bus-for-`3A0``.
/// ## `string`
/// an unescaped string to be included in a D-Bus address
///  as the value in a key-value pair
///
/// # Returns
///
/// a copy of `string` with all
///  non-optionally-escaped bytes escaped
#[doc(alias = "g_dbus_address_escape_value")]
pub fn dbus_address_escape_value(string: &str) -> glib::GString {
    unsafe { from_glib_full(ffi::g_dbus_address_escape_value(string.to_glib_none().0)) }
}

/// Synchronously looks up the D-Bus address for the well-known message
/// bus instance specified by `bus_type`. This may involve using various
/// platform specific mechanisms.
///
/// The returned address will be in the
/// [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html`addresses`).
/// ## `bus_type`
/// a [`BusType`][crate::BusType]
/// ## `cancellable`
/// a [`Cancellable`][crate::Cancellable] or [`None`]
///
/// # Returns
///
/// a valid D-Bus address string for `bus_type` or
///  [`None`] if `error` is set
#[doc(alias = "g_dbus_address_get_for_bus_sync")]
pub fn dbus_address_get_for_bus_sync(
    bus_type: BusType,
    cancellable: Option<&impl IsA<Cancellable>>,
) -> Result<glib::GString, glib::Error> {
    unsafe {
        let mut error = ptr::null_mut();
        let ret = ffi::g_dbus_address_get_for_bus_sync(
            bus_type.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))
        }
    }
}

/// Asynchronously connects to an endpoint specified by `address` and
/// sets up the connection so it is in a state to run the client-side
/// of the D-Bus authentication conversation. `address` must be in the
/// [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html`addresses`).
///
/// When the operation is finished, `callback` will be invoked. You can
/// then call `g_dbus_address_get_stream_finish()` to get the result of
/// the operation.
///
/// This is an asynchronous failable function. See
/// [`dbus_address_get_stream_sync()`][crate::dbus_address_get_stream_sync()] for the synchronous version.
/// ## `address`
/// A valid D-Bus address.
/// ## `cancellable`
/// A [`Cancellable`][crate::Cancellable] or [`None`].
/// ## `callback`
/// A `GAsyncReadyCallback` to call when the request is satisfied.
#[doc(alias = "g_dbus_address_get_stream")]
pub fn dbus_address_get_stream<
    P: FnOnce(Result<(IOStream, Option<glib::GString>), glib::Error>) + 'static,
>(
    address: &str,
    cancellable: Option<&impl IsA<Cancellable>>,
    callback: P,
) {
    let main_context = glib::MainContext::ref_thread_default();
    let is_main_context_owner = main_context.is_owner();
    let has_acquired_main_context = (!is_main_context_owner)
        .then(|| main_context.acquire().ok())
        .flatten();
    assert!(
        is_main_context_owner || has_acquired_main_context.is_some(),
        "Async operations only allowed if the thread is owning the MainContext"
    );

    let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
        Box_::new(glib::thread_guard::ThreadGuard::new(callback));
    unsafe extern "C" fn dbus_address_get_stream_trampoline<
        P: FnOnce(Result<(IOStream, Option<glib::GString>), glib::Error>) + 'static,
    >(
        _source_object: *mut glib::gobject_ffi::GObject,
        res: *mut crate::ffi::GAsyncResult,
        user_data: glib::ffi::gpointer,
    ) {
        let mut error = ptr::null_mut();
        let mut out_guid = ptr::null_mut();
        let ret = ffi::g_dbus_address_get_stream_finish(res, &mut out_guid, &mut error);
        let result = if error.is_null() {
            Ok((from_glib_full(ret), from_glib_full(out_guid)))
        } else {
            Err(from_glib_full(error))
        };
        let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::from_raw(user_data as *mut _);
        let callback: P = callback.into_inner();
        callback(result);
    }
    let callback = dbus_address_get_stream_trampoline::<P>;
    unsafe {
        ffi::g_dbus_address_get_stream(
            address.to_glib_none().0,
            cancellable.map(|p| p.as_ref()).to_glib_none().0,
            Some(callback),
            Box_::into_raw(user_data) as *mut _,
        );
    }
}

pub fn dbus_address_get_stream_future(
    address: &str,
) -> Pin<
    Box_<
        dyn std::future::Future<Output = Result<(IOStream, Option<glib::GString>), glib::Error>>
            + 'static,
    >,
> {
    let address = String::from(address);
    Box_::pin(crate::GioFuture::new(
        &(),
        move |_obj, cancellable, send| {
            dbus_address_get_stream(&address, Some(cancellable), move |res| {
                send.resolve(res);
            });
        },
    ))
}

/// Synchronously connects to an endpoint specified by `address` and
/// sets up the connection so it is in a state to run the client-side
/// of the D-Bus authentication conversation. `address` must be in the
/// [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html`addresses`).
///
/// A server is not required to set a GUID, so `out_guid` may be set to [`None`]
/// even on success.
///
/// This is a synchronous failable function. See
/// [`dbus_address_get_stream()`][crate::dbus_address_get_stream()] for the asynchronous version.
/// ## `address`
/// A valid D-Bus address.
/// ## `cancellable`
/// A [`Cancellable`][crate::Cancellable] or [`None`].
///
/// # Returns
///
/// A [`IOStream`][crate::IOStream] or [`None`] if `error` is set.
///
/// ## `out_guid`
/// [`None`] or return location to store the GUID extracted from `address`, if any.
#[doc(alias = "g_dbus_address_get_stream_sync")]
pub fn dbus_address_get_stream_sync(
    address: &str,
    cancellable: Option<&impl IsA<Cancellable>>,
) -> Result<(IOStream, Option<glib::GString>), glib::Error> {
    unsafe {
        let mut out_guid = ptr::null_mut();
        let mut error = ptr::null_mut();
        let ret = ffi::g_dbus_address_get_stream_sync(
            address.to_glib_none().0,
            &mut out_guid,
            cancellable.map(|p| p.as_ref()).to_glib_none().0,
            &mut error,
        );
        if error.is_null() {
            Ok((from_glib_full(ret), from_glib_full(out_guid)))
        } else {
            Err(from_glib_full(error))
        }
    }
}

/// This is a language binding friendly version of `g_dbus_escape_object_path_bytestring()`.
/// ## `s`
/// the string to escape
///
/// # Returns
///
/// an escaped version of `s`. Free with `g_free()`.
#[cfg(any(feature = "v2_68", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_68")))]
#[doc(alias = "g_dbus_escape_object_path")]
pub fn dbus_escape_object_path(s: &str) -> glib::GString {
    unsafe { from_glib_full(ffi::g_dbus_escape_object_path(s.to_glib_none().0)) }
}

//#[cfg(any(feature = "v2_68", feature = "dox"))]
//#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_68")))]
//#[doc(alias = "g_dbus_escape_object_path_bytestring")]
//pub fn dbus_escape_object_path_bytestring(bytes: &[u8]) -> glib::GString {
//    unsafe { TODO: call ffi:g_dbus_escape_object_path_bytestring() }
//}

/// Generate a D-Bus GUID that can be used with
/// e.g. [`DBusConnection::new()`][crate::DBusConnection::new()].
///
/// See the
/// [D-Bus specification](https://dbus.freedesktop.org/doc/dbus-specification.html`uuids`)
/// regarding what strings are valid D-Bus GUIDs. The specification refers to
/// these as ‘UUIDs’ whereas GLib (for historical reasons) refers to them as
/// ‘GUIDs’. The terms are interchangeable.
///
/// Note that D-Bus GUIDs do not follow
/// [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122).
///
/// # Returns
///
/// A valid D-Bus GUID. Free with `g_free()`.
#[doc(alias = "g_dbus_generate_guid")]
pub fn dbus_generate_guid() -> glib::GString {
    unsafe { from_glib_full(ffi::g_dbus_generate_guid()) }
}

/// Converts a [`glib::Value`][crate::glib::Value] to a [`glib::Variant`][struct@crate::glib::Variant] of the type indicated by the `type_`
/// parameter.
///
/// The conversion is using the following rules:
///
/// - `G_TYPE_STRING`: 's', 'o', 'g' or 'ay'
/// - `G_TYPE_STRV`: 'as', 'ao' or 'aay'
/// - `G_TYPE_BOOLEAN`: 'b'
/// - `G_TYPE_UCHAR`: 'y'
/// - `G_TYPE_INT`: 'i', 'n'
/// - `G_TYPE_UINT`: 'u', 'q'
/// - `G_TYPE_INT64`: 'x'
/// - `G_TYPE_UINT64`: 't'
/// - `G_TYPE_DOUBLE`: 'd'
/// - `G_TYPE_VARIANT`: Any [`glib::VariantType`][crate::glib::VariantType]
///
/// This can fail if e.g. `gvalue` is of type `G_TYPE_STRING` and `type_`
/// is 'i', i.e. `G_VARIANT_TYPE_INT32`. It will also fail for any `GType`
/// (including e.g. `G_TYPE_OBJECT` and `G_TYPE_BOXED` derived-types) not
/// in the table above.
///
/// Note that if `gvalue` is of type `G_TYPE_VARIANT` and its value is
/// [`None`], the empty [`glib::Variant`][struct@crate::glib::Variant] instance (never [`None`]) for `type_` is
/// returned (e.g. 0 for scalar types, the empty string for string types,
/// '/' for object path types, the empty array for any array type and so on).
///
/// See the [`dbus_gvariant_to_gvalue()`][crate::dbus_gvariant_to_gvalue()] function for how to convert a
/// [`glib::Variant`][struct@crate::glib::Variant] to a [`glib::Value`][crate::glib::Value].
/// ## `gvalue`
/// A [`glib::Value`][crate::glib::Value] to convert to a [`glib::Variant`][struct@crate::glib::Variant]
/// ## `type_`
/// A [`glib::VariantType`][crate::glib::VariantType]
///
/// # Returns
///
/// A [`glib::Variant`][struct@crate::glib::Variant] (never floating) of
///  [`glib::VariantType`][crate::glib::VariantType] `type_` holding the data from `gvalue` or an empty [`glib::Variant`][struct@crate::glib::Variant]
///  in case of failure. Free with `g_variant_unref()`.
#[doc(alias = "g_dbus_gvalue_to_gvariant")]
pub fn dbus_gvalue_to_gvariant(gvalue: &glib::Value, type_: &glib::VariantTy) -> glib::Variant {
    unsafe {
        from_glib_full(ffi::g_dbus_gvalue_to_gvariant(
            gvalue.to_glib_none().0,
            type_.to_glib_none().0,
        ))
    }
}

/// Converts a [`glib::Variant`][struct@crate::glib::Variant] to a [`glib::Value`][crate::glib::Value]. If `value` is floating, it is consumed.
///
/// The rules specified in the [`dbus_gvalue_to_gvariant()`][crate::dbus_gvalue_to_gvariant()] function are
/// used - this function is essentially its reverse form. So, a [`glib::Variant`][struct@crate::glib::Variant]
/// containing any basic or string array type will be converted to a [`glib::Value`][crate::glib::Value]
/// containing a basic value or string array. Any other [`glib::Variant`][struct@crate::glib::Variant] (handle,
/// variant, tuple, dict entry) will be converted to a [`glib::Value`][crate::glib::Value] containing that
/// [`glib::Variant`][struct@crate::glib::Variant].
///
/// The conversion never fails - a valid [`glib::Value`][crate::glib::Value] is always returned in
/// `out_gvalue`.
/// ## `value`
/// A [`glib::Variant`][struct@crate::glib::Variant].
///
/// # Returns
///
///
/// ## `out_gvalue`
/// Return location pointing to a zero-filled (uninitialized) [`glib::Value`][crate::glib::Value].
#[doc(alias = "g_dbus_gvariant_to_gvalue")]
pub fn dbus_gvariant_to_gvalue(value: &glib::Variant) -> glib::Value {
    unsafe {
        let mut out_gvalue = glib::Value::uninitialized();
        ffi::g_dbus_gvariant_to_gvalue(value.to_glib_none().0, out_gvalue.to_glib_none_mut().0);
        out_gvalue
    }
}

/// Checks if `string` is a
/// [D-Bus address](https://dbus.freedesktop.org/doc/dbus-specification.html`addresses`).
///
/// This doesn't check if `string` is actually supported by [`DBusServer`][crate::DBusServer]
/// or [`DBusConnection`][crate::DBusConnection] - use [`dbus_is_supported_address()`][crate::dbus_is_supported_address()] to do more
/// checks.
/// ## `string`
/// A string.
///
/// # Returns
///
/// [`true`] if `string` is a valid D-Bus address, [`false`] otherwise.
#[doc(alias = "g_dbus_is_address")]
pub fn dbus_is_address(string: &str) -> bool {
    unsafe { from_glib(ffi::g_dbus_is_address(string.to_glib_none().0)) }
}

/// Check whether `string` is a valid D-Bus error name.
///
/// This function returns the same result as [`dbus_is_interface_name()`][crate::dbus_is_interface_name()],
/// because D-Bus error names are defined to have exactly the
/// same syntax as interface names.
/// ## `string`
/// The string to check.
///
/// # Returns
///
/// [`true`] if valid, [`false`] otherwise.
#[cfg(any(feature = "v2_70", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_70")))]
#[doc(alias = "g_dbus_is_error_name")]
pub fn dbus_is_error_name(string: &str) -> bool {
    unsafe { from_glib(ffi::g_dbus_is_error_name(string.to_glib_none().0)) }
}

/// Checks if `string` is a D-Bus GUID.
///
/// See the documentation for [`dbus_generate_guid()`][crate::dbus_generate_guid()] for more information about
/// the format of a GUID.
/// ## `string`
/// The string to check.
///
/// # Returns
///
/// [`true`] if `string` is a GUID, [`false`] otherwise.
#[doc(alias = "g_dbus_is_guid")]
pub fn dbus_is_guid(string: &str) -> bool {
    unsafe { from_glib(ffi::g_dbus_is_guid(string.to_glib_none().0)) }
}

/// Checks if `string` is a valid D-Bus interface name.
/// ## `string`
/// The string to check.
///
/// # Returns
///
/// [`true`] if valid, [`false`] otherwise.
#[doc(alias = "g_dbus_is_interface_name")]
pub fn dbus_is_interface_name(string: &str) -> bool {
    unsafe { from_glib(ffi::g_dbus_is_interface_name(string.to_glib_none().0)) }
}

/// Checks if `string` is a valid D-Bus member (e.g. signal or method) name.
/// ## `string`
/// The string to check.
///
/// # Returns
///
/// [`true`] if valid, [`false`] otherwise.
#[doc(alias = "g_dbus_is_member_name")]
pub fn dbus_is_member_name(string: &str) -> bool {
    unsafe { from_glib(ffi::g_dbus_is_member_name(string.to_glib_none().0)) }
}

/// Checks if `string` is a valid D-Bus bus name (either unique or well-known).
/// ## `string`
/// The string to check.
///
/// # Returns
///
/// [`true`] if valid, [`false`] otherwise.
#[doc(alias = "g_dbus_is_name")]
pub fn dbus_is_name(string: &str) -> bool {
    unsafe { from_glib(ffi::g_dbus_is_name(string.to_glib_none().0)) }
}

/// Like [`dbus_is_address()`][crate::dbus_is_address()] but also checks if the library supports the
/// transports in `string` and that key/value pairs for each transport
/// are valid. See the specification of the
/// [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html`addresses`).
/// ## `string`
/// A string.
///
/// # Returns
///
/// [`true`] if `string` is a valid D-Bus address that is
/// supported by this library, [`false`] if `error` is set.
#[doc(alias = "g_dbus_is_supported_address")]
pub fn dbus_is_supported_address(string: &str) -> Result<(), glib::Error> {
    unsafe {
        let mut error = ptr::null_mut();
        let is_ok = ffi::g_dbus_is_supported_address(string.to_glib_none().0, &mut error);
        assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
        if error.is_null() {
            Ok(())
        } else {
            Err(from_glib_full(error))
        }
    }
}

/// Checks if `string` is a valid D-Bus unique bus name.
/// ## `string`
/// The string to check.
///
/// # Returns
///
/// [`true`] if valid, [`false`] otherwise.
#[doc(alias = "g_dbus_is_unique_name")]
pub fn dbus_is_unique_name(string: &str) -> bool {
    unsafe { from_glib(ffi::g_dbus_is_unique_name(string.to_glib_none().0)) }
}

/// Converts errno.h error codes into GIO error codes. The fallback
/// value [`IOErrorEnum::Failed`][crate::IOErrorEnum::Failed] is returned for error codes not currently
/// handled (but note that future GLib releases may return a more
/// specific value instead).
///
/// As `errno` is global and may be modified by intermediate function
/// calls, you should save its value as soon as the call which sets it
/// ## `err_no`
/// Error number as defined in errno.h.
///
/// # Returns
///
/// [`IOErrorEnum`][crate::IOErrorEnum] value for the given errno.h error number.
#[doc(alias = "g_io_error_from_errno")]
pub fn io_error_from_errno(err_no: i32) -> IOErrorEnum {
    unsafe { from_glib(ffi::g_io_error_from_errno(err_no)) }
}

//#[doc(alias = "g_io_modules_load_all_in_directory")]
//pub fn io_modules_load_all_in_directory(dirname: impl AsRef<std::path::Path>) -> /*Ignored*/Vec<IOModule> {
//    unsafe { TODO: call ffi:g_io_modules_load_all_in_directory() }
//}

//#[doc(alias = "g_io_modules_load_all_in_directory_with_scope")]
//pub fn io_modules_load_all_in_directory_with_scope(dirname: impl AsRef<std::path::Path>, scope: /*Ignored*/&mut IOModuleScope) -> /*Ignored*/Vec<IOModule> {
//    unsafe { TODO: call ffi:g_io_modules_load_all_in_directory_with_scope() }
//}

/// Scans all the modules in the specified directory, ensuring that
/// any extension point implemented by a module is registered.
///
/// This may not actually load and initialize all the types in each
/// module, some modules may be lazily loaded and initialized when
/// an extension point it implements is used with e.g.
/// [`IOExtensionPoint::extensions()`][crate::IOExtensionPoint::extensions()] or
/// [`IOExtensionPoint::extension_by_name()`][crate::IOExtensionPoint::extension_by_name()].
///
/// If you need to guarantee that all types are loaded in all the modules,
/// use `g_io_modules_load_all_in_directory()`.
/// ## `dirname`
/// pathname for a directory containing modules
///  to scan.
#[doc(alias = "g_io_modules_scan_all_in_directory")]
pub fn io_modules_scan_all_in_directory(dirname: impl AsRef<std::path::Path>) {
    unsafe {
        ffi::g_io_modules_scan_all_in_directory(dirname.as_ref().to_glib_none().0);
    }
}

//#[doc(alias = "g_io_modules_scan_all_in_directory_with_scope")]
//pub fn io_modules_scan_all_in_directory_with_scope(dirname: impl AsRef<std::path::Path>, scope: /*Ignored*/&mut IOModuleScope) {
//    unsafe { TODO: call ffi:g_io_modules_scan_all_in_directory_with_scope() }
//}

/// Creates a keyfile-backed [`SettingsBackend`][crate::SettingsBackend].
///
/// The filename of the keyfile to use is given by `filename`.
///
/// All settings read to or written from the backend must fall under the
/// path given in `root_path` (which must start and end with a slash and
/// not contain two consecutive slashes). `root_path` may be "/".
///
/// If `root_group` is non-[`None`] then it specifies the name of the keyfile
/// group used for keys that are written directly below `root_path`. For
/// example, if `root_path` is "/apps/example/" and `root_group` is
/// "toplevel", then settings the key "/apps/example/enabled" to a value
/// of [`true`] will cause the following to appear in the keyfile:
///
///
/// ```text
///   [toplevel]
///   enabled=true
/// ```
///
/// If `root_group` is [`None`] then it is not permitted to store keys
/// directly below the `root_path`.
///
/// For keys not stored directly below `root_path` (ie: in a sub-path),
/// the name of the subpath (with the final slash stripped) is used as
/// the name of the keyfile group. To continue the example, if
/// "/apps/example/profiles/default/font-size" were set to
/// 12 then the following would appear in the keyfile:
///
///
/// ```text
///   [profiles/default]
///   font-size=12
/// ```
///
/// The backend will refuse writes (and return writability as being
/// [`false`]) for keys outside of `root_path` and, in the event that
/// `root_group` is [`None`], also for keys directly under `root_path`.
/// Writes will also be refused if the backend detects that it has the
/// inability to rewrite the keyfile (ie: the containing directory is not
/// writable).
///
/// There is no checking done for your key namespace clashing with the
/// syntax of the key file format. For example, if you have '[' or ']'
/// characters in your path names or '=' in your key names you may be in
/// trouble.
///
/// The backend reads default values from a keyfile called `defaults` in
/// the directory specified by the `GKeyfileSettingsBackend:defaults-dir` property,
/// and a list of locked keys from a text file with the name `locks` in
/// the same location.
/// ## `filename`
/// the filename of the keyfile
/// ## `root_path`
/// the path under which all settings keys appear
/// ## `root_group`
/// the group name corresponding to
///  `root_path`, or [`None`]
///
/// # Returns
///
/// a keyfile-backed [`SettingsBackend`][crate::SettingsBackend]
#[doc(alias = "g_keyfile_settings_backend_new")]
pub fn keyfile_settings_backend_new(
    filename: &str,
    root_path: &str,
    root_group: Option<&str>,
) -> SettingsBackend {
    unsafe {
        from_glib_full(ffi::g_keyfile_settings_backend_new(
            filename.to_glib_none().0,
            root_path.to_glib_none().0,
            root_group.to_glib_none().0,
        ))
    }
}

/// Creates a memory-backed [`SettingsBackend`][crate::SettingsBackend].
///
/// This backend allows changes to settings, but does not write them
/// to any backing storage, so the next time you run your application,
/// the memory backend will start out with the default values again.
///
/// # Returns
///
/// a newly created [`SettingsBackend`][crate::SettingsBackend]
#[doc(alias = "g_memory_settings_backend_new")]
pub fn memory_settings_backend_new() -> SettingsBackend {
    unsafe { from_glib_full(ffi::g_memory_settings_backend_new()) }
}

/// Creates a readonly [`SettingsBackend`][crate::SettingsBackend].
///
/// This backend does not allow changes to settings, so all settings
/// will always have their default values.
///
/// # Returns
///
/// a newly created [`SettingsBackend`][crate::SettingsBackend]
#[doc(alias = "g_null_settings_backend_new")]
pub fn null_settings_backend_new() -> SettingsBackend {
    unsafe { from_glib_full(ffi::g_null_settings_backend_new()) }
}

/// Returns all the names of children at the specified `path` in the set of
/// globally registered resources.
/// The return result is a [`None`] terminated list of strings which should
/// be released with `g_strfreev()`.
///
/// `lookup_flags` controls the behaviour of the lookup.
/// ## `path`
/// A pathname inside the resource
/// ## `lookup_flags`
/// A [`ResourceLookupFlags`][crate::ResourceLookupFlags]
///
/// # Returns
///
/// an array of constant strings
#[doc(alias = "g_resources_enumerate_children")]
pub fn resources_enumerate_children(
    path: &str,
    lookup_flags: ResourceLookupFlags,
) -> Result<Vec<glib::GString>, glib::Error> {
    unsafe {
        let mut error = ptr::null_mut();
        let ret = ffi::g_resources_enumerate_children(
            path.to_glib_none().0,
            lookup_flags.into_glib(),
            &mut error,
        );
        if error.is_null() {
            Ok(FromGlibPtrContainer::from_glib_full(ret))
        } else {
            Err(from_glib_full(error))
        }
    }
}

/// Looks for a file at the specified `path` in the set of
/// globally registered resources and if found returns information about it.
///
/// `lookup_flags` controls the behaviour of the lookup.
/// ## `path`
/// A pathname inside the resource
/// ## `lookup_flags`
/// A [`ResourceLookupFlags`][crate::ResourceLookupFlags]
///
/// # Returns
///
/// [`true`] if the file was found. [`false`] if there were errors
///
/// ## `size`
/// a location to place the length of the contents of the file,
///  or [`None`] if the length is not needed
///
/// ## `flags`
/// a location to place the `GResourceFlags` about the file,
///  or [`None`] if the flags are not needed
#[doc(alias = "g_resources_get_info")]
pub fn resources_get_info(
    path: &str,
    lookup_flags: ResourceLookupFlags,
) -> Result<(usize, u32), glib::Error> {
    unsafe {
        let mut size = mem::MaybeUninit::uninit();
        let mut flags = mem::MaybeUninit::uninit();
        let mut error = ptr::null_mut();
        let is_ok = ffi::g_resources_get_info(
            path.to_glib_none().0,
            lookup_flags.into_glib(),
            size.as_mut_ptr(),
            flags.as_mut_ptr(),
            &mut error,
        );
        assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
        if error.is_null() {
            Ok((size.assume_init(), flags.assume_init()))
        } else {
            Err(from_glib_full(error))
        }
    }
}

/// Looks for a file at the specified `path` in the set of
/// globally registered resources and returns a [`glib::Bytes`][crate::glib::Bytes] that
/// lets you directly access the data in memory.
///
/// The data is always followed by a zero byte, so you
/// can safely use the data as a C string. However, that byte
/// is not included in the size of the GBytes.
///
/// For uncompressed resource files this is a pointer directly into
/// the resource bundle, which is typically in some readonly data section
/// in the program binary. For compressed files we allocate memory on
/// the heap and automatically uncompress the data.
///
/// `lookup_flags` controls the behaviour of the lookup.
/// ## `path`
/// A pathname inside the resource
/// ## `lookup_flags`
/// A [`ResourceLookupFlags`][crate::ResourceLookupFlags]
///
/// # Returns
///
/// [`glib::Bytes`][crate::glib::Bytes] or [`None`] on error.
///  Free the returned object with `g_bytes_unref()`
#[doc(alias = "g_resources_lookup_data")]
pub fn resources_lookup_data(
    path: &str,
    lookup_flags: ResourceLookupFlags,
) -> Result<glib::Bytes, glib::Error> {
    unsafe {
        let mut error = ptr::null_mut();
        let ret = ffi::g_resources_lookup_data(
            path.to_glib_none().0,
            lookup_flags.into_glib(),
            &mut error,
        );
        if error.is_null() {
            Ok(from_glib_full(ret))
        } else {
            Err(from_glib_full(error))
        }
    }
}

/// Looks for a file at the specified `path` in the set of
/// globally registered resources and returns a [`InputStream`][crate::InputStream]
/// that lets you read the data.
///
/// `lookup_flags` controls the behaviour of the lookup.
/// ## `path`
/// A pathname inside the resource
/// ## `lookup_flags`
/// A [`ResourceLookupFlags`][crate::ResourceLookupFlags]
///
/// # Returns
///
/// [`InputStream`][crate::InputStream] or [`None`] on error.
///  Free the returned object with `g_object_unref()`
#[doc(alias = "g_resources_open_stream")]
pub fn resources_open_stream(
    path: &str,
    lookup_flags: ResourceLookupFlags,
) -> Result<InputStream, glib::Error> {
    unsafe {
        let mut error = ptr::null_mut();
        let ret = ffi::g_resources_open_stream(
            path.to_glib_none().0,
            lookup_flags.into_glib(),
            &mut error,
        );
        if error.is_null() {
            Ok(from_glib_full(ret))
        } else {
            Err(from_glib_full(error))
        }
    }
}

/// Registers the resource with the process-global set of resources.
/// Once a resource is registered the files in it can be accessed
/// with the global resource lookup functions like [`resources_lookup_data()`][crate::resources_lookup_data()].
/// ## `resource`
/// A [`Resource`][crate::Resource]
#[doc(alias = "g_resources_register")]
pub fn resources_register(resource: &Resource) {
    unsafe {
        ffi::g_resources_register(resource.to_glib_none().0);
    }
}

/// Unregisters the resource from the process-global set of resources.
/// ## `resource`
/// A [`Resource`][crate::Resource]
#[doc(alias = "g_resources_unregister")]
pub fn resources_unregister(resource: &Resource) {
    unsafe {
        ffi::g_resources_unregister(resource.to_glib_none().0);
    }
}

/// Determines if `mount_path` is considered an implementation of the
/// OS. This is primarily used for hiding mountable and mounted volumes
/// that only are used in the OS and has little to no relevance to the
/// casual user.
/// ## `mount_path`
/// a mount path, e.g. `/media/disk` or `/usr`
///
/// # Returns
///
/// [`true`] if `mount_path` is considered an implementation detail
///  of the OS.
#[cfg(any(unix, feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(unix)))]
#[doc(alias = "g_unix_is_mount_path_system_internal")]
pub fn unix_is_mount_path_system_internal(mount_path: impl AsRef<std::path::Path>) -> bool {
    unsafe {
        from_glib(ffi::g_unix_is_mount_path_system_internal(
            mount_path.as_ref().to_glib_none().0,
        ))
    }
}

/// Determines if `device_path` is considered a block device path which is only
/// used in implementation of the OS. This is primarily used for hiding
/// mounted volumes that are intended as APIs for programs to read, and system
/// administrators at a shell; rather than something that should, for example,
/// appear in a GUI. For example, the Linux `/proc` filesystem.
///
/// The list of device paths considered ‘system’ ones may change over time.
/// ## `device_path`
/// a device path, e.g. `/dev/loop0` or `nfsd`
///
/// # Returns
///
/// [`true`] if `device_path` is considered an implementation detail of
///  the OS.
#[cfg(any(unix, feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(unix)))]
#[doc(alias = "g_unix_is_system_device_path")]
pub fn unix_is_system_device_path(device_path: impl AsRef<std::path::Path>) -> bool {
    unsafe {
        from_glib(ffi::g_unix_is_system_device_path(
            device_path.as_ref().to_glib_none().0,
        ))
    }
}

/// Determines if `fs_type` is considered a type of file system which is only
/// used in implementation of the OS. This is primarily used for hiding
/// mounted volumes that are intended as APIs for programs to read, and system
/// administrators at a shell; rather than something that should, for example,
/// appear in a GUI. For example, the Linux `/proc` filesystem.
///
/// The list of file system types considered ‘system’ ones may change over time.
/// ## `fs_type`
/// a file system type, e.g. `procfs` or `tmpfs`
///
/// # Returns
///
/// [`true`] if `fs_type` is considered an implementation detail of the OS.
#[cfg(any(unix, feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(unix)))]
#[doc(alias = "g_unix_is_system_fs_type")]
pub fn unix_is_system_fs_type(fs_type: &str) -> bool {
    unsafe { from_glib(ffi::g_unix_is_system_fs_type(fs_type.to_glib_none().0)) }
}