gi-gio-2.0.20: GI/Gio/Enums.hs

{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

module GI.Gio.Enums
    ( 

 -- * Enumerations
-- ** BusType #enum:BusType#

    BusType(..)                             ,


-- ** ConverterResult #enum:ConverterResult#

    ConverterResult(..)                     ,


-- ** CredentialsType #enum:CredentialsType#

    CredentialsType(..)                     ,


-- ** DBusError #enum:DBusError#

    DBusError(..)                           ,
    catchDBusError                          ,
    handleDBusError                         ,


-- ** DBusMessageByteOrder #enum:DBusMessageByteOrder#

    DBusMessageByteOrder(..)                ,


-- ** DBusMessageHeaderField #enum:DBusMessageHeaderField#

    DBusMessageHeaderField(..)              ,


-- ** DBusMessageType #enum:DBusMessageType#

    DBusMessageType(..)                     ,


-- ** DataStreamByteOrder #enum:DataStreamByteOrder#

    DataStreamByteOrder(..)                 ,


-- ** DataStreamNewlineType #enum:DataStreamNewlineType#

    DataStreamNewlineType(..)               ,


-- ** DriveStartStopType #enum:DriveStartStopType#

    DriveStartStopType(..)                  ,


-- ** EmblemOrigin #enum:EmblemOrigin#

    EmblemOrigin(..)                        ,


-- ** FileAttributeStatus #enum:FileAttributeStatus#

    FileAttributeStatus(..)                 ,


-- ** FileAttributeType #enum:FileAttributeType#

    FileAttributeType(..)                   ,


-- ** FileMonitorEvent #enum:FileMonitorEvent#

    FileMonitorEvent(..)                    ,


-- ** FileType #enum:FileType#

    FileType(..)                            ,


-- ** FilesystemPreviewType #enum:FilesystemPreviewType#

    FilesystemPreviewType(..)               ,


-- ** IOErrorEnum #enum:IOErrorEnum#

    IOErrorEnum(..)                         ,
    catchIOErrorEnum                        ,
    handleIOErrorEnum                       ,


-- ** IOModuleScopeFlags #enum:IOModuleScopeFlags#

    IOModuleScopeFlags(..)                  ,


-- ** MountOperationResult #enum:MountOperationResult#

    MountOperationResult(..)                ,


-- ** NetworkConnectivity #enum:NetworkConnectivity#

    NetworkConnectivity(..)                 ,


-- ** NotificationPriority #enum:NotificationPriority#

    NotificationPriority(..)                ,


-- ** PasswordSave #enum:PasswordSave#

    PasswordSave(..)                        ,


-- ** PollableReturn #enum:PollableReturn#

    PollableReturn(..)                      ,


-- ** ResolverError #enum:ResolverError#

    ResolverError(..)                       ,
    catchResolverError                      ,
    handleResolverError                     ,


-- ** ResolverRecordType #enum:ResolverRecordType#

    ResolverRecordType(..)                  ,


-- ** ResourceError #enum:ResourceError#

    ResourceError(..)                       ,
    catchResourceError                      ,
    handleResourceError                     ,


-- ** SocketClientEvent #enum:SocketClientEvent#

    SocketClientEvent(..)                   ,


-- ** SocketFamily #enum:SocketFamily#

    SocketFamily(..)                        ,


-- ** SocketListenerEvent #enum:SocketListenerEvent#

    SocketListenerEvent(..)                 ,


-- ** SocketProtocol #enum:SocketProtocol#

    SocketProtocol(..)                      ,


-- ** SocketType #enum:SocketType#

    SocketType(..)                          ,


-- ** TlsAuthenticationMode #enum:TlsAuthenticationMode#

    TlsAuthenticationMode(..)               ,


-- ** TlsCertificateRequestFlags #enum:TlsCertificateRequestFlags#

    TlsCertificateRequestFlags(..)          ,


-- ** TlsDatabaseLookupFlags #enum:TlsDatabaseLookupFlags#

    TlsDatabaseLookupFlags(..)              ,


-- ** TlsError #enum:TlsError#

    TlsError(..)                            ,
    catchTlsError                           ,
    handleTlsError                          ,


-- ** TlsInteractionResult #enum:TlsInteractionResult#

    TlsInteractionResult(..)                ,


-- ** TlsRehandshakeMode #enum:TlsRehandshakeMode#

    TlsRehandshakeMode(..)                  ,


-- ** UnixSocketAddressType #enum:UnixSocketAddressType#

    UnixSocketAddressType(..)               ,


-- ** ZlibCompressorFormat #enum:ZlibCompressorFormat#

    ZlibCompressorFormat(..)                ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL


-- Enum ZlibCompressorFormat
{- |
Used to select the type of data format to use for 'GI.Gio.Objects.ZlibDecompressor.ZlibDecompressor'
and 'GI.Gio.Objects.ZlibCompressor.ZlibCompressor'.

/Since: 2.24/
-}
data ZlibCompressorFormat = 
      ZlibCompressorFormatZlib
    {- ^
    deflate compression with zlib header
    -}
    | ZlibCompressorFormatGzip
    {- ^
    gzip file format
    -}
    | ZlibCompressorFormatRaw
    {- ^
    deflate compression with no header
    -}
    | AnotherZlibCompressorFormat Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ZlibCompressorFormat where
    fromEnum ZlibCompressorFormatZlib = 0
    fromEnum ZlibCompressorFormatGzip = 1
    fromEnum ZlibCompressorFormatRaw = 2
    fromEnum (AnotherZlibCompressorFormat k) = k

    toEnum 0 = ZlibCompressorFormatZlib
    toEnum 1 = ZlibCompressorFormatGzip
    toEnum 2 = ZlibCompressorFormatRaw
    toEnum k = AnotherZlibCompressorFormat k

instance P.Ord ZlibCompressorFormat where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_zlib_compressor_format_get_type" c_g_zlib_compressor_format_get_type :: 
    IO GType

instance BoxedEnum ZlibCompressorFormat where
    boxedEnumType _ = c_g_zlib_compressor_format_get_type

-- Enum UnixSocketAddressType
{- |
The type of name used by a 'GI.Gio.Objects.UnixSocketAddress.UnixSocketAddress'.
'GI.Gio.Enums.UnixSocketAddressTypePath' indicates a traditional unix domain
socket bound to a filesystem path. 'GI.Gio.Enums.UnixSocketAddressTypeAnonymous'
indicates a socket not bound to any name (eg, a client-side socket,
or a socket created with @/socketpair()/@).

For abstract sockets, there are two incompatible ways of naming
them; the man pages suggest using the entire @struct sockaddr_un@
as the name, padding the unused parts of the @/sun_path/@ field with
zeroes; this corresponds to 'GI.Gio.Enums.UnixSocketAddressTypeAbstractPadded'.
However, many programs instead just use a portion of @/sun_path/@, and
pass an appropriate smaller length to @/bind()/@ or @/connect()/@. This is
'GI.Gio.Enums.UnixSocketAddressTypeAbstract'.

/Since: 2.26/
-}
data UnixSocketAddressType = 
      UnixSocketAddressTypeInvalid
    {- ^
    invalid
    -}
    | UnixSocketAddressTypeAnonymous
    {- ^
    anonymous
    -}
    | UnixSocketAddressTypePath
    {- ^
    a filesystem path
    -}
    | UnixSocketAddressTypeAbstract
    {- ^
    an abstract name
    -}
    | UnixSocketAddressTypeAbstractPadded
    {- ^
    an abstract name, 0-padded
      to the full length of a unix socket name
    -}
    | AnotherUnixSocketAddressType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum UnixSocketAddressType where
    fromEnum UnixSocketAddressTypeInvalid = 0
    fromEnum UnixSocketAddressTypeAnonymous = 1
    fromEnum UnixSocketAddressTypePath = 2
    fromEnum UnixSocketAddressTypeAbstract = 3
    fromEnum UnixSocketAddressTypeAbstractPadded = 4
    fromEnum (AnotherUnixSocketAddressType k) = k

    toEnum 0 = UnixSocketAddressTypeInvalid
    toEnum 1 = UnixSocketAddressTypeAnonymous
    toEnum 2 = UnixSocketAddressTypePath
    toEnum 3 = UnixSocketAddressTypeAbstract
    toEnum 4 = UnixSocketAddressTypeAbstractPadded
    toEnum k = AnotherUnixSocketAddressType k

instance P.Ord UnixSocketAddressType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_unix_socket_address_type_get_type" c_g_unix_socket_address_type_get_type :: 
    IO GType

instance BoxedEnum UnixSocketAddressType where
    boxedEnumType _ = c_g_unix_socket_address_type_get_type

-- Enum TlsRehandshakeMode
{-# DEPRECATED TlsRehandshakeMode ["(Since version 2.60.)","Changing the rehandshake mode is no longer","  required for compatibility. Also, rehandshaking has been removed","  from the TLS protocol in TLS 1.3."] #-}
{- |
When to allow rehandshaking. See
'GI.Gio.Objects.TlsConnection.tlsConnectionSetRehandshakeMode'.

/Since: 2.28/
-}
data TlsRehandshakeMode = 
      TlsRehandshakeModeNever
    {- ^
    Never allow rehandshaking
    -}
    | TlsRehandshakeModeSafely
    {- ^
    Allow safe rehandshaking only
    -}
    | TlsRehandshakeModeUnsafely
    {- ^
    Allow unsafe rehandshaking
    -}
    | AnotherTlsRehandshakeMode Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TlsRehandshakeMode where
    fromEnum TlsRehandshakeModeNever = 0
    fromEnum TlsRehandshakeModeSafely = 1
    fromEnum TlsRehandshakeModeUnsafely = 2
    fromEnum (AnotherTlsRehandshakeMode k) = k

    toEnum 0 = TlsRehandshakeModeNever
    toEnum 1 = TlsRehandshakeModeSafely
    toEnum 2 = TlsRehandshakeModeUnsafely
    toEnum k = AnotherTlsRehandshakeMode k

instance P.Ord TlsRehandshakeMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_tls_rehandshake_mode_get_type" c_g_tls_rehandshake_mode_get_type :: 
    IO GType

instance BoxedEnum TlsRehandshakeMode where
    boxedEnumType _ = c_g_tls_rehandshake_mode_get_type

-- Enum TlsInteractionResult
{- |
'GI.Gio.Enums.TlsInteractionResult' is returned by various functions in 'GI.Gio.Objects.TlsInteraction.TlsInteraction'
when finishing an interaction request.

/Since: 2.30/
-}
data TlsInteractionResult = 
      TlsInteractionResultUnhandled
    {- ^
    The interaction was unhandled (i.e. not
        implemented).
    -}
    | TlsInteractionResultHandled
    {- ^
    The interaction completed, and resulting data
        is available.
    -}
    | TlsInteractionResultFailed
    {- ^
    The interaction has failed, or was cancelled.
        and the operation should be aborted.
    -}
    | AnotherTlsInteractionResult Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TlsInteractionResult where
    fromEnum TlsInteractionResultUnhandled = 0
    fromEnum TlsInteractionResultHandled = 1
    fromEnum TlsInteractionResultFailed = 2
    fromEnum (AnotherTlsInteractionResult k) = k

    toEnum 0 = TlsInteractionResultUnhandled
    toEnum 1 = TlsInteractionResultHandled
    toEnum 2 = TlsInteractionResultFailed
    toEnum k = AnotherTlsInteractionResult k

instance P.Ord TlsInteractionResult where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_tls_interaction_result_get_type" c_g_tls_interaction_result_get_type :: 
    IO GType

instance BoxedEnum TlsInteractionResult where
    boxedEnumType _ = c_g_tls_interaction_result_get_type

-- Enum TlsError
{- |
An error code used with @/G_TLS_ERROR/@ in a 'GError' returned from a
TLS-related routine.

/Since: 2.28/
-}
data TlsError = 
      TlsErrorUnavailable
    {- ^
    No TLS provider is available
    -}
    | TlsErrorMisc
    {- ^
    Miscellaneous TLS error
    -}
    | TlsErrorBadCertificate
    {- ^
    The certificate presented could not
      be parsed or failed validation.
    -}
    | TlsErrorNotTls
    {- ^
    The TLS handshake failed because the
      peer does not seem to be a TLS server.
    -}
    | TlsErrorHandshake
    {- ^
    The TLS handshake failed because the
      peer\'s certificate was not acceptable.
    -}
    | TlsErrorCertificateRequired
    {- ^
    The TLS handshake failed because
      the server requested a client-side certificate, but none was
      provided. See 'GI.Gio.Objects.TlsConnection.tlsConnectionSetCertificate'.
    -}
    | TlsErrorEof
    {- ^
    The TLS connection was closed without proper
      notice, which may indicate an attack. See
      'GI.Gio.Objects.TlsConnection.tlsConnectionSetRequireCloseNotify'.
    -}
    | TlsErrorInappropriateFallback
    {- ^
    The TLS handshake failed
      because the client sent the fallback SCSV, indicating a protocol
      downgrade attack. Since: 2.60
    -}
    | AnotherTlsError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TlsError where
    fromEnum TlsErrorUnavailable = 0
    fromEnum TlsErrorMisc = 1
    fromEnum TlsErrorBadCertificate = 2
    fromEnum TlsErrorNotTls = 3
    fromEnum TlsErrorHandshake = 4
    fromEnum TlsErrorCertificateRequired = 5
    fromEnum TlsErrorEof = 6
    fromEnum TlsErrorInappropriateFallback = 7
    fromEnum (AnotherTlsError k) = k

    toEnum 0 = TlsErrorUnavailable
    toEnum 1 = TlsErrorMisc
    toEnum 2 = TlsErrorBadCertificate
    toEnum 3 = TlsErrorNotTls
    toEnum 4 = TlsErrorHandshake
    toEnum 5 = TlsErrorCertificateRequired
    toEnum 6 = TlsErrorEof
    toEnum 7 = TlsErrorInappropriateFallback
    toEnum k = AnotherTlsError k

instance P.Ord TlsError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass TlsError where
    gerrorClassDomain _ = "g-tls-error-quark"

-- | Catch exceptions of type `TlsError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchTlsError ::
    IO a ->
    (TlsError -> GErrorMessage -> IO a) ->
    IO a
catchTlsError = catchGErrorJustDomain

-- | Handle exceptions of type `TlsError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleTlsError ::
    (TlsError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleTlsError = handleGErrorJustDomain

foreign import ccall "g_tls_error_get_type" c_g_tls_error_get_type :: 
    IO GType

instance BoxedEnum TlsError where
    boxedEnumType _ = c_g_tls_error_get_type

-- Enum TlsDatabaseLookupFlags
{- |
Flags for 'GI.Gio.Objects.TlsDatabase.tlsDatabaseLookupCertificateForHandle',
'GI.Gio.Objects.TlsDatabase.tlsDatabaseLookupCertificateIssuer',
and 'GI.Gio.Objects.TlsDatabase.tlsDatabaseLookupCertificatesIssuedBy'.

/Since: 2.30/
-}
data TlsDatabaseLookupFlags = 
      TlsDatabaseLookupFlagsNone
    {- ^
    No lookup flags
    -}
    | TlsDatabaseLookupFlagsKeypair
    {- ^
    Restrict lookup to certificates that have
        a private key.
    -}
    | AnotherTlsDatabaseLookupFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TlsDatabaseLookupFlags where
    fromEnum TlsDatabaseLookupFlagsNone = 0
    fromEnum TlsDatabaseLookupFlagsKeypair = 1
    fromEnum (AnotherTlsDatabaseLookupFlags k) = k

    toEnum 0 = TlsDatabaseLookupFlagsNone
    toEnum 1 = TlsDatabaseLookupFlagsKeypair
    toEnum k = AnotherTlsDatabaseLookupFlags k

instance P.Ord TlsDatabaseLookupFlags where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_tls_database_lookup_flags_get_type" c_g_tls_database_lookup_flags_get_type :: 
    IO GType

instance BoxedEnum TlsDatabaseLookupFlags where
    boxedEnumType _ = c_g_tls_database_lookup_flags_get_type

-- Enum TlsCertificateRequestFlags
{- |
Flags for 'GI.Gio.Objects.TlsInteraction.tlsInteractionRequestCertificate',
'GI.Gio.Objects.TlsInteraction.tlsInteractionRequestCertificateAsync', and
'GI.Gio.Objects.TlsInteraction.tlsInteractionInvokeRequestCertificate'.

/Since: 2.40/
-}
data TlsCertificateRequestFlags = 
      TlsCertificateRequestFlagsNone
    {- ^
    No flags
    -}
    | AnotherTlsCertificateRequestFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TlsCertificateRequestFlags where
    fromEnum TlsCertificateRequestFlagsNone = 0
    fromEnum (AnotherTlsCertificateRequestFlags k) = k

    toEnum 0 = TlsCertificateRequestFlagsNone
    toEnum k = AnotherTlsCertificateRequestFlags k

instance P.Ord TlsCertificateRequestFlags where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_tls_certificate_request_flags_get_type" c_g_tls_certificate_request_flags_get_type :: 
    IO GType

instance BoxedEnum TlsCertificateRequestFlags where
    boxedEnumType _ = c_g_tls_certificate_request_flags_get_type

-- Enum TlsAuthenticationMode
{- |
The client authentication mode for a 'GI.Gio.Interfaces.TlsServerConnection.TlsServerConnection'.

/Since: 2.28/
-}
data TlsAuthenticationMode = 
      TlsAuthenticationModeNone
    {- ^
    client authentication not required
    -}
    | TlsAuthenticationModeRequested
    {- ^
    client authentication is requested
    -}
    | TlsAuthenticationModeRequired
    {- ^
    client authentication is required
    -}
    | AnotherTlsAuthenticationMode Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TlsAuthenticationMode where
    fromEnum TlsAuthenticationModeNone = 0
    fromEnum TlsAuthenticationModeRequested = 1
    fromEnum TlsAuthenticationModeRequired = 2
    fromEnum (AnotherTlsAuthenticationMode k) = k

    toEnum 0 = TlsAuthenticationModeNone
    toEnum 1 = TlsAuthenticationModeRequested
    toEnum 2 = TlsAuthenticationModeRequired
    toEnum k = AnotherTlsAuthenticationMode k

instance P.Ord TlsAuthenticationMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_tls_authentication_mode_get_type" c_g_tls_authentication_mode_get_type :: 
    IO GType

instance BoxedEnum TlsAuthenticationMode where
    boxedEnumType _ = c_g_tls_authentication_mode_get_type

-- Enum SocketType
{- |
Flags used when creating a 'GI.Gio.Objects.Socket.Socket'. Some protocols may not implement
all the socket types.

/Since: 2.22/
-}
data SocketType = 
      SocketTypeInvalid
    {- ^
    Type unknown or wrong
    -}
    | SocketTypeStream
    {- ^
    Reliable connection-based byte streams (e.g. TCP).
    -}
    | SocketTypeDatagram
    {- ^
    Connectionless, unreliable datagram passing.
        (e.g. UDP)
    -}
    | SocketTypeSeqpacket
    {- ^
    Reliable connection-based passing of datagrams
        of fixed maximum length (e.g. SCTP).
    -}
    | AnotherSocketType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum SocketType where
    fromEnum SocketTypeInvalid = 0
    fromEnum SocketTypeStream = 1
    fromEnum SocketTypeDatagram = 2
    fromEnum SocketTypeSeqpacket = 3
    fromEnum (AnotherSocketType k) = k

    toEnum 0 = SocketTypeInvalid
    toEnum 1 = SocketTypeStream
    toEnum 2 = SocketTypeDatagram
    toEnum 3 = SocketTypeSeqpacket
    toEnum k = AnotherSocketType k

instance P.Ord SocketType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_socket_type_get_type" c_g_socket_type_get_type :: 
    IO GType

instance BoxedEnum SocketType where
    boxedEnumType _ = c_g_socket_type_get_type

-- Enum SocketProtocol
{- |
A protocol identifier is specified when creating a 'GI.Gio.Objects.Socket.Socket', which is a
family\/type specific identifier, where 0 means the default protocol for
the particular family\/type.

This enum contains a set of commonly available and used protocols. You
can also pass any other identifiers handled by the platform in order to
use protocols not listed here.

/Since: 2.22/
-}
data SocketProtocol = 
      SocketProtocolUnknown
    {- ^
    The protocol type is unknown
    -}
    | SocketProtocolDefault
    {- ^
    The default protocol for the family\/type
    -}
    | SocketProtocolTcp
    {- ^
    TCP over IP
    -}
    | SocketProtocolUdp
    {- ^
    UDP over IP
    -}
    | SocketProtocolSctp
    {- ^
    SCTP over IP
    -}
    | AnotherSocketProtocol Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum SocketProtocol where
    fromEnum SocketProtocolUnknown = -1
    fromEnum SocketProtocolDefault = 0
    fromEnum SocketProtocolTcp = 6
    fromEnum SocketProtocolUdp = 17
    fromEnum SocketProtocolSctp = 132
    fromEnum (AnotherSocketProtocol k) = k

    toEnum -1 = SocketProtocolUnknown
    toEnum 0 = SocketProtocolDefault
    toEnum 6 = SocketProtocolTcp
    toEnum 17 = SocketProtocolUdp
    toEnum 132 = SocketProtocolSctp
    toEnum k = AnotherSocketProtocol k

instance P.Ord SocketProtocol where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_socket_protocol_get_type" c_g_socket_protocol_get_type :: 
    IO GType

instance BoxedEnum SocketProtocol where
    boxedEnumType _ = c_g_socket_protocol_get_type

-- Enum SocketListenerEvent
{- |
Describes an event occurring on a 'GI.Gio.Objects.SocketListener.SocketListener'. See the
'GI.Gio.Objects.SocketListener.SocketListener'::@/event/@ signal for more details.

Additional values may be added to this type in the future.

/Since: 2.46/
-}
data SocketListenerEvent = 
      SocketListenerEventBinding
    {- ^
    The listener is about to bind a socket.
    -}
    | SocketListenerEventBound
    {- ^
    The listener has bound a socket.
    -}
    | SocketListenerEventListening
    {- ^
    The listener is about to start
       listening on this socket.
    -}
    | SocketListenerEventListened
    {- ^
    The listener is now listening on
      this socket.
    -}
    | AnotherSocketListenerEvent Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum SocketListenerEvent where
    fromEnum SocketListenerEventBinding = 0
    fromEnum SocketListenerEventBound = 1
    fromEnum SocketListenerEventListening = 2
    fromEnum SocketListenerEventListened = 3
    fromEnum (AnotherSocketListenerEvent k) = k

    toEnum 0 = SocketListenerEventBinding
    toEnum 1 = SocketListenerEventBound
    toEnum 2 = SocketListenerEventListening
    toEnum 3 = SocketListenerEventListened
    toEnum k = AnotherSocketListenerEvent k

instance P.Ord SocketListenerEvent where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_socket_listener_event_get_type" c_g_socket_listener_event_get_type :: 
    IO GType

instance BoxedEnum SocketListenerEvent where
    boxedEnumType _ = c_g_socket_listener_event_get_type

-- Enum SocketFamily
{- |
The protocol family of a 'GI.Gio.Objects.SocketAddress.SocketAddress'. (These values are
identical to the system defines @/AF_INET/@, @/AF_INET6/@ and @/AF_UNIX/@,
if available.)

/Since: 2.22/
-}
data SocketFamily = 
      SocketFamilyInvalid
    {- ^
    no address family
    -}
    | SocketFamilyUnix
    {- ^
    the UNIX domain family
    -}
    | SocketFamilyIpv4
    {- ^
    the IPv4 family
    -}
    | SocketFamilyIpv6
    {- ^
    the IPv6 family
    -}
    | AnotherSocketFamily Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum SocketFamily where
    fromEnum SocketFamilyInvalid = 0
    fromEnum SocketFamilyUnix = 1
    fromEnum SocketFamilyIpv4 = 2
    fromEnum SocketFamilyIpv6 = 10
    fromEnum (AnotherSocketFamily k) = k

    toEnum 0 = SocketFamilyInvalid
    toEnum 1 = SocketFamilyUnix
    toEnum 2 = SocketFamilyIpv4
    toEnum 10 = SocketFamilyIpv6
    toEnum k = AnotherSocketFamily k

instance P.Ord SocketFamily where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_socket_family_get_type" c_g_socket_family_get_type :: 
    IO GType

instance BoxedEnum SocketFamily where
    boxedEnumType _ = c_g_socket_family_get_type

-- Enum SocketClientEvent
{- |
Describes an event occurring on a 'GI.Gio.Objects.SocketClient.SocketClient'. See the
'GI.Gio.Objects.SocketClient.SocketClient'::@/event/@ signal for more details.

Additional values may be added to this type in the future.

/Since: 2.32/
-}
data SocketClientEvent = 
      SocketClientEventResolving
    {- ^
    The client is doing a DNS lookup.
    -}
    | SocketClientEventResolved
    {- ^
    The client has completed a DNS lookup.
    -}
    | SocketClientEventConnecting
    {- ^
    The client is connecting to a remote
      host (either a proxy or the destination server).
    -}
    | SocketClientEventConnected
    {- ^
    The client has connected to a remote
      host.
    -}
    | SocketClientEventProxyNegotiating
    {- ^
    The client is negotiating
      with a proxy to connect to the destination server.
    -}
    | SocketClientEventProxyNegotiated
    {- ^
    The client has negotiated
      with the proxy server.
    -}
    | SocketClientEventTlsHandshaking
    {- ^
    The client is performing a
      TLS handshake.
    -}
    | SocketClientEventTlsHandshaked
    {- ^
    The client has performed a
      TLS handshake.
    -}
    | SocketClientEventComplete
    {- ^
    The client is done with a particular
      'GI.Gio.Interfaces.SocketConnectable.SocketConnectable'.
    -}
    | AnotherSocketClientEvent Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum SocketClientEvent where
    fromEnum SocketClientEventResolving = 0
    fromEnum SocketClientEventResolved = 1
    fromEnum SocketClientEventConnecting = 2
    fromEnum SocketClientEventConnected = 3
    fromEnum SocketClientEventProxyNegotiating = 4
    fromEnum SocketClientEventProxyNegotiated = 5
    fromEnum SocketClientEventTlsHandshaking = 6
    fromEnum SocketClientEventTlsHandshaked = 7
    fromEnum SocketClientEventComplete = 8
    fromEnum (AnotherSocketClientEvent k) = k

    toEnum 0 = SocketClientEventResolving
    toEnum 1 = SocketClientEventResolved
    toEnum 2 = SocketClientEventConnecting
    toEnum 3 = SocketClientEventConnected
    toEnum 4 = SocketClientEventProxyNegotiating
    toEnum 5 = SocketClientEventProxyNegotiated
    toEnum 6 = SocketClientEventTlsHandshaking
    toEnum 7 = SocketClientEventTlsHandshaked
    toEnum 8 = SocketClientEventComplete
    toEnum k = AnotherSocketClientEvent k

instance P.Ord SocketClientEvent where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_socket_client_event_get_type" c_g_socket_client_event_get_type :: 
    IO GType

instance BoxedEnum SocketClientEvent where
    boxedEnumType _ = c_g_socket_client_event_get_type

-- Enum ResourceError
{- |
An error code used with @/G_RESOURCE_ERROR/@ in a 'GError' returned
from a 'GI.Gio.Structs.Resource.Resource' routine.

/Since: 2.32/
-}
data ResourceError = 
      ResourceErrorNotFound
    {- ^
    no file was found at the requested path
    -}
    | ResourceErrorInternal
    {- ^
    unknown error
    -}
    | AnotherResourceError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ResourceError where
    fromEnum ResourceErrorNotFound = 0
    fromEnum ResourceErrorInternal = 1
    fromEnum (AnotherResourceError k) = k

    toEnum 0 = ResourceErrorNotFound
    toEnum 1 = ResourceErrorInternal
    toEnum k = AnotherResourceError k

instance P.Ord ResourceError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass ResourceError where
    gerrorClassDomain _ = "g-resource-error-quark"

-- | Catch exceptions of type `ResourceError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchResourceError ::
    IO a ->
    (ResourceError -> GErrorMessage -> IO a) ->
    IO a
catchResourceError = catchGErrorJustDomain

-- | Handle exceptions of type `ResourceError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleResourceError ::
    (ResourceError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleResourceError = handleGErrorJustDomain

foreign import ccall "g_resource_error_get_type" c_g_resource_error_get_type :: 
    IO GType

instance BoxedEnum ResourceError where
    boxedEnumType _ = c_g_resource_error_get_type

-- Enum ResolverRecordType
{- |
The type of record that 'GI.Gio.Objects.Resolver.resolverLookupRecords' or
'GI.Gio.Objects.Resolver.resolverLookupRecordsAsync' should retrieve. The records are returned
as lists of 'GVariant' tuples. Each record type has different values in
the variant tuples returned.

'GI.Gio.Enums.ResolverRecordTypeSrv' records are returned as variants with the signature
\'(qqqs)\', containing a guint16 with the priority, a guint16 with the
weight, a guint16 with the port, and a string of the hostname.

'GI.Gio.Enums.ResolverRecordTypeMx' records are returned as variants with the signature
\'(qs)\', representing a guint16 with the preference, and a string containing
the mail exchanger hostname.

'GI.Gio.Enums.ResolverRecordTypeTxt' records are returned as variants with the signature
\'(as)\', representing an array of the strings in the text record.

'GI.Gio.Enums.ResolverRecordTypeSoa' records are returned as variants with the signature
\'(ssuuuuu)\', representing a string containing the primary name server, a
string containing the administrator, the serial as a guint32, the refresh
interval as guint32, the retry interval as a guint32, the expire timeout
as a guint32, and the ttl as a guint32.

'GI.Gio.Enums.ResolverRecordTypeNs' records are returned as variants with the signature
\'(s)\', representing a string of the hostname of the name server.

/Since: 2.34/
-}
data ResolverRecordType = 
      ResolverRecordTypeSrv
    {- ^
    lookup DNS SRV records for a domain
    -}
    | ResolverRecordTypeMx
    {- ^
    lookup DNS MX records for a domain
    -}
    | ResolverRecordTypeTxt
    {- ^
    lookup DNS TXT records for a name
    -}
    | ResolverRecordTypeSoa
    {- ^
    lookup DNS SOA records for a zone
    -}
    | ResolverRecordTypeNs
    {- ^
    lookup DNS NS records for a domain
    -}
    | AnotherResolverRecordType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ResolverRecordType where
    fromEnum ResolverRecordTypeSrv = 1
    fromEnum ResolverRecordTypeMx = 2
    fromEnum ResolverRecordTypeTxt = 3
    fromEnum ResolverRecordTypeSoa = 4
    fromEnum ResolverRecordTypeNs = 5
    fromEnum (AnotherResolverRecordType k) = k

    toEnum 1 = ResolverRecordTypeSrv
    toEnum 2 = ResolverRecordTypeMx
    toEnum 3 = ResolverRecordTypeTxt
    toEnum 4 = ResolverRecordTypeSoa
    toEnum 5 = ResolverRecordTypeNs
    toEnum k = AnotherResolverRecordType k

instance P.Ord ResolverRecordType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_resolver_record_type_get_type" c_g_resolver_record_type_get_type :: 
    IO GType

instance BoxedEnum ResolverRecordType where
    boxedEnumType _ = c_g_resolver_record_type_get_type

-- Enum ResolverError
{- |
An error code used with @/G_RESOLVER_ERROR/@ in a 'GError' returned
from a 'GI.Gio.Objects.Resolver.Resolver' routine.

/Since: 2.22/
-}
data ResolverError = 
      ResolverErrorNotFound
    {- ^
    the requested name\/address\/service was not
        found
    -}
    | ResolverErrorTemporaryFailure
    {- ^
    the requested information could not
        be looked up due to a network error or similar problem
    -}
    | ResolverErrorInternal
    {- ^
    unknown error
    -}
    | AnotherResolverError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ResolverError where
    fromEnum ResolverErrorNotFound = 0
    fromEnum ResolverErrorTemporaryFailure = 1
    fromEnum ResolverErrorInternal = 2
    fromEnum (AnotherResolverError k) = k

    toEnum 0 = ResolverErrorNotFound
    toEnum 1 = ResolverErrorTemporaryFailure
    toEnum 2 = ResolverErrorInternal
    toEnum k = AnotherResolverError k

instance P.Ord ResolverError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass ResolverError where
    gerrorClassDomain _ = "g-resolver-error-quark"

-- | Catch exceptions of type `ResolverError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchResolverError ::
    IO a ->
    (ResolverError -> GErrorMessage -> IO a) ->
    IO a
catchResolverError = catchGErrorJustDomain

-- | Handle exceptions of type `ResolverError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleResolverError ::
    (ResolverError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleResolverError = handleGErrorJustDomain

foreign import ccall "g_resolver_error_get_type" c_g_resolver_error_get_type :: 
    IO GType

instance BoxedEnum ResolverError where
    boxedEnumType _ = c_g_resolver_error_get_type

-- Enum PollableReturn
{- |
Return value for various IO operations that signal errors via the
return value and not necessarily via a 'GError'.

This enum exists to be able to return errors to callers without having to
allocate a 'GError'. Allocating @/GErrors/@ can be quite expensive for
regularly happening errors like 'GI.Gio.Enums.IOErrorEnumWouldBlock'.

In case of 'GI.Gio.Enums.PollableReturnFailed' a 'GError' should be set for the
operation to give details about the error that happened.

/Since: 2.60/
-}
data PollableReturn = 
      PollableReturnFailed
    {- ^
    Generic error condition for when an operation fails.
    -}
    | PollableReturnOk
    {- ^
    The operation was successfully finished.
    -}
    | PollableReturnWouldBlock
    {- ^
    The operation would block.
    -}
    | AnotherPollableReturn Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum PollableReturn where
    fromEnum PollableReturnFailed = 0
    fromEnum PollableReturnOk = 1
    fromEnum PollableReturnWouldBlock = -27
    fromEnum (AnotherPollableReturn k) = k

    toEnum 0 = PollableReturnFailed
    toEnum 1 = PollableReturnOk
    toEnum -27 = PollableReturnWouldBlock
    toEnum k = AnotherPollableReturn k

instance P.Ord PollableReturn where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_pollable_return_get_type" c_g_pollable_return_get_type :: 
    IO GType

instance BoxedEnum PollableReturn where
    boxedEnumType _ = c_g_pollable_return_get_type

-- Enum PasswordSave
{- |
'GI.Gio.Enums.PasswordSave' is used to indicate the lifespan of a saved password.

@/Gvfs/@ stores passwords in the Gnome keyring when this flag allows it
to, and later retrieves it again from there.
-}
data PasswordSave = 
      PasswordSaveNever
    {- ^
    never save a password.
    -}
    | PasswordSaveForSession
    {- ^
    save a password for the session.
    -}
    | PasswordSavePermanently
    {- ^
    save a password permanently.
    -}
    | AnotherPasswordSave Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum PasswordSave where
    fromEnum PasswordSaveNever = 0
    fromEnum PasswordSaveForSession = 1
    fromEnum PasswordSavePermanently = 2
    fromEnum (AnotherPasswordSave k) = k

    toEnum 0 = PasswordSaveNever
    toEnum 1 = PasswordSaveForSession
    toEnum 2 = PasswordSavePermanently
    toEnum k = AnotherPasswordSave k

instance P.Ord PasswordSave where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_password_save_get_type" c_g_password_save_get_type :: 
    IO GType

instance BoxedEnum PasswordSave where
    boxedEnumType _ = c_g_password_save_get_type

-- Enum NotificationPriority
{- |
Priority levels for @/GNotifications/@.

/Since: 2.42/
-}
data NotificationPriority = 
      NotificationPriorityNormal
    {- ^
    the default priority, to be used for the
      majority of notifications (for example email messages, software updates,
      completed download\/sync operations)
    -}
    | NotificationPriorityLow
    {- ^
    for notifications that do not require
      immediate attention - typically used for contextual background
      information, such as contact birthdays or local weather
    -}
    | NotificationPriorityHigh
    {- ^
    for events that require more attention,
      usually because responses are time-sensitive (for example chat and SMS
      messages or alarms)
    -}
    | NotificationPriorityUrgent
    {- ^
    for urgent notifications, or notifications
      that require a response in a short space of time (for example phone calls
      or emergency warnings)
    -}
    | AnotherNotificationPriority Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum NotificationPriority where
    fromEnum NotificationPriorityNormal = 0
    fromEnum NotificationPriorityLow = 1
    fromEnum NotificationPriorityHigh = 2
    fromEnum NotificationPriorityUrgent = 3
    fromEnum (AnotherNotificationPriority k) = k

    toEnum 0 = NotificationPriorityNormal
    toEnum 1 = NotificationPriorityLow
    toEnum 2 = NotificationPriorityHigh
    toEnum 3 = NotificationPriorityUrgent
    toEnum k = AnotherNotificationPriority k

instance P.Ord NotificationPriority where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_notification_priority_get_type" c_g_notification_priority_get_type :: 
    IO GType

instance BoxedEnum NotificationPriority where
    boxedEnumType _ = c_g_notification_priority_get_type

-- Enum NetworkConnectivity
{- |
The host\'s network connectivity state, as reported by 'GI.Gio.Interfaces.NetworkMonitor.NetworkMonitor'.

/Since: 2.44/
-}
data NetworkConnectivity = 
      NetworkConnectivityLocal
    {- ^
    The host is not configured with a
      route to the Internet; it may or may not be connected to a local
      network.
    -}
    | NetworkConnectivityLimited
    {- ^
    The host is connected to a network, but
      does not appear to be able to reach the full Internet, perhaps
      due to upstream network problems.
    -}
    | NetworkConnectivityPortal
    {- ^
    The host is behind a captive portal and
      cannot reach the full Internet.
    -}
    | NetworkConnectivityFull
    {- ^
    The host is connected to a network, and
      appears to be able to reach the full Internet.
    -}
    | AnotherNetworkConnectivity Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum NetworkConnectivity where
    fromEnum NetworkConnectivityLocal = 1
    fromEnum NetworkConnectivityLimited = 2
    fromEnum NetworkConnectivityPortal = 3
    fromEnum NetworkConnectivityFull = 4
    fromEnum (AnotherNetworkConnectivity k) = k

    toEnum 1 = NetworkConnectivityLocal
    toEnum 2 = NetworkConnectivityLimited
    toEnum 3 = NetworkConnectivityPortal
    toEnum 4 = NetworkConnectivityFull
    toEnum k = AnotherNetworkConnectivity k

instance P.Ord NetworkConnectivity where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_network_connectivity_get_type" c_g_network_connectivity_get_type :: 
    IO GType

instance BoxedEnum NetworkConnectivity where
    boxedEnumType _ = c_g_network_connectivity_get_type

-- Enum MountOperationResult
{- |
'GI.Gio.Enums.MountOperationResult' is returned as a result when a request for
information is send by the mounting operation.
-}
data MountOperationResult = 
      MountOperationResultHandled
    {- ^
    The request was fulfilled and the
        user specified data is now available
    -}
    | MountOperationResultAborted
    {- ^
    The user requested the mount operation
        to be aborted
    -}
    | MountOperationResultUnhandled
    {- ^
    The request was unhandled (i.e. not
        implemented)
    -}
    | AnotherMountOperationResult Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum MountOperationResult where
    fromEnum MountOperationResultHandled = 0
    fromEnum MountOperationResultAborted = 1
    fromEnum MountOperationResultUnhandled = 2
    fromEnum (AnotherMountOperationResult k) = k

    toEnum 0 = MountOperationResultHandled
    toEnum 1 = MountOperationResultAborted
    toEnum 2 = MountOperationResultUnhandled
    toEnum k = AnotherMountOperationResult k

instance P.Ord MountOperationResult where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_mount_operation_result_get_type" c_g_mount_operation_result_get_type :: 
    IO GType

instance BoxedEnum MountOperationResult where
    boxedEnumType _ = c_g_mount_operation_result_get_type

-- Enum IOModuleScopeFlags
{- |
Flags for use with @/g_io_module_scope_new()/@.

/Since: 2.30/
-}
data IOModuleScopeFlags = 
      IOModuleScopeFlagsNone
    {- ^
    No module scan flags
    -}
    | IOModuleScopeFlagsBlockDuplicates
    {- ^
    When using this scope to load or
        scan modules, automatically block a modules which has the same base
        basename as previously loaded module.
    -}
    | AnotherIOModuleScopeFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum IOModuleScopeFlags where
    fromEnum IOModuleScopeFlagsNone = 0
    fromEnum IOModuleScopeFlagsBlockDuplicates = 1
    fromEnum (AnotherIOModuleScopeFlags k) = k

    toEnum 0 = IOModuleScopeFlagsNone
    toEnum 1 = IOModuleScopeFlagsBlockDuplicates
    toEnum k = AnotherIOModuleScopeFlags k

instance P.Ord IOModuleScopeFlags where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_io_module_scope_flags_get_type" c_g_io_module_scope_flags_get_type :: 
    IO GType

instance BoxedEnum IOModuleScopeFlags where
    boxedEnumType _ = c_g_io_module_scope_flags_get_type

-- Enum IOErrorEnum
{- |
Error codes returned by GIO functions.

Note that this domain may be extended in future GLib releases. In
general, new error codes either only apply to new APIs, or else
replace 'GI.Gio.Enums.IOErrorEnumFailed' in cases that were not explicitly
distinguished before. You should therefore avoid writing code like

=== /C code/
>
>if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED))
>  {
>    // Assume that this is EPRINTERONFIRE
>    ...
>  }

but should instead treat all unrecognized error codes the same as
@/G_IO_ERROR_FAILED/@.

See also 'GI.Gio.Enums.PollableReturn' for a cheaper way of returning
'GI.Gio.Enums.IOErrorEnumWouldBlock' to callers without allocating a 'GError'.
-}
data IOErrorEnum = 
      IOErrorEnumFailed
    {- ^
    Generic error condition for when an operation fails
        and no more specific 'GI.Gio.Enums.IOErrorEnum' value is defined.
    -}
    | IOErrorEnumNotFound
    {- ^
    File not found.
    -}
    | IOErrorEnumExists
    {- ^
    File already exists.
    -}
    | IOErrorEnumIsDirectory
    {- ^
    File is a directory.
    -}
    | IOErrorEnumNotDirectory
    {- ^
    File is not a directory.
    -}
    | IOErrorEnumNotEmpty
    {- ^
    File is a directory that isn\'t empty.
    -}
    | IOErrorEnumNotRegularFile
    {- ^
    File is not a regular file.
    -}
    | IOErrorEnumNotSymbolicLink
    {- ^
    File is not a symbolic link.
    -}
    | IOErrorEnumNotMountableFile
    {- ^
    File cannot be mounted.
    -}
    | IOErrorEnumFilenameTooLong
    {- ^
    Filename is too many characters.
    -}
    | IOErrorEnumInvalidFilename
    {- ^
    Filename is invalid or contains invalid characters.
    -}
    | IOErrorEnumTooManyLinks
    {- ^
    File contains too many symbolic links.
    -}
    | IOErrorEnumNoSpace
    {- ^
    No space left on drive.
    -}
    | IOErrorEnumInvalidArgument
    {- ^
    Invalid argument.
    -}
    | IOErrorEnumPermissionDenied
    {- ^
    Permission denied.
    -}
    | IOErrorEnumNotSupported
    {- ^
    Operation (or one of its parameters) not supported
    -}
    | IOErrorEnumNotMounted
    {- ^
    File isn\'t mounted.
    -}
    | IOErrorEnumAlreadyMounted
    {- ^
    File is already mounted.
    -}
    | IOErrorEnumClosed
    {- ^
    File was closed.
    -}
    | IOErrorEnumCancelled
    {- ^
    Operation was cancelled. See 'GI.Gio.Objects.Cancellable.Cancellable'.
    -}
    | IOErrorEnumPending
    {- ^
    Operations are still pending.
    -}
    | IOErrorEnumReadOnly
    {- ^
    File is read only.
    -}
    | IOErrorEnumCantCreateBackup
    {- ^
    Backup couldn\'t be created.
    -}
    | IOErrorEnumWrongEtag
    {- ^
    File\'s Entity Tag was incorrect.
    -}
    | IOErrorEnumTimedOut
    {- ^
    Operation timed out.
    -}
    | IOErrorEnumWouldRecurse
    {- ^
    Operation would be recursive.
    -}
    | IOErrorEnumBusy
    {- ^
    File is busy.
    -}
    | IOErrorEnumWouldBlock
    {- ^
    Operation would block.
    -}
    | IOErrorEnumHostNotFound
    {- ^
    Host couldn\'t be found (remote operations).
    -}
    | IOErrorEnumWouldMerge
    {- ^
    Operation would merge files.
    -}
    | IOErrorEnumFailedHandled
    {- ^
    Operation failed and a helper program has
        already interacted with the user. Do not display any error dialog.
    -}
    | IOErrorEnumTooManyOpenFiles
    {- ^
    The current process has too many files
        open and can\'t open any more. Duplicate descriptors do count toward
        this limit. Since 2.20
    -}
    | IOErrorEnumNotInitialized
    {- ^
    The object has not been initialized. Since 2.22
    -}
    | IOErrorEnumAddressInUse
    {- ^
    The requested address is already in use. Since 2.22
    -}
    | IOErrorEnumPartialInput
    {- ^
    Need more input to finish operation. Since 2.24
    -}
    | IOErrorEnumInvalidData
    {- ^
    The input data was invalid. Since 2.24
    -}
    | IOErrorEnumDbusError
    {- ^
    A remote object generated an error that
        doesn\'t correspond to a locally registered 'GError' error
        domain. Use 'GI.Gio.Functions.dbusErrorGetRemoteError' to extract the D-Bus
        error name and 'GI.Gio.Functions.dbusErrorStripRemoteError' to fix up the
        message so it matches what was received on the wire. Since 2.26.
    -}
    | IOErrorEnumHostUnreachable
    {- ^
    Host unreachable. Since 2.26
    -}
    | IOErrorEnumNetworkUnreachable
    {- ^
    Network unreachable. Since 2.26
    -}
    | IOErrorEnumConnectionRefused
    {- ^
    Connection refused. Since 2.26
    -}
    | IOErrorEnumProxyFailed
    {- ^
    Connection to proxy server failed. Since 2.26
    -}
    | IOErrorEnumProxyAuthFailed
    {- ^
    Proxy authentication failed. Since 2.26
    -}
    | IOErrorEnumProxyNeedAuth
    {- ^
    Proxy server needs authentication. Since 2.26
    -}
    | IOErrorEnumProxyNotAllowed
    {- ^
    Proxy connection is not allowed by ruleset.
        Since 2.26
    -}
    | IOErrorEnumBrokenPipe
    {- ^
    Broken pipe. Since 2.36
    -}
    | IOErrorEnumConnectionClosed
    {- ^
    Connection closed by peer. Note that this
        is the same code as 'GI.Gio.Enums.IOErrorEnumBrokenPipe'; before 2.44 some
        \"connection closed\" errors returned 'GI.Gio.Enums.IOErrorEnumBrokenPipe', but others
        returned 'GI.Gio.Enums.IOErrorEnumFailed'. Now they should all return the same
        value, which has this more logical name. Since 2.44.
    -}
    | IOErrorEnumNotConnected
    {- ^
    Transport endpoint is not connected. Since 2.44
    -}
    | IOErrorEnumMessageTooLarge
    {- ^
    Message too large. Since 2.48.
    -}
    | AnotherIOErrorEnum Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum IOErrorEnum where
    fromEnum IOErrorEnumFailed = 0
    fromEnum IOErrorEnumNotFound = 1
    fromEnum IOErrorEnumExists = 2
    fromEnum IOErrorEnumIsDirectory = 3
    fromEnum IOErrorEnumNotDirectory = 4
    fromEnum IOErrorEnumNotEmpty = 5
    fromEnum IOErrorEnumNotRegularFile = 6
    fromEnum IOErrorEnumNotSymbolicLink = 7
    fromEnum IOErrorEnumNotMountableFile = 8
    fromEnum IOErrorEnumFilenameTooLong = 9
    fromEnum IOErrorEnumInvalidFilename = 10
    fromEnum IOErrorEnumTooManyLinks = 11
    fromEnum IOErrorEnumNoSpace = 12
    fromEnum IOErrorEnumInvalidArgument = 13
    fromEnum IOErrorEnumPermissionDenied = 14
    fromEnum IOErrorEnumNotSupported = 15
    fromEnum IOErrorEnumNotMounted = 16
    fromEnum IOErrorEnumAlreadyMounted = 17
    fromEnum IOErrorEnumClosed = 18
    fromEnum IOErrorEnumCancelled = 19
    fromEnum IOErrorEnumPending = 20
    fromEnum IOErrorEnumReadOnly = 21
    fromEnum IOErrorEnumCantCreateBackup = 22
    fromEnum IOErrorEnumWrongEtag = 23
    fromEnum IOErrorEnumTimedOut = 24
    fromEnum IOErrorEnumWouldRecurse = 25
    fromEnum IOErrorEnumBusy = 26
    fromEnum IOErrorEnumWouldBlock = 27
    fromEnum IOErrorEnumHostNotFound = 28
    fromEnum IOErrorEnumWouldMerge = 29
    fromEnum IOErrorEnumFailedHandled = 30
    fromEnum IOErrorEnumTooManyOpenFiles = 31
    fromEnum IOErrorEnumNotInitialized = 32
    fromEnum IOErrorEnumAddressInUse = 33
    fromEnum IOErrorEnumPartialInput = 34
    fromEnum IOErrorEnumInvalidData = 35
    fromEnum IOErrorEnumDbusError = 36
    fromEnum IOErrorEnumHostUnreachable = 37
    fromEnum IOErrorEnumNetworkUnreachable = 38
    fromEnum IOErrorEnumConnectionRefused = 39
    fromEnum IOErrorEnumProxyFailed = 40
    fromEnum IOErrorEnumProxyAuthFailed = 41
    fromEnum IOErrorEnumProxyNeedAuth = 42
    fromEnum IOErrorEnumProxyNotAllowed = 43
    fromEnum IOErrorEnumBrokenPipe = 44
    fromEnum IOErrorEnumConnectionClosed = 44
    fromEnum IOErrorEnumNotConnected = 45
    fromEnum IOErrorEnumMessageTooLarge = 46
    fromEnum (AnotherIOErrorEnum k) = k

    toEnum 0 = IOErrorEnumFailed
    toEnum 1 = IOErrorEnumNotFound
    toEnum 2 = IOErrorEnumExists
    toEnum 3 = IOErrorEnumIsDirectory
    toEnum 4 = IOErrorEnumNotDirectory
    toEnum 5 = IOErrorEnumNotEmpty
    toEnum 6 = IOErrorEnumNotRegularFile
    toEnum 7 = IOErrorEnumNotSymbolicLink
    toEnum 8 = IOErrorEnumNotMountableFile
    toEnum 9 = IOErrorEnumFilenameTooLong
    toEnum 10 = IOErrorEnumInvalidFilename
    toEnum 11 = IOErrorEnumTooManyLinks
    toEnum 12 = IOErrorEnumNoSpace
    toEnum 13 = IOErrorEnumInvalidArgument
    toEnum 14 = IOErrorEnumPermissionDenied
    toEnum 15 = IOErrorEnumNotSupported
    toEnum 16 = IOErrorEnumNotMounted
    toEnum 17 = IOErrorEnumAlreadyMounted
    toEnum 18 = IOErrorEnumClosed
    toEnum 19 = IOErrorEnumCancelled
    toEnum 20 = IOErrorEnumPending
    toEnum 21 = IOErrorEnumReadOnly
    toEnum 22 = IOErrorEnumCantCreateBackup
    toEnum 23 = IOErrorEnumWrongEtag
    toEnum 24 = IOErrorEnumTimedOut
    toEnum 25 = IOErrorEnumWouldRecurse
    toEnum 26 = IOErrorEnumBusy
    toEnum 27 = IOErrorEnumWouldBlock
    toEnum 28 = IOErrorEnumHostNotFound
    toEnum 29 = IOErrorEnumWouldMerge
    toEnum 30 = IOErrorEnumFailedHandled
    toEnum 31 = IOErrorEnumTooManyOpenFiles
    toEnum 32 = IOErrorEnumNotInitialized
    toEnum 33 = IOErrorEnumAddressInUse
    toEnum 34 = IOErrorEnumPartialInput
    toEnum 35 = IOErrorEnumInvalidData
    toEnum 36 = IOErrorEnumDbusError
    toEnum 37 = IOErrorEnumHostUnreachable
    toEnum 38 = IOErrorEnumNetworkUnreachable
    toEnum 39 = IOErrorEnumConnectionRefused
    toEnum 40 = IOErrorEnumProxyFailed
    toEnum 41 = IOErrorEnumProxyAuthFailed
    toEnum 42 = IOErrorEnumProxyNeedAuth
    toEnum 43 = IOErrorEnumProxyNotAllowed
    toEnum 44 = IOErrorEnumBrokenPipe
    toEnum 44 = IOErrorEnumConnectionClosed
    toEnum 45 = IOErrorEnumNotConnected
    toEnum 46 = IOErrorEnumMessageTooLarge
    toEnum k = AnotherIOErrorEnum k

instance P.Ord IOErrorEnum where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass IOErrorEnum where
    gerrorClassDomain _ = "g-io-error-quark"

-- | Catch exceptions of type `IOErrorEnum`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchIOErrorEnum ::
    IO a ->
    (IOErrorEnum -> GErrorMessage -> IO a) ->
    IO a
catchIOErrorEnum = catchGErrorJustDomain

-- | Handle exceptions of type `IOErrorEnum`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleIOErrorEnum ::
    (IOErrorEnum -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleIOErrorEnum = handleGErrorJustDomain

foreign import ccall "g_io_error_enum_get_type" c_g_io_error_enum_get_type :: 
    IO GType

instance BoxedEnum IOErrorEnum where
    boxedEnumType _ = c_g_io_error_enum_get_type

-- Enum FilesystemPreviewType
{- |
Indicates a hint from the file system whether files should be
previewed in a file manager. Returned as the value of the key
'GI.Gio.Constants.FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW'.
-}
data FilesystemPreviewType = 
      FilesystemPreviewTypeIfAlways
    {- ^
    Only preview files if user has explicitly requested it.
    -}
    | FilesystemPreviewTypeIfLocal
    {- ^
    Preview files if user has requested preview of \"local\" files.
    -}
    | FilesystemPreviewTypeNever
    {- ^
    Never preview files.
    -}
    | AnotherFilesystemPreviewType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum FilesystemPreviewType where
    fromEnum FilesystemPreviewTypeIfAlways = 0
    fromEnum FilesystemPreviewTypeIfLocal = 1
    fromEnum FilesystemPreviewTypeNever = 2
    fromEnum (AnotherFilesystemPreviewType k) = k

    toEnum 0 = FilesystemPreviewTypeIfAlways
    toEnum 1 = FilesystemPreviewTypeIfLocal
    toEnum 2 = FilesystemPreviewTypeNever
    toEnum k = AnotherFilesystemPreviewType k

instance P.Ord FilesystemPreviewType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_filesystem_preview_type_get_type" c_g_filesystem_preview_type_get_type :: 
    IO GType

instance BoxedEnum FilesystemPreviewType where
    boxedEnumType _ = c_g_filesystem_preview_type_get_type

-- Enum FileType
{- |
Indicates the file\'s on-disk type.
-}
data FileType = 
      FileTypeUnknown
    {- ^
    File\'s type is unknown.
    -}
    | FileTypeRegular
    {- ^
    File handle represents a regular file.
    -}
    | FileTypeDirectory
    {- ^
    File handle represents a directory.
    -}
    | FileTypeSymbolicLink
    {- ^
    File handle represents a symbolic link
       (Unix systems).
    -}
    | FileTypeSpecial
    {- ^
    File is a \"special\" file, such as a socket, fifo,
       block device, or character device.
    -}
    | FileTypeShortcut
    {- ^
    File is a shortcut (Windows systems).
    -}
    | FileTypeMountable
    {- ^
    File is a mountable location.
    -}
    | AnotherFileType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum FileType where
    fromEnum FileTypeUnknown = 0
    fromEnum FileTypeRegular = 1
    fromEnum FileTypeDirectory = 2
    fromEnum FileTypeSymbolicLink = 3
    fromEnum FileTypeSpecial = 4
    fromEnum FileTypeShortcut = 5
    fromEnum FileTypeMountable = 6
    fromEnum (AnotherFileType k) = k

    toEnum 0 = FileTypeUnknown
    toEnum 1 = FileTypeRegular
    toEnum 2 = FileTypeDirectory
    toEnum 3 = FileTypeSymbolicLink
    toEnum 4 = FileTypeSpecial
    toEnum 5 = FileTypeShortcut
    toEnum 6 = FileTypeMountable
    toEnum k = AnotherFileType k

instance P.Ord FileType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_file_type_get_type" c_g_file_type_get_type :: 
    IO GType

instance BoxedEnum FileType where
    boxedEnumType _ = c_g_file_type_get_type

-- Enum FileMonitorEvent
{- |
Specifies what type of event a monitor event is.
-}
data FileMonitorEvent = 
      FileMonitorEventChanged
    {- ^
    a file changed.
    -}
    | FileMonitorEventChangesDoneHint
    {- ^
    a hint that this was probably the last change in a set of changes.
    -}
    | FileMonitorEventDeleted
    {- ^
    a file was deleted.
    -}
    | FileMonitorEventCreated
    {- ^
    a file was created.
    -}
    | FileMonitorEventAttributeChanged
    {- ^
    a file attribute was changed.
    -}
    | FileMonitorEventPreUnmount
    {- ^
    the file location will soon be unmounted.
    -}
    | FileMonitorEventUnmounted
    {- ^
    the file location was unmounted.
    -}
    | FileMonitorEventMoved
    {- ^
    the file was moved -- only sent if the
      (deprecated) 'GI.Gio.Flags.FileMonitorFlagsSendMoved' flag is set
    -}
    | FileMonitorEventRenamed
    {- ^
    the file was renamed within the
      current directory -- only sent if the 'GI.Gio.Flags.FileMonitorFlagsWatchMoves'
      flag is set.  Since: 2.46.
    -}
    | FileMonitorEventMovedIn
    {- ^
    the file was moved into the
      monitored directory from another location -- only sent if the
      'GI.Gio.Flags.FileMonitorFlagsWatchMoves' flag is set.  Since: 2.46.
    -}
    | FileMonitorEventMovedOut
    {- ^
    the file was moved out of the
      monitored directory to another location -- only sent if the
      'GI.Gio.Flags.FileMonitorFlagsWatchMoves' flag is set.  Since: 2.46
    -}
    | AnotherFileMonitorEvent Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum FileMonitorEvent where
    fromEnum FileMonitorEventChanged = 0
    fromEnum FileMonitorEventChangesDoneHint = 1
    fromEnum FileMonitorEventDeleted = 2
    fromEnum FileMonitorEventCreated = 3
    fromEnum FileMonitorEventAttributeChanged = 4
    fromEnum FileMonitorEventPreUnmount = 5
    fromEnum FileMonitorEventUnmounted = 6
    fromEnum FileMonitorEventMoved = 7
    fromEnum FileMonitorEventRenamed = 8
    fromEnum FileMonitorEventMovedIn = 9
    fromEnum FileMonitorEventMovedOut = 10
    fromEnum (AnotherFileMonitorEvent k) = k

    toEnum 0 = FileMonitorEventChanged
    toEnum 1 = FileMonitorEventChangesDoneHint
    toEnum 2 = FileMonitorEventDeleted
    toEnum 3 = FileMonitorEventCreated
    toEnum 4 = FileMonitorEventAttributeChanged
    toEnum 5 = FileMonitorEventPreUnmount
    toEnum 6 = FileMonitorEventUnmounted
    toEnum 7 = FileMonitorEventMoved
    toEnum 8 = FileMonitorEventRenamed
    toEnum 9 = FileMonitorEventMovedIn
    toEnum 10 = FileMonitorEventMovedOut
    toEnum k = AnotherFileMonitorEvent k

instance P.Ord FileMonitorEvent where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_file_monitor_event_get_type" c_g_file_monitor_event_get_type :: 
    IO GType

instance BoxedEnum FileMonitorEvent where
    boxedEnumType _ = c_g_file_monitor_event_get_type

-- Enum FileAttributeType
{- |
The data types for file attributes.
-}
data FileAttributeType = 
      FileAttributeTypeInvalid
    {- ^
    indicates an invalid or uninitalized type.
    -}
    | FileAttributeTypeString
    {- ^
    a null terminated UTF8 string.
    -}
    | FileAttributeTypeByteString
    {- ^
    a zero terminated string of non-zero bytes.
    -}
    | FileAttributeTypeBoolean
    {- ^
    a boolean value.
    -}
    | FileAttributeTypeUint32
    {- ^
    an unsigned 4-byte\/32-bit integer.
    -}
    | FileAttributeTypeInt32
    {- ^
    a signed 4-byte\/32-bit integer.
    -}
    | FileAttributeTypeUint64
    {- ^
    an unsigned 8-byte\/64-bit integer.
    -}
    | FileAttributeTypeInt64
    {- ^
    a signed 8-byte\/64-bit integer.
    -}
    | FileAttributeTypeObject
    {- ^
    a 'GI.GObject.Objects.Object.Object'.
    -}
    | FileAttributeTypeStringv
    {- ^
    a 'Nothing' terminated char **. Since 2.22
    -}
    | AnotherFileAttributeType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum FileAttributeType where
    fromEnum FileAttributeTypeInvalid = 0
    fromEnum FileAttributeTypeString = 1
    fromEnum FileAttributeTypeByteString = 2
    fromEnum FileAttributeTypeBoolean = 3
    fromEnum FileAttributeTypeUint32 = 4
    fromEnum FileAttributeTypeInt32 = 5
    fromEnum FileAttributeTypeUint64 = 6
    fromEnum FileAttributeTypeInt64 = 7
    fromEnum FileAttributeTypeObject = 8
    fromEnum FileAttributeTypeStringv = 9
    fromEnum (AnotherFileAttributeType k) = k

    toEnum 0 = FileAttributeTypeInvalid
    toEnum 1 = FileAttributeTypeString
    toEnum 2 = FileAttributeTypeByteString
    toEnum 3 = FileAttributeTypeBoolean
    toEnum 4 = FileAttributeTypeUint32
    toEnum 5 = FileAttributeTypeInt32
    toEnum 6 = FileAttributeTypeUint64
    toEnum 7 = FileAttributeTypeInt64
    toEnum 8 = FileAttributeTypeObject
    toEnum 9 = FileAttributeTypeStringv
    toEnum k = AnotherFileAttributeType k

instance P.Ord FileAttributeType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_file_attribute_type_get_type" c_g_file_attribute_type_get_type :: 
    IO GType

instance BoxedEnum FileAttributeType where
    boxedEnumType _ = c_g_file_attribute_type_get_type

-- Enum FileAttributeStatus
{- |
Used by 'GI.Gio.Interfaces.File.fileSetAttributesFromInfo' when setting file attributes.
-}
data FileAttributeStatus = 
      FileAttributeStatusUnset
    {- ^
    Attribute value is unset (empty).
    -}
    | FileAttributeStatusSet
    {- ^
    Attribute value is set.
    -}
    | FileAttributeStatusErrorSetting
    {- ^
    Indicates an error in setting the value.
    -}
    | AnotherFileAttributeStatus Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum FileAttributeStatus where
    fromEnum FileAttributeStatusUnset = 0
    fromEnum FileAttributeStatusSet = 1
    fromEnum FileAttributeStatusErrorSetting = 2
    fromEnum (AnotherFileAttributeStatus k) = k

    toEnum 0 = FileAttributeStatusUnset
    toEnum 1 = FileAttributeStatusSet
    toEnum 2 = FileAttributeStatusErrorSetting
    toEnum k = AnotherFileAttributeStatus k

instance P.Ord FileAttributeStatus where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_file_attribute_status_get_type" c_g_file_attribute_status_get_type :: 
    IO GType

instance BoxedEnum FileAttributeStatus where
    boxedEnumType _ = c_g_file_attribute_status_get_type

-- Enum EmblemOrigin
{- |
GEmblemOrigin is used to add information about the origin of the emblem
to 'GI.Gio.Objects.Emblem.Emblem'.

/Since: 2.18/
-}
data EmblemOrigin = 
      EmblemOriginUnknown
    {- ^
    Emblem of unknown origin
    -}
    | EmblemOriginDevice
    {- ^
    Emblem adds device-specific information
    -}
    | EmblemOriginLivemetadata
    {- ^
    Emblem depicts live metadata, such as \"readonly\"
    -}
    | EmblemOriginTag
    {- ^
    Emblem comes from a user-defined tag, e.g. set by nautilus (in the future)
    -}
    | AnotherEmblemOrigin Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum EmblemOrigin where
    fromEnum EmblemOriginUnknown = 0
    fromEnum EmblemOriginDevice = 1
    fromEnum EmblemOriginLivemetadata = 2
    fromEnum EmblemOriginTag = 3
    fromEnum (AnotherEmblemOrigin k) = k

    toEnum 0 = EmblemOriginUnknown
    toEnum 1 = EmblemOriginDevice
    toEnum 2 = EmblemOriginLivemetadata
    toEnum 3 = EmblemOriginTag
    toEnum k = AnotherEmblemOrigin k

instance P.Ord EmblemOrigin where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_emblem_origin_get_type" c_g_emblem_origin_get_type :: 
    IO GType

instance BoxedEnum EmblemOrigin where
    boxedEnumType _ = c_g_emblem_origin_get_type

-- Enum DriveStartStopType
{- |
Enumeration describing how a drive can be started\/stopped.

/Since: 2.22/
-}
data DriveStartStopType = 
      DriveStartStopTypeUnknown
    {- ^
    Unknown or drive doesn\'t support
       start\/stop.
    -}
    | DriveStartStopTypeShutdown
    {- ^
    The stop method will physically
       shut down the drive and e.g. power down the port the drive is
       attached to.
    -}
    | DriveStartStopTypeNetwork
    {- ^
    The start\/stop methods are used
       for connecting\/disconnect to the drive over the network.
    -}
    | DriveStartStopTypeMultidisk
    {- ^
    The start\/stop methods will
       assemble\/disassemble a virtual drive from several physical
       drives.
    -}
    | DriveStartStopTypePassword
    {- ^
    The start\/stop methods will
       unlock\/lock the disk (for example using the ATA \<quote>SECURITY
       UNLOCK DEVICE\<\/quote> command)
    -}
    | AnotherDriveStartStopType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DriveStartStopType where
    fromEnum DriveStartStopTypeUnknown = 0
    fromEnum DriveStartStopTypeShutdown = 1
    fromEnum DriveStartStopTypeNetwork = 2
    fromEnum DriveStartStopTypeMultidisk = 3
    fromEnum DriveStartStopTypePassword = 4
    fromEnum (AnotherDriveStartStopType k) = k

    toEnum 0 = DriveStartStopTypeUnknown
    toEnum 1 = DriveStartStopTypeShutdown
    toEnum 2 = DriveStartStopTypeNetwork
    toEnum 3 = DriveStartStopTypeMultidisk
    toEnum 4 = DriveStartStopTypePassword
    toEnum k = AnotherDriveStartStopType k

instance P.Ord DriveStartStopType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_drive_start_stop_type_get_type" c_g_drive_start_stop_type_get_type :: 
    IO GType

instance BoxedEnum DriveStartStopType where
    boxedEnumType _ = c_g_drive_start_stop_type_get_type

-- Enum DataStreamNewlineType
{- |
'GI.Gio.Enums.DataStreamNewlineType' is used when checking for or setting the line endings for a given file.
-}
data DataStreamNewlineType = 
      DataStreamNewlineTypeLf
    {- ^
    Selects \"LF\" line endings, common on most modern UNIX platforms.
    -}
    | DataStreamNewlineTypeCr
    {- ^
    Selects \"CR\" line endings.
    -}
    | DataStreamNewlineTypeCrLf
    {- ^
    Selects \"CR, LF\" line ending, common on Microsoft Windows.
    -}
    | DataStreamNewlineTypeAny
    {- ^
    Automatically try to handle any line ending type.
    -}
    | AnotherDataStreamNewlineType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DataStreamNewlineType where
    fromEnum DataStreamNewlineTypeLf = 0
    fromEnum DataStreamNewlineTypeCr = 1
    fromEnum DataStreamNewlineTypeCrLf = 2
    fromEnum DataStreamNewlineTypeAny = 3
    fromEnum (AnotherDataStreamNewlineType k) = k

    toEnum 0 = DataStreamNewlineTypeLf
    toEnum 1 = DataStreamNewlineTypeCr
    toEnum 2 = DataStreamNewlineTypeCrLf
    toEnum 3 = DataStreamNewlineTypeAny
    toEnum k = AnotherDataStreamNewlineType k

instance P.Ord DataStreamNewlineType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_data_stream_newline_type_get_type" c_g_data_stream_newline_type_get_type :: 
    IO GType

instance BoxedEnum DataStreamNewlineType where
    boxedEnumType _ = c_g_data_stream_newline_type_get_type

-- Enum DataStreamByteOrder
{- |
'GI.Gio.Enums.DataStreamByteOrder' is used to ensure proper endianness of streaming data sources
across various machine architectures.
-}
data DataStreamByteOrder = 
      DataStreamByteOrderBigEndian
    {- ^
    Selects Big Endian byte order.
    -}
    | DataStreamByteOrderLittleEndian
    {- ^
    Selects Little Endian byte order.
    -}
    | DataStreamByteOrderHostEndian
    {- ^
    Selects endianness based on host machine\'s architecture.
    -}
    | AnotherDataStreamByteOrder Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DataStreamByteOrder where
    fromEnum DataStreamByteOrderBigEndian = 0
    fromEnum DataStreamByteOrderLittleEndian = 1
    fromEnum DataStreamByteOrderHostEndian = 2
    fromEnum (AnotherDataStreamByteOrder k) = k

    toEnum 0 = DataStreamByteOrderBigEndian
    toEnum 1 = DataStreamByteOrderLittleEndian
    toEnum 2 = DataStreamByteOrderHostEndian
    toEnum k = AnotherDataStreamByteOrder k

instance P.Ord DataStreamByteOrder where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_data_stream_byte_order_get_type" c_g_data_stream_byte_order_get_type :: 
    IO GType

instance BoxedEnum DataStreamByteOrder where
    boxedEnumType _ = c_g_data_stream_byte_order_get_type

-- Enum DBusMessageType
{- |
Message types used in 'GI.Gio.Objects.DBusMessage.DBusMessage'.

/Since: 2.26/
-}
data DBusMessageType = 
      DBusMessageTypeInvalid
    {- ^
    Message is of invalid type.
    -}
    | DBusMessageTypeMethodCall
    {- ^
    Method call.
    -}
    | DBusMessageTypeMethodReturn
    {- ^
    Method reply.
    -}
    | DBusMessageTypeError
    {- ^
    Error reply.
    -}
    | DBusMessageTypeSignal
    {- ^
    Signal emission.
    -}
    | AnotherDBusMessageType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DBusMessageType where
    fromEnum DBusMessageTypeInvalid = 0
    fromEnum DBusMessageTypeMethodCall = 1
    fromEnum DBusMessageTypeMethodReturn = 2
    fromEnum DBusMessageTypeError = 3
    fromEnum DBusMessageTypeSignal = 4
    fromEnum (AnotherDBusMessageType k) = k

    toEnum 0 = DBusMessageTypeInvalid
    toEnum 1 = DBusMessageTypeMethodCall
    toEnum 2 = DBusMessageTypeMethodReturn
    toEnum 3 = DBusMessageTypeError
    toEnum 4 = DBusMessageTypeSignal
    toEnum k = AnotherDBusMessageType k

instance P.Ord DBusMessageType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_dbus_message_type_get_type" c_g_dbus_message_type_get_type :: 
    IO GType

instance BoxedEnum DBusMessageType where
    boxedEnumType _ = c_g_dbus_message_type_get_type

-- Enum DBusMessageHeaderField
{- |
Header fields used in 'GI.Gio.Objects.DBusMessage.DBusMessage'.

/Since: 2.26/
-}
data DBusMessageHeaderField = 
      DBusMessageHeaderFieldInvalid
    {- ^
    Not a valid header field.
    -}
    | DBusMessageHeaderFieldPath
    {- ^
    The object path.
    -}
    | DBusMessageHeaderFieldInterface
    {- ^
    The interface name.
    -}
    | DBusMessageHeaderFieldMember
    {- ^
    The method or signal name.
    -}
    | DBusMessageHeaderFieldErrorName
    {- ^
    The name of the error that occurred.
    -}
    | DBusMessageHeaderFieldReplySerial
    {- ^
    The serial number the message is a reply to.
    -}
    | DBusMessageHeaderFieldDestination
    {- ^
    The name the message is intended for.
    -}
    | DBusMessageHeaderFieldSender
    {- ^
    Unique name of the sender of the message (filled in by the bus).
    -}
    | DBusMessageHeaderFieldSignature
    {- ^
    The signature of the message body.
    -}
    | DBusMessageHeaderFieldNumUnixFds
    {- ^
    The number of UNIX file descriptors that accompany the message.
    -}
    | AnotherDBusMessageHeaderField Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DBusMessageHeaderField where
    fromEnum DBusMessageHeaderFieldInvalid = 0
    fromEnum DBusMessageHeaderFieldPath = 1
    fromEnum DBusMessageHeaderFieldInterface = 2
    fromEnum DBusMessageHeaderFieldMember = 3
    fromEnum DBusMessageHeaderFieldErrorName = 4
    fromEnum DBusMessageHeaderFieldReplySerial = 5
    fromEnum DBusMessageHeaderFieldDestination = 6
    fromEnum DBusMessageHeaderFieldSender = 7
    fromEnum DBusMessageHeaderFieldSignature = 8
    fromEnum DBusMessageHeaderFieldNumUnixFds = 9
    fromEnum (AnotherDBusMessageHeaderField k) = k

    toEnum 0 = DBusMessageHeaderFieldInvalid
    toEnum 1 = DBusMessageHeaderFieldPath
    toEnum 2 = DBusMessageHeaderFieldInterface
    toEnum 3 = DBusMessageHeaderFieldMember
    toEnum 4 = DBusMessageHeaderFieldErrorName
    toEnum 5 = DBusMessageHeaderFieldReplySerial
    toEnum 6 = DBusMessageHeaderFieldDestination
    toEnum 7 = DBusMessageHeaderFieldSender
    toEnum 8 = DBusMessageHeaderFieldSignature
    toEnum 9 = DBusMessageHeaderFieldNumUnixFds
    toEnum k = AnotherDBusMessageHeaderField k

instance P.Ord DBusMessageHeaderField where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_dbus_message_header_field_get_type" c_g_dbus_message_header_field_get_type :: 
    IO GType

instance BoxedEnum DBusMessageHeaderField where
    boxedEnumType _ = c_g_dbus_message_header_field_get_type

-- Enum DBusMessageByteOrder
{- |
Enumeration used to describe the byte order of a D-Bus message.

/Since: 2.26/
-}
data DBusMessageByteOrder = 
      DBusMessageByteOrderBigEndian
    {- ^
    The byte order is big endian.
    -}
    | DBusMessageByteOrderLittleEndian
    {- ^
    The byte order is little endian.
    -}
    | AnotherDBusMessageByteOrder Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DBusMessageByteOrder where
    fromEnum DBusMessageByteOrderBigEndian = 66
    fromEnum DBusMessageByteOrderLittleEndian = 108
    fromEnum (AnotherDBusMessageByteOrder k) = k

    toEnum 66 = DBusMessageByteOrderBigEndian
    toEnum 108 = DBusMessageByteOrderLittleEndian
    toEnum k = AnotherDBusMessageByteOrder k

instance P.Ord DBusMessageByteOrder where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_dbus_message_byte_order_get_type" c_g_dbus_message_byte_order_get_type :: 
    IO GType

instance BoxedEnum DBusMessageByteOrder where
    boxedEnumType _ = c_g_dbus_message_byte_order_get_type

-- Enum DBusError
{- |
Error codes for the @/G_DBUS_ERROR/@ error domain.

/Since: 2.26/
-}
data DBusError = 
      DBusErrorFailed
    {- ^
    A generic error; \"something went wrong\" - see the error message for
    more.
    -}
    | DBusErrorNoMemory
    {- ^
    There was not enough memory to complete an operation.
    -}
    | DBusErrorServiceUnknown
    {- ^
    The bus doesn\'t know how to launch a service to supply the bus name
    you wanted.
    -}
    | DBusErrorNameHasNoOwner
    {- ^
    The bus name you referenced doesn\'t exist (i.e. no application owns
    it).
    -}
    | DBusErrorNoReply
    {- ^
    No reply to a message expecting one, usually means a timeout occurred.
    -}
    | DBusErrorIoError
    {- ^
    Something went wrong reading or writing to a socket, for example.
    -}
    | DBusErrorBadAddress
    {- ^
    A D-Bus bus address was malformed.
    -}
    | DBusErrorNotSupported
    {- ^
    Requested operation isn\'t supported (like ENOSYS on UNIX).
    -}
    | DBusErrorLimitsExceeded
    {- ^
    Some limited resource is exhausted.
    -}
    | DBusErrorAccessDenied
    {- ^
    Security restrictions don\'t allow doing what you\'re trying to do.
    -}
    | DBusErrorAuthFailed
    {- ^
    Authentication didn\'t work.
    -}
    | DBusErrorNoServer
    {- ^
    Unable to connect to server (probably caused by ECONNREFUSED on a
    socket).
    -}
    | DBusErrorTimeout
    {- ^
    Certain timeout errors, possibly ETIMEDOUT on a socket.  Note that
    'GI.Gio.Enums.DBusErrorNoReply' is used for message reply timeouts. Warning:
    this is confusingly-named given that 'GI.Gio.Enums.DBusErrorTimedOut' also
    exists. We can\'t fix it for compatibility reasons so just be
    careful.
    -}
    | DBusErrorNoNetwork
    {- ^
    No network access (probably ENETUNREACH on a socket).
    -}
    | DBusErrorAddressInUse
    {- ^
    Can\'t bind a socket since its address is in use (i.e. EADDRINUSE).
    -}
    | DBusErrorDisconnected
    {- ^
    The connection is disconnected and you\'re trying to use it.
    -}
    | DBusErrorInvalidArgs
    {- ^
    Invalid arguments passed to a method call.
    -}
    | DBusErrorFileNotFound
    {- ^
    Missing file.
    -}
    | DBusErrorFileExists
    {- ^
    Existing file and the operation you\'re using does not silently overwrite.
    -}
    | DBusErrorUnknownMethod
    {- ^
    Method name you invoked isn\'t known by the object you invoked it on.
    -}
    | DBusErrorTimedOut
    {- ^
    Certain timeout errors, e.g. while starting a service. Warning: this is
    confusingly-named given that 'GI.Gio.Enums.DBusErrorTimeout' also exists. We
    can\'t fix it for compatibility reasons so just be careful.
    -}
    | DBusErrorMatchRuleNotFound
    {- ^
    Tried to remove or modify a match rule that didn\'t exist.
    -}
    | DBusErrorMatchRuleInvalid
    {- ^
    The match rule isn\'t syntactically valid.
    -}
    | DBusErrorSpawnExecFailed
    {- ^
    While starting a new process, the @/exec()/@ call failed.
    -}
    | DBusErrorSpawnForkFailed
    {- ^
    While starting a new process, the @/fork()/@ call failed.
    -}
    | DBusErrorSpawnChildExited
    {- ^
    While starting a new process, the child exited with a status code.
    -}
    | DBusErrorSpawnChildSignaled
    {- ^
    While starting a new process, the child exited on a signal.
    -}
    | DBusErrorSpawnFailed
    {- ^
    While starting a new process, something went wrong.
    -}
    | DBusErrorSpawnSetupFailed
    {- ^
    We failed to setup the environment correctly.
    -}
    | DBusErrorSpawnConfigInvalid
    {- ^
    We failed to setup the config parser correctly.
    -}
    | DBusErrorSpawnServiceInvalid
    {- ^
    Bus name was not valid.
    -}
    | DBusErrorSpawnServiceNotFound
    {- ^
    Service file not found in system-services directory.
    -}
    | DBusErrorSpawnPermissionsInvalid
    {- ^
    Permissions are incorrect on the setuid helper.
    -}
    | DBusErrorSpawnFileInvalid
    {- ^
    Service file invalid (Name, User or Exec missing).
    -}
    | DBusErrorSpawnNoMemory
    {- ^
    Tried to get a UNIX process ID and it wasn\'t available.
    -}
    | DBusErrorUnixProcessIdUnknown
    {- ^
    Tried to get a UNIX process ID and it wasn\'t available.
    -}
    | DBusErrorInvalidSignature
    {- ^
    A type signature is not valid.
    -}
    | DBusErrorInvalidFileContent
    {- ^
    A file contains invalid syntax or is otherwise broken.
    -}
    | DBusErrorSelinuxSecurityContextUnknown
    {- ^
    Asked for SELinux security context and it wasn\'t available.
    -}
    | DBusErrorAdtAuditDataUnknown
    {- ^
    Asked for ADT audit data and it wasn\'t available.
    -}
    | DBusErrorObjectPathInUse
    {- ^
    There\'s already an object with the requested object path.
    -}
    | DBusErrorUnknownObject
    {- ^
    Object you invoked a method on isn\'t known. Since 2.42
    -}
    | DBusErrorUnknownInterface
    {- ^
    Interface you invoked a method on isn\'t known by the object. Since 2.42
    -}
    | DBusErrorUnknownProperty
    {- ^
    Property you tried to access isn\'t known by the object. Since 2.42
    -}
    | DBusErrorPropertyReadOnly
    {- ^
    Property you tried to set is read-only. Since 2.42
    -}
    | AnotherDBusError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DBusError where
    fromEnum DBusErrorFailed = 0
    fromEnum DBusErrorNoMemory = 1
    fromEnum DBusErrorServiceUnknown = 2
    fromEnum DBusErrorNameHasNoOwner = 3
    fromEnum DBusErrorNoReply = 4
    fromEnum DBusErrorIoError = 5
    fromEnum DBusErrorBadAddress = 6
    fromEnum DBusErrorNotSupported = 7
    fromEnum DBusErrorLimitsExceeded = 8
    fromEnum DBusErrorAccessDenied = 9
    fromEnum DBusErrorAuthFailed = 10
    fromEnum DBusErrorNoServer = 11
    fromEnum DBusErrorTimeout = 12
    fromEnum DBusErrorNoNetwork = 13
    fromEnum DBusErrorAddressInUse = 14
    fromEnum DBusErrorDisconnected = 15
    fromEnum DBusErrorInvalidArgs = 16
    fromEnum DBusErrorFileNotFound = 17
    fromEnum DBusErrorFileExists = 18
    fromEnum DBusErrorUnknownMethod = 19
    fromEnum DBusErrorTimedOut = 20
    fromEnum DBusErrorMatchRuleNotFound = 21
    fromEnum DBusErrorMatchRuleInvalid = 22
    fromEnum DBusErrorSpawnExecFailed = 23
    fromEnum DBusErrorSpawnForkFailed = 24
    fromEnum DBusErrorSpawnChildExited = 25
    fromEnum DBusErrorSpawnChildSignaled = 26
    fromEnum DBusErrorSpawnFailed = 27
    fromEnum DBusErrorSpawnSetupFailed = 28
    fromEnum DBusErrorSpawnConfigInvalid = 29
    fromEnum DBusErrorSpawnServiceInvalid = 30
    fromEnum DBusErrorSpawnServiceNotFound = 31
    fromEnum DBusErrorSpawnPermissionsInvalid = 32
    fromEnum DBusErrorSpawnFileInvalid = 33
    fromEnum DBusErrorSpawnNoMemory = 34
    fromEnum DBusErrorUnixProcessIdUnknown = 35
    fromEnum DBusErrorInvalidSignature = 36
    fromEnum DBusErrorInvalidFileContent = 37
    fromEnum DBusErrorSelinuxSecurityContextUnknown = 38
    fromEnum DBusErrorAdtAuditDataUnknown = 39
    fromEnum DBusErrorObjectPathInUse = 40
    fromEnum DBusErrorUnknownObject = 41
    fromEnum DBusErrorUnknownInterface = 42
    fromEnum DBusErrorUnknownProperty = 43
    fromEnum DBusErrorPropertyReadOnly = 44
    fromEnum (AnotherDBusError k) = k

    toEnum 0 = DBusErrorFailed
    toEnum 1 = DBusErrorNoMemory
    toEnum 2 = DBusErrorServiceUnknown
    toEnum 3 = DBusErrorNameHasNoOwner
    toEnum 4 = DBusErrorNoReply
    toEnum 5 = DBusErrorIoError
    toEnum 6 = DBusErrorBadAddress
    toEnum 7 = DBusErrorNotSupported
    toEnum 8 = DBusErrorLimitsExceeded
    toEnum 9 = DBusErrorAccessDenied
    toEnum 10 = DBusErrorAuthFailed
    toEnum 11 = DBusErrorNoServer
    toEnum 12 = DBusErrorTimeout
    toEnum 13 = DBusErrorNoNetwork
    toEnum 14 = DBusErrorAddressInUse
    toEnum 15 = DBusErrorDisconnected
    toEnum 16 = DBusErrorInvalidArgs
    toEnum 17 = DBusErrorFileNotFound
    toEnum 18 = DBusErrorFileExists
    toEnum 19 = DBusErrorUnknownMethod
    toEnum 20 = DBusErrorTimedOut
    toEnum 21 = DBusErrorMatchRuleNotFound
    toEnum 22 = DBusErrorMatchRuleInvalid
    toEnum 23 = DBusErrorSpawnExecFailed
    toEnum 24 = DBusErrorSpawnForkFailed
    toEnum 25 = DBusErrorSpawnChildExited
    toEnum 26 = DBusErrorSpawnChildSignaled
    toEnum 27 = DBusErrorSpawnFailed
    toEnum 28 = DBusErrorSpawnSetupFailed
    toEnum 29 = DBusErrorSpawnConfigInvalid
    toEnum 30 = DBusErrorSpawnServiceInvalid
    toEnum 31 = DBusErrorSpawnServiceNotFound
    toEnum 32 = DBusErrorSpawnPermissionsInvalid
    toEnum 33 = DBusErrorSpawnFileInvalid
    toEnum 34 = DBusErrorSpawnNoMemory
    toEnum 35 = DBusErrorUnixProcessIdUnknown
    toEnum 36 = DBusErrorInvalidSignature
    toEnum 37 = DBusErrorInvalidFileContent
    toEnum 38 = DBusErrorSelinuxSecurityContextUnknown
    toEnum 39 = DBusErrorAdtAuditDataUnknown
    toEnum 40 = DBusErrorObjectPathInUse
    toEnum 41 = DBusErrorUnknownObject
    toEnum 42 = DBusErrorUnknownInterface
    toEnum 43 = DBusErrorUnknownProperty
    toEnum 44 = DBusErrorPropertyReadOnly
    toEnum k = AnotherDBusError k

instance P.Ord DBusError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass DBusError where
    gerrorClassDomain _ = "g-dbus-error-quark"

-- | Catch exceptions of type `DBusError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchDBusError ::
    IO a ->
    (DBusError -> GErrorMessage -> IO a) ->
    IO a
catchDBusError = catchGErrorJustDomain

-- | Handle exceptions of type `DBusError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleDBusError ::
    (DBusError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleDBusError = handleGErrorJustDomain

foreign import ccall "g_dbus_error_get_type" c_g_dbus_error_get_type :: 
    IO GType

instance BoxedEnum DBusError where
    boxedEnumType _ = c_g_dbus_error_get_type

-- Enum CredentialsType
{- |
Enumeration describing different kinds of native credential types.

/Since: 2.26/
-}
data CredentialsType = 
      CredentialsTypeInvalid
    {- ^
    Indicates an invalid native credential type.
    -}
    | CredentialsTypeLinuxUcred
    {- ^
    The native credentials type is a struct ucred.
    -}
    | CredentialsTypeFreebsdCmsgcred
    {- ^
    The native credentials type is a struct cmsgcred.
    -}
    | CredentialsTypeOpenbsdSockpeercred
    {- ^
    The native credentials type is a struct sockpeercred. Added in 2.30.
    -}
    | CredentialsTypeSolarisUcred
    {- ^
    The native credentials type is a ucred_t. Added in 2.40.
    -}
    | CredentialsTypeNetbsdUnpcbid
    {- ^
    The native credentials type is a struct unpcbid.
    -}
    | AnotherCredentialsType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum CredentialsType where
    fromEnum CredentialsTypeInvalid = 0
    fromEnum CredentialsTypeLinuxUcred = 1
    fromEnum CredentialsTypeFreebsdCmsgcred = 2
    fromEnum CredentialsTypeOpenbsdSockpeercred = 3
    fromEnum CredentialsTypeSolarisUcred = 4
    fromEnum CredentialsTypeNetbsdUnpcbid = 5
    fromEnum (AnotherCredentialsType k) = k

    toEnum 0 = CredentialsTypeInvalid
    toEnum 1 = CredentialsTypeLinuxUcred
    toEnum 2 = CredentialsTypeFreebsdCmsgcred
    toEnum 3 = CredentialsTypeOpenbsdSockpeercred
    toEnum 4 = CredentialsTypeSolarisUcred
    toEnum 5 = CredentialsTypeNetbsdUnpcbid
    toEnum k = AnotherCredentialsType k

instance P.Ord CredentialsType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_credentials_type_get_type" c_g_credentials_type_get_type :: 
    IO GType

instance BoxedEnum CredentialsType where
    boxedEnumType _ = c_g_credentials_type_get_type

-- Enum ConverterResult
{- |
Results returned from 'GI.Gio.Interfaces.Converter.converterConvert'.

/Since: 2.24/
-}
data ConverterResult = 
      ConverterResultError
    {- ^
    There was an error during conversion.
    -}
    | ConverterResultConverted
    {- ^
    Some data was consumed or produced
    -}
    | ConverterResultFinished
    {- ^
    The conversion is finished
    -}
    | ConverterResultFlushed
    {- ^
    Flushing is finished
    -}
    | AnotherConverterResult Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ConverterResult where
    fromEnum ConverterResultError = 0
    fromEnum ConverterResultConverted = 1
    fromEnum ConverterResultFinished = 2
    fromEnum ConverterResultFlushed = 3
    fromEnum (AnotherConverterResult k) = k

    toEnum 0 = ConverterResultError
    toEnum 1 = ConverterResultConverted
    toEnum 2 = ConverterResultFinished
    toEnum 3 = ConverterResultFlushed
    toEnum k = AnotherConverterResult k

instance P.Ord ConverterResult where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_converter_result_get_type" c_g_converter_result_get_type :: 
    IO GType

instance BoxedEnum ConverterResult where
    boxedEnumType _ = c_g_converter_result_get_type

-- Enum BusType
{- |
An enumeration for well-known message buses.

/Since: 2.26/
-}
data BusType = 
      BusTypeStarter
    {- ^
    An alias for the message bus that activated the process, if any.
    -}
    | BusTypeNone
    {- ^
    Not a message bus.
    -}
    | BusTypeSystem
    {- ^
    The system-wide message bus.
    -}
    | BusTypeSession
    {- ^
    The login session message bus.
    -}
    | AnotherBusType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum BusType where
    fromEnum BusTypeStarter = -1
    fromEnum BusTypeNone = 0
    fromEnum BusTypeSystem = 1
    fromEnum BusTypeSession = 2
    fromEnum (AnotherBusType k) = k

    toEnum -1 = BusTypeStarter
    toEnum 0 = BusTypeNone
    toEnum 1 = BusTypeSystem
    toEnum 2 = BusTypeSession
    toEnum k = AnotherBusType k

instance P.Ord BusType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "g_bus_type_get_type" c_g_bus_type_get_type :: 
    IO GType

instance BoxedEnum BusType where
    boxedEnumType _ = c_g_bus_type_get_type