-- | 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.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 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 TlsPasswordFlagsNone = 0
    fromEnum TlsPasswordFlagsRetry = 2
    fromEnum TlsPasswordFlagsManyTries = 4
    fromEnum TlsPasswordFlagsFinalTry = 8
    fromEnum (AnotherTlsPasswordFlags k :: Int
k) = Int
k

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

instance P.Ord TlsPasswordFlags where
    compare :: TlsPasswordFlags -> TlsPasswordFlags -> Ordering
compare a :: TlsPasswordFlags
a b :: 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)

foreign import ccall "g_tls_password_flags_get_type" c_g_tls_password_flags_get_type :: 
    IO GType

instance BoxedFlags TlsPasswordFlags where
    boxedFlagsType :: Proxy TlsPasswordFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_tls_password_flags_get_type

instance IsGFlag TlsPasswordFlags

-- Flags TlsDatabaseVerifyFlags
-- | Flags for 'GI.Gio.Objects.TlsDatabase.tlsDatabaseVerifyChain'.
-- 
-- /Since: 2.30/
data TlsDatabaseVerifyFlags = 
      TlsDatabaseVerifyFlagsNone
    -- ^ No verification flags
    | AnotherTlsDatabaseVerifyFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 TlsDatabaseVerifyFlagsNone = 0
    fromEnum (AnotherTlsDatabaseVerifyFlags k :: Int
k) = Int
k

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

instance P.Ord TlsDatabaseVerifyFlags where
    compare :: TlsDatabaseVerifyFlags -> TlsDatabaseVerifyFlags -> Ordering
compare a :: TlsDatabaseVerifyFlags
a b :: 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)

foreign import ccall "g_tls_database_verify_flags_get_type" c_g_tls_database_verify_flags_get_type :: 
    IO GType

instance BoxedFlags TlsDatabaseVerifyFlags where
    boxedFlagsType :: Proxy TlsDatabaseVerifyFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_tls_database_verify_flags_get_type

instance IsGFlag TlsDatabaseVerifyFlags

-- Flags TlsCertificateFlags
-- | A set of flags describing TLS certification validation. This can be
-- used to set which validation steps to perform (eg, with
-- 'GI.Gio.Interfaces.TlsClientConnection.tlsClientConnectionSetValidationFlags'), or to describe why
-- a particular certificate was rejected (eg, in
-- [acceptCertificate]("GI.Gio.Objects.TlsConnection#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 TlsCertificateFlagsUnknownCa = 1
    fromEnum TlsCertificateFlagsBadIdentity = 2
    fromEnum TlsCertificateFlagsNotActivated = 4
    fromEnum TlsCertificateFlagsExpired = 8
    fromEnum TlsCertificateFlagsRevoked = 16
    fromEnum TlsCertificateFlagsInsecure = 32
    fromEnum TlsCertificateFlagsGenericError = 64
    fromEnum TlsCertificateFlagsValidateAll = 127
    fromEnum (AnotherTlsCertificateFlags k :: Int
k) = Int
k

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

instance P.Ord TlsCertificateFlags where
    compare :: TlsCertificateFlags -> TlsCertificateFlags -> Ordering
compare a :: TlsCertificateFlags
a b :: 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)

foreign import ccall "g_tls_certificate_flags_get_type" c_g_tls_certificate_flags_get_type :: 
    IO GType

instance BoxedFlags TlsCertificateFlags where
    boxedFlagsType :: Proxy TlsCertificateFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_tls_certificate_flags_get_type

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 TestDBusFlagsNone = 0
    fromEnum (AnotherTestDBusFlags k :: Int
k) = Int
k

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

instance P.Ord TestDBusFlags where
    compare :: TestDBusFlags -> TestDBusFlags -> Ordering
compare a :: TestDBusFlags
a b :: 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)

foreign import ccall "g_test_dbus_flags_get_type" c_g_test_dbus_flags_get_type :: 
    IO GType

instance BoxedFlags TestDBusFlags where
    boxedFlagsType :: Proxy TestDBusFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_test_dbus_flags_get_type

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 SubprocessFlagsNone = 0
    fromEnum SubprocessFlagsStdinPipe = 1
    fromEnum SubprocessFlagsStdinInherit = 2
    fromEnum SubprocessFlagsStdoutPipe = 4
    fromEnum SubprocessFlagsStdoutSilence = 8
    fromEnum SubprocessFlagsStderrPipe = 16
    fromEnum SubprocessFlagsStderrSilence = 32
    fromEnum SubprocessFlagsStderrMerge = 64
    fromEnum SubprocessFlagsInheritFds = 128
    fromEnum (AnotherSubprocessFlags k :: Int
k) = Int
k

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

instance P.Ord SubprocessFlags where
    compare :: SubprocessFlags -> SubprocessFlags -> Ordering
compare a :: SubprocessFlags
a b :: 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)

foreign import ccall "g_subprocess_flags_get_type" c_g_subprocess_flags_get_type :: 
    IO GType

instance BoxedFlags SubprocessFlags where
    boxedFlagsType :: Proxy SubprocessFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_subprocess_flags_get_type

instance IsGFlag SubprocessFlags

