gi-gio-2.0.20: GI/Gio/Flags.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.Flags
    ( 

 -- * Flags
-- ** AppInfoCreateFlags #flag:AppInfoCreateFlags#

    AppInfoCreateFlags(..)                  ,


-- ** ApplicationFlags #flag:ApplicationFlags#

    ApplicationFlags(..)                    ,


-- ** AskPasswordFlags #flag:AskPasswordFlags#

    AskPasswordFlags(..)                    ,


-- ** BusNameOwnerFlags #flag:BusNameOwnerFlags#

    BusNameOwnerFlags(..)                   ,


-- ** BusNameWatcherFlags #flag:BusNameWatcherFlags#

    BusNameWatcherFlags(..)                 ,


-- ** ConverterFlags #flag:ConverterFlags#

    ConverterFlags(..)                      ,


-- ** DBusCallFlags #flag:DBusCallFlags#

    DBusCallFlags(..)                       ,


-- ** DBusCapabilityFlags #flag:DBusCapabilityFlags#

    DBusCapabilityFlags(..)                 ,


-- ** DBusConnectionFlags #flag:DBusConnectionFlags#

    DBusConnectionFlags(..)                 ,


-- ** DBusInterfaceSkeletonFlags #flag:DBusInterfaceSkeletonFlags#

    DBusInterfaceSkeletonFlags(..)          ,


-- ** DBusMessageFlags #flag:DBusMessageFlags#

    DBusMessageFlags(..)                    ,


-- ** DBusObjectManagerClientFlags #flag:DBusObjectManagerClientFlags#

    DBusObjectManagerClientFlags(..)        ,


-- ** DBusPropertyInfoFlags #flag:DBusPropertyInfoFlags#

    DBusPropertyInfoFlags(..)               ,


-- ** DBusProxyFlags #flag:DBusProxyFlags#

    DBusProxyFlags(..)                      ,


-- ** DBusSendMessageFlags #flag:DBusSendMessageFlags#

    DBusSendMessageFlags(..)                ,


-- ** DBusServerFlags #flag:DBusServerFlags#

    DBusServerFlags(..)                     ,


-- ** DBusSignalFlags #flag:DBusSignalFlags#

    DBusSignalFlags(..)                     ,


-- ** DBusSubtreeFlags #flag:DBusSubtreeFlags#

    DBusSubtreeFlags(..)                    ,


-- ** DriveStartFlags #flag:DriveStartFlags#

    DriveStartFlags(..)                     ,


-- ** FileAttributeInfoFlags #flag:FileAttributeInfoFlags#

    FileAttributeInfoFlags(..)              ,


-- ** FileCopyFlags #flag:FileCopyFlags#

    FileCopyFlags(..)                       ,


-- ** FileCreateFlags #flag:FileCreateFlags#

    FileCreateFlags(..)                     ,


-- ** FileMeasureFlags #flag:FileMeasureFlags#

    FileMeasureFlags(..)                    ,


-- ** FileMonitorFlags #flag:FileMonitorFlags#

    FileMonitorFlags(..)                    ,


-- ** FileQueryInfoFlags #flag:FileQueryInfoFlags#

    FileQueryInfoFlags(..)                  ,


-- ** IOStreamSpliceFlags #flag:IOStreamSpliceFlags#

    IOStreamSpliceFlags(..)                 ,


-- ** MountMountFlags #flag:MountMountFlags#

    MountMountFlags(..)                     ,


-- ** MountUnmountFlags #flag:MountUnmountFlags#

    MountUnmountFlags(..)                   ,


-- ** OutputStreamSpliceFlags #flag:OutputStreamSpliceFlags#

    OutputStreamSpliceFlags(..)             ,


-- ** ResolverNameLookupFlags #flag:ResolverNameLookupFlags#

    ResolverNameLookupFlags(..)             ,


-- ** ResourceFlags #flag:ResourceFlags#

    ResourceFlags(..)                       ,


-- ** ResourceLookupFlags #flag:ResourceLookupFlags#

    ResourceLookupFlags(..)                 ,


-- ** SettingsBindFlags #flag:SettingsBindFlags#

    SettingsBindFlags(..)                   ,


-- ** SocketMsgFlags #flag:SocketMsgFlags#

    SocketMsgFlags(..)                      ,


-- ** SubprocessFlags #flag:SubprocessFlags#

    SubprocessFlags(..)                     ,


-- ** TestDBusFlags #flag:TestDBusFlags#

    TestDBusFlags(..)                       ,


-- ** TlsCertificateFlags #flag:TlsCertificateFlags#

    TlsCertificateFlags(..)                 ,


-- ** TlsDatabaseVerifyFlags #flag:TlsDatabaseVerifyFlags#

    TlsDatabaseVerifyFlags(..)              ,


-- ** TlsPasswordFlags #flag:TlsPasswordFlags#

    TlsPasswordFlags(..)                    ,




    ) 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


-- Flags TlsPasswordFlags
{- |
Various flags for the password.

/Since: 2.30/
-}
data TlsPasswordFlags = 
      TlsPasswordFlagsNone
    {- ^
    No flags
    -}
    | TlsPasswordFlagsRetry
    {- ^
    The password was wrong, and the user should retry.
    -}
    | TlsPasswordFlagsManyTries
    {- ^
    Hint to the user that the password has been
       wrong many times, and the user may not have many chances left.
    -}
    | TlsPasswordFlagsFinalTry
    {- ^
    Hint to the user that this is the last try to get
       this password right.
    -}
    | AnotherTlsPasswordFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TlsPasswordFlags where
    fromEnum TlsPasswordFlagsNone = 0
    fromEnum TlsPasswordFlagsRetry = 2
    fromEnum TlsPasswordFlagsManyTries = 4
    fromEnum TlsPasswordFlagsFinalTry = 8
    fromEnum (AnotherTlsPasswordFlags k) = k

    toEnum 0 = TlsPasswordFlagsNone
    toEnum 2 = TlsPasswordFlagsRetry
    toEnum 4 = TlsPasswordFlagsManyTries
    toEnum 8 = TlsPasswordFlagsFinalTry
    toEnum k = AnotherTlsPasswordFlags k

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

foreign import ccall "g_tls_password_flags_get_type" c_g_tls_password_flags_get_type :: 
    IO GType

instance BoxedFlags TlsPasswordFlags where
    boxedFlagsType _ = c_g_tls_password_flags_get_type

instance IsGFlag TlsPasswordFlags

-- Flags TlsDatabaseVerifyFlags
{- |
Flags for 'GI.Gio.Objects.TlsDatabase.tlsDatabaseVerifyChain'.

/Since: 2.30/
-}
data TlsDatabaseVerifyFlags = 
      TlsDatabaseVerifyFlagsNone
    {- ^
    No verification flags
    -}
    | AnotherTlsDatabaseVerifyFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TlsDatabaseVerifyFlags where
    fromEnum TlsDatabaseVerifyFlagsNone = 0
    fromEnum (AnotherTlsDatabaseVerifyFlags k) = k

    toEnum 0 = TlsDatabaseVerifyFlagsNone
    toEnum k = AnotherTlsDatabaseVerifyFlags k

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

foreign import ccall "g_tls_database_verify_flags_get_type" c_g_tls_database_verify_flags_get_type :: 
    IO GType

instance BoxedFlags TlsDatabaseVerifyFlags where
    boxedFlagsType _ = c_g_tls_database_verify_flags_get_type

instance IsGFlag TlsDatabaseVerifyFlags

-- Flags TlsCertificateFlags
{- |
A set of flags describing TLS certification validation. This can be
used to set which validation steps to perform (eg, with
'GI.Gio.Interfaces.TlsClientConnection.tlsClientConnectionSetValidationFlags'), or to describe why
a particular certificate was rejected (eg, in
'GI.Gio.Objects.TlsConnection.TlsConnection'::@/accept-certificate/@).

/Since: 2.28/
-}
data TlsCertificateFlags = 
      TlsCertificateFlagsUnknownCa
    {- ^
    The signing certificate authority is
      not known.
    -}
    | TlsCertificateFlagsBadIdentity
    {- ^
    The certificate does not match the
      expected identity of the site that it was retrieved from.
    -}
    | TlsCertificateFlagsNotActivated
    {- ^
    The certificate\'s activation time
      is still in the future
    -}
    | TlsCertificateFlagsExpired
    {- ^
    The certificate has expired
    -}
    | TlsCertificateFlagsRevoked
    {- ^
    The certificate has been revoked
      according to the 'GI.Gio.Objects.TlsConnection.TlsConnection'\'s certificate revocation list.
    -}
    | TlsCertificateFlagsInsecure
    {- ^
    The certificate\'s algorithm is
      considered insecure.
    -}
    | TlsCertificateFlagsGenericError
    {- ^
    Some other error occurred validating
      the certificate
    -}
    | TlsCertificateFlagsValidateAll
    {- ^
    the combination of all of the above
      flags
    -}
    | AnotherTlsCertificateFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TlsCertificateFlags where
    fromEnum TlsCertificateFlagsUnknownCa = 1
    fromEnum TlsCertificateFlagsBadIdentity = 2
    fromEnum TlsCertificateFlagsNotActivated = 4
    fromEnum TlsCertificateFlagsExpired = 8
    fromEnum TlsCertificateFlagsRevoked = 16
    fromEnum TlsCertificateFlagsInsecure = 32
    fromEnum TlsCertificateFlagsGenericError = 64
    fromEnum TlsCertificateFlagsValidateAll = 127
    fromEnum (AnotherTlsCertificateFlags k) = k

    toEnum 1 = TlsCertificateFlagsUnknownCa
    toEnum 2 = TlsCertificateFlagsBadIdentity
    toEnum 4 = TlsCertificateFlagsNotActivated
    toEnum 8 = TlsCertificateFlagsExpired
    toEnum 16 = TlsCertificateFlagsRevoked
    toEnum 32 = TlsCertificateFlagsInsecure
    toEnum 64 = TlsCertificateFlagsGenericError
    toEnum 127 = TlsCertificateFlagsValidateAll
    toEnum k = AnotherTlsCertificateFlags k

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

