-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

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

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.BasicTypes as B.Types
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
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 (Int -> TlsPasswordFlags -> ShowS
[TlsPasswordFlags] -> ShowS
TlsPasswordFlags -> String
(Int -> TlsPasswordFlags -> ShowS)
-> (TlsPasswordFlags -> String)
-> ([TlsPasswordFlags] -> ShowS)
-> Show TlsPasswordFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TlsPasswordFlags] -> ShowS
$cshowList :: [TlsPasswordFlags] -> ShowS
show :: TlsPasswordFlags -> String
$cshow :: TlsPasswordFlags -> String
showsPrec :: Int -> TlsPasswordFlags -> ShowS
$cshowsPrec :: Int -> TlsPasswordFlags -> ShowS
Show, TlsPasswordFlags -> TlsPasswordFlags -> Bool
(TlsPasswordFlags -> TlsPasswordFlags -> Bool)
-> (TlsPasswordFlags -> TlsPasswordFlags -> Bool)
-> Eq TlsPasswordFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TlsPasswordFlags -> TlsPasswordFlags -> Bool
$c/= :: TlsPasswordFlags -> TlsPasswordFlags -> Bool
== :: TlsPasswordFlags -> TlsPasswordFlags -> Bool
$c== :: TlsPasswordFlags -> TlsPasswordFlags -> Bool
Eq)

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

    toEnum :: Int -> TlsPasswordFlags
toEnum Int
0 = TlsPasswordFlags
TlsPasswordFlagsNone
    toEnum Int
2 = TlsPasswordFlags
TlsPasswordFlagsRetry
    toEnum Int
4 = TlsPasswordFlags
TlsPasswordFlagsManyTries
    toEnum Int
8 = TlsPasswordFlags
TlsPasswordFlagsFinalTry
    toEnum Int
k = Int -> TlsPasswordFlags
AnotherTlsPasswordFlags Int
k

instance P.Ord TlsPasswordFlags where
    compare :: TlsPasswordFlags -> TlsPasswordFlags -> Ordering
compare TlsPasswordFlags
a TlsPasswordFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TlsPasswordFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum TlsPasswordFlags
a) (TlsPasswordFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum TlsPasswordFlags
b)

type instance O.ParentTypes TlsPasswordFlags = '[]
instance O.HasParentTypes TlsPasswordFlags

foreign import ccall "g_tls_password_flags_get_type" c_g_tls_password_flags_get_type :: 
    IO GType

instance B.Types.TypedObject TlsPasswordFlags where
    glibType :: IO GType
glibType = IO GType
c_g_tls_password_flags_get_type

instance B.Types.BoxedFlags TlsPasswordFlags

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 (Int -> TlsDatabaseVerifyFlags -> ShowS
[TlsDatabaseVerifyFlags] -> ShowS
TlsDatabaseVerifyFlags -> String
(Int -> TlsDatabaseVerifyFlags -> ShowS)
-> (TlsDatabaseVerifyFlags -> String)
-> ([TlsDatabaseVerifyFlags] -> ShowS)
-> Show TlsDatabaseVerifyFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TlsDatabaseVerifyFlags] -> ShowS
$cshowList :: [TlsDatabaseVerifyFlags] -> ShowS
show :: TlsDatabaseVerifyFlags -> String
$cshow :: TlsDatabaseVerifyFlags -> String
showsPrec :: Int -> TlsDatabaseVerifyFlags -> ShowS
$cshowsPrec :: Int -> TlsDatabaseVerifyFlags -> ShowS
Show, TlsDatabaseVerifyFlags -> TlsDatabaseVerifyFlags -> Bool
(TlsDatabaseVerifyFlags -> TlsDatabaseVerifyFlags -> Bool)
-> (TlsDatabaseVerifyFlags -> TlsDatabaseVerifyFlags -> Bool)
-> Eq TlsDatabaseVerifyFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TlsDatabaseVerifyFlags -> TlsDatabaseVerifyFlags -> Bool
$c/= :: TlsDatabaseVerifyFlags -> TlsDatabaseVerifyFlags -> Bool
== :: TlsDatabaseVerifyFlags -> TlsDatabaseVerifyFlags -> Bool
$c== :: TlsDatabaseVerifyFlags -> TlsDatabaseVerifyFlags -> Bool
Eq)

instance P.Enum TlsDatabaseVerifyFlags where
    fromEnum :: TlsDatabaseVerifyFlags -> Int
fromEnum TlsDatabaseVerifyFlags
TlsDatabaseVerifyFlagsNone = Int
0
    fromEnum (AnotherTlsDatabaseVerifyFlags Int
k) = Int
k

    toEnum :: Int -> TlsDatabaseVerifyFlags
toEnum Int
0 = TlsDatabaseVerifyFlags
TlsDatabaseVerifyFlagsNone
    toEnum Int
k = Int -> TlsDatabaseVerifyFlags
AnotherTlsDatabaseVerifyFlags Int
k

instance P.Ord TlsDatabaseVerifyFlags where
    compare :: TlsDatabaseVerifyFlags -> TlsDatabaseVerifyFlags -> Ordering
compare TlsDatabaseVerifyFlags
a TlsDatabaseVerifyFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TlsDatabaseVerifyFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum TlsDatabaseVerifyFlags
a) (TlsDatabaseVerifyFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum TlsDatabaseVerifyFlags
b)

type instance O.ParentTypes TlsDatabaseVerifyFlags = '[]
instance O.HasParentTypes TlsDatabaseVerifyFlags

foreign import ccall "g_tls_database_verify_flags_get_type" c_g_tls_database_verify_flags_get_type :: 
    IO GType

instance B.Types.TypedObject TlsDatabaseVerifyFlags where
    glibType :: IO GType
glibType = IO GType
c_g_tls_database_verify_flags_get_type

instance B.Types.BoxedFlags TlsDatabaseVerifyFlags

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
-- [acceptCertificate]("GI.Gio.Objects.TlsConnection#g:signal:acceptCertificate")).
-- 
-- /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 t'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 (Int -> TlsCertificateFlags -> ShowS
[TlsCertificateFlags] -> ShowS
TlsCertificateFlags -> String
(Int -> TlsCertificateFlags -> ShowS)
-> (TlsCertificateFlags -> String)
-> ([TlsCertificateFlags] -> ShowS)
-> Show TlsCertificateFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TlsCertificateFlags] -> ShowS
$cshowList :: [TlsCertificateFlags] -> ShowS
show :: TlsCertificateFlags -> String
$cshow :: TlsCertificateFlags -> String
showsPrec :: Int -> TlsCertificateFlags -> ShowS
$cshowsPrec :: Int -> TlsCertificateFlags -> ShowS
Show, TlsCertificateFlags -> TlsCertificateFlags -> Bool
(TlsCertificateFlags -> TlsCertificateFlags -> Bool)
-> (TlsCertificateFlags -> TlsCertificateFlags -> Bool)
-> Eq TlsCertificateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TlsCertificateFlags -> TlsCertificateFlags -> Bool
$c/= :: TlsCertificateFlags -> TlsCertificateFlags -> Bool
== :: TlsCertificateFlags -> TlsCertificateFlags -> Bool
$c== :: TlsCertificateFlags -> TlsCertificateFlags -> Bool
Eq)

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

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

instance P.Ord TlsCertificateFlags where
    compare :: TlsCertificateFlags -> TlsCertificateFlags -> Ordering
compare TlsCertificateFlags
a TlsCertificateFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TlsCertificateFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum TlsCertificateFlags
a) (TlsCertificateFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum TlsCertificateFlags
b)

type instance O.ParentTypes TlsCertificateFlags = '[]
instance O.HasParentTypes TlsCertificateFlags

foreign import ccall "g_tls_certificate_flags_get_type" c_g_tls_certificate_flags_get_type :: 
    IO GType

instance B.Types.TypedObject TlsCertificateFlags where
    glibType :: IO GType
glibType = IO GType
c_g_tls_certificate_flags_get_type

instance B.Types.BoxedFlags TlsCertificateFlags

instance IsGFlag TlsCertificateFlags

-- Flags TestDBusFlags
-- | Flags to define future t'GI.Gio.Objects.TestDBus.TestDBus' behaviour.
-- 
-- /Since: 2.34/
data TestDBusFlags = 
      TestDBusFlagsNone
    -- ^ No flags.
    | AnotherTestDBusFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TestDBusFlags -> ShowS
[TestDBusFlags] -> ShowS
TestDBusFlags -> String
(Int -> TestDBusFlags -> ShowS)
-> (TestDBusFlags -> String)
-> ([TestDBusFlags] -> ShowS)
-> Show TestDBusFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TestDBusFlags] -> ShowS
$cshowList :: [TestDBusFlags] -> ShowS
show :: TestDBusFlags -> String
$cshow :: TestDBusFlags -> String
showsPrec :: Int -> TestDBusFlags -> ShowS
$cshowsPrec :: Int -> TestDBusFlags -> ShowS
Show, TestDBusFlags -> TestDBusFlags -> Bool
(TestDBusFlags -> TestDBusFlags -> Bool)
-> (TestDBusFlags -> TestDBusFlags -> Bool) -> Eq TestDBusFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TestDBusFlags -> TestDBusFlags -> Bool
$c/= :: TestDBusFlags -> TestDBusFlags -> Bool
== :: TestDBusFlags -> TestDBusFlags -> Bool
$c== :: TestDBusFlags -> TestDBusFlags -> Bool
Eq)

instance P.Enum TestDBusFlags where
    fromEnum :: TestDBusFlags -> Int
fromEnum TestDBusFlags
TestDBusFlagsNone = Int
0
    fromEnum (AnotherTestDBusFlags Int
k) = Int
k

    toEnum :: Int -> TestDBusFlags
toEnum Int
0 = TestDBusFlags
TestDBusFlagsNone
    toEnum Int
k = Int -> TestDBusFlags
AnotherTestDBusFlags Int
k

instance P.Ord TestDBusFlags where
    compare :: TestDBusFlags -> TestDBusFlags -> Ordering
compare TestDBusFlags
a TestDBusFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TestDBusFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum TestDBusFlags
a) (TestDBusFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum TestDBusFlags
b)

type instance O.ParentTypes TestDBusFlags = '[]
instance O.HasParentTypes TestDBusFlags

foreign import ccall "g_test_dbus_flags_get_type" c_g_test_dbus_flags_get_type :: 
    IO GType

instance B.Types.TypedObject TestDBusFlags where
    glibType :: IO GType
glibType = IO GType
c_g_test_dbus_flags_get_type

instance B.Types.BoxedFlags TestDBusFlags

instance IsGFlag TestDBusFlags

-- Flags SubprocessFlags
-- | Flags to define the behaviour of a t'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 (Int -> SubprocessFlags -> ShowS
[SubprocessFlags] -> ShowS
SubprocessFlags -> String
(Int -> SubprocessFlags -> ShowS)
-> (SubprocessFlags -> String)
-> ([SubprocessFlags] -> ShowS)
-> Show SubprocessFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SubprocessFlags] -> ShowS
$cshowList :: [SubprocessFlags] -> ShowS
show :: SubprocessFlags -> String
$cshow :: SubprocessFlags -> String
showsPrec :: Int -> SubprocessFlags -> ShowS
$cshowsPrec :: Int -> SubprocessFlags -> ShowS
Show, SubprocessFlags -> SubprocessFlags -> Bool
(SubprocessFlags -> SubprocessFlags -> Bool)
-> (SubprocessFlags -> SubprocessFlags -> Bool)
-> Eq SubprocessFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubprocessFlags -> SubprocessFlags -> Bool
$c/= :: SubprocessFlags -> SubprocessFlags -> Bool
== :: SubprocessFlags -> SubprocessFlags -> Bool
$c== :: SubprocessFlags -> SubprocessFlags -> Bool
Eq)

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

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

instance P.Ord SubprocessFlags where
    compare :: SubprocessFlags -> SubprocessFlags -> Ordering
compare SubprocessFlags
a SubprocessFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SubprocessFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SubprocessFlags
a) (SubprocessFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SubprocessFlags
b)

type instance O.ParentTypes SubprocessFlags = '[]
instance O.HasParentTypes SubprocessFlags

foreign import ccall "g_subprocess_flags_get_type" c_g_subprocess_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SubprocessFlags where
    glibType :: IO GType
glibType = IO GType
c_g_subprocess_flags_get_type