-- Flags SocketMsgFlags
-- | Flags used in 'GI.Gio.Objects.Socket.socketReceiveMessage' and 'GI.Gio.Objects.Socket.socketSendMessage'.
-- The flags listed in the enum are some commonly available flags, but the
-- values used for them are the same as on the platform, and any other flags
-- are passed in\/out as is. So to use a platform specific flag, just include
-- the right system header and pass in the flag.
-- 
-- /Since: 2.22/
data SocketMsgFlags = 
      SocketMsgFlagsNone
    -- ^ No flags.
    | SocketMsgFlagsOob
    -- ^ Request to send\/receive out of band data.
    | SocketMsgFlagsPeek
    -- ^ Read data from the socket without removing it from
    --     the queue.
    | SocketMsgFlagsDontroute
    -- ^ Don\'t use a gateway to send out the packet,
    --     only send to hosts on directly connected networks.
    | AnotherSocketMsgFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 SocketMsgFlagsNone = 0
    fromEnum SocketMsgFlagsOob = 1
    fromEnum SocketMsgFlagsPeek = 2
    fromEnum SocketMsgFlagsDontroute = 4
    fromEnum (AnotherSocketMsgFlags k :: Int
k) = Int
k

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

instance P.Ord SocketMsgFlags where
    compare :: SocketMsgFlags -> SocketMsgFlags -> Ordering
compare a :: SocketMsgFlags
a b :: 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)

foreign import ccall "g_socket_msg_flags_get_type" c_g_socket_msg_flags_get_type :: 
    IO GType

instance BoxedFlags SocketMsgFlags where
    boxedFlagsType :: Proxy SocketMsgFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_socket_msg_flags_get_type

instance IsGFlag SocketMsgFlags

-- Flags SettingsBindFlags
-- | Flags used when creating a binding. These flags determine in which
-- direction the binding works. The default is to synchronize in both
-- directions.
data SettingsBindFlags = 
      SettingsBindFlagsDefault
    -- ^ Equivalent to @G_SETTINGS_BIND_GET|G_SETTINGS_BIND_SET@
    | SettingsBindFlagsGet
    -- ^ Update the 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 SettingsBindFlagsDefault = 0
    fromEnum SettingsBindFlagsGet = 1
    fromEnum SettingsBindFlagsSet = 2
    fromEnum SettingsBindFlagsNoSensitivity = 4
    fromEnum SettingsBindFlagsGetNoChanges = 8
    fromEnum SettingsBindFlagsInvertBoolean = 16
    fromEnum (AnotherSettingsBindFlags k :: Int
k) = Int
k

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

instance P.Ord SettingsBindFlags where
    compare :: SettingsBindFlags -> SettingsBindFlags -> Ordering
compare a :: SettingsBindFlags
a b :: 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)

foreign import ccall "g_settings_bind_flags_get_type" c_g_settings_bind_flags_get_type :: 
    IO GType

instance BoxedFlags SettingsBindFlags where
    boxedFlagsType :: Proxy SettingsBindFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_settings_bind_flags_get_type

instance IsGFlag SettingsBindFlags

-- Flags ResourceLookupFlags
-- | GResourceLookupFlags determine how resource path lookups are handled.
-- 
-- /Since: 2.32/
data ResourceLookupFlags = 
      ResourceLookupFlagsNone
    -- ^ No flags set.
    | AnotherResourceLookupFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 ResourceLookupFlagsNone = 0
    fromEnum (AnotherResourceLookupFlags k :: Int
k) = Int
k

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

instance P.Ord ResourceLookupFlags where
    compare :: ResourceLookupFlags -> ResourceLookupFlags -> Ordering
compare a :: ResourceLookupFlags
a b :: 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)

foreign import ccall "g_resource_lookup_flags_get_type" c_g_resource_lookup_flags_get_type :: 
    IO GType

instance BoxedFlags ResourceLookupFlags where
    boxedFlagsType :: Proxy ResourceLookupFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_resource_lookup_flags_get_type

instance IsGFlag ResourceLookupFlags

-- Flags ResourceFlags
-- | GResourceFlags give information about a particular file inside a resource
-- bundle.
-- 
-- /Since: 2.32/
data ResourceFlags = 
      ResourceFlagsNone
    -- ^ No flags set.
    | ResourceFlagsCompressed
    -- ^ The file is compressed.
    | AnotherResourceFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 ResourceFlagsNone = 0
    fromEnum ResourceFlagsCompressed = 1
    fromEnum (AnotherResourceFlags k :: Int
k) = Int
k

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

instance P.Ord ResourceFlags where
    compare :: ResourceFlags -> ResourceFlags -> Ordering
compare a :: ResourceFlags
a b :: 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)

foreign import ccall "g_resource_flags_get_type" c_g_resource_flags_get_type :: 
    IO GType

instance BoxedFlags ResourceFlags where
    boxedFlagsType :: Proxy ResourceFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_resource_flags_get_type

instance IsGFlag ResourceFlags

-- Flags ResolverNameLookupFlags
-- | Flags to modify lookup behavior.
-- 
-- /Since: 2.60/
data ResolverNameLookupFlags = 
      ResolverNameLookupFlagsDefault
    -- ^ default behavior (same as 'GI.Gio.Objects.Resolver.resolverLookupByName')
    | ResolverNameLookupFlagsIpv4Only
    -- ^ only resolve ipv4 addresses
    | ResolverNameLookupFlagsIpv6Only
    -- ^ only resolve ipv6 addresses
    | AnotherResolverNameLookupFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 ResolverNameLookupFlagsDefault = 0
    fromEnum ResolverNameLookupFlagsIpv4Only = 1
    fromEnum ResolverNameLookupFlagsIpv6Only = 2
    fromEnum (AnotherResolverNameLookupFlags k :: Int
k) = Int
k

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

