// 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 std::ffi::CStr;

/// Extension point for debug control functionality.
/// See [Extending GIO][extending-gio].
#[cfg(any(feature = "v2_72", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_72")))]
#[doc(alias = "G_DEBUG_CONTROLLER_EXTENSION_POINT_NAME")]
pub static DEBUG_CONTROLLER_EXTENSION_POINT_NAME: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_DEBUG_CONTROLLER_EXTENSION_POINT_NAME)
            .to_str()
            .unwrap()
    });
/// The string used to obtain a Unix device path with [`DriveExt::identifier()`][crate::prelude::DriveExt::identifier()].
#[cfg(any(feature = "v2_58", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_58")))]
#[doc(alias = "G_DRIVE_IDENTIFIER_KIND_UNIX_DEVICE")]
pub static DRIVE_IDENTIFIER_KIND_UNIX_DEVICE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_DRIVE_IDENTIFIER_KIND_UNIX_DEVICE)
            .to_str()
            .unwrap()
    });
/// A key in the "access" namespace for checking deletion privileges.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
///
/// This attribute will be [`true`] if the user is able to delete the file.
#[doc(alias = "G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE")]
pub static FILE_ATTRIBUTE_ACCESS_CAN_DELETE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE)
            .to_str()
            .unwrap()
    });
/// A key in the "access" namespace for getting execution privileges.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
///
/// This attribute will be [`true`] if the user is able to execute the file.
#[doc(alias = "G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE")]
pub static FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE)
            .to_str()
            .unwrap()
    });
/// A key in the "access" namespace for getting read privileges.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
///
/// This attribute will be [`true`] if the user is able to read the file.
#[doc(alias = "G_FILE_ATTRIBUTE_ACCESS_CAN_READ")]
pub static FILE_ATTRIBUTE_ACCESS_CAN_READ: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_ACCESS_CAN_READ)
            .to_str()
            .unwrap()
    });
/// A key in the "access" namespace for checking renaming privileges.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
///
/// This attribute will be [`true`] if the user is able to rename the file.
#[doc(alias = "G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME")]
pub static FILE_ATTRIBUTE_ACCESS_CAN_RENAME: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME)
            .to_str()
            .unwrap()
    });
/// A key in the "access" namespace for checking trashing privileges.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
///
/// This attribute will be [`true`] if the user is able to move the file to
/// the trash.
#[doc(alias = "G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH")]
pub static FILE_ATTRIBUTE_ACCESS_CAN_TRASH: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH)
            .to_str()
            .unwrap()
    });
/// A key in the "access" namespace for getting write privileges.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
///
/// This attribute will be [`true`] if the user is able to write to the file.
#[doc(alias = "G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE")]
pub static FILE_ATTRIBUTE_ACCESS_CAN_WRITE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE)
            .to_str()
            .unwrap()
    });
/// A key in the "dos" namespace for checking if the file's archive flag
/// is set.
///
/// This attribute is [`true`] if the archive flag is set.
///
/// This attribute is only available for DOS file systems.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_DOS_IS_ARCHIVE")]
pub static FILE_ATTRIBUTE_DOS_IS_ARCHIVE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_DOS_IS_ARCHIVE)
            .to_str()
            .unwrap()
    });
/// A key in the "dos" namespace for checking if the file is a NTFS mount point
/// (a volume mount or a junction point).
///
/// This attribute is [`true`] if file is a reparse point of type
/// [IO_REPARSE_TAG_MOUNT_POINT](https://msdn.microsoft.com/en-us/library/dd541667.aspx).
///
/// This attribute is only available for DOS file systems.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[cfg(any(feature = "v2_60", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_60")))]
#[doc(alias = "G_FILE_ATTRIBUTE_DOS_IS_MOUNTPOINT")]
pub static FILE_ATTRIBUTE_DOS_IS_MOUNTPOINT: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_DOS_IS_MOUNTPOINT)
            .to_str()
            .unwrap()
    });
/// A key in the "dos" namespace for checking if the file's backup flag
/// is set.
///
/// This attribute is [`true`] if the backup flag is set.
///
/// This attribute is only available for DOS file systems.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_DOS_IS_SYSTEM")]
pub static FILE_ATTRIBUTE_DOS_IS_SYSTEM: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_DOS_IS_SYSTEM)
            .to_str()
            .unwrap()
    });
/// A key in the "dos" namespace for getting the file NTFS reparse tag.
///
/// This value is 0 for files that are not reparse points.
///
/// See the [Reparse Tags](https://msdn.microsoft.com/en-us/library/dd541667.aspx)
/// page for possible reparse tag values.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint32`][crate::FileAttributeType::Uint32].
#[cfg(any(feature = "v2_60", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_60")))]
#[doc(alias = "G_FILE_ATTRIBUTE_DOS_REPARSE_POINT_TAG")]
pub static FILE_ATTRIBUTE_DOS_REPARSE_POINT_TAG: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_DOS_REPARSE_POINT_TAG)
            .to_str()
            .unwrap()
    });