instance B.Types.BoxedFlags SubprocessFlags

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 (Int -> SocketMsgFlags -> ShowS
[SocketMsgFlags] -> ShowS
SocketMsgFlags -> String
(Int -> SocketMsgFlags -> ShowS)
-> (SocketMsgFlags -> String)
-> ([SocketMsgFlags] -> ShowS)
-> Show SocketMsgFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SocketMsgFlags] -> ShowS
$cshowList :: [SocketMsgFlags] -> ShowS
show :: SocketMsgFlags -> String
$cshow :: SocketMsgFlags -> String
showsPrec :: Int -> SocketMsgFlags -> ShowS
$cshowsPrec :: Int -> SocketMsgFlags -> ShowS
Show, SocketMsgFlags -> SocketMsgFlags -> Bool
(SocketMsgFlags -> SocketMsgFlags -> Bool)
-> (SocketMsgFlags -> SocketMsgFlags -> Bool) -> Eq SocketMsgFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SocketMsgFlags -> SocketMsgFlags -> Bool
$c/= :: SocketMsgFlags -> SocketMsgFlags -> Bool
== :: SocketMsgFlags -> SocketMsgFlags -> Bool
$c== :: SocketMsgFlags -> SocketMsgFlags -> Bool
Eq)

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

    toEnum :: Int -> SocketMsgFlags
toEnum Int
0 = SocketMsgFlags
SocketMsgFlagsNone
    toEnum Int
1 = SocketMsgFlags
SocketMsgFlagsOob
    toEnum Int
2 = SocketMsgFlags
SocketMsgFlagsPeek
    toEnum Int
4 = SocketMsgFlags
SocketMsgFlagsDontroute
    toEnum Int
k = Int -> SocketMsgFlags
AnotherSocketMsgFlags Int
k

instance P.Ord SocketMsgFlags where
    compare :: SocketMsgFlags -> SocketMsgFlags -> Ordering
compare SocketMsgFlags
a SocketMsgFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SocketMsgFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SocketMsgFlags
a) (SocketMsgFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SocketMsgFlags
b)

type instance O.ParentTypes SocketMsgFlags = '[]
instance O.HasParentTypes SocketMsgFlags

foreign import ccall "g_socket_msg_flags_get_type" c_g_socket_msg_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SocketMsgFlags where
    glibType :: IO GType
glibType = IO GType
c_g_socket_msg_flags_get_type

instance B.Types.BoxedFlags SocketMsgFlags

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 t'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 t'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 t'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 (Int -> SettingsBindFlags -> ShowS
[SettingsBindFlags] -> ShowS
SettingsBindFlags -> String
(Int -> SettingsBindFlags -> ShowS)
-> (SettingsBindFlags -> String)
-> ([SettingsBindFlags] -> ShowS)
-> Show SettingsBindFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SettingsBindFlags] -> ShowS
$cshowList :: [SettingsBindFlags] -> ShowS
show :: SettingsBindFlags -> String
$cshow :: SettingsBindFlags -> String
showsPrec :: Int -> SettingsBindFlags -> ShowS
$cshowsPrec :: Int -> SettingsBindFlags -> ShowS
Show, SettingsBindFlags -> SettingsBindFlags -> Bool
(SettingsBindFlags -> SettingsBindFlags -> Bool)
-> (SettingsBindFlags -> SettingsBindFlags -> Bool)
-> Eq SettingsBindFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SettingsBindFlags -> SettingsBindFlags -> Bool
$c/= :: SettingsBindFlags -> SettingsBindFlags -> Bool
== :: SettingsBindFlags -> SettingsBindFlags -> Bool
$c== :: SettingsBindFlags -> SettingsBindFlags -> Bool
Eq)

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

    toEnum :: Int -> SettingsBindFlags
toEnum Int
0 = SettingsBindFlags
SettingsBindFlagsDefault
    toEnum Int
1 = SettingsBindFlags
SettingsBindFlagsGet
    toEnum Int
2 = SettingsBindFlags
SettingsBindFlagsSet
    toEnum Int
4 = SettingsBindFlags
SettingsBindFlagsNoSensitivity
    toEnum Int
8 = SettingsBindFlags
SettingsBindFlagsGetNoChanges
    toEnum Int
16 = SettingsBindFlags
SettingsBindFlagsInvertBoolean
    toEnum Int
k = Int -> SettingsBindFlags
AnotherSettingsBindFlags Int
k

instance P.Ord SettingsBindFlags where
    compare :: SettingsBindFlags -> SettingsBindFlags -> Ordering
compare SettingsBindFlags
a SettingsBindFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingsBindFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingsBindFlags
a) (SettingsBindFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingsBindFlags
b)

type instance O.ParentTypes SettingsBindFlags = '[]
instance O.HasParentTypes SettingsBindFlags

foreign import ccall "g_settings_bind_flags_get_type" c_g_settings_bind_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SettingsBindFlags where
    glibType :: IO GType
glibType = IO GType
c_g_settings_bind_flags_get_type

instance B.Types.BoxedFlags SettingsBindFlags

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 (Int -> ResourceLookupFlags -> ShowS
[ResourceLookupFlags] -> ShowS
ResourceLookupFlags -> String
(Int -> ResourceLookupFlags -> ShowS)
-> (ResourceLookupFlags -> String)
-> ([ResourceLookupFlags] -> ShowS)
-> Show ResourceLookupFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ResourceLookupFlags] -> ShowS
$cshowList :: [ResourceLookupFlags] -> ShowS
show :: ResourceLookupFlags -> String
$cshow :: ResourceLookupFlags -> String
showsPrec :: Int -> ResourceLookupFlags -> ShowS
$cshowsPrec :: Int -> ResourceLookupFlags -> ShowS
Show, ResourceLookupFlags -> ResourceLookupFlags -> Bool
(ResourceLookupFlags -> ResourceLookupFlags -> Bool)
-> (ResourceLookupFlags -> ResourceLookupFlags -> Bool)
-> Eq ResourceLookupFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ResourceLookupFlags -> ResourceLookupFlags -> Bool
$c/= :: ResourceLookupFlags -> ResourceLookupFlags -> Bool
== :: ResourceLookupFlags -> ResourceLookupFlags -> Bool
$c== :: ResourceLookupFlags -> ResourceLookupFlags -> Bool
Eq)

instance P.Enum ResourceLookupFlags where
    fromEnum :: ResourceLookupFlags -> Int
fromEnum ResourceLookupFlags
ResourceLookupFlagsNone = Int
0
    fromEnum (AnotherResourceLookupFlags Int
k) = Int
k

    toEnum :: Int -> ResourceLookupFlags
toEnum Int
0 = ResourceLookupFlags
ResourceLookupFlagsNone
    toEnum Int
k = Int -> ResourceLookupFlags
AnotherResourceLookupFlags Int
k

instance P.Ord ResourceLookupFlags where
    compare :: ResourceLookupFlags -> ResourceLookupFlags -> Ordering
compare ResourceLookupFlags
a ResourceLookupFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ResourceLookupFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ResourceLookupFlags
a) (ResourceLookupFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ResourceLookupFlags
b)

type instance O.ParentTypes ResourceLookupFlags = '[]
instance O.HasParentTypes ResourceLookupFlags

foreign import ccall "g_resource_lookup_flags_get_type" c_g_resource_lookup_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ResourceLookupFlags where
    glibType :: IO GType
glibType = IO GType
c_g_resource_lookup_flags_get_type

instance B.Types.BoxedFlags ResourceLookupFlags

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 (Int -> ResourceFlags -> ShowS
[ResourceFlags] -> ShowS
ResourceFlags -> String
(Int -> ResourceFlags -> ShowS)
-> (ResourceFlags -> String)
-> ([ResourceFlags] -> ShowS)
-> Show ResourceFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ResourceFlags] -> ShowS
$cshowList :: [ResourceFlags] -> ShowS
show :: ResourceFlags -> String
$cshow :: ResourceFlags -> String
showsPrec :: Int -> ResourceFlags -> ShowS
$cshowsPrec :: Int -> ResourceFlags -> ShowS
Show, ResourceFlags -> ResourceFlags -> Bool
(ResourceFlags -> ResourceFlags -> Bool)
-> (ResourceFlags -> ResourceFlags -> Bool) -> Eq ResourceFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ResourceFlags -> ResourceFlags -> Bool
$c/= :: ResourceFlags -> ResourceFlags -> Bool
== :: ResourceFlags -> ResourceFlags -> Bool
$c== :: ResourceFlags -> ResourceFlags -> Bool
Eq)

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

    toEnum :: Int -> ResourceFlags
toEnum Int
0 = ResourceFlags
ResourceFlagsNone
    toEnum Int
1 = ResourceFlags
ResourceFlagsCompressed
    toEnum Int
k = Int -> ResourceFlags
AnotherResourceFlags Int
k

instance P.Ord ResourceFlags where
    compare :: ResourceFlags -> ResourceFlags -> Ordering
compare ResourceFlags
a ResourceFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ResourceFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ResourceFlags
a) (ResourceFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ResourceFlags
b)

type instance O.ParentTypes ResourceFlags = '[]
instance O.HasParentTypes ResourceFlags

foreign import ccall "g_resource_flags_get_type" c_g_resource_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ResourceFlags where
    glibType :: IO GType
glibType = IO GType
c_g_resource_flags_get_type

instance B.Types.BoxedFlags ResourceFlags

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 (Int -> ResolverNameLookupFlags -> ShowS
[ResolverNameLookupFlags] -> ShowS
ResolverNameLookupFlags -> String
(Int -> ResolverNameLookupFlags -> ShowS)
-> (ResolverNameLookupFlags -> String)
-> ([ResolverNameLookupFlags] -> ShowS)
-> Show ResolverNameLookupFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ResolverNameLookupFlags] -> ShowS
$cshowList :: [ResolverNameLookupFlags] -> ShowS
show :: ResolverNameLookupFlags -> String
$cshow :: ResolverNameLookupFlags -> String
showsPrec :: Int -> ResolverNameLookupFlags -> ShowS
$cshowsPrec :: Int -> ResolverNameLookupFlags -> ShowS
Show, ResolverNameLookupFlags -> ResolverNameLookupFlags -> Bool
(ResolverNameLookupFlags -> ResolverNameLookupFlags -> Bool)
-> (ResolverNameLookupFlags -> ResolverNameLookupFlags -> Bool)
-> Eq ResolverNameLookupFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ResolverNameLookupFlags -> ResolverNameLookupFlags -> Bool
$c/= :: ResolverNameLookupFlags -> ResolverNameLookupFlags -> Bool
== :: ResolverNameLookupFlags -> ResolverNameLookupFlags -> Bool
$c== :: ResolverNameLookupFlags -> ResolverNameLookupFlags -> Bool
Eq)

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

    toEnum :: Int -> ResolverNameLookupFlags
toEnum Int
0 = ResolverNameLookupFlags
ResolverNameLookupFlagsDefault
    toEnum Int
1 = ResolverNameLookupFlags
ResolverNameLookupFlagsIpv4Only
    toEnum Int
2 = ResolverNameLookupFlags
ResolverNameLookupFlagsIpv6Only
    toEnum Int
k = Int -> ResolverNameLookupFlags
AnotherResolverNameLookupFlags Int
k

instance P.Ord ResolverNameLookupFlags where
    compare :: ResolverNameLookupFlags -> ResolverNameLookupFlags -> Ordering
compare ResolverNameLookupFlags
a ResolverNameLookupFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ResolverNameLookupFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ResolverNameLookupFlags
a) (ResolverNameLookupFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ResolverNameLookupFlags
b)

type instance O.ParentTypes ResolverNameLookupFlags = '[]
instance O.HasParentTypes ResolverNameLookupFlags

foreign import ccall "g_resolver_name_lookup_flags_get_type" c_g_resolver_name_lookup_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ResolverNameLookupFlags where
    glibType :: IO GType
glibType = IO GType
c_g_resolver_name_lookup_flags_get_type