foreign import ccall "g_tls_certificate_flags_get_type" c_g_tls_certificate_flags_get_type :: 
    IO GType

instance BoxedFlags TlsCertificateFlags where
    boxedFlagsType _ = c_g_tls_certificate_flags_get_type

instance IsGFlag TlsCertificateFlags

-- Flags TestDBusFlags
{- |
Flags to define future 'GI.Gio.Objects.TestDBus.TestDBus' behaviour.

/Since: 2.34/
-}
data TestDBusFlags = 
      TestDBusFlagsNone
    {- ^
    No flags.
    -}
    | AnotherTestDBusFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TestDBusFlags where
    fromEnum TestDBusFlagsNone = 0
    fromEnum (AnotherTestDBusFlags k) = k

    toEnum 0 = TestDBusFlagsNone
    toEnum k = AnotherTestDBusFlags k

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

foreign import ccall "g_test_dbus_flags_get_type" c_g_test_dbus_flags_get_type :: 
    IO GType

instance BoxedFlags TestDBusFlags where
    boxedFlagsType _ = c_g_test_dbus_flags_get_type

instance IsGFlag TestDBusFlags

-- Flags SubprocessFlags
{- |
Flags to define the behaviour of a 'GI.Gio.Objects.Subprocess.Subprocess'.

Note that the default for stdin is to redirect from @\/dev\/null@.  For
stdout and stderr the default are for them to inherit the
corresponding descriptor from the calling process.

Note that it is a programmer error to mix \'incompatible\' flags.  For
example, you may not request both 'GI.Gio.Flags.SubprocessFlagsStdoutPipe' and
'GI.Gio.Flags.SubprocessFlagsStdoutSilence'.

/Since: 2.40/
-}
data SubprocessFlags = 
      SubprocessFlagsNone
    {- ^
    No flags.
    -}
    | SubprocessFlagsStdinPipe
    {- ^
    create a pipe for the stdin of the
      spawned process that can be accessed with
      'GI.Gio.Objects.Subprocess.subprocessGetStdinPipe'.
    -}
    | SubprocessFlagsStdinInherit
    {- ^
    stdin is inherited from the
      calling process.
    -}
    | SubprocessFlagsStdoutPipe
    {- ^
    create a pipe for the stdout of the
      spawned process that can be accessed with
      'GI.Gio.Objects.Subprocess.subprocessGetStdoutPipe'.
    -}
    | SubprocessFlagsStdoutSilence
    {- ^
    silence the stdout of the spawned
      process (ie: redirect to @\/dev\/null@).
    -}
    | SubprocessFlagsStderrPipe
    {- ^
    create a pipe for the stderr of the
      spawned process that can be accessed with
      'GI.Gio.Objects.Subprocess.subprocessGetStderrPipe'.
    -}
    | SubprocessFlagsStderrSilence
    {- ^
    silence the stderr of the spawned
      process (ie: redirect to @\/dev\/null@).
    -}
    | SubprocessFlagsStderrMerge
    {- ^
    merge the stderr of the spawned
      process with whatever the stdout happens to be.  This is a good way
      of directing both streams to a common log file, for example.
    -}
    | SubprocessFlagsInheritFds
    {- ^
    spawned processes will inherit the
      file descriptors of their parent, unless those descriptors have
      been explicitly marked as close-on-exec.  This flag has no effect
      over the \"standard\" file descriptors (stdin, stdout, stderr).
    -}
    | AnotherSubprocessFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum SubprocessFlags where
    fromEnum SubprocessFlagsNone = 0
    fromEnum SubprocessFlagsStdinPipe = 1
    fromEnum SubprocessFlagsStdinInherit = 2
    fromEnum SubprocessFlagsStdoutPipe = 4
    fromEnum SubprocessFlagsStdoutSilence = 8
    fromEnum SubprocessFlagsStderrPipe = 16
    fromEnum SubprocessFlagsStderrSilence = 32
    fromEnum SubprocessFlagsStderrMerge = 64
    fromEnum SubprocessFlagsInheritFds = 128
    fromEnum (AnotherSubprocessFlags k) = k

    toEnum 0 = SubprocessFlagsNone
    toEnum 1 = SubprocessFlagsStdinPipe
    toEnum 2 = SubprocessFlagsStdinInherit
    toEnum 4 = SubprocessFlagsStdoutPipe
    toEnum 8 = SubprocessFlagsStdoutSilence
    toEnum 16 = SubprocessFlagsStderrPipe
    toEnum 32 = SubprocessFlagsStderrSilence
    toEnum 64 = SubprocessFlagsStderrMerge
    toEnum 128 = SubprocessFlagsInheritFds
    toEnum k = AnotherSubprocessFlags k

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

foreign import ccall "g_subprocess_flags_get_type" c_g_subprocess_flags_get_type :: 
    IO GType

instance BoxedFlags SubprocessFlags where
    boxedFlagsType _ = c_g_subprocess_flags_get_type

instance IsGFlag SubprocessFlags

-- Flags SocketMsgFlags
{- |
Flags used in 'GI.Gio.Objects.Socket.socketReceiveMessage' and 'GI.Gio.Objects.Socket.socketSendMessage'.
The flags listed in the enum are some commonly available flags, but the
values used for them are the same as on the platform, and any other flags
are passed in\/out as is. So to use a platform specific flag, just include
the right system header and pass in the flag.

/Since: 2.22/
-}
data SocketMsgFlags = 
      SocketMsgFlagsNone
    {- ^
    No flags.
    -}
    | SocketMsgFlagsOob
    {- ^
    Request to send\/receive out of band data.
    -}
    | SocketMsgFlagsPeek
    {- ^
    Read data from the socket without removing it from
        the queue.
    -}
    | SocketMsgFlagsDontroute
    {- ^
    Don\'t use a gateway to send out the packet,
        only send to hosts on directly connected networks.
    -}
    | AnotherSocketMsgFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum SocketMsgFlags where
    fromEnum SocketMsgFlagsNone = 0
    fromEnum SocketMsgFlagsOob = 1
    fromEnum SocketMsgFlagsPeek = 2
    fromEnum SocketMsgFlagsDontroute = 4
    fromEnum (AnotherSocketMsgFlags k) = k

    toEnum 0 = SocketMsgFlagsNone
    toEnum 1 = SocketMsgFlagsOob
    toEnum 2 = SocketMsgFlagsPeek
    toEnum 4 = SocketMsgFlagsDontroute
    toEnum k = AnotherSocketMsgFlags k

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

foreign import ccall "g_socket_msg_flags_get_type" c_g_socket_msg_flags_get_type :: 
    IO GType

instance BoxedFlags SocketMsgFlags where
    boxedFlagsType _ = c_g_socket_msg_flags_get_type

instance IsGFlag SocketMsgFlags