/// A key in the "etag" namespace for getting the value of the file's
/// entity tag.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
#[doc(alias = "G_FILE_ATTRIBUTE_ETAG_VALUE")]
pub static FILE_ATTRIBUTE_ETAG_VALUE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_ETAG_VALUE)
            .to_str()
            .unwrap()
    });
/// A key in the "filesystem" namespace for getting the number of bytes
/// of free space left on the file system.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint64`][crate::FileAttributeType::Uint64].
#[doc(alias = "G_FILE_ATTRIBUTE_FILESYSTEM_FREE")]
pub static FILE_ATTRIBUTE_FILESYSTEM_FREE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_FILESYSTEM_FREE)
            .to_str()
            .unwrap()
    });
/// A key in the "filesystem" namespace for checking if the file system
/// is read only.
///
/// Is set to [`true`] if the file system is read only.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_FILESYSTEM_READONLY")]
pub static FILE_ATTRIBUTE_FILESYSTEM_READONLY: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_FILESYSTEM_READONLY)
            .to_str()
            .unwrap()
    });
/// A key in the "filesystem" namespace for checking if the file system
/// is remote.
///
/// Is set to [`true`] if the file system is remote.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_FILESYSTEM_REMOTE")]
pub static FILE_ATTRIBUTE_FILESYSTEM_REMOTE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_FILESYSTEM_REMOTE)
            .to_str()
            .unwrap()
    });
/// A key in the "filesystem" namespace for getting the total size (in
/// bytes) of the file system, used in [`FileExt::query_filesystem_info()`][crate::prelude::FileExt::query_filesystem_info()].
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint64`][crate::FileAttributeType::Uint64].
#[doc(alias = "G_FILE_ATTRIBUTE_FILESYSTEM_SIZE")]
pub static FILE_ATTRIBUTE_FILESYSTEM_SIZE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_FILESYSTEM_SIZE)
            .to_str()
            .unwrap()
    });
/// A key in the "filesystem" namespace for getting the file system's type.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
#[doc(alias = "G_FILE_ATTRIBUTE_FILESYSTEM_TYPE")]
pub static FILE_ATTRIBUTE_FILESYSTEM_TYPE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_FILESYSTEM_TYPE)
            .to_str()
            .unwrap()
    });
/// A key in the "filesystem" namespace for getting the number of bytes
/// used by data on the file system.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint64`][crate::FileAttributeType::Uint64].
#[doc(alias = "G_FILE_ATTRIBUTE_FILESYSTEM_USED")]
pub static FILE_ATTRIBUTE_FILESYSTEM_USED: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_FILESYSTEM_USED)
            .to_str()
            .unwrap()
    });
/// A key in the "filesystem" namespace for hinting a file manager
/// application whether it should preview (e.g. thumbnail) files on the
/// file system.
///
/// The value for this key contain a `GFilesystemPreviewType`.
#[doc(alias = "G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW")]
pub static FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW)
            .to_str()
            .unwrap()
    });
/// A key in the "gvfs" namespace that gets the name of the current
/// GVFS backend in use.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
#[doc(alias = "G_FILE_ATTRIBUTE_GVFS_BACKEND")]
pub static FILE_ATTRIBUTE_GVFS_BACKEND: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_GVFS_BACKEND)
            .to_str()
            .unwrap()
    });
/// A key in the "id" namespace for getting a file identifier.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
///
/// An example use would be during listing files, to avoid recursive
/// directory scanning.
#[doc(alias = "G_FILE_ATTRIBUTE_ID_FILE")]
pub static FILE_ATTRIBUTE_ID_FILE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_ID_FILE)
            .to_str()
            .unwrap()
    });
/// A key in the "id" namespace for getting the file system identifier.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
///
/// An example use would be during drag and drop to see if the source
/// and target are on the same filesystem (default to move) or not (default
/// to copy).
#[doc(alias = "G_FILE_ATTRIBUTE_ID_FILESYSTEM")]
pub static FILE_ATTRIBUTE_ID_FILESYSTEM: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_ID_FILESYSTEM)
            .to_str()
            .unwrap()
    });
/// A key in the "mountable" namespace for checking if a file (of
/// type G_FILE_TYPE_MOUNTABLE) can be ejected.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT")]
pub static FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT)
            .to_str()
            .unwrap()
    });
/// A key in the "mountable" namespace for checking if a file (of
/// type G_FILE_TYPE_MOUNTABLE) is mountable.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT")]
pub static FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT)
            .to_str()
            .unwrap()
    });
/// A key in the "mountable" namespace for checking if a file (of
/// type G_FILE_TYPE_MOUNTABLE) can be polled.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL")]
pub static FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL)
            .to_str()
            .unwrap()
    });
/// A key in the "mountable" namespace for checking if a file (of
/// type G_FILE_TYPE_MOUNTABLE) can be started.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START")]
pub static FILE_ATTRIBUTE_MOUNTABLE_CAN_START: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START)
            .to_str()
            .unwrap()
    });
/// A key in the "mountable" namespace for checking if a file (of
/// type G_FILE_TYPE_MOUNTABLE) can be started degraded.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED")]
pub static FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED)
            .to_str()
            .unwrap()
    });