instance B.Types.BoxedFlags ResolverNameLookupFlags

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 (Int -> OutputStreamSpliceFlags -> ShowS
[OutputStreamSpliceFlags] -> ShowS
OutputStreamSpliceFlags -> String
(Int -> OutputStreamSpliceFlags -> ShowS)
-> (OutputStreamSpliceFlags -> String)
-> ([OutputStreamSpliceFlags] -> ShowS)
-> Show OutputStreamSpliceFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OutputStreamSpliceFlags] -> ShowS
$cshowList :: [OutputStreamSpliceFlags] -> ShowS
show :: OutputStreamSpliceFlags -> String
$cshow :: OutputStreamSpliceFlags -> String
showsPrec :: Int -> OutputStreamSpliceFlags -> ShowS
$cshowsPrec :: Int -> OutputStreamSpliceFlags -> ShowS
Show, OutputStreamSpliceFlags -> OutputStreamSpliceFlags -> Bool
(OutputStreamSpliceFlags -> OutputStreamSpliceFlags -> Bool)
-> (OutputStreamSpliceFlags -> OutputStreamSpliceFlags -> Bool)
-> Eq OutputStreamSpliceFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OutputStreamSpliceFlags -> OutputStreamSpliceFlags -> Bool
$c/= :: OutputStreamSpliceFlags -> OutputStreamSpliceFlags -> Bool
== :: OutputStreamSpliceFlags -> OutputStreamSpliceFlags -> Bool
$c== :: OutputStreamSpliceFlags -> OutputStreamSpliceFlags -> Bool
Eq)

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

    toEnum :: Int -> OutputStreamSpliceFlags
toEnum Int
0 = OutputStreamSpliceFlags
OutputStreamSpliceFlagsNone
    toEnum Int
1 = OutputStreamSpliceFlags
OutputStreamSpliceFlagsCloseSource
    toEnum Int
2 = OutputStreamSpliceFlags
OutputStreamSpliceFlagsCloseTarget
    toEnum Int
k = Int -> OutputStreamSpliceFlags
AnotherOutputStreamSpliceFlags Int
k

instance P.Ord OutputStreamSpliceFlags where
    compare :: OutputStreamSpliceFlags -> OutputStreamSpliceFlags -> Ordering
compare OutputStreamSpliceFlags
a OutputStreamSpliceFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (OutputStreamSpliceFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum OutputStreamSpliceFlags
a) (OutputStreamSpliceFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum OutputStreamSpliceFlags
b)

type instance O.ParentTypes OutputStreamSpliceFlags = '[]
instance O.HasParentTypes OutputStreamSpliceFlags

foreign import ccall "g_output_stream_splice_flags_get_type" c_g_output_stream_splice_flags_get_type :: 
    IO GType

instance B.Types.TypedObject OutputStreamSpliceFlags where
    glibType :: IO GType
glibType = IO GType
c_g_output_stream_splice_flags_get_type

instance B.Types.BoxedFlags OutputStreamSpliceFlags

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 (Int -> MountUnmountFlags -> ShowS
[MountUnmountFlags] -> ShowS
MountUnmountFlags -> String
(Int -> MountUnmountFlags -> ShowS)
-> (MountUnmountFlags -> String)
-> ([MountUnmountFlags] -> ShowS)
-> Show MountUnmountFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MountUnmountFlags] -> ShowS
$cshowList :: [MountUnmountFlags] -> ShowS
show :: MountUnmountFlags -> String
$cshow :: MountUnmountFlags -> String
showsPrec :: Int -> MountUnmountFlags -> ShowS
$cshowsPrec :: Int -> MountUnmountFlags -> ShowS
Show, MountUnmountFlags -> MountUnmountFlags -> Bool
(MountUnmountFlags -> MountUnmountFlags -> Bool)
-> (MountUnmountFlags -> MountUnmountFlags -> Bool)
-> Eq MountUnmountFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MountUnmountFlags -> MountUnmountFlags -> Bool
$c/= :: MountUnmountFlags -> MountUnmountFlags -> Bool
== :: MountUnmountFlags -> MountUnmountFlags -> Bool
$c== :: MountUnmountFlags -> MountUnmountFlags -> Bool
Eq)

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

    toEnum :: Int -> MountUnmountFlags
toEnum Int
0 = MountUnmountFlags
MountUnmountFlagsNone
    toEnum Int
1 = MountUnmountFlags
MountUnmountFlagsForce
    toEnum Int
k = Int -> MountUnmountFlags
AnotherMountUnmountFlags Int
k

instance P.Ord MountUnmountFlags where
    compare :: MountUnmountFlags -> MountUnmountFlags -> Ordering
compare MountUnmountFlags
a MountUnmountFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MountUnmountFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MountUnmountFlags
a) (MountUnmountFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MountUnmountFlags
b)

type instance O.ParentTypes MountUnmountFlags = '[]
instance O.HasParentTypes MountUnmountFlags

foreign import ccall "g_mount_unmount_flags_get_type" c_g_mount_unmount_flags_get_type :: 
    IO GType

instance B.Types.TypedObject MountUnmountFlags where
    glibType :: IO GType
glibType = IO GType
c_g_mount_unmount_flags_get_type

instance B.Types.BoxedFlags MountUnmountFlags

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 (Int -> MountMountFlags -> ShowS
[MountMountFlags] -> ShowS
MountMountFlags -> String
(Int -> MountMountFlags -> ShowS)
-> (MountMountFlags -> String)
-> ([MountMountFlags] -> ShowS)
-> Show MountMountFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MountMountFlags] -> ShowS
$cshowList :: [MountMountFlags] -> ShowS
show :: MountMountFlags -> String
$cshow :: MountMountFlags -> String
showsPrec :: Int -> MountMountFlags -> ShowS
$cshowsPrec :: Int -> MountMountFlags -> ShowS
Show, MountMountFlags -> MountMountFlags -> Bool
(MountMountFlags -> MountMountFlags -> Bool)
-> (MountMountFlags -> MountMountFlags -> Bool)
-> Eq MountMountFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MountMountFlags -> MountMountFlags -> Bool
$c/= :: MountMountFlags -> MountMountFlags -> Bool
== :: MountMountFlags -> MountMountFlags -> Bool
$c== :: MountMountFlags -> MountMountFlags -> Bool
Eq)

instance P.Enum MountMountFlags where
    fromEnum :: MountMountFlags -> Int
fromEnum MountMountFlags
MountMountFlagsNone = Int
0
    fromEnum (AnotherMountMountFlags Int
k) = Int
k

    toEnum :: Int -> MountMountFlags
toEnum Int
0 = MountMountFlags
MountMountFlagsNone
    toEnum Int
k = Int -> MountMountFlags
AnotherMountMountFlags Int
k

instance P.Ord MountMountFlags where
    compare :: MountMountFlags -> MountMountFlags -> Ordering
compare MountMountFlags
a MountMountFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MountMountFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MountMountFlags
a) (MountMountFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MountMountFlags
b)

type instance O.ParentTypes MountMountFlags = '[]
instance O.HasParentTypes MountMountFlags

foreign import ccall "g_mount_mount_flags_get_type" c_g_mount_mount_flags_get_type :: 
    IO GType

instance B.Types.TypedObject MountMountFlags where
    glibType :: IO GType
glibType = IO GType
c_g_mount_mount_flags_get_type

instance B.Types.BoxedFlags MountMountFlags

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 (Int -> IOStreamSpliceFlags -> ShowS
[IOStreamSpliceFlags] -> ShowS
IOStreamSpliceFlags -> String
(Int -> IOStreamSpliceFlags -> ShowS)
-> (IOStreamSpliceFlags -> String)
-> ([IOStreamSpliceFlags] -> ShowS)
-> Show IOStreamSpliceFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IOStreamSpliceFlags] -> ShowS
$cshowList :: [IOStreamSpliceFlags] -> ShowS
show :: IOStreamSpliceFlags -> String
$cshow :: IOStreamSpliceFlags -> String
showsPrec :: Int -> IOStreamSpliceFlags -> ShowS
$cshowsPrec :: Int -> IOStreamSpliceFlags -> ShowS
Show, IOStreamSpliceFlags -> IOStreamSpliceFlags -> Bool
(IOStreamSpliceFlags -> IOStreamSpliceFlags -> Bool)
-> (IOStreamSpliceFlags -> IOStreamSpliceFlags -> Bool)
-> Eq IOStreamSpliceFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IOStreamSpliceFlags -> IOStreamSpliceFlags -> Bool
$c/= :: IOStreamSpliceFlags -> IOStreamSpliceFlags -> Bool
== :: IOStreamSpliceFlags -> IOStreamSpliceFlags -> Bool
$c== :: IOStreamSpliceFlags -> IOStreamSpliceFlags -> Bool
Eq)

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

    toEnum :: Int -> IOStreamSpliceFlags
toEnum Int
0 = IOStreamSpliceFlags
IOStreamSpliceFlagsNone
    toEnum Int
1 = IOStreamSpliceFlags
IOStreamSpliceFlagsCloseStream1
    toEnum Int
2 = IOStreamSpliceFlags
IOStreamSpliceFlagsCloseStream2
    toEnum Int
4 = IOStreamSpliceFlags
IOStreamSpliceFlagsWaitForBoth
    toEnum Int
k = Int -> IOStreamSpliceFlags
AnotherIOStreamSpliceFlags Int
k

instance P.Ord IOStreamSpliceFlags where
    compare :: IOStreamSpliceFlags -> IOStreamSpliceFlags -> Ordering
compare IOStreamSpliceFlags
a IOStreamSpliceFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (IOStreamSpliceFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum IOStreamSpliceFlags
a) (IOStreamSpliceFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum IOStreamSpliceFlags
b)

type instance O.ParentTypes IOStreamSpliceFlags = '[]
instance O.HasParentTypes IOStreamSpliceFlags

foreign import ccall "g_io_stream_splice_flags_get_type" c_g_io_stream_splice_flags_get_type :: 
    IO GType

instance B.Types.TypedObject IOStreamSpliceFlags where
    glibType :: IO GType
glibType = IO GType
c_g_io_stream_splice_flags_get_type

instance B.Types.BoxedFlags IOStreamSpliceFlags

instance IsGFlag IOStreamSpliceFlags

-- Flags FileQueryInfoFlags
-- | Flags used when querying a t'GI.Gio.Objects.FileInfo.FileInfo'.
data FileQueryInfoFlags = 
      FileQueryInfoFlagsNone
    -- ^ No flags set.
    | FileQueryInfoFlagsNofollowSymlinks
    -- ^ Don\'t follow symlinks.
    | AnotherFileQueryInfoFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FileQueryInfoFlags -> ShowS
[FileQueryInfoFlags] -> ShowS
FileQueryInfoFlags -> String
(Int -> FileQueryInfoFlags -> ShowS)
-> (FileQueryInfoFlags -> String)
-> ([FileQueryInfoFlags] -> ShowS)
-> Show FileQueryInfoFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FileQueryInfoFlags] -> ShowS
$cshowList :: [FileQueryInfoFlags] -> ShowS
show :: FileQueryInfoFlags -> String
$cshow :: FileQueryInfoFlags -> String
showsPrec :: Int -> FileQueryInfoFlags -> ShowS
$cshowsPrec :: Int -> FileQueryInfoFlags -> ShowS
Show, FileQueryInfoFlags -> FileQueryInfoFlags -> Bool
(FileQueryInfoFlags -> FileQueryInfoFlags -> Bool)
-> (FileQueryInfoFlags -> FileQueryInfoFlags -> Bool)
-> Eq FileQueryInfoFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileQueryInfoFlags -> FileQueryInfoFlags -> Bool
$c/= :: FileQueryInfoFlags -> FileQueryInfoFlags -> Bool
== :: FileQueryInfoFlags -> FileQueryInfoFlags -> Bool
$c== :: FileQueryInfoFlags -> FileQueryInfoFlags -> Bool
Eq)

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

    toEnum :: Int -> FileQueryInfoFlags
toEnum Int
0 = FileQueryInfoFlags
FileQueryInfoFlagsNone
    toEnum Int
1 = FileQueryInfoFlags
FileQueryInfoFlagsNofollowSymlinks
    toEnum Int
k = Int -> FileQueryInfoFlags
AnotherFileQueryInfoFlags Int
k

instance P.Ord FileQueryInfoFlags where
    compare :: FileQueryInfoFlags -> FileQueryInfoFlags -> Ordering
compare FileQueryInfoFlags
a FileQueryInfoFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FileQueryInfoFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum FileQueryInfoFlags
a) (FileQueryInfoFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum FileQueryInfoFlags
b)

type instance O.ParentTypes FileQueryInfoFlags = '[]
instance O.HasParentTypes FileQueryInfoFlags

foreign import ccall "g_file_query_info_flags_get_type" c_g_file_query_info_flags_get_type :: 
    IO GType

instance B.Types.TypedObject FileQueryInfoFlags where
    glibType :: IO GType