-- Flags SettingsBindFlags
{- |
Flags used when creating a binding. These flags determine in which
direction the binding works. The default is to synchronize in both
directions.
-}
data SettingsBindFlags = 
      SettingsBindFlagsDefault
    {- ^
    Equivalent to @G_SETTINGS_BIND_GET|G_SETTINGS_BIND_SET@
    -}
    | SettingsBindFlagsGet
    {- ^
    Update the 'GI.GObject.Objects.Object.Object' property when the setting changes.
        It is an error to use this flag if the property is not writable.
    -}
    | SettingsBindFlagsSet
    {- ^
    Update the setting when the 'GI.GObject.Objects.Object.Object' property changes.
        It is an error to use this flag if the property is not readable.
    -}
    | SettingsBindFlagsNoSensitivity
    {- ^
    Do not try to bind a \"sensitivity\" property to the writability of the setting
    -}
    | SettingsBindFlagsGetNoChanges
    {- ^
    When set in addition to @/G_SETTINGS_BIND_GET/@, set the 'GI.GObject.Objects.Object.Object' property
        value initially from the setting, but do not listen for changes of the setting
    -}
    | SettingsBindFlagsInvertBoolean
    {- ^
    When passed to 'GI.Gio.Objects.Settings.settingsBind', uses a pair of mapping functions that invert
        the boolean value when mapping between the setting and the property.  The setting and property must both
        be booleans.  You cannot pass this flag to @/g_settings_bind_with_mapping()/@.
    -}
    | AnotherSettingsBindFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum SettingsBindFlags where
    fromEnum SettingsBindFlagsDefault = 0
    fromEnum SettingsBindFlagsGet = 1
    fromEnum SettingsBindFlagsSet = 2
    fromEnum SettingsBindFlagsNoSensitivity = 4
    fromEnum SettingsBindFlagsGetNoChanges = 8
    fromEnum SettingsBindFlagsInvertBoolean = 16
    fromEnum (AnotherSettingsBindFlags k) = k

    toEnum 0 = SettingsBindFlagsDefault
    toEnum 1 = SettingsBindFlagsGet
    toEnum 2 = SettingsBindFlagsSet
    toEnum 4 = SettingsBindFlagsNoSensitivity
    toEnum 8 = SettingsBindFlagsGetNoChanges
    toEnum 16 = SettingsBindFlagsInvertBoolean
    toEnum k = AnotherSettingsBindFlags k

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

foreign import ccall "g_settings_bind_flags_get_type" c_g_settings_bind_flags_get_type :: 
    IO GType

instance BoxedFlags SettingsBindFlags where
    boxedFlagsType _ = c_g_settings_bind_flags_get_type

instance IsGFlag SettingsBindFlags

-- Flags ResourceLookupFlags
{- |
GResourceLookupFlags determine how resource path lookups are handled.

/Since: 2.32/
-}
data ResourceLookupFlags = 
      ResourceLookupFlagsNone
    {- ^
    No flags set.
    -}
    | AnotherResourceLookupFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ResourceLookupFlags where
    fromEnum ResourceLookupFlagsNone = 0
    fromEnum (AnotherResourceLookupFlags k) = k

    toEnum 0 = ResourceLookupFlagsNone
    toEnum k = AnotherResourceLookupFlags k

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

foreign import ccall "g_resource_lookup_flags_get_type" c_g_resource_lookup_flags_get_type :: 
    IO GType

instance BoxedFlags ResourceLookupFlags where
    boxedFlagsType _ = c_g_resource_lookup_flags_get_type

instance IsGFlag ResourceLookupFlags

-- Flags ResourceFlags
{- |
GResourceFlags give information about a particular file inside a resource
bundle.

/Since: 2.32/
-}
data ResourceFlags = 
      ResourceFlagsNone
    {- ^
    No flags set.
    -}
    | ResourceFlagsCompressed
    {- ^
    The file is compressed.
    -}
    | AnotherResourceFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ResourceFlags where
    fromEnum ResourceFlagsNone = 0
    fromEnum ResourceFlagsCompressed = 1
    fromEnum (AnotherResourceFlags k) = k

    toEnum 0 = ResourceFlagsNone
    toEnum 1 = ResourceFlagsCompressed
    toEnum k = AnotherResourceFlags k

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

foreign import ccall "g_resource_flags_get_type" c_g_resource_flags_get_type :: 
    IO GType

instance BoxedFlags ResourceFlags where
    boxedFlagsType _ = c_g_resource_flags_get_type

instance IsGFlag ResourceFlags

-- Flags ResolverNameLookupFlags
{- |
Flags to modify lookup behavior.

/Since: 2.60/
-}
data ResolverNameLookupFlags = 
      ResolverNameLookupFlagsDefault
    {- ^
    default behavior (same as 'GI.Gio.Objects.Resolver.resolverLookupByName')
    -}
    | ResolverNameLookupFlagsIpv4Only
    {- ^
    only resolve ipv4 addresses
    -}
    | ResolverNameLookupFlagsIpv6Only
    {- ^
    only resolve ipv6 addresses
    -}
    | AnotherResolverNameLookupFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ResolverNameLookupFlags where
    fromEnum ResolverNameLookupFlagsDefault = 0
    fromEnum ResolverNameLookupFlagsIpv4Only = 1
    fromEnum ResolverNameLookupFlagsIpv6Only = 2
    fromEnum (AnotherResolverNameLookupFlags k) = k

    toEnum 0 = ResolverNameLookupFlagsDefault
    toEnum 1 = ResolverNameLookupFlagsIpv4Only
    toEnum 2 = ResolverNameLookupFlagsIpv6Only
    toEnum k = AnotherResolverNameLookupFlags k

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

foreign import ccall "g_resolver_name_lookup_flags_get_type" c_g_resolver_name_lookup_flags_get_type :: 
    IO GType

instance BoxedFlags ResolverNameLookupFlags where
    boxedFlagsType _ = c_g_resolver_name_lookup_flags_get_type

instance IsGFlag ResolverNameLookupFlags

-- Flags OutputStreamSpliceFlags
{- |
GOutputStreamSpliceFlags determine how streams should be spliced.
-}
data OutputStreamSpliceFlags = 
      OutputStreamSpliceFlagsNone
    {- ^
    Do not close either stream.
    -}
    | OutputStreamSpliceFlagsCloseSource
    {- ^
    Close the source stream after
        the splice.
    -}
    | OutputStreamSpliceFlagsCloseTarget
    {- ^
    Close the target stream after
        the splice.
    -}
    | AnotherOutputStreamSpliceFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum OutputStreamSpliceFlags where
    fromEnum OutputStreamSpliceFlagsNone = 0
    fromEnum OutputStreamSpliceFlagsCloseSource = 1
    fromEnum OutputStreamSpliceFlagsCloseTarget = 2
    fromEnum (AnotherOutputStreamSpliceFlags k) = k

    toEnum 0 = OutputStreamSpliceFlagsNone
    toEnum 1 = OutputStreamSpliceFlagsCloseSource
    toEnum 2 = OutputStreamSpliceFlagsCloseTarget
    toEnum k = AnotherOutputStreamSpliceFlags k

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

foreign import ccall "g_output_stream_splice_flags_get_type" c_g_output_stream_splice_flags_get_type :: 
    IO GType

instance BoxedFlags OutputStreamSpliceFlags where
    boxedFlagsType _ = c_g_output_stream_splice_flags_get_type

instance IsGFlag OutputStreamSpliceFlags

-- Flags MountUnmountFlags
{- |
Flags used when an unmounting a mount.
-}
data MountUnmountFlags = 
      MountUnmountFlagsNone
    {- ^
    No flags set.
    -}
    | MountUnmountFlagsForce
    {- ^
    Unmount even if there are outstanding
     file operations on the mount.
    -}
    | AnotherMountUnmountFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum MountUnmountFlags where
    fromEnum MountUnmountFlagsNone = 0
    fromEnum MountUnmountFlagsForce = 1
    fromEnum (AnotherMountUnmountFlags k) = k

    toEnum 0 = MountUnmountFlagsNone
    toEnum 1 = MountUnmountFlagsForce
    toEnum k = AnotherMountUnmountFlags k

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

foreign import ccall "g_mount_unmount_flags_get_type" c_g_mount_unmount_flags_get_type :: 
    IO GType

instance BoxedFlags MountUnmountFlags where
    boxedFlagsType _ = c_g_mount_unmount_flags_get_type

instance IsGFlag MountUnmountFlags

-- Flags MountMountFlags
{- |
Flags used when mounting a mount.
-}
data MountMountFlags = 
      MountMountFlagsNone
    {- ^
    No flags set.
    -}
    | AnotherMountMountFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum MountMountFlags where
    fromEnum MountMountFlagsNone = 0
    fromEnum (AnotherMountMountFlags k) = k

    toEnum 0 = MountMountFlagsNone
    toEnum k = AnotherMountMountFlags k

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

foreign import ccall "g_mount_mount_flags_get_type" c_g_mount_mount_flags_get_type :: 
    IO GType

instance BoxedFlags MountMountFlags where
    boxedFlagsType _ = c_g_mount_mount_flags_get_type

instance IsGFlag MountMountFlags

-- Flags IOStreamSpliceFlags
{- |
GIOStreamSpliceFlags determine how streams should be spliced.

/Since: 2.28/
-}
data IOStreamSpliceFlags = 
      IOStreamSpliceFlagsNone
    {- ^
    Do not close either stream.
    -}
    | IOStreamSpliceFlagsCloseStream1
    {- ^
    Close the first stream after
        the splice.
    -}
    | IOStreamSpliceFlagsCloseStream2
    {- ^
    Close the second stream after
        the splice.
    -}
    | IOStreamSpliceFlagsWaitForBoth
    {- ^
    Wait for both splice operations to finish
        before calling the callback.
    -}
    | AnotherIOStreamSpliceFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum IOStreamSpliceFlags where
    fromEnum IOStreamSpliceFlagsNone = 0
    fromEnum IOStreamSpliceFlagsCloseStream1 = 1
    fromEnum IOStreamSpliceFlagsCloseStream2 = 2
    fromEnum IOStreamSpliceFlagsWaitForBoth = 4
    fromEnum (AnotherIOStreamSpliceFlags k) = k

    toEnum 0 = IOStreamSpliceFlagsNone
    toEnum 1 = IOStreamSpliceFlagsCloseStream1
    toEnum 2 = IOStreamSpliceFlagsCloseStream2
    toEnum 4 = IOStreamSpliceFlagsWaitForBoth
    toEnum k = AnotherIOStreamSpliceFlags k

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