instance P.Ord ResolverNameLookupFlags where
    compare :: ResolverNameLookupFlags -> ResolverNameLookupFlags -> Ordering
compare a :: ResolverNameLookupFlags
a b :: 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)

foreign import ccall "g_resolver_name_lookup_flags_get_type" c_g_resolver_name_lookup_flags_get_type :: 
    IO GType

instance BoxedFlags ResolverNameLookupFlags where
    boxedFlagsType :: Proxy ResolverNameLookupFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_resolver_name_lookup_flags_get_type

instance IsGFlag ResolverNameLookupFlags

-- Flags OutputStreamSpliceFlags
-- | GOutputStreamSpliceFlags determine how streams should be spliced.
data OutputStreamSpliceFlags = 
      OutputStreamSpliceFlagsNone
    -- ^ Do not close either stream.
    | OutputStreamSpliceFlagsCloseSource
    -- ^ Close the source stream after
    --     the splice.
    | OutputStreamSpliceFlagsCloseTarget
    -- ^ Close the target stream after
    --     the splice.
    | AnotherOutputStreamSpliceFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 OutputStreamSpliceFlagsNone = 0
    fromEnum OutputStreamSpliceFlagsCloseSource = 1
    fromEnum OutputStreamSpliceFlagsCloseTarget = 2
    fromEnum (AnotherOutputStreamSpliceFlags k :: Int
k) = Int
k

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

instance P.Ord OutputStreamSpliceFlags where
    compare :: OutputStreamSpliceFlags -> OutputStreamSpliceFlags -> Ordering
compare a :: OutputStreamSpliceFlags
a b :: 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)

foreign import ccall "g_output_stream_splice_flags_get_type" c_g_output_stream_splice_flags_get_type :: 
    IO GType

instance BoxedFlags OutputStreamSpliceFlags where
    boxedFlagsType :: Proxy OutputStreamSpliceFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_output_stream_splice_flags_get_type

instance IsGFlag OutputStreamSpliceFlags

-- Flags MountUnmountFlags
-- | Flags used when an unmounting a mount.
data MountUnmountFlags = 
      MountUnmountFlagsNone
    -- ^ No flags set.
    | MountUnmountFlagsForce
    -- ^ Unmount even if there are outstanding
    --  file operations on the mount.
    | AnotherMountUnmountFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 MountUnmountFlagsNone = 0
    fromEnum MountUnmountFlagsForce = 1
    fromEnum (AnotherMountUnmountFlags k :: Int
k) = Int
k

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

instance P.Ord MountUnmountFlags where
    compare :: MountUnmountFlags -> MountUnmountFlags -> Ordering
compare a :: MountUnmountFlags
a b :: 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)

foreign import ccall "g_mount_unmount_flags_get_type" c_g_mount_unmount_flags_get_type :: 
    IO GType

instance BoxedFlags MountUnmountFlags where
    boxedFlagsType :: Proxy MountUnmountFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_mount_unmount_flags_get_type

instance IsGFlag MountUnmountFlags

-- Flags MountMountFlags
-- | Flags used when mounting a mount.
data MountMountFlags = 
      MountMountFlagsNone
    -- ^ No flags set.
    | AnotherMountMountFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 MountMountFlagsNone = 0
    fromEnum (AnotherMountMountFlags k :: Int
k) = Int
k

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

instance P.Ord MountMountFlags where
    compare :: MountMountFlags -> MountMountFlags -> Ordering
compare a :: MountMountFlags
a b :: 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)

foreign import ccall "g_mount_mount_flags_get_type" c_g_mount_mount_flags_get_type :: 
    IO GType

instance BoxedFlags MountMountFlags where
    boxedFlagsType :: Proxy MountMountFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_mount_mount_flags_get_type

instance IsGFlag MountMountFlags

-- Flags IOStreamSpliceFlags
-- | GIOStreamSpliceFlags determine how streams should be spliced.
-- 
-- /Since: 2.28/
data IOStreamSpliceFlags = 
      IOStreamSpliceFlagsNone
    -- ^ Do not close either stream.
    | IOStreamSpliceFlagsCloseStream1
    -- ^ Close the first stream after
    --     the splice.
    | IOStreamSpliceFlagsCloseStream2
    -- ^ Close the second stream after
    --     the splice.
    | IOStreamSpliceFlagsWaitForBoth
    -- ^ Wait for both splice operations to finish
    --     before calling the callback.
    | AnotherIOStreamSpliceFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 IOStreamSpliceFlagsNone = 0
    fromEnum IOStreamSpliceFlagsCloseStream1 = 1
    fromEnum IOStreamSpliceFlagsCloseStream2 = 2
    fromEnum IOStreamSpliceFlagsWaitForBoth = 4
    fromEnum (AnotherIOStreamSpliceFlags k :: Int
k) = Int
k

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

instance P.Ord IOStreamSpliceFlags where
    compare :: IOStreamSpliceFlags -> IOStreamSpliceFlags -> Ordering
compare a :: IOStreamSpliceFlags
a b :: 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)

foreign import ccall "g_io_stream_splice_flags_get_type" c_g_io_stream_splice_flags_get_type :: 
    IO GType

instance BoxedFlags IOStreamSpliceFlags where
    boxedFlagsType :: Proxy IOStreamSpliceFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_io_stream_splice_flags_get_type

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 FileQueryInfoFlagsNone = 0
    fromEnum FileQueryInfoFlagsNofollowSymlinks = 1
    fromEnum (AnotherFileQueryInfoFlags k :: Int
k) = Int
k

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