/// A key in the "mountable" namespace for checking if a file (of
/// type G_FILE_TYPE_MOUNTABLE) can be stopped.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP")]
pub static FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP)
            .to_str()
            .unwrap()
    });
/// A key in the "mountable" namespace for checking if a file (of
/// type G_FILE_TYPE_MOUNTABLE) is unmountable.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT")]
pub static FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT)
            .to_str()
            .unwrap()
    });
/// A key in the "mountable" namespace for getting the HAL UDI for the mountable
/// file.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
#[doc(alias = "G_FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI")]
pub static FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI)
            .to_str()
            .unwrap()
    });
/// A key in the "mountable" namespace for checking if a file (of
/// type G_FILE_TYPE_MOUNTABLE) is automatically polled for media.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC")]
pub static FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC)
            .to_str()
            .unwrap()
    });
/// A key in the "mountable" namespace for getting the [`DriveStartStopType`][crate::DriveStartStopType].
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint32`][crate::FileAttributeType::Uint32].
#[doc(alias = "G_FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE")]
pub static FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE)
            .to_str()
            .unwrap()
    });
/// A key in the "mountable" namespace for getting the unix device.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint32`][crate::FileAttributeType::Uint32].
#[doc(alias = "G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE")]
pub static FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE)
            .to_str()
            .unwrap()
    });
/// A key in the "mountable" namespace for getting the unix device file.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
#[doc(alias = "G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE_FILE")]
pub static FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE_FILE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE_FILE)
            .to_str()
            .unwrap()
    });
/// A key in the "owner" namespace for getting the file owner's group.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
#[doc(alias = "G_FILE_ATTRIBUTE_OWNER_GROUP")]
pub static FILE_ATTRIBUTE_OWNER_GROUP: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_OWNER_GROUP)
            .to_str()
            .unwrap()
    });
/// A key in the "owner" namespace for getting the user name of the
/// file's owner.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
#[doc(alias = "G_FILE_ATTRIBUTE_OWNER_USER")]
pub static FILE_ATTRIBUTE_OWNER_USER: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_OWNER_USER)
            .to_str()
            .unwrap()
    });
/// A key in the "owner" namespace for getting the real name of the
/// user that owns the file.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
#[doc(alias = "G_FILE_ATTRIBUTE_OWNER_USER_REAL")]
pub static FILE_ATTRIBUTE_OWNER_USER_REAL: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_OWNER_USER_REAL)
            .to_str()
            .unwrap()
    });
/// A key in the "preview" namespace for getting a [`Icon`][crate::Icon] that can be
/// used to get preview of the file.
///
/// For example, it may be a low resolution thumbnail without metadata.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Object`][crate::FileAttributeType::Object].
///
/// The value for this key should contain a [`Icon`][crate::Icon].
#[doc(alias = "G_FILE_ATTRIBUTE_PREVIEW_ICON")]
pub static FILE_ATTRIBUTE_PREVIEW_ICON: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_PREVIEW_ICON)
            .to_str()
            .unwrap()
    });
/// A key in the "recent" namespace for getting time, when the metadata for the
/// file in `recent:///` was last changed.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Int64`][crate::FileAttributeType::Int64].
#[cfg(any(feature = "v2_52", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_52")))]
#[doc(alias = "G_FILE_ATTRIBUTE_RECENT_MODIFIED")]
pub static FILE_ATTRIBUTE_RECENT_MODIFIED: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_RECENT_MODIFIED)
            .to_str()
            .unwrap()
    });