foreign import ccall "g_io_stream_splice_flags_get_type" c_g_io_stream_splice_flags_get_type :: 
    IO GType

instance BoxedFlags IOStreamSpliceFlags where
    boxedFlagsType _ = c_g_io_stream_splice_flags_get_type

instance IsGFlag IOStreamSpliceFlags

-- Flags FileQueryInfoFlags
{- |
Flags used when querying a 'GI.Gio.Objects.FileInfo.FileInfo'.
-}
data FileQueryInfoFlags = 
      FileQueryInfoFlagsNone
    {- ^
    No flags set.
    -}
    | FileQueryInfoFlagsNofollowSymlinks
    {- ^
    Don\'t follow symlinks.
    -}
    | AnotherFileQueryInfoFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum FileQueryInfoFlags where
    fromEnum FileQueryInfoFlagsNone = 0
    fromEnum FileQueryInfoFlagsNofollowSymlinks = 1
    fromEnum (AnotherFileQueryInfoFlags k) = k

    toEnum 0 = FileQueryInfoFlagsNone
    toEnum 1 = FileQueryInfoFlagsNofollowSymlinks
    toEnum k = AnotherFileQueryInfoFlags k

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

foreign import ccall "g_file_query_info_flags_get_type" c_g_file_query_info_flags_get_type :: 
    IO GType

instance BoxedFlags FileQueryInfoFlags where
    boxedFlagsType _ = c_g_file_query_info_flags_get_type

instance IsGFlag FileQueryInfoFlags

-- Flags FileMonitorFlags
{- |
Flags used to set what a 'GI.Gio.Objects.FileMonitor.FileMonitor' will watch for.
-}
data FileMonitorFlags = 
      FileMonitorFlagsNone
    {- ^
    No flags set.
    -}
    | FileMonitorFlagsWatchMounts
    {- ^
    Watch for mount events.
    -}
    | FileMonitorFlagsSendMoved
    {- ^
    Pair DELETED and CREATED events caused
      by file renames (moves) and send a single G_FILE_MONITOR_EVENT_MOVED
      event instead (NB: not supported on all backends; the default
      behaviour -without specifying this flag- is to send single DELETED
      and CREATED events).  Deprecated since 2.46: use
      'GI.Gio.Flags.FileMonitorFlagsWatchMoves' instead.
    -}
    | FileMonitorFlagsWatchHardLinks
    {- ^
    Watch for changes to the file made
      via another hard link. Since 2.36.
    -}
    | FileMonitorFlagsWatchMoves
    {- ^
    Watch for rename operations on a
      monitored directory.  This causes 'GI.Gio.Enums.FileMonitorEventRenamed',
      'GI.Gio.Enums.FileMonitorEventMovedIn' and 'GI.Gio.Enums.FileMonitorEventMovedOut'
      events to be emitted when possible.  Since: 2.46.
    -}
    | AnotherFileMonitorFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum FileMonitorFlags where
    fromEnum FileMonitorFlagsNone = 0
    fromEnum FileMonitorFlagsWatchMounts = 1
    fromEnum FileMonitorFlagsSendMoved = 2
    fromEnum FileMonitorFlagsWatchHardLinks = 4
    fromEnum FileMonitorFlagsWatchMoves = 8
    fromEnum (AnotherFileMonitorFlags k) = k

    toEnum 0 = FileMonitorFlagsNone
    toEnum 1 = FileMonitorFlagsWatchMounts
    toEnum 2 = FileMonitorFlagsSendMoved
    toEnum 4 = FileMonitorFlagsWatchHardLinks
    toEnum 8 = FileMonitorFlagsWatchMoves
    toEnum k = AnotherFileMonitorFlags k

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

foreign import ccall "g_file_monitor_flags_get_type" c_g_file_monitor_flags_get_type :: 
    IO GType

instance BoxedFlags FileMonitorFlags where
    boxedFlagsType _ = c_g_file_monitor_flags_get_type

instance IsGFlag FileMonitorFlags

-- Flags FileMeasureFlags
{- |
Flags that can be used with @/g_file_measure_disk_usage()/@.

/Since: 2.38/
-}
data FileMeasureFlags = 
      FileMeasureFlagsNone
    {- ^
    No flags set.
    -}
    | FileMeasureFlagsReportAnyError
    {- ^
    Report any error encountered
      while traversing the directory tree.  Normally errors are only
      reported for the toplevel file.
    -}
    | FileMeasureFlagsApparentSize
    {- ^
    Tally usage based on apparent file
      sizes.  Normally, the block-size is used, if available, as this is a
      more accurate representation of disk space used.
      Compare with @du --apparent-size@.
    -}
    | FileMeasureFlagsNoXdev
    {- ^
    Do not cross mount point boundaries.
      Compare with @du -x@.
    -}
    | AnotherFileMeasureFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum FileMeasureFlags where
    fromEnum FileMeasureFlagsNone = 0
    fromEnum FileMeasureFlagsReportAnyError = 2
    fromEnum FileMeasureFlagsApparentSize = 4
    fromEnum FileMeasureFlagsNoXdev = 8
    fromEnum (AnotherFileMeasureFlags k) = k

    toEnum 0 = FileMeasureFlagsNone
    toEnum 2 = FileMeasureFlagsReportAnyError
    toEnum 4 = FileMeasureFlagsApparentSize
    toEnum 8 = FileMeasureFlagsNoXdev
    toEnum k = AnotherFileMeasureFlags k

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

foreign import ccall "g_file_measure_flags_get_type" c_g_file_measure_flags_get_type :: 
    IO GType

instance BoxedFlags FileMeasureFlags where
    boxedFlagsType _ = c_g_file_measure_flags_get_type

instance IsGFlag FileMeasureFlags

-- Flags FileCreateFlags
{- |
Flags used when an operation may create a file.
-}
data FileCreateFlags = 
      FileCreateFlagsNone
    {- ^
    No flags set.
    -}
    | FileCreateFlagsPrivate
    {- ^
    Create a file that can only be
       accessed by the current user.
    -}
    | FileCreateFlagsReplaceDestination
    {- ^
    Replace the destination
       as if it didn\'t exist before. Don\'t try to keep any old
       permissions, replace instead of following links. This
       is generally useful if you\'re doing a \"copy over\"
       rather than a \"save new version of\" replace operation.
       You can think of it as \"unlink destination\" before
       writing to it, although the implementation may not
       be exactly like that. Since 2.20
    -}
    | AnotherFileCreateFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum FileCreateFlags where
    fromEnum FileCreateFlagsNone = 0
    fromEnum FileCreateFlagsPrivate = 1
    fromEnum FileCreateFlagsReplaceDestination = 2
    fromEnum (AnotherFileCreateFlags k) = k

    toEnum 0 = FileCreateFlagsNone
    toEnum 1 = FileCreateFlagsPrivate
    toEnum 2 = FileCreateFlagsReplaceDestination
    toEnum k = AnotherFileCreateFlags k

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

foreign import ccall "g_file_create_flags_get_type" c_g_file_create_flags_get_type :: 
    IO GType

instance BoxedFlags FileCreateFlags where
    boxedFlagsType _ = c_g_file_create_flags_get_type

instance IsGFlag FileCreateFlags

-- Flags FileCopyFlags
{- |
Flags used when copying or moving files.
-}
data FileCopyFlags = 
      FileCopyFlagsNone
    {- ^
    No flags set.
    -}
    | FileCopyFlagsOverwrite
    {- ^
    Overwrite any existing files
    -}
    | FileCopyFlagsBackup
    {- ^
    Make a backup of any existing files.
    -}
    | FileCopyFlagsNofollowSymlinks
    {- ^
    Don\'t follow symlinks.
    -}
    | FileCopyFlagsAllMetadata
    {- ^
    Copy all file metadata instead of just default set used for copy (see 'GI.Gio.Objects.FileInfo.FileInfo').
    -}
    | FileCopyFlagsNoFallbackForMove
    {- ^
    Don\'t use copy and delete fallback if native move not supported.
    -}
    | FileCopyFlagsTargetDefaultPerms
    {- ^
    Leaves target file with default perms, instead of setting the source file perms.
    -}
    | AnotherFileCopyFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum FileCopyFlags where
    fromEnum FileCopyFlagsNone = 0
    fromEnum FileCopyFlagsOverwrite = 1
    fromEnum FileCopyFlagsBackup = 2
    fromEnum FileCopyFlagsNofollowSymlinks = 4
    fromEnum FileCopyFlagsAllMetadata = 8
    fromEnum FileCopyFlagsNoFallbackForMove = 16
    fromEnum FileCopyFlagsTargetDefaultPerms = 32
    fromEnum (AnotherFileCopyFlags k) = k

    toEnum 0 = FileCopyFlagsNone
    toEnum 1 = FileCopyFlagsOverwrite
    toEnum 2 = FileCopyFlagsBackup
    toEnum 4 = FileCopyFlagsNofollowSymlinks
    toEnum 8 = FileCopyFlagsAllMetadata
    toEnum 16 = FileCopyFlagsNoFallbackForMove
    toEnum 32 = FileCopyFlagsTargetDefaultPerms
    toEnum k = AnotherFileCopyFlags k

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