glibType = IO GType
c_g_file_query_info_flags_get_type

instance B.Types.BoxedFlags FileQueryInfoFlags

instance IsGFlag FileQueryInfoFlags

-- Flags FileMonitorFlags
-- | Flags used to set what a t'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 (Int -> FileMonitorFlags -> ShowS
[FileMonitorFlags] -> ShowS
FileMonitorFlags -> String
(Int -> FileMonitorFlags -> ShowS)
-> (FileMonitorFlags -> String)
-> ([FileMonitorFlags] -> ShowS)
-> Show FileMonitorFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FileMonitorFlags] -> ShowS
$cshowList :: [FileMonitorFlags] -> ShowS
show :: FileMonitorFlags -> String
$cshow :: FileMonitorFlags -> String
showsPrec :: Int -> FileMonitorFlags -> ShowS
$cshowsPrec :: Int -> FileMonitorFlags -> ShowS
Show, FileMonitorFlags -> FileMonitorFlags -> Bool
(FileMonitorFlags -> FileMonitorFlags -> Bool)
-> (FileMonitorFlags -> FileMonitorFlags -> Bool)
-> Eq FileMonitorFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileMonitorFlags -> FileMonitorFlags -> Bool
$c/= :: FileMonitorFlags -> FileMonitorFlags -> Bool
== :: FileMonitorFlags -> FileMonitorFlags -> Bool
$c== :: FileMonitorFlags -> FileMonitorFlags -> Bool
Eq)

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

    toEnum :: Int -> FileMonitorFlags
toEnum Int
0 = FileMonitorFlags
FileMonitorFlagsNone
    toEnum Int
1 = FileMonitorFlags
FileMonitorFlagsWatchMounts
    toEnum Int
2 = FileMonitorFlags
FileMonitorFlagsSendMoved
    toEnum Int
4 = FileMonitorFlags
FileMonitorFlagsWatchHardLinks
    toEnum Int
8 = FileMonitorFlags
FileMonitorFlagsWatchMoves
    toEnum Int
k = Int -> FileMonitorFlags
AnotherFileMonitorFlags Int
k

instance P.Ord FileMonitorFlags where
    compare :: FileMonitorFlags -> FileMonitorFlags -> Ordering
compare FileMonitorFlags
a FileMonitorFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FileMonitorFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum FileMonitorFlags
a) (FileMonitorFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum FileMonitorFlags
b)

type instance O.ParentTypes FileMonitorFlags = '[]
instance O.HasParentTypes FileMonitorFlags

foreign import ccall "g_file_monitor_flags_get_type" c_g_file_monitor_flags_get_type :: 
    IO GType

instance B.Types.TypedObject FileMonitorFlags where
    glibType :: IO GType
glibType = IO GType
c_g_file_monitor_flags_get_type

instance B.Types.BoxedFlags FileMonitorFlags

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 (Int -> FileMeasureFlags -> ShowS
[FileMeasureFlags] -> ShowS
FileMeasureFlags -> String
(Int -> FileMeasureFlags -> ShowS)
-> (FileMeasureFlags -> String)
-> ([FileMeasureFlags] -> ShowS)
-> Show FileMeasureFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FileMeasureFlags] -> ShowS
$cshowList :: [FileMeasureFlags] -> ShowS
show :: FileMeasureFlags -> String
$cshow :: FileMeasureFlags -> String
showsPrec :: Int -> FileMeasureFlags -> ShowS
$cshowsPrec :: Int -> FileMeasureFlags -> ShowS
Show, FileMeasureFlags -> FileMeasureFlags -> Bool
(FileMeasureFlags -> FileMeasureFlags -> Bool)
-> (FileMeasureFlags -> FileMeasureFlags -> Bool)
-> Eq FileMeasureFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileMeasureFlags -> FileMeasureFlags -> Bool
$c/= :: FileMeasureFlags -> FileMeasureFlags -> Bool
== :: FileMeasureFlags -> FileMeasureFlags -> Bool
$c== :: FileMeasureFlags -> FileMeasureFlags -> Bool
Eq)

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

    toEnum :: Int -> FileMeasureFlags
toEnum Int
0 = FileMeasureFlags
FileMeasureFlagsNone
    toEnum Int
2 = FileMeasureFlags
FileMeasureFlagsReportAnyError
    toEnum Int
4 = FileMeasureFlags
FileMeasureFlagsApparentSize
    toEnum Int
8 = FileMeasureFlags
FileMeasureFlagsNoXdev
    toEnum Int
k = Int -> FileMeasureFlags
AnotherFileMeasureFlags Int
k

instance P.Ord FileMeasureFlags where
    compare :: FileMeasureFlags -> FileMeasureFlags -> Ordering
compare FileMeasureFlags
a FileMeasureFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FileMeasureFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum FileMeasureFlags
a) (FileMeasureFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum FileMeasureFlags
b)

type instance O.ParentTypes FileMeasureFlags = '[]
instance O.HasParentTypes FileMeasureFlags

foreign import ccall "g_file_measure_flags_get_type" c_g_file_measure_flags_get_type :: 
    IO GType

instance B.Types.TypedObject FileMeasureFlags where
    glibType :: IO GType
glibType = IO GType
c_g_file_measure_flags_get_type

instance B.Types.BoxedFlags FileMeasureFlags

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 (Int -> FileCreateFlags -> ShowS
[FileCreateFlags] -> ShowS
FileCreateFlags -> String
(Int -> FileCreateFlags -> ShowS)
-> (FileCreateFlags -> String)
-> ([FileCreateFlags] -> ShowS)
-> Show FileCreateFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FileCreateFlags] -> ShowS
$cshowList :: [FileCreateFlags] -> ShowS
show :: FileCreateFlags -> String
$cshow :: FileCreateFlags -> String
showsPrec :: Int -> FileCreateFlags -> ShowS
$cshowsPrec :: Int -> FileCreateFlags -> ShowS
Show, FileCreateFlags -> FileCreateFlags -> Bool
(FileCreateFlags -> FileCreateFlags -> Bool)
-> (FileCreateFlags -> FileCreateFlags -> Bool)
-> Eq FileCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileCreateFlags -> FileCreateFlags -> Bool
$c/= :: FileCreateFlags -> FileCreateFlags -> Bool
== :: FileCreateFlags -> FileCreateFlags -> Bool
$c== :: FileCreateFlags -> FileCreateFlags -> Bool
Eq)

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

    toEnum :: Int -> FileCreateFlags
toEnum Int
0 = FileCreateFlags
FileCreateFlagsNone
    toEnum Int
1 = FileCreateFlags
FileCreateFlagsPrivate
    toEnum Int
2 = FileCreateFlags
FileCreateFlagsReplaceDestination
    toEnum Int
k = Int -> FileCreateFlags
AnotherFileCreateFlags Int
k

instance P.Ord FileCreateFlags where
    compare :: FileCreateFlags -> FileCreateFlags -> Ordering
compare FileCreateFlags
a FileCreateFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FileCreateFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum FileCreateFlags
a) (FileCreateFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum FileCreateFlags
b)

type instance O.ParentTypes FileCreateFlags = '[]
instance O.HasParentTypes FileCreateFlags

foreign import ccall "g_file_create_flags_get_type" c_g_file_create_flags_get_type :: 
    IO GType

instance B.Types.TypedObject FileCreateFlags where
    glibType :: IO GType
glibType = IO GType
c_g_file_create_flags_get_type

instance B.Types.BoxedFlags FileCreateFlags

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 t'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 (Int -> FileCopyFlags -> ShowS
[FileCopyFlags] -> ShowS
FileCopyFlags -> String
(Int -> FileCopyFlags -> ShowS)
-> (FileCopyFlags -> String)
-> ([FileCopyFlags] -> ShowS)
-> Show FileCopyFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FileCopyFlags] -> ShowS
$cshowList :: [FileCopyFlags] -> ShowS
show :: FileCopyFlags -> String
$cshow :: FileCopyFlags -> String
showsPrec :: Int -> FileCopyFlags -> ShowS
$cshowsPrec :: Int -> FileCopyFlags -> ShowS
Show, FileCopyFlags -> FileCopyFlags -> Bool
(FileCopyFlags -> FileCopyFlags -> Bool)
-> (FileCopyFlags -> FileCopyFlags -> Bool) -> Eq FileCopyFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileCopyFlags -> FileCopyFlags -> Bool
$c/= :: FileCopyFlags -> FileCopyFlags -> Bool
== :: FileCopyFlags -> FileCopyFlags -> Bool
$c== :: FileCopyFlags -> FileCopyFlags -> Bool
Eq)

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

    toEnum :: Int -> FileCopyFlags
toEnum Int
0 = FileCopyFlags
FileCopyFlagsNone
    toEnum Int
1 = FileCopyFlags
FileCopyFlagsOverwrite
    toEnum Int
2 = FileCopyFlags
FileCopyFlagsBackup
    toEnum Int
4 = FileCopyFlags
FileCopyFlagsNofollowSymlinks
    toEnum Int
8 = FileCopyFlags
FileCopyFlagsAllMetadata
    toEnum Int
16 = FileCopyFlags
FileCopyFlagsNoFallbackForMove
    toEnum Int
32 = FileCopyFlags
FileCopyFlagsTargetDefaultPerms
    toEnum Int
k = Int -> FileCopyFlags
AnotherFileCopyFlags Int
k

instance P.Ord FileCopyFlags where
    compare :: FileCopyFlags -> FileCopyFlags -> Ordering
compare FileCopyFlags
a FileCopyFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FileCopyFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum FileCopyFlags
a) (FileCopyFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum FileCopyFlags
b)

type instance O.ParentTypes FileCopyFlags = '[]
instance O.HasParentTypes FileCopyFlags

foreign import ccall "g_file_copy_flags_get_type" c_g_file_copy_flags_get_type :: 
    IO GType

instance B.Types.TypedObject FileCopyFlags where
    glibType :: IO GType
glibType = IO GType
c_g_file_copy_flags_get_type

instance B.Types.BoxedFlags FileCopyFlags

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 (Int -> FileAttributeInfoFlags -> ShowS
[FileAttributeInfoFlags] -> ShowS
FileAttributeInfoFlags -> String
(Int -> FileAttributeInfoFlags -> ShowS)
-> (FileAttributeInfoFlags -> String)
-> ([FileAttributeInfoFlags] -> ShowS)
-> Show FileAttributeInfoFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FileAttributeInfoFlags] -> ShowS
$cshowList :: [FileAttributeInfoFlags] -> ShowS
show :: FileAttributeInfoFlags -> String
$cshow :: FileAttributeInfoFlags -> String
showsPrec :: Int -> FileAttributeInfoFlags -> ShowS
$cshowsPrec :: Int -> FileAttributeInfoFlags -> ShowS
Show, FileAttributeInfoFlags -> FileAttributeInfoFlags -> Bool
(FileAttributeInfoFlags -> FileAttributeInfoFlags -> Bool)
-> (FileAttributeInfoFlags -> FileAttributeInfoFlags -> Bool)
-> Eq FileAttributeInfoFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileAttributeInfoFlags -> FileAttributeInfoFlags -> Bool
$c/= :: FileAttributeInfoFlags -> FileAttributeInfoFlags -> Bool
== :: FileAttributeInfoFlags -> FileAttributeInfoFlags -> Bool
$c== :: FileAttributeInfoFlags -> FileAttributeInfoFlags -> Bool
Eq)

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

    toEnum :: Int -> FileAttributeInfoFlags
toEnum Int
0 = FileAttributeInfoFlags
FileAttributeInfoFlagsNone
    toEnum Int
1 = FileAttributeInfoFlags
FileAttributeInfoFlagsCopyWithFile
    toEnum Int
2 = FileAttributeInfoFlags
FileAttributeInfoFlagsCopyWhenMoved
    toEnum Int
k = Int -> FileAttributeInfoFlags
AnotherFileAttributeInfoFlags Int
k

instance P.Ord FileAttributeInfoFlags where
    compare :: FileAttributeInfoFlags -> FileAttributeInfoFlags -> Ordering
compare FileAttributeInfoFlags
a FileAttributeInfoFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FileAttributeInfoFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum FileAttributeInfoFlags
a) (FileAttributeInfoFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum FileAttributeInfoFlags
b)

type instance O.ParentTypes FileAttributeInfoFlags = '[]
instance O.HasParentTypes FileAttributeInfoFlags