/// A key in the "selinux" namespace for getting the file's SELinux
/// context.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
///
/// Note that this attribute is only available if GLib has been built
/// with SELinux support.
#[doc(alias = "G_FILE_ATTRIBUTE_SELINUX_CONTEXT")]
pub static FILE_ATTRIBUTE_SELINUX_CONTEXT: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_SELINUX_CONTEXT)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for getting the amount of disk space
/// that is consumed by the file (in bytes).
///
/// This will generally be larger than the file size (due to block size
/// overhead) but can occasionally be smaller (for example, for sparse files).
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint64`][crate::FileAttributeType::Uint64].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE")]
pub static FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for getting the content type of the file.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
///
/// The value for this key should contain a valid content type.
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE")]
pub static FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for getting the copy name of the file.
///
/// The copy name is an optional version of the name. If available it's always
/// in UTF8, and corresponds directly to the original filename (only transcoded to
/// UTF8). This is useful if you want to copy the file to another filesystem that
/// might have a different encoding. If the filename is not a valid string in the
/// encoding selected for the filesystem it is in then the copy name will not be set.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_COPY_NAME")]
pub static FILE_ATTRIBUTE_STANDARD_COPY_NAME: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_COPY_NAME)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for getting the description of the file.
///
/// The description is a utf8 string that describes the file, generally containing
/// the filename, but can also contain further information. Example descriptions
/// could be "filename (on hostname)" for a remote file or "filename (in trash)"
/// for a file in the trash. This is useful for instance as the window title
/// when displaying a directory or for a bookmarks menu.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_DESCRIPTION")]
pub static FILE_ATTRIBUTE_STANDARD_DESCRIPTION: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_DESCRIPTION)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for getting the display name of the file.
///
/// A display name is guaranteed to be in UTF-8 and can thus be displayed in
/// the UI. It is guaranteed to be set on every file.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME")]
pub static FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for edit name of the file.
///
/// An edit name is similar to the display name, but it is meant to be
/// used when you want to rename the file in the UI. The display name
/// might contain information you don't want in the new filename (such as
/// "(invalid unicode)" if the filename was in an invalid encoding).
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME")]
pub static FILE_ATTRIBUTE_STANDARD_EDIT_NAME: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for getting the fast content type.
///
/// The fast content type isn't as reliable as the regular one, as it
/// only uses the filename to guess it, but it is faster to calculate than the
/// regular content type.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE")]
pub static FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for getting the icon for the file.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Object`][crate::FileAttributeType::Object].
///
/// The value for this key should contain a [`Icon`][crate::Icon].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_ICON")]
pub static FILE_ATTRIBUTE_STANDARD_ICON: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_ICON)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for checking if a file is a backup file.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP")]
pub static FILE_ATTRIBUTE_STANDARD_IS_BACKUP: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for checking if a file is hidden.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN")]
pub static FILE_ATTRIBUTE_STANDARD_IS_HIDDEN: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for checking if the file is a symlink.
/// Typically the actual type is something else, if we followed the symlink
/// to get the type.
///
/// On Windows NTFS mountpoints are considered to be symlinks as well.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK")]
pub static FILE_ATTRIBUTE_STANDARD_IS_SYMLINK: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for checking if a file is virtual.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL")]
pub static FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for checking if a file is
/// volatile. This is meant for opaque, non-POSIX-like backends to
/// indicate that the URI is not persistent. Applications should look
/// at [`FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET`][crate::FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET] for the persistent URI.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_IS_VOLATILE")]
pub static FILE_ATTRIBUTE_STANDARD_IS_VOLATILE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_IS_VOLATILE)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for getting the name of the file.
///
/// The name is the on-disk filename which may not be in any known encoding,
/// and can thus not be generally displayed as is. It is guaranteed to be set on
/// every file.
///
/// Use [`FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME`][crate::FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME] if you need to display the
/// name in a user interface.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::ByteString`][crate::FileAttributeType::ByteString].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_NAME")]
pub static FILE_ATTRIBUTE_STANDARD_NAME: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_NAME)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for getting the file's size (in bytes).
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint64`][crate::FileAttributeType::Uint64].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_SIZE")]
pub static FILE_ATTRIBUTE_STANDARD_SIZE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_SIZE)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for setting the sort order of a file.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Int32`][crate::FileAttributeType::Int32].
///
/// An example use would be in file managers, which would use this key
/// to set the order files are displayed. Files with smaller sort order
/// should be sorted first, and files without sort order as if sort order
/// was zero.
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER")]
pub static FILE_ATTRIBUTE_STANDARD_SORT_ORDER: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for getting the symbolic icon for the file.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Object`][crate::FileAttributeType::Object].
///
/// The value for this key should contain a [`Icon`][crate::Icon].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON")]
pub static FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for getting the symlink target, if the file
/// is a symlink.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::ByteString`][crate::FileAttributeType::ByteString].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET")]
pub static FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for getting the target URI for the file, in
/// the case of [`FileType::Shortcut`][crate::FileType::Shortcut] or [`FileType::Mountable`][crate::FileType::Mountable] files.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_TARGET_URI")]
pub static FILE_ATTRIBUTE_STANDARD_TARGET_URI: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_TARGET_URI)
            .to_str()
            .unwrap()
    });
/// A key in the "standard" namespace for storing file types.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint32`][crate::FileAttributeType::Uint32].
///
/// The value for this key should contain a [`FileType`][crate::FileType].
#[doc(alias = "G_FILE_ATTRIBUTE_STANDARD_TYPE")]
pub static FILE_ATTRIBUTE_STANDARD_TYPE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_STANDARD_TYPE)
            .to_str()
            .unwrap()
    });
/// A key in the "thumbnail" namespace for checking if thumbnailing failed.
///
/// This attribute is [`true`] if thumbnailing failed.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_THUMBNAILING_FAILED")]
pub static FILE_ATTRIBUTE_THUMBNAILING_FAILED: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_THUMBNAILING_FAILED)
            .to_str()
            .unwrap()
    });
/// A key in the "thumbnail" namespace for checking whether the thumbnail is outdated.
///
/// This attribute is [`true`] if the thumbnail is up-to-date with the file it represents,
/// and [`false`] if the file has been modified since the thumbnail was generated.
///
/// If [`FILE_ATTRIBUTE_THUMBNAILING_FAILED`][crate::FILE_ATTRIBUTE_THUMBNAILING_FAILED] is [`true`] and this attribute is [`false`],
/// it indicates that thumbnailing may be attempted again and may succeed.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_THUMBNAIL_IS_VALID")]
pub static FILE_ATTRIBUTE_THUMBNAIL_IS_VALID: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_THUMBNAIL_IS_VALID)
            .to_str()
            .unwrap()
    });