instance P.Ord FileQueryInfoFlags where
    compare :: FileQueryInfoFlags -> FileQueryInfoFlags -> Ordering
compare a :: FileQueryInfoFlags
a b :: 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)

foreign import ccall "g_file_query_info_flags_get_type" c_g_file_query_info_flags_get_type :: 
    IO GType

instance BoxedFlags FileQueryInfoFlags where
    boxedFlagsType :: Proxy FileQueryInfoFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_file_query_info_flags_get_type

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 FileMonitorFlagsNone = 0
    fromEnum FileMonitorFlagsWatchMounts = 1
    fromEnum FileMonitorFlagsSendMoved = 2
    fromEnum FileMonitorFlagsWatchHardLinks = 4
    fromEnum FileMonitorFlagsWatchMoves = 8
    fromEnum (AnotherFileMonitorFlags k :: Int
k) = Int
k

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

instance P.Ord FileMonitorFlags where
    compare :: FileMonitorFlags -> FileMonitorFlags -> Ordering
compare a :: FileMonitorFlags
a b :: 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)

foreign import ccall "g_file_monitor_flags_get_type" c_g_file_monitor_flags_get_type :: 
    IO GType

instance BoxedFlags FileMonitorFlags where
    boxedFlagsType :: Proxy FileMonitorFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_file_monitor_flags_get_type

instance IsGFlag FileMonitorFlags

-- Flags FileMeasureFlags
-- | Flags that can be used with @/g_file_measure_disk_usage()/@.
-- 
-- /Since: 2.38/
data FileMeasureFlags = 
      FileMeasureFlagsNone
    -- ^ No flags set.
    | FileMeasureFlagsReportAnyError
    -- ^ Report any error encountered
    --   while traversing the directory tree.  Normally errors are only
    --   reported for the toplevel file.
    | FileMeasureFlagsApparentSize
    -- ^ Tally usage based on apparent file
    --   sizes.  Normally, the block-size is used, if available, as this is a
    --   more accurate representation of disk space used.
    --   Compare with @du --apparent-size@.
    | FileMeasureFlagsNoXdev
    -- ^ Do not cross mount point boundaries.
    --   Compare with @du -x@.
    | AnotherFileMeasureFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 FileMeasureFlagsNone = 0
    fromEnum FileMeasureFlagsReportAnyError = 2
    fromEnum FileMeasureFlagsApparentSize = 4
    fromEnum FileMeasureFlagsNoXdev = 8
    fromEnum (AnotherFileMeasureFlags k :: Int
k) = Int
k

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

instance P.Ord FileMeasureFlags where
    compare :: FileMeasureFlags -> FileMeasureFlags -> Ordering
compare a :: FileMeasureFlags
a b :: 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)

foreign import ccall "g_file_measure_flags_get_type" c_g_file_measure_flags_get_type :: 
    IO GType

instance BoxedFlags FileMeasureFlags where
    boxedFlagsType :: Proxy FileMeasureFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_file_measure_flags_get_type

instance IsGFlag FileMeasureFlags

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

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

instance P.Ord FileCreateFlags where
    compare :: FileCreateFlags -> FileCreateFlags -> Ordering
compare a :: FileCreateFlags
a b :: 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)

foreign import ccall "g_file_create_flags_get_type" c_g_file_create_flags_get_type :: 
    IO GType

instance BoxedFlags FileCreateFlags where
    boxedFlagsType :: Proxy FileCreateFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_file_create_flags_get_type

instance IsGFlag FileCreateFlags

-- Flags FileCopyFlags
-- | Flags used when copying or moving files.
data FileCopyFlags = 
      FileCopyFlagsNone
    -- ^ No flags set.
    | FileCopyFlagsOverwrite
    -- ^ Overwrite any existing files
    | FileCopyFlagsBackup
    -- ^ Make a backup of any existing files.
    | FileCopyFlagsNofollowSymlinks
    -- ^ Don\'t follow symlinks.
    | FileCopyFlagsAllMetadata
    -- ^ Copy all file metadata instead of just default set used for copy (see 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 FileCopyFlagsNone = 0
    fromEnum FileCopyFlagsOverwrite = 1
    fromEnum FileCopyFlagsBackup = 2
    fromEnum FileCopyFlagsNofollowSymlinks = 4
    fromEnum FileCopyFlagsAllMetadata = 8
    fromEnum FileCopyFlagsNoFallbackForMove = 16
    fromEnum FileCopyFlagsTargetDefaultPerms = 32
    fromEnum (AnotherFileCopyFlags k :: Int
k) = Int
k

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

instance P.Ord FileCopyFlags where
    compare :: FileCopyFlags -> FileCopyFlags -> Ordering
compare a :: FileCopyFlags
a b :: 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)

foreign import ccall "g_file_copy_flags_get_type" c_g_file_copy_flags_get_type :: 
    IO GType

instance BoxedFlags FileCopyFlags where
    boxedFlagsType :: Proxy FileCopyFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_file_copy_flags_get_type

instance IsGFlag FileCopyFlags