foreign import ccall "g_file_copy_flags_get_type" c_g_file_copy_flags_get_type :: 
    IO GType

instance BoxedFlags FileCopyFlags where
    boxedFlagsType _ = c_g_file_copy_flags_get_type

instance IsGFlag FileCopyFlags

-- Flags FileAttributeInfoFlags
{- |
Flags specifying the behaviour of an attribute.
-}
data FileAttributeInfoFlags = 
      FileAttributeInfoFlagsNone
    {- ^
    no flags set.
    -}
    | FileAttributeInfoFlagsCopyWithFile
    {- ^
    copy the attribute values when the file is copied.
    -}
    | FileAttributeInfoFlagsCopyWhenMoved
    {- ^
    copy the attribute values when the file is moved.
    -}
    | AnotherFileAttributeInfoFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum FileAttributeInfoFlags where
    fromEnum FileAttributeInfoFlagsNone = 0
    fromEnum FileAttributeInfoFlagsCopyWithFile = 1
    fromEnum FileAttributeInfoFlagsCopyWhenMoved = 2
    fromEnum (AnotherFileAttributeInfoFlags k) = k

    toEnum 0 = FileAttributeInfoFlagsNone
    toEnum 1 = FileAttributeInfoFlagsCopyWithFile
    toEnum 2 = FileAttributeInfoFlagsCopyWhenMoved
    toEnum k = AnotherFileAttributeInfoFlags k

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

foreign import ccall "g_file_attribute_info_flags_get_type" c_g_file_attribute_info_flags_get_type :: 
    IO GType

instance BoxedFlags FileAttributeInfoFlags where
    boxedFlagsType _ = c_g_file_attribute_info_flags_get_type

instance IsGFlag FileAttributeInfoFlags

-- Flags DriveStartFlags
{- |
Flags used when starting a drive.

/Since: 2.22/
-}
data DriveStartFlags = 
      DriveStartFlagsNone
    {- ^
    No flags set.
    -}
    | AnotherDriveStartFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DriveStartFlags where
    fromEnum DriveStartFlagsNone = 0
    fromEnum (AnotherDriveStartFlags k) = k

    toEnum 0 = DriveStartFlagsNone
    toEnum k = AnotherDriveStartFlags k

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

foreign import ccall "g_drive_start_flags_get_type" c_g_drive_start_flags_get_type :: 
    IO GType

instance BoxedFlags DriveStartFlags where
    boxedFlagsType _ = c_g_drive_start_flags_get_type

instance IsGFlag DriveStartFlags

-- Flags DBusSubtreeFlags
{- |
Flags passed to 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.

/Since: 2.26/
-}
data DBusSubtreeFlags = 
      DBusSubtreeFlagsNone
    {- ^
    No flags set.
    -}
    | DBusSubtreeFlagsDispatchToUnenumeratedNodes
    {- ^
    Method calls to objects not in the enumerated range
                                                          will still be dispatched. This is useful if you want
                                                          to dynamically spawn objects in the subtree.
    -}
    | AnotherDBusSubtreeFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DBusSubtreeFlags where
    fromEnum DBusSubtreeFlagsNone = 0
    fromEnum DBusSubtreeFlagsDispatchToUnenumeratedNodes = 1
    fromEnum (AnotherDBusSubtreeFlags k) = k

    toEnum 0 = DBusSubtreeFlagsNone
    toEnum 1 = DBusSubtreeFlagsDispatchToUnenumeratedNodes
    toEnum k = AnotherDBusSubtreeFlags k

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

foreign import ccall "g_dbus_subtree_flags_get_type" c_g_dbus_subtree_flags_get_type :: 
    IO GType

instance BoxedFlags DBusSubtreeFlags where
    boxedFlagsType _ = c_g_dbus_subtree_flags_get_type

instance IsGFlag DBusSubtreeFlags

-- Flags DBusSignalFlags
{- |
Flags used when subscribing to signals via 'GI.Gio.Objects.DBusConnection.dBusConnectionSignalSubscribe'.

/Since: 2.26/
-}
data DBusSignalFlags = 
      DBusSignalFlagsNone
    {- ^
    No flags set.
    -}
    | DBusSignalFlagsNoMatchRule
    {- ^
    Don\'t actually send the AddMatch
    D-Bus call for this signal subscription.  This gives you more control
    over which match rules you add (but you must add them manually).
    -}
    | DBusSignalFlagsMatchArg0Namespace
    {- ^
    Match first arguments that
    contain a bus or interface name with the given namespace.
    -}
    | DBusSignalFlagsMatchArg0Path
    {- ^
    Match first arguments that
    contain an object path that is either equivalent to the given path,
    or one of the paths is a subpath of the other.
    -}
    | AnotherDBusSignalFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DBusSignalFlags where
    fromEnum DBusSignalFlagsNone = 0
    fromEnum DBusSignalFlagsNoMatchRule = 1
    fromEnum DBusSignalFlagsMatchArg0Namespace = 2
    fromEnum DBusSignalFlagsMatchArg0Path = 4
    fromEnum (AnotherDBusSignalFlags k) = k

    toEnum 0 = DBusSignalFlagsNone
    toEnum 1 = DBusSignalFlagsNoMatchRule
    toEnum 2 = DBusSignalFlagsMatchArg0Namespace
    toEnum 4 = DBusSignalFlagsMatchArg0Path
    toEnum k = AnotherDBusSignalFlags k

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

foreign import ccall "g_dbus_signal_flags_get_type" c_g_dbus_signal_flags_get_type :: 
    IO GType

instance BoxedFlags DBusSignalFlags where
    boxedFlagsType _ = c_g_dbus_signal_flags_get_type

instance IsGFlag DBusSignalFlags

-- Flags DBusServerFlags
{- |
Flags used when creating a 'GI.Gio.Objects.DBusServer.DBusServer'.

/Since: 2.26/
-}
data DBusServerFlags = 
      DBusServerFlagsNone
    {- ^
    No flags set.
    -}
    | DBusServerFlagsRunInThread
    {- ^
    All 'GI.Gio.Objects.DBusServer.DBusServer'::@/new-connection/@
    signals will run in separated dedicated threads (see signal for
    details).
    -}
    | DBusServerFlagsAuthenticationAllowAnonymous
    {- ^
    Allow the anonymous
    authentication method.
    -}
    | AnotherDBusServerFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DBusServerFlags where
    fromEnum DBusServerFlagsNone = 0
    fromEnum DBusServerFlagsRunInThread = 1
    fromEnum DBusServerFlagsAuthenticationAllowAnonymous = 2
    fromEnum (AnotherDBusServerFlags k) = k

    toEnum 0 = DBusServerFlagsNone
    toEnum 1 = DBusServerFlagsRunInThread
    toEnum 2 = DBusServerFlagsAuthenticationAllowAnonymous
    toEnum k = AnotherDBusServerFlags k

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

foreign import ccall "g_dbus_server_flags_get_type" c_g_dbus_server_flags_get_type :: 
    IO GType

instance BoxedFlags DBusServerFlags where
    boxedFlagsType _ = c_g_dbus_server_flags_get_type

instance IsGFlag DBusServerFlags

-- Flags DBusSendMessageFlags
{- |
Flags used when sending @/GDBusMessages/@ on a 'GI.Gio.Objects.DBusConnection.DBusConnection'.

/Since: 2.26/
-}
data DBusSendMessageFlags = 
      DBusSendMessageFlagsNone
    {- ^
    No flags set.
    -}
    | DBusSendMessageFlagsPreserveSerial
    {- ^
    Do not automatically
    assign a serial number from the 'GI.Gio.Objects.DBusConnection.DBusConnection' object when
    sending a message.
    -}
    | AnotherDBusSendMessageFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DBusSendMessageFlags where
    fromEnum DBusSendMessageFlagsNone = 0
    fromEnum DBusSendMessageFlagsPreserveSerial = 1
    fromEnum (AnotherDBusSendMessageFlags k) = k

    toEnum 0 = DBusSendMessageFlagsNone
    toEnum 1 = DBusSendMessageFlagsPreserveSerial
    toEnum k = AnotherDBusSendMessageFlags k

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