/// A key in the "thumbnail" namespace for getting the path to the thumbnail
/// image.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::ByteString`][crate::FileAttributeType::ByteString].
#[doc(alias = "G_FILE_ATTRIBUTE_THUMBNAIL_PATH")]
pub static FILE_ATTRIBUTE_THUMBNAIL_PATH: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_THUMBNAIL_PATH)
            .to_str()
            .unwrap()
    });
/// A key in the "time" namespace for getting the time the file was last
/// accessed.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint64`][crate::FileAttributeType::Uint64], and
/// contains the time since the file was last accessed, in seconds since the
/// UNIX epoch.
#[doc(alias = "G_FILE_ATTRIBUTE_TIME_ACCESS")]
pub static FILE_ATTRIBUTE_TIME_ACCESS: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_TIME_ACCESS)
            .to_str()
            .unwrap()
    });
/// A key in the "time" namespace for getting the microseconds of the time
/// the file was last accessed.
///
/// This should be used in conjunction with [`FILE_ATTRIBUTE_TIME_ACCESS`][crate::FILE_ATTRIBUTE_TIME_ACCESS].
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint32`][crate::FileAttributeType::Uint32].
#[doc(alias = "G_FILE_ATTRIBUTE_TIME_ACCESS_USEC")]
pub static FILE_ATTRIBUTE_TIME_ACCESS_USEC: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_TIME_ACCESS_USEC)
            .to_str()
            .unwrap()
    });
/// A key in the "time" namespace for getting the time the file was last
/// changed.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint64`][crate::FileAttributeType::Uint64],
/// and contains the time since the file was last changed, in seconds since
/// the UNIX epoch.
///
/// This corresponds to the traditional UNIX ctime.
#[doc(alias = "G_FILE_ATTRIBUTE_TIME_CHANGED")]
pub static FILE_ATTRIBUTE_TIME_CHANGED: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_TIME_CHANGED)
            .to_str()
            .unwrap()
    });
/// A key in the "time" namespace for getting the microseconds of the time
/// the file was last changed.
///
/// This should be used in conjunction with [`FILE_ATTRIBUTE_TIME_CHANGED`][crate::FILE_ATTRIBUTE_TIME_CHANGED].
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint32`][crate::FileAttributeType::Uint32].
#[doc(alias = "G_FILE_ATTRIBUTE_TIME_CHANGED_USEC")]
pub static FILE_ATTRIBUTE_TIME_CHANGED_USEC: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_TIME_CHANGED_USEC)
            .to_str()
            .unwrap()
    });
/// A key in the "time" namespace for getting the time the file was created.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint64`][crate::FileAttributeType::Uint64],
/// and contains the time since the file was created, in seconds since the UNIX
/// epoch.
///
/// This may correspond to Linux `stx_btime`, FreeBSD `st_birthtim`, NetBSD
/// `st_birthtime` or NTFS `ctime`.
#[doc(alias = "G_FILE_ATTRIBUTE_TIME_CREATED")]
pub static FILE_ATTRIBUTE_TIME_CREATED: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_TIME_CREATED)
            .to_str()
            .unwrap()
    });
/// A key in the "time" namespace for getting the microseconds of the time
/// the file was created.
///
/// This should be used in conjunction with [`FILE_ATTRIBUTE_TIME_CREATED`][crate::FILE_ATTRIBUTE_TIME_CREATED].
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint32`][crate::FileAttributeType::Uint32].
#[doc(alias = "G_FILE_ATTRIBUTE_TIME_CREATED_USEC")]
pub static FILE_ATTRIBUTE_TIME_CREATED_USEC: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_TIME_CREATED_USEC)
            .to_str()
            .unwrap()
    });
/// A key in the "time" namespace for getting the time the file was last
/// modified.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint64`][crate::FileAttributeType::Uint64], and
/// contains the time since the file was modified, in seconds since the UNIX
/// epoch.
#[doc(alias = "G_FILE_ATTRIBUTE_TIME_MODIFIED")]
pub static FILE_ATTRIBUTE_TIME_MODIFIED: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_TIME_MODIFIED)
            .to_str()
            .unwrap()
    });
/// A key in the "time" namespace for getting the microseconds of the time
/// the file was last modified.
///
/// This should be used in conjunction with [`FILE_ATTRIBUTE_TIME_MODIFIED`][crate::FILE_ATTRIBUTE_TIME_MODIFIED].
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint32`][crate::FileAttributeType::Uint32].
#[doc(alias = "G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC")]
pub static FILE_ATTRIBUTE_TIME_MODIFIED_USEC: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC)
            .to_str()
            .unwrap()
    });
/// A key in the "trash" namespace for getting the deletion date and time
/// of a file inside the `trash:///` folder.
///
/// The format of the returned string is `YYYY-MM-DDThh:mm:ss`.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::String`][crate::FileAttributeType::String].
#[doc(alias = "G_FILE_ATTRIBUTE_TRASH_DELETION_DATE")]
pub static FILE_ATTRIBUTE_TRASH_DELETION_DATE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_TRASH_DELETION_DATE)
            .to_str()
            .unwrap()
    });