-- Flags FileAttributeInfoFlags
-- | Flags specifying the behaviour of an attribute.
data FileAttributeInfoFlags = 
      FileAttributeInfoFlagsNone
    -- ^ no flags set.
    | FileAttributeInfoFlagsCopyWithFile
    -- ^ copy the attribute values when the file is copied.
    | FileAttributeInfoFlagsCopyWhenMoved
    -- ^ copy the attribute values when the file is moved.
    | AnotherFileAttributeInfoFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 FileAttributeInfoFlagsNone = 0
    fromEnum FileAttributeInfoFlagsCopyWithFile = 1
    fromEnum FileAttributeInfoFlagsCopyWhenMoved = 2
    fromEnum (AnotherFileAttributeInfoFlags k :: Int
k) = Int
k

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

instance P.Ord FileAttributeInfoFlags where
    compare :: FileAttributeInfoFlags -> FileAttributeInfoFlags -> Ordering
compare a :: FileAttributeInfoFlags
a b :: 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)

foreign import ccall "g_file_attribute_info_flags_get_type" c_g_file_attribute_info_flags_get_type :: 
    IO GType

instance BoxedFlags FileAttributeInfoFlags where
    boxedFlagsType :: Proxy FileAttributeInfoFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_file_attribute_info_flags_get_type

instance IsGFlag FileAttributeInfoFlags

-- Flags DriveStartFlags
-- | Flags used when starting a drive.
-- 
-- /Since: 2.22/
data DriveStartFlags = 
      DriveStartFlagsNone
    -- ^ No flags set.
    | AnotherDriveStartFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 DriveStartFlagsNone = 0
    fromEnum (AnotherDriveStartFlags k :: Int
k) = Int
k

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

instance P.Ord DriveStartFlags where
    compare :: DriveStartFlags -> DriveStartFlags -> Ordering
compare a :: DriveStartFlags
a b :: 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)

foreign import ccall "g_drive_start_flags_get_type" c_g_drive_start_flags_get_type :: 
    IO GType

instance BoxedFlags DriveStartFlags where
    boxedFlagsType :: Proxy DriveStartFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_drive_start_flags_get_type

instance IsGFlag DriveStartFlags

-- Flags DBusSubtreeFlags
-- | Flags passed to 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.
-- 
-- /Since: 2.26/
data DBusSubtreeFlags = 
      DBusSubtreeFlagsNone
    -- ^ No flags set.
    | DBusSubtreeFlagsDispatchToUnenumeratedNodes
    -- ^ Method calls to objects not in the enumerated range
    --                                                       will still be dispatched. This is useful if you want
    --                                                       to dynamically spawn objects in the subtree.
    | AnotherDBusSubtreeFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 DBusSubtreeFlagsNone = 0
    fromEnum DBusSubtreeFlagsDispatchToUnenumeratedNodes = 1
    fromEnum (AnotherDBusSubtreeFlags k :: Int
k) = Int
k

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

instance P.Ord DBusSubtreeFlags where
    compare :: DBusSubtreeFlags -> DBusSubtreeFlags -> Ordering
compare a :: DBusSubtreeFlags
a b :: 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)

foreign import ccall "g_dbus_subtree_flags_get_type" c_g_dbus_subtree_flags_get_type :: 
    IO GType

instance BoxedFlags DBusSubtreeFlags where
    boxedFlagsType :: Proxy DBusSubtreeFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_dbus_subtree_flags_get_type

instance IsGFlag DBusSubtreeFlags

-- Flags DBusSignalFlags
-- | Flags used when subscribing to signals via 'GI.Gio.Objects.DBusConnection.dBusConnectionSignalSubscribe'.
-- 
-- /Since: 2.26/
data DBusSignalFlags = 
      DBusSignalFlagsNone
    -- ^ No flags set.
    | DBusSignalFlagsNoMatchRule
    -- ^ Don\'t actually send the AddMatch
    -- D-Bus call for this signal subscription.  This gives you more control
    -- over which match rules you add (but you must add them manually).
    | DBusSignalFlagsMatchArg0Namespace
    -- ^ Match first arguments that
    -- contain a bus or interface name with the given namespace.
    | DBusSignalFlagsMatchArg0Path
    -- ^ Match first arguments that
    -- contain an object path that is either equivalent to the given path,
    -- or one of the paths is a subpath of the other.
    | AnotherDBusSignalFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 DBusSignalFlagsNone = 0
    fromEnum DBusSignalFlagsNoMatchRule = 1
    fromEnum DBusSignalFlagsMatchArg0Namespace = 2
    fromEnum DBusSignalFlagsMatchArg0Path = 4
    fromEnum (AnotherDBusSignalFlags k :: Int
k) = Int
k

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

instance P.Ord DBusSignalFlags where
    compare :: DBusSignalFlags -> DBusSignalFlags -> Ordering
compare a :: DBusSignalFlags
a b :: 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)

foreign import ccall "g_dbus_signal_flags_get_type" c_g_dbus_signal_flags_get_type :: 
    IO GType

instance BoxedFlags DBusSignalFlags where
    boxedFlagsType :: Proxy DBusSignalFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_dbus_signal_flags_get_type

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#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 DBusServerFlagsNone = 0
    fromEnum DBusServerFlagsRunInThread = 1
    fromEnum DBusServerFlagsAuthenticationAllowAnonymous = 2
    fromEnum (AnotherDBusServerFlags k :: Int
k) = Int
k

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

instance P.Ord DBusServerFlags where
    compare :: DBusServerFlags -> DBusServerFlags -> Ordering
compare a :: DBusServerFlags
a b :: 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)

foreign import ccall "g_dbus_server_flags_get_type" c_g_dbus_server_flags_get_type :: 
    IO GType