foreign import ccall "g_dbus_send_message_flags_get_type" c_g_dbus_send_message_flags_get_type :: 
    IO GType

instance BoxedFlags DBusSendMessageFlags where
    boxedFlagsType _ = c_g_dbus_send_message_flags_get_type

instance IsGFlag DBusSendMessageFlags

-- Flags DBusProxyFlags
{- |
Flags used when constructing an instance of a 'GI.Gio.Objects.DBusProxy.DBusProxy' derived class.

/Since: 2.26/
-}
data DBusProxyFlags = 
      DBusProxyFlagsNone
    {- ^
    No flags set.
    -}
    | DBusProxyFlagsDoNotLoadProperties
    {- ^
    Don\'t load properties.
    -}
    | DBusProxyFlagsDoNotConnectSignals
    {- ^
    Don\'t connect to signals on the remote object.
    -}
    | DBusProxyFlagsDoNotAutoStart
    {- ^
    If the proxy is for a well-known name,
    do not ask the bus to launch an owner during proxy initialization or a method call.
    This flag is only meaningful in proxies for well-known names.
    -}
    | DBusProxyFlagsGetInvalidatedProperties
    {- ^
    If set, the property value for any __invalidated property__ will be (asynchronously) retrieved upon receiving the <http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties `PropertiesChanged`> D-Bus signal and the property will not cause emission of the 'GI.Gio.Objects.DBusProxy.DBusProxy'::@/g-properties-changed/@ signal. When the value is received the 'GI.Gio.Objects.DBusProxy.DBusProxy'::@/g-properties-changed/@ signal is emitted for the property along with the retrieved value. Since 2.32.
    -}
    | DBusProxyFlagsDoNotAutoStartAtConstruction
    {- ^
    If the proxy is for a well-known name,
    do not ask the bus to launch an owner during proxy initialization, but allow it to be
    autostarted by a method call. This flag is only meaningful in proxies for well-known names,
    and only if 'GI.Gio.Flags.DBusProxyFlagsDoNotAutoStart' is not also specified.
    -}
    | AnotherDBusProxyFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DBusProxyFlags where
    fromEnum DBusProxyFlagsNone = 0
    fromEnum DBusProxyFlagsDoNotLoadProperties = 1
    fromEnum DBusProxyFlagsDoNotConnectSignals = 2
    fromEnum DBusProxyFlagsDoNotAutoStart = 4
    fromEnum DBusProxyFlagsGetInvalidatedProperties = 8
    fromEnum DBusProxyFlagsDoNotAutoStartAtConstruction = 16
    fromEnum (AnotherDBusProxyFlags k) = k

    toEnum 0 = DBusProxyFlagsNone
    toEnum 1 = DBusProxyFlagsDoNotLoadProperties
    toEnum 2 = DBusProxyFlagsDoNotConnectSignals
    toEnum 4 = DBusProxyFlagsDoNotAutoStart
    toEnum 8 = DBusProxyFlagsGetInvalidatedProperties
    toEnum 16 = DBusProxyFlagsDoNotAutoStartAtConstruction
    toEnum k = AnotherDBusProxyFlags k

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

foreign import ccall "g_dbus_proxy_flags_get_type" c_g_dbus_proxy_flags_get_type :: 
    IO GType

instance BoxedFlags DBusProxyFlags where
    boxedFlagsType _ = c_g_dbus_proxy_flags_get_type

instance IsGFlag DBusProxyFlags

-- Flags DBusPropertyInfoFlags
{- |
Flags describing the access control of a D-Bus property.

/Since: 2.26/
-}
data DBusPropertyInfoFlags = 
      DBusPropertyInfoFlagsNone
    {- ^
    No flags set.
    -}
    | DBusPropertyInfoFlagsReadable
    {- ^
    Property is readable.
    -}
    | DBusPropertyInfoFlagsWritable
    {- ^
    Property is writable.
    -}
    | AnotherDBusPropertyInfoFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DBusPropertyInfoFlags where
    fromEnum DBusPropertyInfoFlagsNone = 0
    fromEnum DBusPropertyInfoFlagsReadable = 1
    fromEnum DBusPropertyInfoFlagsWritable = 2
    fromEnum (AnotherDBusPropertyInfoFlags k) = k

    toEnum 0 = DBusPropertyInfoFlagsNone
    toEnum 1 = DBusPropertyInfoFlagsReadable
    toEnum 2 = DBusPropertyInfoFlagsWritable
    toEnum k = AnotherDBusPropertyInfoFlags k

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

foreign import ccall "g_dbus_property_info_flags_get_type" c_g_dbus_property_info_flags_get_type :: 
    IO GType

instance BoxedFlags DBusPropertyInfoFlags where
    boxedFlagsType _ = c_g_dbus_property_info_flags_get_type

instance IsGFlag DBusPropertyInfoFlags

-- Flags DBusObjectManagerClientFlags
{- |
Flags used when constructing a 'GI.Gio.Objects.DBusObjectManagerClient.DBusObjectManagerClient'.

/Since: 2.30/
-}
data DBusObjectManagerClientFlags = 
      DBusObjectManagerClientFlagsNone
    {- ^
    No flags set.
    -}
    | DBusObjectManagerClientFlagsDoNotAutoStart
    {- ^
    If not set and the
      manager is for a well-known name, then request the bus to launch
      an owner for the name if no-one owns the name. This flag can only
      be used in managers for well-known names.
    -}
    | AnotherDBusObjectManagerClientFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DBusObjectManagerClientFlags where
    fromEnum DBusObjectManagerClientFlagsNone = 0
    fromEnum DBusObjectManagerClientFlagsDoNotAutoStart = 1
    fromEnum (AnotherDBusObjectManagerClientFlags k) = k

    toEnum 0 = DBusObjectManagerClientFlagsNone
    toEnum 1 = DBusObjectManagerClientFlagsDoNotAutoStart
    toEnum k = AnotherDBusObjectManagerClientFlags k

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

foreign import ccall "g_dbus_object_manager_client_flags_get_type" c_g_dbus_object_manager_client_flags_get_type :: 
    IO GType

instance BoxedFlags DBusObjectManagerClientFlags where
    boxedFlagsType _ = c_g_dbus_object_manager_client_flags_get_type

instance IsGFlag DBusObjectManagerClientFlags

-- Flags DBusMessageFlags
{- |
Message flags used in 'GI.Gio.Objects.DBusMessage.DBusMessage'.

/Since: 2.26/
-}
data DBusMessageFlags = 
      DBusMessageFlagsNone
    {- ^
    No flags set.
    -}
    | DBusMessageFlagsNoReplyExpected
    {- ^
    A reply is not expected.
    -}
    | DBusMessageFlagsNoAutoStart
    {- ^
    The bus must not launch an
    owner for the destination name in response to this message.
    -}
    | DBusMessageFlagsAllowInteractiveAuthorization
    {- ^
    If set on a method
    call, this flag means that the caller is prepared to wait for interactive
    authorization. Since 2.46.
    -}
    | AnotherDBusMessageFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DBusMessageFlags where
    fromEnum DBusMessageFlagsNone = 0
    fromEnum DBusMessageFlagsNoReplyExpected = 1
    fromEnum DBusMessageFlagsNoAutoStart = 2
    fromEnum DBusMessageFlagsAllowInteractiveAuthorization = 4
    fromEnum (AnotherDBusMessageFlags k) = k

    toEnum 0 = DBusMessageFlagsNone
    toEnum 1 = DBusMessageFlagsNoReplyExpected
    toEnum 2 = DBusMessageFlagsNoAutoStart
    toEnum 4 = DBusMessageFlagsAllowInteractiveAuthorization
    toEnum k = AnotherDBusMessageFlags k

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

foreign import ccall "g_dbus_message_flags_get_type" c_g_dbus_message_flags_get_type :: 
    IO GType

instance BoxedFlags DBusMessageFlags where
    boxedFlagsType _ = c_g_dbus_message_flags_get_type

instance IsGFlag DBusMessageFlags

-- Flags DBusInterfaceSkeletonFlags
{- |
Flags describing the behavior of a 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton' instance.

/Since: 2.30/
-}
data DBusInterfaceSkeletonFlags = 
      DBusInterfaceSkeletonFlagsNone
    {- ^
    No flags set.
    -}
    | DBusInterfaceSkeletonFlagsHandleMethodInvocationsInThread
    {- ^
    Each method invocation is handled in
      a thread dedicated to the invocation. This means that the method implementation can use blocking IO
      without blocking any other part of the process. It also means that the method implementation must
      use locking to access data structures used by other threads.
    -}
    | AnotherDBusInterfaceSkeletonFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DBusInterfaceSkeletonFlags where
    fromEnum DBusInterfaceSkeletonFlagsNone = 0
    fromEnum DBusInterfaceSkeletonFlagsHandleMethodInvocationsInThread = 1
    fromEnum (AnotherDBusInterfaceSkeletonFlags k) = k

    toEnum 0 = DBusInterfaceSkeletonFlagsNone
    toEnum 1 = DBusInterfaceSkeletonFlagsHandleMethodInvocationsInThread
    toEnum k = AnotherDBusInterfaceSkeletonFlags k

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