/// A key in the "trash" namespace for getting the number of (toplevel) items
/// that are present in the `trash:///` folder.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint32`][crate::FileAttributeType::Uint32].
#[doc(alias = "G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT")]
pub static FILE_ATTRIBUTE_TRASH_ITEM_COUNT: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT)
            .to_str()
            .unwrap()
    });
/// A key in the "trash" namespace for getting the original path of a file
/// inside the `trash:///` folder before it was trashed.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::ByteString`][crate::FileAttributeType::ByteString].
#[doc(alias = "G_FILE_ATTRIBUTE_TRASH_ORIG_PATH")]
pub static FILE_ATTRIBUTE_TRASH_ORIG_PATH: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_TRASH_ORIG_PATH)
            .to_str()
            .unwrap()
    });
/// A key in the "unix" namespace for getting the number of blocks allocated
/// for the file.
///
/// This attribute is only available for UNIX file systems.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint64`][crate::FileAttributeType::Uint64].
#[doc(alias = "G_FILE_ATTRIBUTE_UNIX_BLOCKS")]
pub static FILE_ATTRIBUTE_UNIX_BLOCKS: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_UNIX_BLOCKS)
            .to_str()
            .unwrap()
    });
/// A key in the "unix" namespace for getting the block size for the file
/// system.
///
/// This attribute is only available for UNIX file systems.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint32`][crate::FileAttributeType::Uint32].
#[doc(alias = "G_FILE_ATTRIBUTE_UNIX_BLOCK_SIZE")]
pub static FILE_ATTRIBUTE_UNIX_BLOCK_SIZE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_UNIX_BLOCK_SIZE)
            .to_str()
            .unwrap()
    });
/// A key in the "unix" namespace for getting the device id of the device the
/// file is located on (see `stat()` documentation).
///
/// This attribute is only available for UNIX file systems.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint32`][crate::FileAttributeType::Uint32].
#[doc(alias = "G_FILE_ATTRIBUTE_UNIX_DEVICE")]
pub static FILE_ATTRIBUTE_UNIX_DEVICE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_UNIX_DEVICE)
            .to_str()
            .unwrap()
    });
/// A key in the "unix" namespace for getting the group ID for the file.
///
/// This attribute is only available for UNIX file systems.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint32`][crate::FileAttributeType::Uint32].
#[doc(alias = "G_FILE_ATTRIBUTE_UNIX_GID")]
pub static FILE_ATTRIBUTE_UNIX_GID: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_UNIX_GID)
            .to_str()
            .unwrap()
    });
/// A key in the "unix" namespace for getting the inode of the file.
///
/// This attribute is only available for UNIX file systems.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint64`][crate::FileAttributeType::Uint64].
#[doc(alias = "G_FILE_ATTRIBUTE_UNIX_INODE")]
pub static FILE_ATTRIBUTE_UNIX_INODE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_UNIX_INODE)
            .to_str()
            .unwrap()
    });
/// A key in the "unix" namespace for checking if the file represents a
/// UNIX mount point.
///
/// This attribute is [`true`] if the file is a UNIX mount point.
///
/// Since 2.58, `/` is considered to be a mount point.
///
/// This attribute is only available for UNIX file systems.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Boolean`][crate::FileAttributeType::Boolean].
#[doc(alias = "G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT")]
pub static FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT)
            .to_str()
            .unwrap()
    });
/// A key in the "unix" namespace for getting the mode of the file
/// (e.g. whether the file is a regular file, symlink, etc).
///
/// See the documentation for ``lstat()``: this attribute is equivalent to
/// the `st_mode` member of `struct stat`, and includes both the file type
/// and permissions.
///
/// This attribute is only available for UNIX file systems.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint32`][crate::FileAttributeType::Uint32].
#[doc(alias = "G_FILE_ATTRIBUTE_UNIX_MODE")]
pub static FILE_ATTRIBUTE_UNIX_MODE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_UNIX_MODE)
            .to_str()
            .unwrap()
    });
/// A key in the "unix" namespace for getting the number of hard links
/// for a file.
///
/// See the documentation for ``lstat()``.
///
/// This attribute is only available for UNIX file systems.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint32`][crate::FileAttributeType::Uint32].
#[doc(alias = "G_FILE_ATTRIBUTE_UNIX_NLINK")]
pub static FILE_ATTRIBUTE_UNIX_NLINK: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_UNIX_NLINK)
            .to_str()
            .unwrap()
    });
/// A key in the "unix" namespace for getting the device ID for the file
/// (if it is a special file).
///
/// See the documentation for ``lstat()``.
///
/// This attribute is only available for UNIX file systems.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint32`][crate::FileAttributeType::Uint32].
#[doc(alias = "G_FILE_ATTRIBUTE_UNIX_RDEV")]
pub static FILE_ATTRIBUTE_UNIX_RDEV: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_UNIX_RDEV)
            .to_str()
            .unwrap()
    });
/// A key in the "unix" namespace for getting the user ID for the file.
///
/// This attribute is only available for UNIX file systems.
///
/// Corresponding [`FileAttributeType`][crate::FileAttributeType] is [`FileAttributeType::Uint32`][crate::FileAttributeType::Uint32].
#[doc(alias = "G_FILE_ATTRIBUTE_UNIX_UID")]
pub static FILE_ATTRIBUTE_UNIX_UID: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_FILE_ATTRIBUTE_UNIX_UID)
            .to_str()
            .unwrap()
    });