foreign import ccall "g_file_attribute_info_flags_get_type" c_g_file_attribute_info_flags_get_type :: 
    IO GType

instance B.Types.TypedObject FileAttributeInfoFlags where
    glibType :: IO GType
glibType = IO GType
c_g_file_attribute_info_flags_get_type

instance B.Types.BoxedFlags FileAttributeInfoFlags

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 (Int -> DriveStartFlags -> ShowS
[DriveStartFlags] -> ShowS
DriveStartFlags -> String
(Int -> DriveStartFlags -> ShowS)
-> (DriveStartFlags -> String)
-> ([DriveStartFlags] -> ShowS)
-> Show DriveStartFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DriveStartFlags] -> ShowS
$cshowList :: [DriveStartFlags] -> ShowS
show :: DriveStartFlags -> String
$cshow :: DriveStartFlags -> String
showsPrec :: Int -> DriveStartFlags -> ShowS
$cshowsPrec :: Int -> DriveStartFlags -> ShowS
Show, DriveStartFlags -> DriveStartFlags -> Bool
(DriveStartFlags -> DriveStartFlags -> Bool)
-> (DriveStartFlags -> DriveStartFlags -> Bool)
-> Eq DriveStartFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DriveStartFlags -> DriveStartFlags -> Bool
$c/= :: DriveStartFlags -> DriveStartFlags -> Bool
== :: DriveStartFlags -> DriveStartFlags -> Bool
$c== :: DriveStartFlags -> DriveStartFlags -> Bool
Eq)

instance P.Enum DriveStartFlags where
    fromEnum :: DriveStartFlags -> Int
fromEnum DriveStartFlags
DriveStartFlagsNone = Int
0
    fromEnum (AnotherDriveStartFlags Int
k) = Int
k

    toEnum :: Int -> DriveStartFlags
toEnum Int
0 = DriveStartFlags
DriveStartFlagsNone
    toEnum Int
k = Int -> DriveStartFlags
AnotherDriveStartFlags Int
k

instance P.Ord DriveStartFlags where
    compare :: DriveStartFlags -> DriveStartFlags -> Ordering
compare DriveStartFlags
a DriveStartFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DriveStartFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DriveStartFlags
a) (DriveStartFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DriveStartFlags
b)

type instance O.ParentTypes DriveStartFlags = '[]
instance O.HasParentTypes DriveStartFlags

foreign import ccall "g_drive_start_flags_get_type" c_g_drive_start_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DriveStartFlags where
    glibType :: IO GType
glibType = IO GType
c_g_drive_start_flags_get_type

instance B.Types.BoxedFlags DriveStartFlags

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 (Int -> DBusSubtreeFlags -> ShowS
[DBusSubtreeFlags] -> ShowS
DBusSubtreeFlags -> String
(Int -> DBusSubtreeFlags -> ShowS)
-> (DBusSubtreeFlags -> String)
-> ([DBusSubtreeFlags] -> ShowS)
-> Show DBusSubtreeFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DBusSubtreeFlags] -> ShowS
$cshowList :: [DBusSubtreeFlags] -> ShowS
show :: DBusSubtreeFlags -> String
$cshow :: DBusSubtreeFlags -> String
showsPrec :: Int -> DBusSubtreeFlags -> ShowS
$cshowsPrec :: Int -> DBusSubtreeFlags -> ShowS
Show, DBusSubtreeFlags -> DBusSubtreeFlags -> Bool
(DBusSubtreeFlags -> DBusSubtreeFlags -> Bool)
-> (DBusSubtreeFlags -> DBusSubtreeFlags -> Bool)
-> Eq DBusSubtreeFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBusSubtreeFlags -> DBusSubtreeFlags -> Bool
$c/= :: DBusSubtreeFlags -> DBusSubtreeFlags -> Bool
== :: DBusSubtreeFlags -> DBusSubtreeFlags -> Bool
$c== :: DBusSubtreeFlags -> DBusSubtreeFlags -> Bool
Eq)

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

    toEnum :: Int -> DBusSubtreeFlags
toEnum Int
0 = DBusSubtreeFlags
DBusSubtreeFlagsNone
    toEnum Int
1 = DBusSubtreeFlags
DBusSubtreeFlagsDispatchToUnenumeratedNodes
    toEnum Int
k = Int -> DBusSubtreeFlags
AnotherDBusSubtreeFlags Int
k

instance P.Ord DBusSubtreeFlags where
    compare :: DBusSubtreeFlags -> DBusSubtreeFlags -> Ordering
compare DBusSubtreeFlags
a DBusSubtreeFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DBusSubtreeFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusSubtreeFlags
a) (DBusSubtreeFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusSubtreeFlags
b)

type instance O.ParentTypes DBusSubtreeFlags = '[]
instance O.HasParentTypes DBusSubtreeFlags

foreign import ccall "g_dbus_subtree_flags_get_type" c_g_dbus_subtree_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DBusSubtreeFlags where
    glibType :: IO GType
glibType = IO GType
c_g_dbus_subtree_flags_get_type

instance B.Types.BoxedFlags DBusSubtreeFlags

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 (Int -> DBusSignalFlags -> ShowS
[DBusSignalFlags] -> ShowS
DBusSignalFlags -> String
(Int -> DBusSignalFlags -> ShowS)
-> (DBusSignalFlags -> String)
-> ([DBusSignalFlags] -> ShowS)
-> Show DBusSignalFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DBusSignalFlags] -> ShowS
$cshowList :: [DBusSignalFlags] -> ShowS
show :: DBusSignalFlags -> String
$cshow :: DBusSignalFlags -> String
showsPrec :: Int -> DBusSignalFlags -> ShowS
$cshowsPrec :: Int -> DBusSignalFlags -> ShowS
Show, DBusSignalFlags -> DBusSignalFlags -> Bool
(DBusSignalFlags -> DBusSignalFlags -> Bool)
-> (DBusSignalFlags -> DBusSignalFlags -> Bool)
-> Eq DBusSignalFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBusSignalFlags -> DBusSignalFlags -> Bool
$c/= :: DBusSignalFlags -> DBusSignalFlags -> Bool
== :: DBusSignalFlags -> DBusSignalFlags -> Bool
$c== :: DBusSignalFlags -> DBusSignalFlags -> Bool
Eq)

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

    toEnum :: Int -> DBusSignalFlags
toEnum Int
0 = DBusSignalFlags
DBusSignalFlagsNone
    toEnum Int
1 = DBusSignalFlags
DBusSignalFlagsNoMatchRule
    toEnum Int
2 = DBusSignalFlags
DBusSignalFlagsMatchArg0Namespace
    toEnum Int
4 = DBusSignalFlags
DBusSignalFlagsMatchArg0Path
    toEnum Int
k = Int -> DBusSignalFlags
AnotherDBusSignalFlags Int
k

instance P.Ord DBusSignalFlags where
    compare :: DBusSignalFlags -> DBusSignalFlags -> Ordering
compare DBusSignalFlags
a DBusSignalFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DBusSignalFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusSignalFlags
a) (DBusSignalFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusSignalFlags
b)

type instance O.ParentTypes DBusSignalFlags = '[]
instance O.HasParentTypes DBusSignalFlags

foreign import ccall "g_dbus_signal_flags_get_type" c_g_dbus_signal_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DBusSignalFlags where
    glibType :: IO GType
glibType = IO GType
c_g_dbus_signal_flags_get_type

instance B.Types.BoxedFlags DBusSignalFlags

instance IsGFlag DBusSignalFlags

-- Flags DBusServerFlags
-- | Flags used when creating a t'GI.Gio.Objects.DBusServer.DBusServer'.
-- 
-- /Since: 2.26/
data DBusServerFlags = 
      DBusServerFlagsNone
    -- ^ No flags set.
    | DBusServerFlagsRunInThread
    -- ^ All [newConnection]("GI.Gio.Objects.DBusServer#g:signal:newConnection")
    -- 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 (Int -> DBusServerFlags -> ShowS
[DBusServerFlags] -> ShowS
DBusServerFlags -> String
(Int -> DBusServerFlags -> ShowS)
-> (DBusServerFlags -> String)
-> ([DBusServerFlags] -> ShowS)
-> Show DBusServerFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DBusServerFlags] -> ShowS
$cshowList :: [DBusServerFlags] -> ShowS
show :: DBusServerFlags -> String
$cshow :: DBusServerFlags -> String
showsPrec :: Int -> DBusServerFlags -> ShowS
$cshowsPrec :: Int -> DBusServerFlags -> ShowS
Show, DBusServerFlags -> DBusServerFlags -> Bool
(DBusServerFlags -> DBusServerFlags -> Bool)
-> (DBusServerFlags -> DBusServerFlags -> Bool)
-> Eq DBusServerFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBusServerFlags -> DBusServerFlags -> Bool
$c/= :: DBusServerFlags -> DBusServerFlags -> Bool
== :: DBusServerFlags -> DBusServerFlags -> Bool
$c== :: DBusServerFlags -> DBusServerFlags -> Bool
Eq)

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

    toEnum :: Int -> DBusServerFlags
toEnum Int
0 = DBusServerFlags
DBusServerFlagsNone
    toEnum Int
1 = DBusServerFlags
DBusServerFlagsRunInThread
    toEnum Int
2 = DBusServerFlags
DBusServerFlagsAuthenticationAllowAnonymous
    toEnum Int
k = Int -> DBusServerFlags
AnotherDBusServerFlags Int
k

instance P.Ord DBusServerFlags where
    compare :: DBusServerFlags -> DBusServerFlags -> Ordering
compare DBusServerFlags
a DBusServerFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DBusServerFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusServerFlags
a) (DBusServerFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusServerFlags
b)

type instance O.ParentTypes DBusServerFlags = '[]
instance O.HasParentTypes DBusServerFlags

foreign import ccall "g_dbus_server_flags_get_type" c_g_dbus_server_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DBusServerFlags where
    glibType :: IO GType
glibType = IO GType
c_g_dbus_server_flags_get_type

instance B.Types.BoxedFlags DBusServerFlags

instance IsGFlag DBusServerFlags

-- Flags DBusSendMessageFlags
-- | Flags used when sending @/GDBusMessages/@ on a t'GI.Gio.Objects.DBusConnection.DBusConnection'.
-- 
-- /Since: 2.26/
data DBusSendMessageFlags = 
      DBusSendMessageFlagsNone
    -- ^ No flags set.
    | DBusSendMessageFlagsPreserveSerial
    -- ^ Do not automatically
    -- assign a serial number from the t'GI.Gio.Objects.DBusConnection.DBusConnection' object when
    -- sending a message.
    | AnotherDBusSendMessageFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DBusSendMessageFlags -> ShowS
[DBusSendMessageFlags] -> ShowS
DBusSendMessageFlags -> String
(Int -> DBusSendMessageFlags -> ShowS)
-> (DBusSendMessageFlags -> String)
-> ([DBusSendMessageFlags] -> ShowS)
-> Show DBusSendMessageFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DBusSendMessageFlags] -> ShowS
$cshowList :: [DBusSendMessageFlags] -> ShowS
show :: DBusSendMessageFlags -> String
$cshow :: DBusSendMessageFlags -> String
showsPrec :: Int -> DBusSendMessageFlags -> ShowS
$cshowsPrec :: Int -> DBusSendMessageFlags -> ShowS
Show, DBusSendMessageFlags -> DBusSendMessageFlags -> Bool
(DBusSendMessageFlags -> DBusSendMessageFlags -> Bool)
-> (DBusSendMessageFlags -> DBusSendMessageFlags -> Bool)
-> Eq DBusSendMessageFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBusSendMessageFlags -> DBusSendMessageFlags -> Bool
$c/= :: DBusSendMessageFlags -> DBusSendMessageFlags -> Bool
== :: DBusSendMessageFlags -> DBusSendMessageFlags -> Bool
$c== :: DBusSendMessageFlags -> DBusSendMessageFlags -> Bool
Eq)

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

    toEnum :: Int -> DBusSendMessageFlags
toEnum Int
0 = DBusSendMessageFlags
DBusSendMessageFlagsNone
    toEnum Int
1 = DBusSendMessageFlags
DBusSendMessageFlagsPreserveSerial
    toEnum Int
k = Int -> DBusSendMessageFlags
AnotherDBusSendMessageFlags Int
k

instance P.Ord DBusSendMessageFlags where
    compare :: DBusSendMessageFlags -> DBusSendMessageFlags -> Ordering