foreign import ccall "g_dbus_interface_skeleton_flags_get_type" c_g_dbus_interface_skeleton_flags_get_type :: 
    IO GType

instance BoxedFlags DBusInterfaceSkeletonFlags where
    boxedFlagsType _ = c_g_dbus_interface_skeleton_flags_get_type

instance IsGFlag DBusInterfaceSkeletonFlags

-- Flags DBusConnectionFlags
{- |
Flags used when creating a new 'GI.Gio.Objects.DBusConnection.DBusConnection'.

/Since: 2.26/
-}
data DBusConnectionFlags = 
      DBusConnectionFlagsNone
    {- ^
    No flags set.
    -}
    | DBusConnectionFlagsAuthenticationClient
    {- ^
    Perform authentication against server.
    -}
    | DBusConnectionFlagsAuthenticationServer
    {- ^
    Perform authentication against client.
    -}
    | DBusConnectionFlagsAuthenticationAllowAnonymous
    {- ^
    When
    authenticating as a server, allow the anonymous authentication
    method.
    -}
    | DBusConnectionFlagsMessageBusConnection
    {- ^
    Pass this flag if connecting to a peer that is a
    message bus. This means that the @/Hello()/@ method will be invoked as part of the connection setup.
    -}
    | DBusConnectionFlagsDelayMessageProcessing
    {- ^
    If set, processing of D-Bus messages is
    delayed until 'GI.Gio.Objects.DBusConnection.dBusConnectionStartMessageProcessing' is called.
    -}
    | AnotherDBusConnectionFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DBusConnectionFlags where
    fromEnum DBusConnectionFlagsNone = 0
    fromEnum DBusConnectionFlagsAuthenticationClient = 1
    fromEnum DBusConnectionFlagsAuthenticationServer = 2
    fromEnum DBusConnectionFlagsAuthenticationAllowAnonymous = 4
    fromEnum DBusConnectionFlagsMessageBusConnection = 8
    fromEnum DBusConnectionFlagsDelayMessageProcessing = 16
    fromEnum (AnotherDBusConnectionFlags k) = k

    toEnum 0 = DBusConnectionFlagsNone
    toEnum 1 = DBusConnectionFlagsAuthenticationClient
    toEnum 2 = DBusConnectionFlagsAuthenticationServer
    toEnum 4 = DBusConnectionFlagsAuthenticationAllowAnonymous
    toEnum 8 = DBusConnectionFlagsMessageBusConnection
    toEnum 16 = DBusConnectionFlagsDelayMessageProcessing
    toEnum k = AnotherDBusConnectionFlags k

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

foreign import ccall "g_dbus_connection_flags_get_type" c_g_dbus_connection_flags_get_type :: 
    IO GType

instance BoxedFlags DBusConnectionFlags where
    boxedFlagsType _ = c_g_dbus_connection_flags_get_type

instance IsGFlag DBusConnectionFlags

-- Flags DBusCapabilityFlags
{- |
Capabilities negotiated with the remote peer.

/Since: 2.26/
-}
data DBusCapabilityFlags = 
      DBusCapabilityFlagsNone
    {- ^
    No flags set.
    -}
    | DBusCapabilityFlagsUnixFdPassing
    {- ^
    The connection
    supports exchanging UNIX file descriptors with the remote peer.
    -}
    | AnotherDBusCapabilityFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DBusCapabilityFlags where
    fromEnum DBusCapabilityFlagsNone = 0
    fromEnum DBusCapabilityFlagsUnixFdPassing = 1
    fromEnum (AnotherDBusCapabilityFlags k) = k

    toEnum 0 = DBusCapabilityFlagsNone
    toEnum 1 = DBusCapabilityFlagsUnixFdPassing
    toEnum k = AnotherDBusCapabilityFlags k

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

foreign import ccall "g_dbus_capability_flags_get_type" c_g_dbus_capability_flags_get_type :: 
    IO GType

instance BoxedFlags DBusCapabilityFlags where
    boxedFlagsType _ = c_g_dbus_capability_flags_get_type

instance IsGFlag DBusCapabilityFlags

-- Flags DBusCallFlags
{- |
Flags used in 'GI.Gio.Objects.DBusConnection.dBusConnectionCall' and similar APIs.

/Since: 2.26/
-}
data DBusCallFlags = 
      DBusCallFlagsNone
    {- ^
    No flags set.
    -}
    | DBusCallFlagsNoAutoStart
    {- ^
    The bus must not launch
    an owner for the destination name in response to this method
    invocation.
    -}
    | DBusCallFlagsAllowInteractiveAuthorization
    {- ^
    the caller is prepared to
    wait for interactive authorization. Since 2.46.
    -}
    | AnotherDBusCallFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DBusCallFlags where
    fromEnum DBusCallFlagsNone = 0
    fromEnum DBusCallFlagsNoAutoStart = 1
    fromEnum DBusCallFlagsAllowInteractiveAuthorization = 2
    fromEnum (AnotherDBusCallFlags k) = k

    toEnum 0 = DBusCallFlagsNone
    toEnum 1 = DBusCallFlagsNoAutoStart
    toEnum 2 = DBusCallFlagsAllowInteractiveAuthorization
    toEnum k = AnotherDBusCallFlags k

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

foreign import ccall "g_dbus_call_flags_get_type" c_g_dbus_call_flags_get_type :: 
    IO GType

instance BoxedFlags DBusCallFlags where
    boxedFlagsType _ = c_g_dbus_call_flags_get_type

instance IsGFlag DBusCallFlags

-- Flags ConverterFlags
{- |
Flags used when calling a 'GI.Gio.Interfaces.Converter.converterConvert'.

/Since: 2.24/
-}
data ConverterFlags = 
      ConverterFlagsNone
    {- ^
    No flags.
    -}
    | ConverterFlagsInputAtEnd
    {- ^
    At end of input data
    -}
    | ConverterFlagsFlush
    {- ^
    Flush data
    -}
    | AnotherConverterFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ConverterFlags where
    fromEnum ConverterFlagsNone = 0
    fromEnum ConverterFlagsInputAtEnd = 1
    fromEnum ConverterFlagsFlush = 2
    fromEnum (AnotherConverterFlags k) = k

    toEnum 0 = ConverterFlagsNone
    toEnum 1 = ConverterFlagsInputAtEnd
    toEnum 2 = ConverterFlagsFlush
    toEnum k = AnotherConverterFlags k

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

foreign import ccall "g_converter_flags_get_type" c_g_converter_flags_get_type :: 
    IO GType

instance BoxedFlags ConverterFlags where
    boxedFlagsType _ = c_g_converter_flags_get_type

instance IsGFlag ConverterFlags

-- Flags BusNameWatcherFlags
{- |
Flags used in @/g_bus_watch_name()/@.

/Since: 2.26/
-}
data BusNameWatcherFlags = 
      BusNameWatcherFlagsNone
    {- ^
    No flags set.
    -}
    | BusNameWatcherFlagsAutoStart
    {- ^
    If no-one owns the name when
    beginning to watch the name, ask the bus to launch an owner for the
    name.
    -}
    | AnotherBusNameWatcherFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum BusNameWatcherFlags where
    fromEnum BusNameWatcherFlagsNone = 0
    fromEnum BusNameWatcherFlagsAutoStart = 1
    fromEnum (AnotherBusNameWatcherFlags k) = k

    toEnum 0 = BusNameWatcherFlagsNone
    toEnum 1 = BusNameWatcherFlagsAutoStart
    toEnum k = AnotherBusNameWatcherFlags k

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

foreign import ccall "g_bus_name_watcher_flags_get_type" c_g_bus_name_watcher_flags_get_type :: 
    IO GType

instance BoxedFlags BusNameWatcherFlags where
    boxedFlagsType _ = c_g_bus_name_watcher_flags_get_type

instance IsGFlag BusNameWatcherFlags

-- Flags BusNameOwnerFlags
{- |
Flags used in @/g_bus_own_name()/@.

/Since: 2.26/
-}
data BusNameOwnerFlags = 
      BusNameOwnerFlagsNone
    {- ^
    No flags set.
    -}
    | BusNameOwnerFlagsAllowReplacement
    {- ^
    Allow another message bus connection to claim the name.
    -}
    | BusNameOwnerFlagsReplace
    {- ^
    If another message bus connection owns the name and have
    specified @/G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT/@, then take the name from the other connection.
    -}
    | BusNameOwnerFlagsDoNotQueue
    {- ^
    If another message bus connection owns the name, immediately
    return an error from @/g_bus_own_name()/@ rather than entering the waiting queue for that name. (Since 2.54)
    -}
    | AnotherBusNameOwnerFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum BusNameOwnerFlags where
    fromEnum BusNameOwnerFlagsNone = 0
    fromEnum BusNameOwnerFlagsAllowReplacement = 1
    fromEnum BusNameOwnerFlagsReplace = 2
    fromEnum BusNameOwnerFlagsDoNotQueue = 4
    fromEnum (AnotherBusNameOwnerFlags k) = k

    toEnum 0 = BusNameOwnerFlagsNone
    toEnum 1 = BusNameOwnerFlagsAllowReplacement
    toEnum 2 = BusNameOwnerFlagsReplace
    toEnum 4 = BusNameOwnerFlagsDoNotQueue
    toEnum k = AnotherBusNameOwnerFlags k

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