instance BoxedFlags DBusServerFlags where
    boxedFlagsType :: Proxy DBusServerFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_dbus_server_flags_get_type

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 DBusSendMessageFlagsNone = 0
    fromEnum DBusSendMessageFlagsPreserveSerial = 1
    fromEnum (AnotherDBusSendMessageFlags k :: Int
k) = Int
k

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

instance P.Ord DBusSendMessageFlags where
    compare :: DBusSendMessageFlags -> DBusSendMessageFlags -> Ordering
compare a :: DBusSendMessageFlags
a b :: 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)

foreign import ccall "g_dbus_send_message_flags_get_type" c_g_dbus_send_message_flags_get_type :: 
    IO GType

instance BoxedFlags DBusSendMessageFlags where
    boxedFlagsType :: Proxy DBusSendMessageFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_dbus_send_message_flags_get_type

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#signal:gPropertiesChanged") signal. When the value is received the [gPropertiesChanged]("GI.Gio.Objects.DBusProxy#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 DBusProxyFlagsNone = 0
    fromEnum DBusProxyFlagsDoNotLoadProperties = 1
    fromEnum DBusProxyFlagsDoNotConnectSignals = 2
    fromEnum DBusProxyFlagsDoNotAutoStart = 4
    fromEnum DBusProxyFlagsGetInvalidatedProperties = 8
    fromEnum DBusProxyFlagsDoNotAutoStartAtConstruction = 16
    fromEnum (AnotherDBusProxyFlags k :: Int
k) = Int
k

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

instance P.Ord DBusProxyFlags where
    compare :: DBusProxyFlags -> DBusProxyFlags -> Ordering
compare a :: DBusProxyFlags
a b :: 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)

foreign import ccall "g_dbus_proxy_flags_get_type" c_g_dbus_proxy_flags_get_type :: 
    IO GType

instance BoxedFlags DBusProxyFlags where
    boxedFlagsType :: Proxy DBusProxyFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_dbus_proxy_flags_get_type

instance IsGFlag DBusProxyFlags

-- Flags DBusPropertyInfoFlags
-- | Flags describing the access control of a D-Bus property.
-- 
-- /Since: 2.26/
data DBusPropertyInfoFlags = 
      DBusPropertyInfoFlagsNone
    -- ^ No flags set.
    | DBusPropertyInfoFlagsReadable
    -- ^ Property is readable.
    | DBusPropertyInfoFlagsWritable
    -- ^ Property is writable.
    | AnotherDBusPropertyInfoFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 DBusPropertyInfoFlagsNone = 0
    fromEnum DBusPropertyInfoFlagsReadable = 1
    fromEnum DBusPropertyInfoFlagsWritable = 2
    fromEnum (AnotherDBusPropertyInfoFlags k :: Int
k) = Int
k

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

instance P.Ord DBusPropertyInfoFlags where
    compare :: DBusPropertyInfoFlags -> DBusPropertyInfoFlags -> Ordering
compare a :: DBusPropertyInfoFlags
a b :: 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)

foreign import ccall "g_dbus_property_info_flags_get_type" c_g_dbus_property_info_flags_get_type :: 
    IO GType

instance BoxedFlags DBusPropertyInfoFlags where
    boxedFlagsType :: Proxy DBusPropertyInfoFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_dbus_property_info_flags_get_type

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 DBusObjectManagerClientFlagsNone = 0
    fromEnum DBusObjectManagerClientFlagsDoNotAutoStart = 1
    fromEnum (AnotherDBusObjectManagerClientFlags k :: Int
k) = Int
k

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

instance P.Ord DBusObjectManagerClientFlags where
    compare :: DBusObjectManagerClientFlags
-> DBusObjectManagerClientFlags -> Ordering
compare a :: DBusObjectManagerClientFlags
a b :: 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)

foreign import ccall "g_dbus_object_manager_client_flags_get_type" c_g_dbus_object_manager_client_flags_get_type :: 
    IO GType

instance BoxedFlags DBusObjectManagerClientFlags where
    boxedFlagsType :: Proxy DBusObjectManagerClientFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_dbus_object_manager_client_flags_get_type

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 DBusMessageFlagsNone = 0
    fromEnum DBusMessageFlagsNoReplyExpected = 1
    fromEnum DBusMessageFlagsNoAutoStart = 2
    fromEnum DBusMessageFlagsAllowInteractiveAuthorization = 4
    fromEnum (AnotherDBusMessageFlags k :: Int
k) = Int
k

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

instance P.Ord DBusMessageFlags where
    compare :: DBusMessageFlags -> DBusMessageFlags -> Ordering
compare a :: DBusMessageFlags
a b :: 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)

foreign import ccall "g_dbus_message_flags_get_type" c_g_dbus_message_flags_get_type :: 
    IO GType

instance BoxedFlags DBusMessageFlags where
    boxedFlagsType :: Proxy DBusMessageFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_dbus_message_flags_get_type

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 DBusInterfaceSkeletonFlagsNone = 0
    fromEnum DBusInterfaceSkeletonFlagsHandleMethodInvocationsInThread = 1
    fromEnum (AnotherDBusInterfaceSkeletonFlags k :: Int
k) = Int
k

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

instance P.Ord DBusInterfaceSkeletonFlags where
    compare :: DBusInterfaceSkeletonFlags
-> DBusInterfaceSkeletonFlags -> Ordering
compare a :: DBusInterfaceSkeletonFlags
a b :: 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)