/// Extension point for memory usage monitoring functionality.
/// See [Extending GIO][extending-gio].
#[cfg(any(feature = "v2_64", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_64")))]
#[doc(alias = "G_MEMORY_MONITOR_EXTENSION_POINT_NAME")]
pub static MEMORY_MONITOR_EXTENSION_POINT_NAME: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_MEMORY_MONITOR_EXTENSION_POINT_NAME)
            .to_str()
            .unwrap()
    });
/// The menu item attribute which holds the action name of the item. Action
/// names are namespaced with an identifier for the action group in which the
/// action resides. For example, "win." for window-specific actions and "app."
/// for application-wide actions.
///
/// See also `g_menu_model_get_item_attribute()` and `g_menu_item_set_attribute()`.
#[doc(alias = "G_MENU_ATTRIBUTE_ACTION")]
pub static MENU_ATTRIBUTE_ACTION: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_MENU_ATTRIBUTE_ACTION)
            .to_str()
            .unwrap()
    });
/// The menu item attribute that holds the namespace for all action names in
/// menus that are linked from this item.
#[doc(alias = "G_MENU_ATTRIBUTE_ACTION_NAMESPACE")]
pub static MENU_ATTRIBUTE_ACTION_NAMESPACE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_MENU_ATTRIBUTE_ACTION_NAMESPACE)
            .to_str()
            .unwrap()
    });
/// The menu item attribute which holds the icon of the item.
///
/// The icon is stored in the format returned by [`IconExt::serialize()`][crate::prelude::IconExt::serialize()].
///
/// This attribute is intended only to represent 'noun' icons such as
/// favicons for a webpage, or application icons. It should not be used
/// for 'verbs' (ie: stock icons).
#[doc(alias = "G_MENU_ATTRIBUTE_ICON")]
pub static MENU_ATTRIBUTE_ICON: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_MENU_ATTRIBUTE_ICON).to_str().unwrap()
    });
/// The menu item attribute which holds the label of the item.
#[doc(alias = "G_MENU_ATTRIBUTE_LABEL")]
pub static MENU_ATTRIBUTE_LABEL: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_MENU_ATTRIBUTE_LABEL)
            .to_str()
            .unwrap()
    });
/// The menu item attribute which holds the target with which the item's action
/// will be activated.
///
/// See also `g_menu_item_set_action_and_target()`
#[doc(alias = "G_MENU_ATTRIBUTE_TARGET")]
pub static MENU_ATTRIBUTE_TARGET: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_MENU_ATTRIBUTE_TARGET)
            .to_str()
            .unwrap()
    });
/// The name of the link that associates a menu item with a section. The linked
/// menu will usually be shown in place of the menu item, using the item's label
/// as a header.
///
/// See also [`MenuItem::set_link()`][crate::MenuItem::set_link()].
#[doc(alias = "G_MENU_LINK_SECTION")]
pub static MENU_LINK_SECTION: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_MENU_LINK_SECTION).to_str().unwrap()
    });
/// The name of the link that associates a menu item with a submenu.
///
/// See also [`MenuItem::set_link()`][crate::MenuItem::set_link()].
#[doc(alias = "G_MENU_LINK_SUBMENU")]
pub static MENU_LINK_SUBMENU: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_MENU_LINK_SUBMENU).to_str().unwrap()
    });
#[doc(alias = "G_NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME")]
pub static NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME)
            .to_str()
            .unwrap()
    });
/// Extension point for network status monitoring functionality.
/// See [Extending GIO][extending-gio].
#[doc(alias = "G_NETWORK_MONITOR_EXTENSION_POINT_NAME")]
pub static NETWORK_MONITOR_EXTENSION_POINT_NAME: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_NETWORK_MONITOR_EXTENSION_POINT_NAME)
            .to_str()
            .unwrap()
    });
/// Extension point for power profile usage monitoring functionality.
/// See [Extending GIO][extending-gio].
#[cfg(any(feature = "v2_70", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_70")))]
#[doc(alias = "G_POWER_PROFILE_MONITOR_EXTENSION_POINT_NAME")]
pub static POWER_PROFILE_MONITOR_EXTENSION_POINT_NAME: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_POWER_PROFILE_MONITOR_EXTENSION_POINT_NAME)
            .to_str()
            .unwrap()
    });
/// Extension point for proxy functionality.
/// See [Extending GIO][extending-gio].
#[doc(alias = "G_PROXY_EXTENSION_POINT_NAME")]
pub static PROXY_EXTENSION_POINT_NAME: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_PROXY_EXTENSION_POINT_NAME)
            .to_str()
            .unwrap()
    });
/// Extension point for proxy resolving functionality.
/// See [Extending GIO][extending-gio].
#[doc(alias = "G_PROXY_RESOLVER_EXTENSION_POINT_NAME")]
pub static PROXY_RESOLVER_EXTENSION_POINT_NAME: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_PROXY_RESOLVER_EXTENSION_POINT_NAME)
            .to_str()
            .unwrap()
    });