foreign import ccall "g_bus_name_owner_flags_get_type" c_g_bus_name_owner_flags_get_type :: 
    IO GType

instance BoxedFlags BusNameOwnerFlags where
    boxedFlagsType _ = c_g_bus_name_owner_flags_get_type

instance IsGFlag BusNameOwnerFlags

-- Flags AskPasswordFlags
{- |
'GI.Gio.Flags.AskPasswordFlags' are used to request specific information from the
user, or to notify the user of their choices in an authentication
situation.
-}
data AskPasswordFlags = 
      AskPasswordFlagsNeedPassword
    {- ^
    operation requires a password.
    -}
    | AskPasswordFlagsNeedUsername
    {- ^
    operation requires a username.
    -}
    | AskPasswordFlagsNeedDomain
    {- ^
    operation requires a domain.
    -}
    | AskPasswordFlagsSavingSupported
    {- ^
    operation supports saving settings.
    -}
    | AskPasswordFlagsAnonymousSupported
    {- ^
    operation supports anonymous users.
    -}
    | AskPasswordFlagsTcrypt
    {- ^
    operation takes TCRYPT parameters (Since: 2.58)
    -}
    | AnotherAskPasswordFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AskPasswordFlags where
    fromEnum AskPasswordFlagsNeedPassword = 1
    fromEnum AskPasswordFlagsNeedUsername = 2
    fromEnum AskPasswordFlagsNeedDomain = 4
    fromEnum AskPasswordFlagsSavingSupported = 8
    fromEnum AskPasswordFlagsAnonymousSupported = 16
    fromEnum AskPasswordFlagsTcrypt = 32
    fromEnum (AnotherAskPasswordFlags k) = k

    toEnum 1 = AskPasswordFlagsNeedPassword
    toEnum 2 = AskPasswordFlagsNeedUsername
    toEnum 4 = AskPasswordFlagsNeedDomain
    toEnum 8 = AskPasswordFlagsSavingSupported
    toEnum 16 = AskPasswordFlagsAnonymousSupported
    toEnum 32 = AskPasswordFlagsTcrypt
    toEnum k = AnotherAskPasswordFlags k

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

foreign import ccall "g_ask_password_flags_get_type" c_g_ask_password_flags_get_type :: 
    IO GType

instance BoxedFlags AskPasswordFlags where
    boxedFlagsType _ = c_g_ask_password_flags_get_type

instance IsGFlag AskPasswordFlags

-- Flags ApplicationFlags
{- |
Flags used to define the behaviour of a 'GI.Gio.Objects.Application.Application'.

/Since: 2.28/
-}
data ApplicationFlags = 
      ApplicationFlagsFlagsNone
    {- ^
    Default
    -}
    | ApplicationFlagsIsService
    {- ^
    Run as a service. In this mode, registration
         fails if the service is already running, and the application
         will initially wait up to 10 seconds for an initial activation
         message to arrive.
    -}
    | ApplicationFlagsIsLauncher
    {- ^
    Don\'t try to become the primary instance.
    -}
    | ApplicationFlagsHandlesOpen
    {- ^
    This application handles opening files (in
        the primary instance). Note that this flag only affects the default
        implementation of @/local_command_line()/@, and has no effect if
        'GI.Gio.Flags.ApplicationFlagsHandlesCommandLine' is given.
        See 'GI.Gio.Objects.Application.applicationRun' for details.
    -}
    | ApplicationFlagsHandlesCommandLine
    {- ^
    This application handles command line
        arguments (in the primary instance). Note that this flag only affect
        the default implementation of @/local_command_line()/@.
        See 'GI.Gio.Objects.Application.applicationRun' for details.
    -}
    | ApplicationFlagsSendEnvironment
    {- ^
    Send the environment of the
        launching process to the primary instance. Set this flag if your
        application is expected to behave differently depending on certain
        environment variables. For instance, an editor might be expected
        to use the @GIT_COMMITTER_NAME@ environment variable
        when editing a git commit message. The environment is available
        to the 'GI.Gio.Objects.Application.Application'::@/command-line/@ signal handler, via
        'GI.Gio.Objects.ApplicationCommandLine.applicationCommandLineGetenv'.
    -}
    | ApplicationFlagsNonUnique
    {- ^
    Make no attempts to do any of the typical
        single-instance application negotiation, even if the application
        ID is given.  The application neither attempts to become the
        owner of the application ID nor does it check if an existing
        owner already exists.  Everything occurs in the local process.
        Since: 2.30.
    -}
    | ApplicationFlagsCanOverrideAppId
    {- ^
    Allow users to override the
        application ID from the command line with @--gapplication-app-id@.
        Since: 2.48
    -}
    | ApplicationFlagsAllowReplacement
    {- ^
    Allow another instance to take over
        the bus name. Since: 2.60
    -}
    | ApplicationFlagsReplace
    {- ^
    Take over from another instance. This flag is
        usually set by passing @--gapplication-replace@ on the commandline.
        Since: 2.60
    -}
    | AnotherApplicationFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ApplicationFlags where
    fromEnum ApplicationFlagsFlagsNone = 0
    fromEnum ApplicationFlagsIsService = 1
    fromEnum ApplicationFlagsIsLauncher = 2
    fromEnum ApplicationFlagsHandlesOpen = 4
    fromEnum ApplicationFlagsHandlesCommandLine = 8
    fromEnum ApplicationFlagsSendEnvironment = 16
    fromEnum ApplicationFlagsNonUnique = 32
    fromEnum ApplicationFlagsCanOverrideAppId = 64
    fromEnum ApplicationFlagsAllowReplacement = 128
    fromEnum ApplicationFlagsReplace = 256
    fromEnum (AnotherApplicationFlags k) = k

    toEnum 0 = ApplicationFlagsFlagsNone
    toEnum 1 = ApplicationFlagsIsService
    toEnum 2 = ApplicationFlagsIsLauncher
    toEnum 4 = ApplicationFlagsHandlesOpen
    toEnum 8 = ApplicationFlagsHandlesCommandLine
    toEnum 16 = ApplicationFlagsSendEnvironment
    toEnum 32 = ApplicationFlagsNonUnique
    toEnum 64 = ApplicationFlagsCanOverrideAppId
    toEnum 128 = ApplicationFlagsAllowReplacement
    toEnum 256 = ApplicationFlagsReplace
    toEnum k = AnotherApplicationFlags k

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

foreign import ccall "g_application_flags_get_type" c_g_application_flags_get_type :: 
    IO GType

instance BoxedFlags ApplicationFlags where
    boxedFlagsType _ = c_g_application_flags_get_type

instance IsGFlag ApplicationFlags

-- Flags AppInfoCreateFlags
{- |
Flags used when creating a 'GI.Gio.Interfaces.AppInfo.AppInfo'.
-}
data AppInfoCreateFlags = 
      AppInfoCreateFlagsNone
    {- ^
    No flags.
    -}
    | AppInfoCreateFlagsNeedsTerminal
    {- ^
    Application opens in a terminal window.
    -}
    | AppInfoCreateFlagsSupportsUris
    {- ^
    Application supports URI arguments.
    -}
    | AppInfoCreateFlagsSupportsStartupNotification
    {- ^
    Application supports startup notification. Since 2.26
    -}
    | AnotherAppInfoCreateFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AppInfoCreateFlags where
    fromEnum AppInfoCreateFlagsNone = 0
    fromEnum AppInfoCreateFlagsNeedsTerminal = 1
    fromEnum AppInfoCreateFlagsSupportsUris = 2
    fromEnum AppInfoCreateFlagsSupportsStartupNotification = 4
    fromEnum (AnotherAppInfoCreateFlags k) = k

    toEnum 0 = AppInfoCreateFlagsNone
    toEnum 1 = AppInfoCreateFlagsNeedsTerminal
    toEnum 2 = AppInfoCreateFlagsSupportsUris
    toEnum 4 = AppInfoCreateFlagsSupportsStartupNotification
    toEnum k = AnotherAppInfoCreateFlags k

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

foreign import ccall "g_app_info_create_flags_get_type" c_g_app_info_create_flags_get_type :: 
    IO GType

instance BoxedFlags AppInfoCreateFlags where
    boxedFlagsType _ = c_g_app_info_create_flags_get_type

instance IsGFlag AppInfoCreateFlags