foreign import ccall "g_dbus_interface_skeleton_flags_get_type" c_g_dbus_interface_skeleton_flags_get_type :: 
    IO GType

instance BoxedFlags DBusInterfaceSkeletonFlags where
    boxedFlagsType :: Proxy DBusInterfaceSkeletonFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_dbus_interface_skeleton_flags_get_type

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 DBusConnectionFlagsNone = 0
    fromEnum DBusConnectionFlagsAuthenticationClient = 1
    fromEnum DBusConnectionFlagsAuthenticationServer = 2
    fromEnum DBusConnectionFlagsAuthenticationAllowAnonymous = 4
    fromEnum DBusConnectionFlagsMessageBusConnection = 8
    fromEnum DBusConnectionFlagsDelayMessageProcessing = 16
    fromEnum (AnotherDBusConnectionFlags k :: Int
k) = Int
k

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

instance P.Ord DBusConnectionFlags where
    compare :: DBusConnectionFlags -> DBusConnectionFlags -> Ordering
compare a :: DBusConnectionFlags
a b :: 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)

foreign import ccall "g_dbus_connection_flags_get_type" c_g_dbus_connection_flags_get_type :: 
    IO GType

instance BoxedFlags DBusConnectionFlags where
    boxedFlagsType :: Proxy DBusConnectionFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_dbus_connection_flags_get_type

instance IsGFlag DBusConnectionFlags

-- Flags DBusCapabilityFlags
-- | Capabilities negotiated with the remote peer.
-- 
-- /Since: 2.26/
data DBusCapabilityFlags = 
      DBusCapabilityFlagsNone
    -- ^ No flags set.
    | DBusCapabilityFlagsUnixFdPassing
    -- ^ The connection
    -- supports exchanging UNIX file descriptors with the remote peer.
    | AnotherDBusCapabilityFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 DBusCapabilityFlagsNone = 0
    fromEnum DBusCapabilityFlagsUnixFdPassing = 1
    fromEnum (AnotherDBusCapabilityFlags k :: Int
k) = Int
k

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

instance P.Ord DBusCapabilityFlags where
    compare :: DBusCapabilityFlags -> DBusCapabilityFlags -> Ordering
compare a :: DBusCapabilityFlags
a b :: 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)

foreign import ccall "g_dbus_capability_flags_get_type" c_g_dbus_capability_flags_get_type :: 
    IO GType

instance BoxedFlags DBusCapabilityFlags where
    boxedFlagsType :: Proxy DBusCapabilityFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_dbus_capability_flags_get_type

instance IsGFlag DBusCapabilityFlags

-- Flags DBusCallFlags
-- | Flags used in 'GI.Gio.Objects.DBusConnection.dBusConnectionCall' and similar APIs.
-- 
-- /Since: 2.26/
data DBusCallFlags = 
      DBusCallFlagsNone
    -- ^ No flags set.
    | DBusCallFlagsNoAutoStart
    -- ^ The bus must not launch
    -- an owner for the destination name in response to this method
    -- invocation.
    | DBusCallFlagsAllowInteractiveAuthorization
    -- ^ the caller is prepared to
    -- wait for interactive authorization. Since 2.46.
    | AnotherDBusCallFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 DBusCallFlagsNone = 0
    fromEnum DBusCallFlagsNoAutoStart = 1
    fromEnum DBusCallFlagsAllowInteractiveAuthorization = 2
    fromEnum (AnotherDBusCallFlags k :: Int
k) = Int
k

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

instance P.Ord DBusCallFlags where
    compare :: DBusCallFlags -> DBusCallFlags -> Ordering
compare a :: DBusCallFlags
a b :: 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)

foreign import ccall "g_dbus_call_flags_get_type" c_g_dbus_call_flags_get_type :: 
    IO GType

instance BoxedFlags DBusCallFlags where
    boxedFlagsType :: Proxy DBusCallFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_dbus_call_flags_get_type

instance IsGFlag DBusCallFlags

-- Flags ConverterFlags
-- | Flags used when calling a 'GI.Gio.Interfaces.Converter.converterConvert'.
-- 
-- /Since: 2.24/
data ConverterFlags = 
      ConverterFlagsNone
    -- ^ No flags.
    | ConverterFlagsInputAtEnd
    -- ^ At end of input data
    | ConverterFlagsFlush
    -- ^ Flush data
    | AnotherConverterFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 ConverterFlagsNone = 0
    fromEnum ConverterFlagsInputAtEnd = 1
    fromEnum ConverterFlagsFlush = 2
    fromEnum (AnotherConverterFlags k :: Int
k) = Int
k

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

instance P.Ord ConverterFlags where
    compare :: ConverterFlags -> ConverterFlags -> Ordering
compare a :: ConverterFlags
a b :: 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)

foreign import ccall "g_converter_flags_get_type" c_g_converter_flags_get_type :: 
    IO GType

instance BoxedFlags ConverterFlags where
    boxedFlagsType :: Proxy ConverterFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_converter_flags_get_type

instance IsGFlag ConverterFlags

-- Flags BusNameWatcherFlags
-- | Flags used in @/g_bus_watch_name()/@.
-- 
-- /Since: 2.26/
data BusNameWatcherFlags = 
      BusNameWatcherFlagsNone
    -- ^ No flags set.
    | BusNameWatcherFlagsAutoStart
    -- ^ If no-one owns the name when
    -- beginning to watch the name, ask the bus to launch an owner for the
    -- name.
    | AnotherBusNameWatcherFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 BusNameWatcherFlagsNone = 0
    fromEnum BusNameWatcherFlagsAutoStart = 1
    fromEnum (AnotherBusNameWatcherFlags k :: Int
k) = Int
k

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