compare DBusSendMessageFlags
a DBusSendMessageFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DBusSendMessageFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusSendMessageFlags
a) (DBusSendMessageFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusSendMessageFlags
b)

type instance O.ParentTypes DBusSendMessageFlags = '[]
instance O.HasParentTypes DBusSendMessageFlags

foreign import ccall "g_dbus_send_message_flags_get_type" c_g_dbus_send_message_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DBusSendMessageFlags where
    glibType :: IO GType
glibType = IO GType
c_g_dbus_send_message_flags_get_type

instance B.Types.BoxedFlags DBusSendMessageFlags

instance IsGFlag DBusSendMessageFlags

-- Flags DBusProxyFlags
-- | Flags used when constructing an instance of a t'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 [gPropertiesChanged]("GI.Gio.Objects.DBusProxy#g:signal:gPropertiesChanged") signal. When the value is received the [gPropertiesChanged]("GI.Gio.Objects.DBusProxy#g:signal:gPropertiesChanged") 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 (Int -> DBusProxyFlags -> ShowS
[DBusProxyFlags] -> ShowS
DBusProxyFlags -> String
(Int -> DBusProxyFlags -> ShowS)
-> (DBusProxyFlags -> String)
-> ([DBusProxyFlags] -> ShowS)
-> Show DBusProxyFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DBusProxyFlags] -> ShowS
$cshowList :: [DBusProxyFlags] -> ShowS
show :: DBusProxyFlags -> String
$cshow :: DBusProxyFlags -> String
showsPrec :: Int -> DBusProxyFlags -> ShowS
$cshowsPrec :: Int -> DBusProxyFlags -> ShowS
Show, DBusProxyFlags -> DBusProxyFlags -> Bool
(DBusProxyFlags -> DBusProxyFlags -> Bool)
-> (DBusProxyFlags -> DBusProxyFlags -> Bool) -> Eq DBusProxyFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBusProxyFlags -> DBusProxyFlags -> Bool
$c/= :: DBusProxyFlags -> DBusProxyFlags -> Bool
== :: DBusProxyFlags -> DBusProxyFlags -> Bool
$c== :: DBusProxyFlags -> DBusProxyFlags -> Bool
Eq)

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

    toEnum :: Int -> DBusProxyFlags
toEnum Int
0 = DBusProxyFlags
DBusProxyFlagsNone
    toEnum Int
1 = DBusProxyFlags
DBusProxyFlagsDoNotLoadProperties
    toEnum Int
2 = DBusProxyFlags
DBusProxyFlagsDoNotConnectSignals
    toEnum Int
4 = DBusProxyFlags
DBusProxyFlagsDoNotAutoStart
    toEnum Int
8 = DBusProxyFlags
DBusProxyFlagsGetInvalidatedProperties
    toEnum Int
16 = DBusProxyFlags
DBusProxyFlagsDoNotAutoStartAtConstruction
    toEnum Int
k = Int -> DBusProxyFlags
AnotherDBusProxyFlags Int
k

instance P.Ord DBusProxyFlags where
    compare :: DBusProxyFlags -> DBusProxyFlags -> Ordering
compare DBusProxyFlags
a DBusProxyFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DBusProxyFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusProxyFlags
a) (DBusProxyFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusProxyFlags
b)

type instance O.ParentTypes DBusProxyFlags = '[]
instance O.HasParentTypes DBusProxyFlags

foreign import ccall "g_dbus_proxy_flags_get_type" c_g_dbus_proxy_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DBusProxyFlags where
    glibType :: IO GType
glibType = IO GType
c_g_dbus_proxy_flags_get_type

instance B.Types.BoxedFlags DBusProxyFlags

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 (Int -> DBusPropertyInfoFlags -> ShowS
[DBusPropertyInfoFlags] -> ShowS
DBusPropertyInfoFlags -> String
(Int -> DBusPropertyInfoFlags -> ShowS)
-> (DBusPropertyInfoFlags -> String)
-> ([DBusPropertyInfoFlags] -> ShowS)
-> Show DBusPropertyInfoFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DBusPropertyInfoFlags] -> ShowS
$cshowList :: [DBusPropertyInfoFlags] -> ShowS
show :: DBusPropertyInfoFlags -> String
$cshow :: DBusPropertyInfoFlags -> String
showsPrec :: Int -> DBusPropertyInfoFlags -> ShowS
$cshowsPrec :: Int -> DBusPropertyInfoFlags -> ShowS
Show, DBusPropertyInfoFlags -> DBusPropertyInfoFlags -> Bool
(DBusPropertyInfoFlags -> DBusPropertyInfoFlags -> Bool)
-> (DBusPropertyInfoFlags -> DBusPropertyInfoFlags -> Bool)
-> Eq DBusPropertyInfoFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBusPropertyInfoFlags -> DBusPropertyInfoFlags -> Bool
$c/= :: DBusPropertyInfoFlags -> DBusPropertyInfoFlags -> Bool
== :: DBusPropertyInfoFlags -> DBusPropertyInfoFlags -> Bool
$c== :: DBusPropertyInfoFlags -> DBusPropertyInfoFlags -> Bool
Eq)

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

    toEnum :: Int -> DBusPropertyInfoFlags
toEnum Int
0 = DBusPropertyInfoFlags
DBusPropertyInfoFlagsNone
    toEnum Int
1 = DBusPropertyInfoFlags
DBusPropertyInfoFlagsReadable
    toEnum Int
2 = DBusPropertyInfoFlags
DBusPropertyInfoFlagsWritable
    toEnum Int
k = Int -> DBusPropertyInfoFlags
AnotherDBusPropertyInfoFlags Int
k

instance P.Ord DBusPropertyInfoFlags where
    compare :: DBusPropertyInfoFlags -> DBusPropertyInfoFlags -> Ordering
compare DBusPropertyInfoFlags
a DBusPropertyInfoFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DBusPropertyInfoFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusPropertyInfoFlags
a) (DBusPropertyInfoFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusPropertyInfoFlags
b)

type instance O.ParentTypes DBusPropertyInfoFlags = '[]
instance O.HasParentTypes DBusPropertyInfoFlags

foreign import ccall "g_dbus_property_info_flags_get_type" c_g_dbus_property_info_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DBusPropertyInfoFlags where
    glibType :: IO GType
glibType = IO GType
c_g_dbus_property_info_flags_get_type

instance B.Types.BoxedFlags DBusPropertyInfoFlags

instance IsGFlag DBusPropertyInfoFlags

-- Flags DBusObjectManagerClientFlags
-- | Flags used when constructing a t'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 (Int -> DBusObjectManagerClientFlags -> ShowS
[DBusObjectManagerClientFlags] -> ShowS
DBusObjectManagerClientFlags -> String
(Int -> DBusObjectManagerClientFlags -> ShowS)
-> (DBusObjectManagerClientFlags -> String)
-> ([DBusObjectManagerClientFlags] -> ShowS)
-> Show DBusObjectManagerClientFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DBusObjectManagerClientFlags] -> ShowS
$cshowList :: [DBusObjectManagerClientFlags] -> ShowS
show :: DBusObjectManagerClientFlags -> String
$cshow :: DBusObjectManagerClientFlags -> String
showsPrec :: Int -> DBusObjectManagerClientFlags -> ShowS
$cshowsPrec :: Int -> DBusObjectManagerClientFlags -> ShowS
Show, DBusObjectManagerClientFlags
-> DBusObjectManagerClientFlags -> Bool
(DBusObjectManagerClientFlags
 -> DBusObjectManagerClientFlags -> Bool)
-> (DBusObjectManagerClientFlags
    -> DBusObjectManagerClientFlags -> Bool)
-> Eq DBusObjectManagerClientFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBusObjectManagerClientFlags
-> DBusObjectManagerClientFlags -> Bool
$c/= :: DBusObjectManagerClientFlags
-> DBusObjectManagerClientFlags -> Bool
== :: DBusObjectManagerClientFlags
-> DBusObjectManagerClientFlags -> Bool
$c== :: DBusObjectManagerClientFlags
-> DBusObjectManagerClientFlags -> Bool
Eq)

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

    toEnum :: Int -> DBusObjectManagerClientFlags
toEnum Int
0 = DBusObjectManagerClientFlags
DBusObjectManagerClientFlagsNone
    toEnum Int
1 = DBusObjectManagerClientFlags
DBusObjectManagerClientFlagsDoNotAutoStart
    toEnum Int
k = Int -> DBusObjectManagerClientFlags
AnotherDBusObjectManagerClientFlags Int
k

instance P.Ord DBusObjectManagerClientFlags where
    compare :: DBusObjectManagerClientFlags
-> DBusObjectManagerClientFlags -> Ordering
compare DBusObjectManagerClientFlags
a DBusObjectManagerClientFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DBusObjectManagerClientFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusObjectManagerClientFlags
a) (DBusObjectManagerClientFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusObjectManagerClientFlags
b)

type instance O.ParentTypes DBusObjectManagerClientFlags = '[]
instance O.HasParentTypes DBusObjectManagerClientFlags

foreign import ccall "g_dbus_object_manager_client_flags_get_type" c_g_dbus_object_manager_client_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DBusObjectManagerClientFlags where
    glibType :: IO GType
glibType = IO GType
c_g_dbus_object_manager_client_flags_get_type

instance B.Types.BoxedFlags DBusObjectManagerClientFlags

instance IsGFlag DBusObjectManagerClientFlags

-- Flags DBusMessageFlags
-- | Message flags used in t'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 (Int -> DBusMessageFlags -> ShowS
[DBusMessageFlags] -> ShowS
DBusMessageFlags -> String
(Int -> DBusMessageFlags -> ShowS)
-> (DBusMessageFlags -> String)
-> ([DBusMessageFlags] -> ShowS)
-> Show DBusMessageFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DBusMessageFlags] -> ShowS
$cshowList :: [DBusMessageFlags] -> ShowS
show :: DBusMessageFlags -> String
$cshow :: DBusMessageFlags -> String
showsPrec :: Int -> DBusMessageFlags -> ShowS
$cshowsPrec :: Int -> DBusMessageFlags -> ShowS
Show, DBusMessageFlags -> DBusMessageFlags -> Bool
(DBusMessageFlags -> DBusMessageFlags -> Bool)
-> (DBusMessageFlags -> DBusMessageFlags -> Bool)
-> Eq DBusMessageFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBusMessageFlags -> DBusMessageFlags -> Bool
$c/= :: DBusMessageFlags -> DBusMessageFlags -> Bool
== :: DBusMessageFlags -> DBusMessageFlags -> Bool
$c== :: DBusMessageFlags -> DBusMessageFlags -> Bool
Eq)

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

    toEnum :: Int -> DBusMessageFlags
toEnum Int
0 = DBusMessageFlags
DBusMessageFlagsNone
    toEnum Int
1 = DBusMessageFlags
DBusMessageFlagsNoReplyExpected
    toEnum Int
2 = DBusMessageFlags
DBusMessageFlagsNoAutoStart
    toEnum Int
4 = DBusMessageFlags
DBusMessageFlagsAllowInteractiveAuthorization
    toEnum Int
k = Int -> DBusMessageFlags
AnotherDBusMessageFlags Int
k

instance P.Ord DBusMessageFlags where
    compare :: DBusMessageFlags -> DBusMessageFlags -> Ordering
compare DBusMessageFlags
a DBusMessageFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DBusMessageFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusMessageFlags
a) (DBusMessageFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusMessageFlags
b)

type instance O.ParentTypes DBusMessageFlags = '[]
instance O.HasParentTypes DBusMessageFlags

foreign import ccall "g_dbus_message_flags_get_type" c_g_dbus_message_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DBusMessageFlags where
    glibType :: IO GType
glibType = IO GType
c_g_dbus_message_flags_get_type

instance B.Types.BoxedFlags DBusMessageFlags

instance IsGFlag DBusMessageFlags