/// Extension point for [`SettingsBackend`][crate::SettingsBackend] functionality.
#[doc(alias = "G_SETTINGS_BACKEND_EXTENSION_POINT_NAME")]
pub static SETTINGS_BACKEND_EXTENSION_POINT_NAME: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_SETTINGS_BACKEND_EXTENSION_POINT_NAME)
            .to_str()
            .unwrap()
    });
/// Extension point for TLS functionality via [`TlsBackend`][crate::TlsBackend].
/// See [Extending GIO][extending-gio].
#[doc(alias = "G_TLS_BACKEND_EXTENSION_POINT_NAME")]
pub static TLS_BACKEND_EXTENSION_POINT_NAME: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_TLS_BACKEND_EXTENSION_POINT_NAME)
            .to_str()
            .unwrap()
    });
/// The purpose used to verify the client certificate in a TLS connection.
/// Used by TLS servers.
#[doc(alias = "G_TLS_DATABASE_PURPOSE_AUTHENTICATE_CLIENT")]
pub static TLS_DATABASE_PURPOSE_AUTHENTICATE_CLIENT: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_TLS_DATABASE_PURPOSE_AUTHENTICATE_CLIENT)
            .to_str()
            .unwrap()
    });
/// The purpose used to verify the server certificate in a TLS connection. This
/// is the most common purpose in use. Used by TLS clients.
#[doc(alias = "G_TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER")]
pub static TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER)
            .to_str()
            .unwrap()
    });
/// Extension point for [`Vfs`][crate::Vfs] functionality.
/// See [Extending GIO][extending-gio].
#[doc(alias = "G_VFS_EXTENSION_POINT_NAME")]
pub static VFS_EXTENSION_POINT_NAME: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_VFS_EXTENSION_POINT_NAME)
            .to_str()
            .unwrap()
    });
/// The string used to obtain the volume class with [`VolumeExt::identifier()`][crate::prelude::VolumeExt::identifier()].
///
/// Known volume classes include `device`, `network`, and `loop`. Other
/// classes may be added in the future.
///
/// This is intended to be used by applications to classify [`Volume`][crate::Volume]
/// instances into different sections - for example a file manager or
/// file chooser can use this information to show `network` volumes under
/// a "Network" heading and `device` volumes under a "Devices" heading.
#[doc(alias = "G_VOLUME_IDENTIFIER_KIND_CLASS")]
pub static VOLUME_IDENTIFIER_KIND_CLASS: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_VOLUME_IDENTIFIER_KIND_CLASS)
            .to_str()
            .unwrap()
    });
/// The string used to obtain a Hal UDI with [`VolumeExt::identifier()`][crate::prelude::VolumeExt::identifier()].
#[cfg_attr(feature = "v2_58", deprecated = "Since 2.58")]
#[doc(alias = "G_VOLUME_IDENTIFIER_KIND_HAL_UDI")]
pub static VOLUME_IDENTIFIER_KIND_HAL_UDI: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_VOLUME_IDENTIFIER_KIND_HAL_UDI)
            .to_str()
            .unwrap()
    });
/// The string used to obtain a filesystem label with [`VolumeExt::identifier()`][crate::prelude::VolumeExt::identifier()].
#[doc(alias = "G_VOLUME_IDENTIFIER_KIND_LABEL")]
pub static VOLUME_IDENTIFIER_KIND_LABEL: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_VOLUME_IDENTIFIER_KIND_LABEL)
            .to_str()
            .unwrap()
    });
/// The string used to obtain a NFS mount with [`VolumeExt::identifier()`][crate::prelude::VolumeExt::identifier()].
#[doc(alias = "G_VOLUME_IDENTIFIER_KIND_NFS_MOUNT")]
pub static VOLUME_IDENTIFIER_KIND_NFS_MOUNT: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_VOLUME_IDENTIFIER_KIND_NFS_MOUNT)
            .to_str()
            .unwrap()
    });
/// The string used to obtain a Unix device path with [`VolumeExt::identifier()`][crate::prelude::VolumeExt::identifier()].
#[doc(alias = "G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE")]
pub static VOLUME_IDENTIFIER_KIND_UNIX_DEVICE: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE)
            .to_str()
            .unwrap()
    });
/// The string used to obtain a UUID with [`VolumeExt::identifier()`][crate::prelude::VolumeExt::identifier()].
#[doc(alias = "G_VOLUME_IDENTIFIER_KIND_UUID")]
pub static VOLUME_IDENTIFIER_KIND_UUID: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_VOLUME_IDENTIFIER_KIND_UUID)
            .to_str()
            .unwrap()
    });
/// Extension point for volume monitor functionality.
/// See [Extending GIO][extending-gio].
#[doc(alias = "G_VOLUME_MONITOR_EXTENSION_POINT_NAME")]
pub static VOLUME_MONITOR_EXTENSION_POINT_NAME: once_cell::sync::Lazy<&'static str> =
    once_cell::sync::Lazy::new(|| unsafe {
        CStr::from_ptr(ffi::G_VOLUME_MONITOR_EXTENSION_POINT_NAME)
            .to_str()
            .unwrap()
    });