instance P.Ord BusNameWatcherFlags where
    compare :: BusNameWatcherFlags -> BusNameWatcherFlags -> Ordering
compare a :: BusNameWatcherFlags
a b :: 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)

foreign import ccall "g_bus_name_watcher_flags_get_type" c_g_bus_name_watcher_flags_get_type :: 
    IO GType

instance BoxedFlags BusNameWatcherFlags where
    boxedFlagsType :: Proxy BusNameWatcherFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_bus_name_watcher_flags_get_type

instance IsGFlag BusNameWatcherFlags

-- Flags BusNameOwnerFlags
-- | Flags used in @/g_bus_own_name()/@.
-- 
-- /Since: 2.26/
data BusNameOwnerFlags = 
      BusNameOwnerFlagsNone
    -- ^ No flags set.
    | BusNameOwnerFlagsAllowReplacement
    -- ^ Allow another message bus connection to claim the name.
    | BusNameOwnerFlagsReplace
    -- ^ If another message bus connection owns the name and have
    -- specified @/G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT/@, then take the name from the other connection.
    | BusNameOwnerFlagsDoNotQueue
    -- ^ If another message bus connection owns the name, immediately
    -- return an error from @/g_bus_own_name()/@ rather than entering the waiting queue for that name. (Since 2.54)
    | AnotherBusNameOwnerFlags Int
    -- ^ Catch-all for unknown values
    deriving (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 BusNameOwnerFlagsNone = 0
    fromEnum BusNameOwnerFlagsAllowReplacement = 1
    fromEnum BusNameOwnerFlagsReplace = 2
    fromEnum BusNameOwnerFlagsDoNotQueue = 4
    fromEnum (AnotherBusNameOwnerFlags k :: Int
k) = Int
k

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

instance P.Ord BusNameOwnerFlags where
    compare :: BusNameOwnerFlags -> BusNameOwnerFlags -> Ordering
compare a :: BusNameOwnerFlags
a b :: 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)

foreign import ccall "g_bus_name_owner_flags_get_type" c_g_bus_name_owner_flags_get_type :: 
    IO GType

instance BoxedFlags BusNameOwnerFlags where
    boxedFlagsType :: Proxy BusNameOwnerFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_bus_name_owner_flags_get_type

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 AskPasswordFlagsNeedPassword = 1
    fromEnum AskPasswordFlagsNeedUsername = 2
    fromEnum AskPasswordFlagsNeedDomain = 4
    fromEnum AskPasswordFlagsSavingSupported = 8
    fromEnum AskPasswordFlagsAnonymousSupported = 16
    fromEnum AskPasswordFlagsTcrypt = 32
    fromEnum (AnotherAskPasswordFlags k :: Int
k) = Int
k

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

instance P.Ord AskPasswordFlags where
    compare :: AskPasswordFlags -> AskPasswordFlags -> Ordering
compare a :: AskPasswordFlags
a b :: 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)

foreign import ccall "g_ask_password_flags_get_type" c_g_ask_password_flags_get_type :: 
    IO GType

instance BoxedFlags AskPasswordFlags where
    boxedFlagsType :: Proxy AskPasswordFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_ask_password_flags_get_type

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#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 ApplicationFlagsFlagsNone = 0
    fromEnum ApplicationFlagsIsService = 1
    fromEnum ApplicationFlagsIsLauncher = 2
    fromEnum ApplicationFlagsHandlesOpen = 4
    fromEnum ApplicationFlagsHandlesCommandLine = 8
    fromEnum ApplicationFlagsSendEnvironment = 16
    fromEnum ApplicationFlagsNonUnique = 32
    fromEnum ApplicationFlagsCanOverrideAppId = 64
    fromEnum ApplicationFlagsAllowReplacement = 128
    fromEnum ApplicationFlagsReplace = 256
    fromEnum (AnotherApplicationFlags k :: Int
k) = Int
k

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

instance P.Ord ApplicationFlags where
    compare :: ApplicationFlags -> ApplicationFlags -> Ordering
compare a :: ApplicationFlags
a b :: 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)

foreign import ccall "g_application_flags_get_type" c_g_application_flags_get_type :: 
    IO GType

instance BoxedFlags ApplicationFlags where
    boxedFlagsType :: Proxy ApplicationFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_application_flags_get_type

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 AppInfoCreateFlagsNone = 0
    fromEnum AppInfoCreateFlagsNeedsTerminal = 1
    fromEnum AppInfoCreateFlagsSupportsUris = 2
    fromEnum AppInfoCreateFlagsSupportsStartupNotification = 4
    fromEnum (AnotherAppInfoCreateFlags k :: Int
k) = Int
k

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

instance P.Ord AppInfoCreateFlags where
    compare :: AppInfoCreateFlags -> AppInfoCreateFlags -> Ordering
compare a :: AppInfoCreateFlags
a b :: 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)

foreign import ccall "g_app_info_create_flags_get_type" c_g_app_info_create_flags_get_type :: 
    IO GType

instance BoxedFlags AppInfoCreateFlags where
    boxedFlagsType :: Proxy AppInfoCreateFlags -> IO GType
boxedFlagsType _ = IO GType
c_g_app_info_create_flags_get_type

instance IsGFlag AppInfoCreateFlags