-- Flags DBusInterfaceSkeletonFlags
-- | Flags describing the behavior of a t'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 (Int -> DBusInterfaceSkeletonFlags -> ShowS
[DBusInterfaceSkeletonFlags] -> ShowS
DBusInterfaceSkeletonFlags -> String
(Int -> DBusInterfaceSkeletonFlags -> ShowS)
-> (DBusInterfaceSkeletonFlags -> String)
-> ([DBusInterfaceSkeletonFlags] -> ShowS)
-> Show DBusInterfaceSkeletonFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DBusInterfaceSkeletonFlags] -> ShowS
$cshowList :: [DBusInterfaceSkeletonFlags] -> ShowS
show :: DBusInterfaceSkeletonFlags -> String
$cshow :: DBusInterfaceSkeletonFlags -> String
showsPrec :: Int -> DBusInterfaceSkeletonFlags -> ShowS
$cshowsPrec :: Int -> DBusInterfaceSkeletonFlags -> ShowS
Show, DBusInterfaceSkeletonFlags -> DBusInterfaceSkeletonFlags -> Bool
(DBusInterfaceSkeletonFlags -> DBusInterfaceSkeletonFlags -> Bool)
-> (DBusInterfaceSkeletonFlags
    -> DBusInterfaceSkeletonFlags -> Bool)
-> Eq DBusInterfaceSkeletonFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBusInterfaceSkeletonFlags -> DBusInterfaceSkeletonFlags -> Bool
$c/= :: DBusInterfaceSkeletonFlags -> DBusInterfaceSkeletonFlags -> Bool
== :: DBusInterfaceSkeletonFlags -> DBusInterfaceSkeletonFlags -> Bool
$c== :: DBusInterfaceSkeletonFlags -> DBusInterfaceSkeletonFlags -> Bool
Eq)

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

    toEnum :: Int -> DBusInterfaceSkeletonFlags
toEnum Int
0 = DBusInterfaceSkeletonFlags
DBusInterfaceSkeletonFlagsNone
    toEnum Int
1 = DBusInterfaceSkeletonFlags
DBusInterfaceSkeletonFlagsHandleMethodInvocationsInThread
    toEnum Int
k = Int -> DBusInterfaceSkeletonFlags
AnotherDBusInterfaceSkeletonFlags Int
k

instance P.Ord DBusInterfaceSkeletonFlags where
    compare :: DBusInterfaceSkeletonFlags
-> DBusInterfaceSkeletonFlags -> Ordering
compare DBusInterfaceSkeletonFlags
a DBusInterfaceSkeletonFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DBusInterfaceSkeletonFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusInterfaceSkeletonFlags
a) (DBusInterfaceSkeletonFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusInterfaceSkeletonFlags
b)

type instance O.ParentTypes DBusInterfaceSkeletonFlags = '[]
instance O.HasParentTypes DBusInterfaceSkeletonFlags

foreign import ccall "g_dbus_interface_skeleton_flags_get_type" c_g_dbus_interface_skeleton_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DBusInterfaceSkeletonFlags where
    glibType :: IO GType
glibType = IO GType
c_g_dbus_interface_skeleton_flags_get_type

instance B.Types.BoxedFlags DBusInterfaceSkeletonFlags

instance IsGFlag DBusInterfaceSkeletonFlags

-- Flags DBusConnectionFlags
-- | Flags used when creating a new t'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 (Int -> DBusConnectionFlags -> ShowS
[DBusConnectionFlags] -> ShowS
DBusConnectionFlags -> String
(Int -> DBusConnectionFlags -> ShowS)
-> (DBusConnectionFlags -> String)
-> ([DBusConnectionFlags] -> ShowS)
-> Show DBusConnectionFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DBusConnectionFlags] -> ShowS
$cshowList :: [DBusConnectionFlags] -> ShowS
show :: DBusConnectionFlags -> String
$cshow :: DBusConnectionFlags -> String
showsPrec :: Int -> DBusConnectionFlags -> ShowS
$cshowsPrec :: Int -> DBusConnectionFlags -> ShowS
Show, DBusConnectionFlags -> DBusConnectionFlags -> Bool
(DBusConnectionFlags -> DBusConnectionFlags -> Bool)
-> (DBusConnectionFlags -> DBusConnectionFlags -> Bool)
-> Eq DBusConnectionFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBusConnectionFlags -> DBusConnectionFlags -> Bool
$c/= :: DBusConnectionFlags -> DBusConnectionFlags -> Bool
== :: DBusConnectionFlags -> DBusConnectionFlags -> Bool
$c== :: DBusConnectionFlags -> DBusConnectionFlags -> Bool
Eq)

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

    toEnum :: Int -> DBusConnectionFlags
toEnum Int
0 = DBusConnectionFlags
DBusConnectionFlagsNone
    toEnum Int
1 = DBusConnectionFlags
DBusConnectionFlagsAuthenticationClient
    toEnum Int
2 = DBusConnectionFlags
DBusConnectionFlagsAuthenticationServer
    toEnum Int
4 = DBusConnectionFlags
DBusConnectionFlagsAuthenticationAllowAnonymous
    toEnum Int
8 = DBusConnectionFlags
DBusConnectionFlagsMessageBusConnection
    toEnum Int
16 = DBusConnectionFlags
DBusConnectionFlagsDelayMessageProcessing
    toEnum Int
k = Int -> DBusConnectionFlags
AnotherDBusConnectionFlags Int
k

instance P.Ord DBusConnectionFlags where
    compare :: DBusConnectionFlags -> DBusConnectionFlags -> Ordering
compare DBusConnectionFlags
a DBusConnectionFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DBusConnectionFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusConnectionFlags
a) (DBusConnectionFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusConnectionFlags
b)

type instance O.ParentTypes DBusConnectionFlags = '[]
instance O.HasParentTypes DBusConnectionFlags

foreign import ccall "g_dbus_connection_flags_get_type" c_g_dbus_connection_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DBusConnectionFlags where
    glibType :: IO GType
glibType = IO GType
c_g_dbus_connection_flags_get_type

instance B.Types.BoxedFlags DBusConnectionFlags

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 (Int -> DBusCapabilityFlags -> ShowS
[DBusCapabilityFlags] -> ShowS
DBusCapabilityFlags -> String
(Int -> DBusCapabilityFlags -> ShowS)
-> (DBusCapabilityFlags -> String)
-> ([DBusCapabilityFlags] -> ShowS)
-> Show DBusCapabilityFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DBusCapabilityFlags] -> ShowS
$cshowList :: [DBusCapabilityFlags] -> ShowS
show :: DBusCapabilityFlags -> String
$cshow :: DBusCapabilityFlags -> String
showsPrec :: Int -> DBusCapabilityFlags -> ShowS
$cshowsPrec :: Int -> DBusCapabilityFlags -> ShowS
Show, DBusCapabilityFlags -> DBusCapabilityFlags -> Bool
(DBusCapabilityFlags -> DBusCapabilityFlags -> Bool)
-> (DBusCapabilityFlags -> DBusCapabilityFlags -> Bool)
-> Eq DBusCapabilityFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBusCapabilityFlags -> DBusCapabilityFlags -> Bool
$c/= :: DBusCapabilityFlags -> DBusCapabilityFlags -> Bool
== :: DBusCapabilityFlags -> DBusCapabilityFlags -> Bool
$c== :: DBusCapabilityFlags -> DBusCapabilityFlags -> Bool
Eq)

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

    toEnum :: Int -> DBusCapabilityFlags
toEnum Int
0 = DBusCapabilityFlags
DBusCapabilityFlagsNone
    toEnum Int
1 = DBusCapabilityFlags
DBusCapabilityFlagsUnixFdPassing
    toEnum Int
k = Int -> DBusCapabilityFlags
AnotherDBusCapabilityFlags Int
k

instance P.Ord DBusCapabilityFlags where
    compare :: DBusCapabilityFlags -> DBusCapabilityFlags -> Ordering
compare DBusCapabilityFlags
a DBusCapabilityFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DBusCapabilityFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusCapabilityFlags
a) (DBusCapabilityFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusCapabilityFlags
b)

type instance O.ParentTypes DBusCapabilityFlags = '[]
instance O.HasParentTypes DBusCapabilityFlags

foreign import ccall "g_dbus_capability_flags_get_type" c_g_dbus_capability_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DBusCapabilityFlags where
    glibType :: IO GType
glibType = IO GType
c_g_dbus_capability_flags_get_type

instance B.Types.BoxedFlags DBusCapabilityFlags

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 (Int -> DBusCallFlags -> ShowS
[DBusCallFlags] -> ShowS
DBusCallFlags -> String
(Int -> DBusCallFlags -> ShowS)
-> (DBusCallFlags -> String)
-> ([DBusCallFlags] -> ShowS)
-> Show DBusCallFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DBusCallFlags] -> ShowS
$cshowList :: [DBusCallFlags] -> ShowS
show :: DBusCallFlags -> String
$cshow :: DBusCallFlags -> String
showsPrec :: Int -> DBusCallFlags -> ShowS
$cshowsPrec :: Int -> DBusCallFlags -> ShowS
Show, DBusCallFlags -> DBusCallFlags -> Bool
(DBusCallFlags -> DBusCallFlags -> Bool)
-> (DBusCallFlags -> DBusCallFlags -> Bool) -> Eq DBusCallFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBusCallFlags -> DBusCallFlags -> Bool
$c/= :: DBusCallFlags -> DBusCallFlags -> Bool
== :: DBusCallFlags -> DBusCallFlags -> Bool
$c== :: DBusCallFlags -> DBusCallFlags -> Bool
Eq)

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

    toEnum :: Int -> DBusCallFlags
toEnum Int
0 = DBusCallFlags
DBusCallFlagsNone
    toEnum Int
1 = DBusCallFlags
DBusCallFlagsNoAutoStart
    toEnum Int
2 = DBusCallFlags
DBusCallFlagsAllowInteractiveAuthorization
    toEnum Int
k = Int -> DBusCallFlags
AnotherDBusCallFlags Int
k

instance P.Ord DBusCallFlags where
    compare :: DBusCallFlags -> DBusCallFlags -> Ordering
compare DBusCallFlags
a DBusCallFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DBusCallFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusCallFlags
a) (DBusCallFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DBusCallFlags
b)

type instance O.ParentTypes DBusCallFlags = '[]
instance O.HasParentTypes DBusCallFlags

foreign import ccall "g_dbus_call_flags_get_type" c_g_dbus_call_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DBusCallFlags where
    glibType :: IO GType
glibType = IO GType
c_g_dbus_call_flags_get_type

instance B.Types.BoxedFlags DBusCallFlags

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 (Int -> ConverterFlags -> ShowS
[ConverterFlags] -> ShowS
ConverterFlags -> String
(Int -> ConverterFlags -> ShowS)
-> (ConverterFlags -> String)
-> ([ConverterFlags] -> ShowS)
-> Show ConverterFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConverterFlags] -> ShowS
$cshowList :: [ConverterFlags] -> ShowS
show :: ConverterFlags -> String
$cshow :: ConverterFlags -> String
showsPrec :: Int -> ConverterFlags -> ShowS
$cshowsPrec :: Int -> ConverterFlags -> ShowS
Show, ConverterFlags -> ConverterFlags -> Bool
(ConverterFlags -> ConverterFlags -> Bool)
-> (ConverterFlags -> ConverterFlags -> Bool) -> Eq ConverterFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConverterFlags -> ConverterFlags -> Bool
$c/= :: ConverterFlags -> ConverterFlags -> Bool
== :: ConverterFlags -> ConverterFlags -> Bool
$c== :: ConverterFlags -> ConverterFlags -> Bool
Eq)

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

    toEnum :: Int -> ConverterFlags
toEnum Int
0 = ConverterFlags
ConverterFlagsNone
    toEnum Int
1 = ConverterFlags
ConverterFlagsInputAtEnd
    toEnum Int
2 = ConverterFlags
ConverterFlagsFlush
    toEnum Int
k = Int -> ConverterFlags
AnotherConverterFlags Int
k

instance P.Ord ConverterFlags where
    compare :: ConverterFlags -> ConverterFlags -> Ordering
compare ConverterFlags
a ConverterFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ConverterFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ConverterFlags
a) (ConverterFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ConverterFlags
b)

type instance O.ParentTypes ConverterFlags = '[]
instance O.HasParentTypes ConverterFlags

foreign import ccall "g_converter_flags_get_type" c_g_converter_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ConverterFlags where
    glibType :: IO GType
glibType = IO GType
c_g_converter_flags_get_type

instance B.Types.BoxedFlags ConverterFlags

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 (Int -> BusNameWatcherFlags -> ShowS
[BusNameWatcherFlags] -> ShowS
BusNameWatcherFlags -> String
(Int -> BusNameWatcherFlags -> ShowS)
-> (BusNameWatcherFlags -> String)
-> ([BusNameWatcherFlags] -> ShowS)
-> Show BusNameWatcherFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BusNameWatcherFlags] -> ShowS
$cshowList :: [BusNameWatcherFlags] -> ShowS
show :: BusNameWatcherFlags -> String
$cshow :: BusNameWatcherFlags -> String
showsPrec :: Int -> BusNameWatcherFlags -> ShowS
$cshowsPrec :: Int -> BusNameWatcherFlags -> ShowS
Show, BusNameWatcherFlags -> BusNameWatcherFlags -> Bool
(BusNameWatcherFlags -> BusNameWatcherFlags -> Bool)
-> (BusNameWatcherFlags -> BusNameWatcherFlags -> Bool)
-> Eq BusNameWatcherFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BusNameWatcherFlags -> BusNameWatcherFlags -> Bool
$c/= :: BusNameWatcherFlags -> BusNameWatcherFlags -> Bool
== :: BusNameWatcherFlags -> BusNameWatcherFlags -> Bool
$c== :: BusNameWatcherFlags -> BusNameWatcherFlags -> Bool
Eq)

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

    toEnum :: Int -> BusNameWatcherFlags
toEnum Int
0 = BusNameWatcherFlags
BusNameWatcherFlagsNone
    toEnum Int
1 = BusNameWatcherFlags
BusNameWatcherFlagsAutoStart
    toEnum Int
k = Int -> BusNameWatcherFlags
AnotherBusNameWatcherFlags Int
k

instance P.Ord BusNameWatcherFlags where
    compare :: BusNameWatcherFlags -> BusNameWatcherFlags -> Ordering
compare BusNameWatcherFlags
a BusNameWatcherFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BusNameWatcherFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum BusNameWatcherFlags
a) (BusNameWatcherFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum BusNameWatcherFlags
b)

type instance O.ParentTypes BusNameWatcherFlags = '[]
instance O.HasParentTypes BusNameWatcherFlags

foreign import ccall "g_bus_name_watcher_flags_get_type" c_g_bus_name_watcher_flags_get_type :: 
    IO GType

instance B.Types.TypedObject BusNameWatcherFlags where
    glibType :: IO GType
glibType = IO GType
c_g_bus_name_watcher_flags_get_type

instance B.Types.BoxedFlags BusNameWatcherFlags

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 (Int -> BusNameOwnerFlags -> ShowS
[BusNameOwnerFlags] -> ShowS
BusNameOwnerFlags -> String
(Int -> BusNameOwnerFlags -> ShowS)
-> (BusNameOwnerFlags -> String)
-> ([BusNameOwnerFlags] -> ShowS)
-> Show BusNameOwnerFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BusNameOwnerFlags] -> ShowS
$cshowList :: [BusNameOwnerFlags] -> ShowS
show :: BusNameOwnerFlags -> String
$cshow :: BusNameOwnerFlags -> String
showsPrec :: Int -> BusNameOwnerFlags -> ShowS
$cshowsPrec :: Int -> BusNameOwnerFlags -> ShowS
Show, BusNameOwnerFlags -> BusNameOwnerFlags -> Bool
(BusNameOwnerFlags -> BusNameOwnerFlags -> Bool)
-> (BusNameOwnerFlags -> BusNameOwnerFlags -> Bool)
-> Eq BusNameOwnerFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BusNameOwnerFlags -> BusNameOwnerFlags -> Bool
$c/= :: BusNameOwnerFlags -> BusNameOwnerFlags -> Bool
== :: BusNameOwnerFlags -> BusNameOwnerFlags -> Bool
$c== :: BusNameOwnerFlags -> BusNameOwnerFlags -> Bool
Eq)

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

    toEnum :: Int -> BusNameOwnerFlags
toEnum Int
0 = BusNameOwnerFlags
BusNameOwnerFlagsNone
    toEnum Int
1 = BusNameOwnerFlags
BusNameOwnerFlagsAllowReplacement
    toEnum Int
2 = BusNameOwnerFlags
BusNameOwnerFlagsReplace
    toEnum Int
4 = BusNameOwnerFlags
BusNameOwnerFlagsDoNotQueue
    toEnum Int
k = Int -> BusNameOwnerFlags
AnotherBusNameOwnerFlags Int
k

instance P.Ord BusNameOwnerFlags where
    compare :: BusNameOwnerFlags -> BusNameOwnerFlags -> Ordering
compare BusNameOwnerFlags
a BusNameOwnerFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BusNameOwnerFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum BusNameOwnerFlags
a) (BusNameOwnerFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum BusNameOwnerFlags
b)

type instance O.ParentTypes BusNameOwnerFlags = '[]
instance O.HasParentTypes BusNameOwnerFlags

foreign import ccall "g_bus_name_owner_flags_get_type" c_g_bus_name_owner_flags_get_type :: 
    IO GType

instance B.Types.TypedObject BusNameOwnerFlags where
    glibType :: IO GType
glibType = IO GType
c_g_bus_name_owner_flags_get_type

instance B.Types.BoxedFlags BusNameOwnerFlags

instance IsGFlag BusNameOwnerFlags

-- Flags AskPasswordFlags
-- | t'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 (Int -> AskPasswordFlags -> ShowS
[AskPasswordFlags] -> ShowS
AskPasswordFlags -> String
(Int -> AskPasswordFlags -> ShowS)
-> (AskPasswordFlags -> String)
-> ([AskPasswordFlags] -> ShowS)
-> Show AskPasswordFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AskPasswordFlags] -> ShowS
$cshowList :: [AskPasswordFlags] -> ShowS
show :: AskPasswordFlags -> String
$cshow :: AskPasswordFlags -> String
showsPrec :: Int -> AskPasswordFlags -> ShowS
$cshowsPrec :: Int -> AskPasswordFlags -> ShowS
Show, AskPasswordFlags -> AskPasswordFlags -> Bool
(AskPasswordFlags -> AskPasswordFlags -> Bool)
-> (AskPasswordFlags -> AskPasswordFlags -> Bool)
-> Eq AskPasswordFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AskPasswordFlags -> AskPasswordFlags -> Bool
$c/= :: AskPasswordFlags -> AskPasswordFlags -> Bool
== :: AskPasswordFlags -> AskPasswordFlags -> Bool
$c== :: AskPasswordFlags -> AskPasswordFlags -> Bool
Eq)

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

    toEnum :: Int -> AskPasswordFlags
toEnum Int
1 = AskPasswordFlags
AskPasswordFlagsNeedPassword
    toEnum Int
2 = AskPasswordFlags
AskPasswordFlagsNeedUsername
    toEnum Int
4 = AskPasswordFlags
AskPasswordFlagsNeedDomain
    toEnum Int
8 = AskPasswordFlags
AskPasswordFlagsSavingSupported
    toEnum Int
16 = AskPasswordFlags
AskPasswordFlagsAnonymousSupported
    toEnum Int
32 = AskPasswordFlags
AskPasswordFlagsTcrypt
    toEnum Int
k = Int -> AskPasswordFlags
AnotherAskPasswordFlags Int
k

instance P.Ord AskPasswordFlags where
    compare :: AskPasswordFlags -> AskPasswordFlags -> Ordering
compare AskPasswordFlags
a AskPasswordFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AskPasswordFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AskPasswordFlags
a) (AskPasswordFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AskPasswordFlags
b)

type instance O.ParentTypes AskPasswordFlags = '[]
instance O.HasParentTypes AskPasswordFlags

foreign import ccall "g_ask_password_flags_get_type" c_g_ask_password_flags_get_type :: 
    IO GType

instance B.Types.TypedObject AskPasswordFlags where
    glibType :: IO GType
glibType = IO GType
c_g_ask_password_flags_get_type

instance B.Types.BoxedFlags AskPasswordFlags

instance IsGFlag AskPasswordFlags

-- Flags ApplicationFlags
-- | Flags used to define the behaviour of a t'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 [commandLine]("GI.Gio.Objects.Application#g:signal:commandLine") 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 (Int -> ApplicationFlags -> ShowS
[ApplicationFlags] -> ShowS
ApplicationFlags -> String
(Int -> ApplicationFlags -> ShowS)
-> (ApplicationFlags -> String)
-> ([ApplicationFlags] -> ShowS)
-> Show ApplicationFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ApplicationFlags] -> ShowS
$cshowList :: [ApplicationFlags] -> ShowS
show :: ApplicationFlags -> String
$cshow :: ApplicationFlags -> String
showsPrec :: Int -> ApplicationFlags -> ShowS
$cshowsPrec :: Int -> ApplicationFlags -> ShowS
Show, ApplicationFlags -> ApplicationFlags -> Bool
(ApplicationFlags -> ApplicationFlags -> Bool)
-> (ApplicationFlags -> ApplicationFlags -> Bool)
-> Eq ApplicationFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ApplicationFlags -> ApplicationFlags -> Bool
$c/= :: ApplicationFlags -> ApplicationFlags -> Bool
== :: ApplicationFlags -> ApplicationFlags -> Bool
$c== :: ApplicationFlags -> ApplicationFlags -> Bool
Eq)

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

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

instance P.Ord ApplicationFlags where
    compare :: ApplicationFlags -> ApplicationFlags -> Ordering
compare ApplicationFlags
a ApplicationFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ApplicationFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ApplicationFlags
a) (ApplicationFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ApplicationFlags
b)

type instance O.ParentTypes ApplicationFlags = '[]
instance O.HasParentTypes ApplicationFlags

foreign import ccall "g_application_flags_get_type" c_g_application_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ApplicationFlags where
    glibType :: IO GType
glibType = IO GType
c_g_application_flags_get_type

instance B.Types.BoxedFlags ApplicationFlags

instance IsGFlag ApplicationFlags

-- Flags AppInfoCreateFlags
-- | Flags used when creating a t'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 (Int -> AppInfoCreateFlags -> ShowS
[AppInfoCreateFlags] -> ShowS
AppInfoCreateFlags -> String
(Int -> AppInfoCreateFlags -> ShowS)
-> (AppInfoCreateFlags -> String)
-> ([AppInfoCreateFlags] -> ShowS)
-> Show AppInfoCreateFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AppInfoCreateFlags] -> ShowS
$cshowList :: [AppInfoCreateFlags] -> ShowS
show :: AppInfoCreateFlags -> String
$cshow :: AppInfoCreateFlags -> String
showsPrec :: Int -> AppInfoCreateFlags -> ShowS
$cshowsPrec :: Int -> AppInfoCreateFlags -> ShowS
Show, AppInfoCreateFlags -> AppInfoCreateFlags -> Bool
(AppInfoCreateFlags -> AppInfoCreateFlags -> Bool)
-> (AppInfoCreateFlags -> AppInfoCreateFlags -> Bool)
-> Eq AppInfoCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AppInfoCreateFlags -> AppInfoCreateFlags -> Bool
$c/= :: AppInfoCreateFlags -> AppInfoCreateFlags -> Bool
== :: AppInfoCreateFlags -> AppInfoCreateFlags -> Bool
$c== :: AppInfoCreateFlags -> AppInfoCreateFlags -> Bool
Eq)

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

    toEnum :: Int -> AppInfoCreateFlags
toEnum Int
0 = AppInfoCreateFlags
AppInfoCreateFlagsNone
    toEnum Int
1 = AppInfoCreateFlags
AppInfoCreateFlagsNeedsTerminal
    toEnum Int
2 = AppInfoCreateFlags
AppInfoCreateFlagsSupportsUris
    toEnum Int
4 = AppInfoCreateFlags
AppInfoCreateFlagsSupportsStartupNotification
    toEnum Int
k = Int -> AppInfoCreateFlags
AnotherAppInfoCreateFlags Int
k

instance P.Ord AppInfoCreateFlags where
    compare :: AppInfoCreateFlags -> AppInfoCreateFlags -> Ordering
compare AppInfoCreateFlags
a AppInfoCreateFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AppInfoCreateFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AppInfoCreateFlags
a) (AppInfoCreateFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AppInfoCreateFlags
b)

type instance O.ParentTypes AppInfoCreateFlags = '[]
instance O.HasParentTypes AppInfoCreateFlags

foreign import ccall "g_app_info_create_flags_get_type" c_g_app_info_create_flags_get_type :: 
    IO GType

instance B.Types.TypedObject AppInfoCreateFlags where
    glibType :: IO GType
glibType = IO GType
c_g_app_info_create_flags_get_type

instance B.Types.BoxedFlags AppInfoCreateFlags

instance IsGFlag AppInfoCreateFlags