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

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gio.Flags
        (

     -- * Flags

    -- ** AppInfoCreateFlags #flag:AppInfoCreateFlags#

        AppInfoCreateFlags(..)                  ,

    -- ** ApplicationFlags #flag:ApplicationFlags#

        ApplicationFlags(..)                    ,

    -- ** AskPasswordFlags #flag:AskPasswordFlags#

        AskPasswordFlags(..)                    ,

    -- ** BusNameOwnerFlags #flag:BusNameOwnerFlags#

        BusNameOwnerFlags(..)                   ,

    -- ** BusNameWatcherFlags #flag:BusNameWatcherFlags#

        BusNameWatcherFlags(..)                 ,

    -- ** ConverterFlags #flag:ConverterFlags#

        ConverterFlags(..)                      ,

    -- ** DBusCallFlags #flag:DBusCallFlags#

        DBusCallFlags(..)                       ,

    -- ** DBusCapabilityFlags #flag:DBusCapabilityFlags#

        DBusCapabilityFlags(..)                 ,

    -- ** DBusConnectionFlags #flag:DBusConnectionFlags#

        DBusConnectionFlags(..)                 ,

    -- ** DBusInterfaceSkeletonFlags #flag:DBusInterfaceSkeletonFlags#

        DBusInterfaceSkeletonFlags(..)          ,

    -- ** DBusMessageFlags #flag:DBusMessageFlags#

        DBusMessageFlags(..)                    ,

    -- ** DBusObjectManagerClientFlags #flag:DBusObjectManagerClientFlags#

        DBusObjectManagerClientFlags(..)        ,

    -- ** DBusPropertyInfoFlags #flag:DBusPropertyInfoFlags#

        DBusPropertyInfoFlags(..)               ,

    -- ** DBusProxyFlags #flag:DBusProxyFlags#

        DBusProxyFlags(..)                      ,

    -- ** DBusSendMessageFlags #flag:DBusSendMessageFlags#

        DBusSendMessageFlags(..)                ,

    -- ** DBusServerFlags #flag:DBusServerFlags#

        DBusServerFlags(..)                     ,

    -- ** DBusSignalFlags #flag:DBusSignalFlags#

        DBusSignalFlags(..)                     ,

    -- ** DBusSubtreeFlags #flag:DBusSubtreeFlags#

        DBusSubtreeFlags(..)                    ,

    -- ** DriveStartFlags #flag:DriveStartFlags#

        DriveStartFlags(..)                     ,

    -- ** FileAttributeInfoFlags #flag:FileAttributeInfoFlags#

        FileAttributeInfoFlags(..)              ,

    -- ** FileCopyFlags #flag:FileCopyFlags#

        FileCopyFlags(..)                       ,

    -- ** FileCreateFlags #flag:FileCreateFlags#

        FileCreateFlags(..)                     ,

    -- ** FileMeasureFlags #flag:FileMeasureFlags#

        FileMeasureFlags(..)                    ,

    -- ** FileMonitorFlags #flag:FileMonitorFlags#

        FileMonitorFlags(..)                    ,

    -- ** FileQueryInfoFlags #flag:FileQueryInfoFlags#

        FileQueryInfoFlags(..)                  ,

    -- ** IOStreamSpliceFlags #flag:IOStreamSpliceFlags#

        IOStreamSpliceFlags(..)                 ,

    -- ** MountMountFlags #flag:MountMountFlags#

        MountMountFlags(..)                     ,

    -- ** MountUnmountFlags #flag:MountUnmountFlags#

        MountUnmountFlags(..)                   ,

    -- ** OutputStreamSpliceFlags #flag:OutputStreamSpliceFlags#

        OutputStreamSpliceFlags(..)             ,

    -- ** ResolverNameLookupFlags #flag:ResolverNameLookupFlags#

        ResolverNameLookupFlags(..)             ,

    -- ** ResourceFlags #flag:ResourceFlags#

        ResourceFlags(..)                       ,

    -- ** ResourceLookupFlags #flag:ResourceLookupFlags#

        ResourceLookupFlags(..)                 ,

    -- ** SettingsBindFlags #flag:SettingsBindFlags#

        SettingsBindFlags(..)                   ,

    -- ** SocketMsgFlags #flag:SocketMsgFlags#

        SocketMsgFlags(..)                      ,

    -- ** SubprocessFlags #flag:SubprocessFlags#

        SubprocessFlags(..)                     ,

    -- ** TestDBusFlags #flag:TestDBusFlags#

        TestDBusFlags(..)                       ,

    -- ** TlsCertificateFlags #flag:TlsCertificateFlags#

        TlsCertificateFlags(..)                 ,

    -- ** TlsDatabaseVerifyFlags #flag:TlsDatabaseVerifyFlags#

        TlsDatabaseVerifyFlags(..)              ,

    -- ** TlsPasswordFlags #flag:TlsPasswordFlags#

        TlsPasswordFlags(..)                    ,

        ) where

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

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    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
    import qualified GHC.Records as R

    -- 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.
        | TlsPasswordFlagsPkcs11User
        -- ^ For PKCS @/11/@, the user PIN is required.
        --    Since: 2.70.
        | TlsPasswordFlagsPkcs11SecurityOfficer
        -- ^ For PKCS @/11/@, the security officer
        --    PIN is required. Since: 2.70.
        | TlsPasswordFlagsPkcs11ContextSpecific
        -- ^ For PKCS @/11/@, the context-specific
        --    PIN is required. Since: 2.70.
        | 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
    $cshowsPrec :: Int -> TlsPasswordFlags -> ShowS
    showsPrec :: Int -> TlsPasswordFlags -> ShowS
    $cshow :: TlsPasswordFlags -> String
    show :: TlsPasswordFlags -> String
    $cshowList :: [TlsPasswordFlags] -> ShowS
    showList :: [TlsPasswordFlags] -> ShowS
    Show, TlsPasswordFlags -> TlsPasswordFlags -> Bool
    (TlsPasswordFlags -> TlsPasswordFlags -> Bool)
    -> (TlsPasswordFlags -> TlsPasswordFlags -> Bool)
    -> Eq TlsPasswordFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TlsPasswordFlags -> TlsPasswordFlags -> Bool
    == :: TlsPasswordFlags -> TlsPasswordFlags -> Bool
    $c/= :: TlsPasswordFlags -> TlsPasswordFlags -> Bool
    /= :: TlsPasswordFlags -> TlsPasswordFlags -> Bool
    Eq)

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

        toEnum :: Int -> TlsPasswordFlags
    toEnum Int
    0 = TlsPasswordFlags
    TlsPasswordFlagsNone
        toEnum Int
    2 = TlsPasswordFlags
    TlsPasswordFlagsRetry
        toEnum Int
    4 = TlsPasswordFlags
    TlsPasswordFlagsManyTries
        toEnum Int
    8 = TlsPasswordFlags
    TlsPasswordFlagsFinalTry
        toEnum Int
    16 = TlsPasswordFlags
    TlsPasswordFlagsPkcs11User
        toEnum Int
    32 = TlsPasswordFlags
    TlsPasswordFlagsPkcs11SecurityOfficer
        toEnum Int
    64 = TlsPasswordFlags
    TlsPasswordFlagsPkcs11ContextSpecific
        toEnum Int
    k = Int -> TlsPasswordFlags
    AnotherTlsPasswordFlags Int
    k

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

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

    foreign import ccall "g_tls_password_flags_get_type" c_g_tls_password_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags TlsPasswordFlags

    instance IsGFlag TlsPasswordFlags

    -- Flags TlsDatabaseVerifyFlags
    -- | Flags for 'GI.Gio.Objects.TlsDatabase.tlsDatabaseVerifyChain'.
    --
    -- /Since: 2.30/
    data TlsDatabaseVerifyFlags =
          TlsDatabaseVerifyFlagsNone
        -- ^ No verification flags
        | AnotherTlsDatabaseVerifyFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TlsDatabaseVerifyFlags -> ShowS
    [TlsDatabaseVerifyFlags] -> ShowS
    TlsDatabaseVerifyFlags -> String
    (Int -> TlsDatabaseVerifyFlags -> ShowS)
    -> (TlsDatabaseVerifyFlags -> String)
    -> ([TlsDatabaseVerifyFlags] -> ShowS)
    -> Show TlsDatabaseVerifyFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TlsDatabaseVerifyFlags -> ShowS
    showsPrec :: Int -> TlsDatabaseVerifyFlags -> ShowS
    $cshow :: TlsDatabaseVerifyFlags -> String
    show :: TlsDatabaseVerifyFlags -> String
    $cshowList :: [TlsDatabaseVerifyFlags] -> ShowS
    showList :: [TlsDatabaseVerifyFlags] -> ShowS
    Show, TlsDatabaseVerifyFlags -> TlsDatabaseVerifyFlags -> Bool
    (TlsDatabaseVerifyFlags -> TlsDatabaseVerifyFlags -> Bool)
    -> (TlsDatabaseVerifyFlags -> TlsDatabaseVerifyFlags -> Bool)
    -> Eq TlsDatabaseVerifyFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TlsDatabaseVerifyFlags -> TlsDatabaseVerifyFlags -> Bool
    == :: TlsDatabaseVerifyFlags -> TlsDatabaseVerifyFlags -> Bool
    $c/= :: TlsDatabaseVerifyFlags -> TlsDatabaseVerifyFlags -> Bool
    /= :: TlsDatabaseVerifyFlags -> TlsDatabaseVerifyFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_tls_database_verify_flags_get_type" c_g_tls_database_verify_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags TlsDatabaseVerifyFlags

    instance IsGFlag TlsDatabaseVerifyFlags

    -- Flags TlsCertificateFlags
    -- | A set of flags describing TLS certification validation. This can be
    -- used to describe why a particular certificate was rejected (for
    -- example, in [TlsConnection::acceptCertificate]("GI.Gio.Objects.TlsConnection#g:signal:acceptCertificate")).
    --
    -- GLib guarantees that if certificate verification fails, at least one
    -- flag will be set, but it does not guarantee that all possible flags
    -- will be set. Accordingly, you may not safely decide to ignore any
    -- particular type of error. For example, it would be incorrect to mask
    -- 'GI.Gio.Flags.TlsCertificateFlagsExpired' if you want to allow expired certificates,
    -- because this could potentially be the only error flag set even if
    -- other problems exist with the certificate.
    --
    -- /Since: 2.28/
    data TlsCertificateFlags =
          TlsCertificateFlagsNoFlags
        -- ^ No flags set. Since: 2.74
        | 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
    $cshowsPrec :: Int -> TlsCertificateFlags -> ShowS
    showsPrec :: Int -> TlsCertificateFlags -> ShowS
    $cshow :: TlsCertificateFlags -> String
    show :: TlsCertificateFlags -> String
    $cshowList :: [TlsCertificateFlags] -> ShowS
    showList :: [TlsCertificateFlags] -> ShowS
    Show, TlsCertificateFlags -> TlsCertificateFlags -> Bool
    (TlsCertificateFlags -> TlsCertificateFlags -> Bool)
    -> (TlsCertificateFlags -> TlsCertificateFlags -> Bool)
    -> Eq TlsCertificateFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TlsCertificateFlags -> TlsCertificateFlags -> Bool
    == :: TlsCertificateFlags -> TlsCertificateFlags -> Bool
    $c/= :: TlsCertificateFlags -> TlsCertificateFlags -> Bool
    /= :: TlsCertificateFlags -> TlsCertificateFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_tls_certificate_flags_get_type" c_g_tls_certificate_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags TlsCertificateFlags

    instance IsGFlag TlsCertificateFlags

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

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

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

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

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

    foreign import ccall "g_test_dbus_flags_get_type" c_g_test_dbus_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags TestDBusFlags

    instance IsGFlag TestDBusFlags

    -- Flags SubprocessFlags
    -- | Flags to define the behaviour of a t'GI.Gio.Objects.Subprocess.Subprocess'.
    --
    -- Note that the default for stdin is to redirect from @\/dev\/null@.  For
    -- stdout and stderr the default are for them to inherit the
    -- corresponding descriptor from the calling process.
    --
    -- Note that it is a programmer error to mix \'incompatible\' flags.  For
    -- example, you may not request both 'GI.Gio.Flags.SubprocessFlagsStdoutPipe' and
    -- 'GI.Gio.Flags.SubprocessFlagsStdoutSilence'.
    --
    -- /Since: 2.40/
    data SubprocessFlags =
          SubprocessFlagsNone
        -- ^ No flags.
        | SubprocessFlagsStdinPipe
        -- ^ create a pipe for the stdin of the
        --   spawned process that can be accessed with
        --   'GI.Gio.Objects.Subprocess.subprocessGetStdinPipe'.
        | SubprocessFlagsStdinInherit
        -- ^ stdin is inherited from the
        --   calling process.
        | SubprocessFlagsStdoutPipe
        -- ^ create a pipe for the stdout of the
        --   spawned process that can be accessed with
        --   'GI.Gio.Objects.Subprocess.subprocessGetStdoutPipe'.
        | SubprocessFlagsStdoutSilence
        -- ^ silence the stdout of the spawned
        --   process (ie: redirect to @\/dev\/null@).
        | SubprocessFlagsStderrPipe
        -- ^ create a pipe for the stderr of the
        --   spawned process that can be accessed with
        --   'GI.Gio.Objects.Subprocess.subprocessGetStderrPipe'.
        | SubprocessFlagsStderrSilence
        -- ^ silence the stderr of the spawned
        --   process (ie: redirect to @\/dev\/null@).
        | SubprocessFlagsStderrMerge
        -- ^ merge the stderr of the spawned
        --   process with whatever the stdout happens to be.  This is a good way
        --   of directing both streams to a common log file, for example.
        | SubprocessFlagsInheritFds
        -- ^ spawned processes will inherit the
        --   file descriptors of their parent, unless those descriptors have
        --   been explicitly marked as close-on-exec.  This flag has no effect
        --   over the \"standard\" file descriptors (stdin, stdout, stderr).
        | SubprocessFlagsSearchPathFromEnvp
        -- ^ if path searching is
        --   needed when spawning the subprocess, use the @PATH@ in the launcher
        --   environment. (Since: 2.72)
        | 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
    $cshowsPrec :: Int -> SubprocessFlags -> ShowS
    showsPrec :: Int -> SubprocessFlags -> ShowS
    $cshow :: SubprocessFlags -> String
    show :: SubprocessFlags -> String
    $cshowList :: [SubprocessFlags] -> ShowS
    showList :: [SubprocessFlags] -> ShowS
    Show, SubprocessFlags -> SubprocessFlags -> Bool
    (SubprocessFlags -> SubprocessFlags -> Bool)
    -> (SubprocessFlags -> SubprocessFlags -> Bool)
    -> Eq SubprocessFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SubprocessFlags -> SubprocessFlags -> Bool
    == :: SubprocessFlags -> SubprocessFlags -> Bool
    $c/= :: SubprocessFlags -> SubprocessFlags -> Bool
    /= :: SubprocessFlags -> SubprocessFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_subprocess_flags_get_type" c_g_subprocess_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags SubprocessFlags

    instance IsGFlag SubprocessFlags

    -- Flags SocketMsgFlags
    -- | Flags used in 'GI.Gio.Objects.Socket.socketReceiveMessage' and 'GI.Gio.Objects.Socket.socketSendMessage'.
    -- The flags listed in the enum are some commonly available flags, but the
    -- values used for them are the same as on the platform, and any other flags
    -- are passed in\/out as is. So to use a platform specific flag, just include
    -- the right system header and pass in the flag.
    --
    -- /Since: 2.22/
    data SocketMsgFlags =
          SocketMsgFlagsNone
        -- ^ No flags.
        | SocketMsgFlagsOob
        -- ^ Request to send\/receive out of band data.
        | SocketMsgFlagsPeek
        -- ^ Read data from the socket without removing it from
        --     the queue.
        | SocketMsgFlagsDontroute
        -- ^ Don\'t use a gateway to send out the packet,
        --     only send to hosts on directly connected networks.
        | AnotherSocketMsgFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SocketMsgFlags -> ShowS
    [SocketMsgFlags] -> ShowS
    SocketMsgFlags -> String
    (Int -> SocketMsgFlags -> ShowS)
    -> (SocketMsgFlags -> String)
    -> ([SocketMsgFlags] -> ShowS)
    -> Show SocketMsgFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SocketMsgFlags -> ShowS
    showsPrec :: Int -> SocketMsgFlags -> ShowS
    $cshow :: SocketMsgFlags -> String
    show :: SocketMsgFlags -> String
    $cshowList :: [SocketMsgFlags] -> ShowS
    showList :: [SocketMsgFlags] -> ShowS
    Show, SocketMsgFlags -> SocketMsgFlags -> Bool
    (SocketMsgFlags -> SocketMsgFlags -> Bool)
    -> (SocketMsgFlags -> SocketMsgFlags -> Bool) -> Eq SocketMsgFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SocketMsgFlags -> SocketMsgFlags -> Bool
    == :: SocketMsgFlags -> SocketMsgFlags -> Bool
    $c/= :: SocketMsgFlags -> SocketMsgFlags -> Bool
    /= :: SocketMsgFlags -> SocketMsgFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_socket_msg_flags_get_type" c_g_socket_msg_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags SocketMsgFlags

    instance IsGFlag SocketMsgFlags

    -- Flags SettingsBindFlags
    -- | Flags used when creating a binding. These flags determine in which
    -- direction the binding works. The default is to synchronize in both
    -- directions.
    data SettingsBindFlags =
          SettingsBindFlagsDefault
        -- ^ Equivalent to @G_SETTINGS_BIND_GET|G_SETTINGS_BIND_SET@
        | SettingsBindFlagsGet
        -- ^ Update the t'GI.GObject.Objects.Object.Object' property when the setting changes.
        --     It is an error to use this flag if the property is not writable.
        | SettingsBindFlagsSet
        -- ^ Update the setting when the t'GI.GObject.Objects.Object.Object' property changes.
        --     It is an error to use this flag if the property is not readable.
        | SettingsBindFlagsNoSensitivity
        -- ^ Do not try to bind a \"sensitivity\" property to the writability of the setting
        | SettingsBindFlagsGetNoChanges
        -- ^ When set in addition to 'GI.Gio.Flags.SettingsBindFlagsGet', 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
    $cshowsPrec :: Int -> SettingsBindFlags -> ShowS
    showsPrec :: Int -> SettingsBindFlags -> ShowS
    $cshow :: SettingsBindFlags -> String
    show :: SettingsBindFlags -> String
    $cshowList :: [SettingsBindFlags] -> ShowS
    showList :: [SettingsBindFlags] -> ShowS
    Show, SettingsBindFlags -> SettingsBindFlags -> Bool
    (SettingsBindFlags -> SettingsBindFlags -> Bool)
    -> (SettingsBindFlags -> SettingsBindFlags -> Bool)
    -> Eq SettingsBindFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SettingsBindFlags -> SettingsBindFlags -> Bool
    == :: SettingsBindFlags -> SettingsBindFlags -> Bool
    $c/= :: SettingsBindFlags -> SettingsBindFlags -> Bool
    /= :: SettingsBindFlags -> SettingsBindFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_settings_bind_flags_get_type" c_g_settings_bind_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags SettingsBindFlags

    instance IsGFlag SettingsBindFlags

    -- Flags ResourceLookupFlags
    -- | GResourceLookupFlags determine how resource path lookups are handled.
    --
    -- /Since: 2.32/
    data ResourceLookupFlags =
          ResourceLookupFlagsNone
        -- ^ No flags set.
        | AnotherResourceLookupFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ResourceLookupFlags -> ShowS
    [ResourceLookupFlags] -> ShowS
    ResourceLookupFlags -> String
    (Int -> ResourceLookupFlags -> ShowS)
    -> (ResourceLookupFlags -> String)
    -> ([ResourceLookupFlags] -> ShowS)
    -> Show ResourceLookupFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ResourceLookupFlags -> ShowS
    showsPrec :: Int -> ResourceLookupFlags -> ShowS
    $cshow :: ResourceLookupFlags -> String
    show :: ResourceLookupFlags -> String
    $cshowList :: [ResourceLookupFlags] -> ShowS
    showList :: [ResourceLookupFlags] -> ShowS
    Show, ResourceLookupFlags -> ResourceLookupFlags -> Bool
    (ResourceLookupFlags -> ResourceLookupFlags -> Bool)
    -> (ResourceLookupFlags -> ResourceLookupFlags -> Bool)
    -> Eq ResourceLookupFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ResourceLookupFlags -> ResourceLookupFlags -> Bool
    == :: ResourceLookupFlags -> ResourceLookupFlags -> Bool
    $c/= :: ResourceLookupFlags -> ResourceLookupFlags -> Bool
    /= :: ResourceLookupFlags -> ResourceLookupFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_resource_lookup_flags_get_type" c_g_resource_lookup_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags ResourceLookupFlags

    instance IsGFlag ResourceLookupFlags

    -- Flags ResourceFlags
    -- | GResourceFlags give information about a particular file inside a resource
    -- bundle.
    --
    -- /Since: 2.32/
    data ResourceFlags =
          ResourceFlagsNone
        -- ^ No flags set.
        | ResourceFlagsCompressed
        -- ^ The file is compressed.
        | AnotherResourceFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ResourceFlags -> ShowS
    [ResourceFlags] -> ShowS
    ResourceFlags -> String
    (Int -> ResourceFlags -> ShowS)
    -> (ResourceFlags -> String)
    -> ([ResourceFlags] -> ShowS)
    -> Show ResourceFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ResourceFlags -> ShowS
    showsPrec :: Int -> ResourceFlags -> ShowS
    $cshow :: ResourceFlags -> String
    show :: ResourceFlags -> String
    $cshowList :: [ResourceFlags] -> ShowS
    showList :: [ResourceFlags] -> ShowS
    Show, ResourceFlags -> ResourceFlags -> Bool
    (ResourceFlags -> ResourceFlags -> Bool)
    -> (ResourceFlags -> ResourceFlags -> Bool) -> Eq ResourceFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ResourceFlags -> ResourceFlags -> Bool
    == :: ResourceFlags -> ResourceFlags -> Bool
    $c/= :: ResourceFlags -> ResourceFlags -> Bool
    /= :: ResourceFlags -> ResourceFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_resource_flags_get_type" c_g_resource_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags ResourceFlags

    instance IsGFlag ResourceFlags

    -- Flags ResolverNameLookupFlags
    -- | Flags to modify lookup behavior.
    --
    -- /Since: 2.60/
    data ResolverNameLookupFlags =
          ResolverNameLookupFlagsDefault
        -- ^ default behavior (same as 'GI.Gio.Objects.Resolver.resolverLookupByName')
        | ResolverNameLookupFlagsIpv4Only
        -- ^ only resolve ipv4 addresses
        | ResolverNameLookupFlagsIpv6Only
        -- ^ only resolve ipv6 addresses
        | AnotherResolverNameLookupFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ResolverNameLookupFlags -> ShowS
    [ResolverNameLookupFlags] -> ShowS
    ResolverNameLookupFlags -> String
    (Int -> ResolverNameLookupFlags -> ShowS)
    -> (ResolverNameLookupFlags -> String)
    -> ([ResolverNameLookupFlags] -> ShowS)
    -> Show ResolverNameLookupFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ResolverNameLookupFlags -> ShowS
    showsPrec :: Int -> ResolverNameLookupFlags -> ShowS
    $cshow :: ResolverNameLookupFlags -> String
    show :: ResolverNameLookupFlags -> String
    $cshowList :: [ResolverNameLookupFlags] -> ShowS
    showList :: [ResolverNameLookupFlags] -> ShowS
    Show, ResolverNameLookupFlags -> ResolverNameLookupFlags -> Bool
    (ResolverNameLookupFlags -> ResolverNameLookupFlags -> Bool)
    -> (ResolverNameLookupFlags -> ResolverNameLookupFlags -> Bool)
    -> Eq ResolverNameLookupFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ResolverNameLookupFlags -> ResolverNameLookupFlags -> Bool
    == :: ResolverNameLookupFlags -> ResolverNameLookupFlags -> Bool
    $c/= :: ResolverNameLookupFlags -> ResolverNameLookupFlags -> Bool
    /= :: ResolverNameLookupFlags -> ResolverNameLookupFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_resolver_name_lookup_flags_get_type" c_g_resolver_name_lookup_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags ResolverNameLookupFlags

    instance IsGFlag ResolverNameLookupFlags

    -- Flags OutputStreamSpliceFlags
    -- | GOutputStreamSpliceFlags determine how streams should be spliced.
    data OutputStreamSpliceFlags =
          OutputStreamSpliceFlagsNone
        -- ^ Do not close either stream.
        | OutputStreamSpliceFlagsCloseSource
        -- ^ Close the source stream after
        --     the splice.
        | OutputStreamSpliceFlagsCloseTarget
        -- ^ Close the target stream after
        --     the splice.
        | AnotherOutputStreamSpliceFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> OutputStreamSpliceFlags -> ShowS
    [OutputStreamSpliceFlags] -> ShowS
    OutputStreamSpliceFlags -> String
    (Int -> OutputStreamSpliceFlags -> ShowS)
    -> (OutputStreamSpliceFlags -> String)
    -> ([OutputStreamSpliceFlags] -> ShowS)
    -> Show OutputStreamSpliceFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> OutputStreamSpliceFlags -> ShowS
    showsPrec :: Int -> OutputStreamSpliceFlags -> ShowS
    $cshow :: OutputStreamSpliceFlags -> String
    show :: OutputStreamSpliceFlags -> String
    $cshowList :: [OutputStreamSpliceFlags] -> ShowS
    showList :: [OutputStreamSpliceFlags] -> ShowS
    Show, OutputStreamSpliceFlags -> OutputStreamSpliceFlags -> Bool
    (OutputStreamSpliceFlags -> OutputStreamSpliceFlags -> Bool)
    -> (OutputStreamSpliceFlags -> OutputStreamSpliceFlags -> Bool)
    -> Eq OutputStreamSpliceFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: OutputStreamSpliceFlags -> OutputStreamSpliceFlags -> Bool
    == :: OutputStreamSpliceFlags -> OutputStreamSpliceFlags -> Bool
    $c/= :: OutputStreamSpliceFlags -> OutputStreamSpliceFlags -> Bool
    /= :: OutputStreamSpliceFlags -> OutputStreamSpliceFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_output_stream_splice_flags_get_type" c_g_output_stream_splice_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags OutputStreamSpliceFlags

    instance IsGFlag OutputStreamSpliceFlags

    -- Flags MountUnmountFlags
    -- | Flags used when an unmounting a mount.
    data MountUnmountFlags =
          MountUnmountFlagsNone
        -- ^ No flags set.
        | MountUnmountFlagsForce
        -- ^ Unmount even if there are outstanding
        --  file operations on the mount.
        | AnotherMountUnmountFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> MountUnmountFlags -> ShowS
    [MountUnmountFlags] -> ShowS
    MountUnmountFlags -> String
    (Int -> MountUnmountFlags -> ShowS)
    -> (MountUnmountFlags -> String)
    -> ([MountUnmountFlags] -> ShowS)
    -> Show MountUnmountFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> MountUnmountFlags -> ShowS
    showsPrec :: Int -> MountUnmountFlags -> ShowS
    $cshow :: MountUnmountFlags -> String
    show :: MountUnmountFlags -> String
    $cshowList :: [MountUnmountFlags] -> ShowS
    showList :: [MountUnmountFlags] -> ShowS
    Show, MountUnmountFlags -> MountUnmountFlags -> Bool
    (MountUnmountFlags -> MountUnmountFlags -> Bool)
    -> (MountUnmountFlags -> MountUnmountFlags -> Bool)
    -> Eq MountUnmountFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MountUnmountFlags -> MountUnmountFlags -> Bool
    == :: MountUnmountFlags -> MountUnmountFlags -> Bool
    $c/= :: MountUnmountFlags -> MountUnmountFlags -> Bool
    /= :: MountUnmountFlags -> MountUnmountFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_mount_unmount_flags_get_type" c_g_mount_unmount_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags MountUnmountFlags

    instance IsGFlag MountUnmountFlags

    -- Flags MountMountFlags
    -- | Flags used when mounting a mount.
    data MountMountFlags =
          MountMountFlagsNone
        -- ^ No flags set.
        | AnotherMountMountFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> MountMountFlags -> ShowS
    [MountMountFlags] -> ShowS
    MountMountFlags -> String
    (Int -> MountMountFlags -> ShowS)
    -> (MountMountFlags -> String)
    -> ([MountMountFlags] -> ShowS)
    -> Show MountMountFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> MountMountFlags -> ShowS
    showsPrec :: Int -> MountMountFlags -> ShowS
    $cshow :: MountMountFlags -> String
    show :: MountMountFlags -> String
    $cshowList :: [MountMountFlags] -> ShowS
    showList :: [MountMountFlags] -> ShowS
    Show, MountMountFlags -> MountMountFlags -> Bool
    (MountMountFlags -> MountMountFlags -> Bool)
    -> (MountMountFlags -> MountMountFlags -> Bool)
    -> Eq MountMountFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MountMountFlags -> MountMountFlags -> Bool
    == :: MountMountFlags -> MountMountFlags -> Bool
    $c/= :: MountMountFlags -> MountMountFlags -> Bool
    /= :: MountMountFlags -> MountMountFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_mount_mount_flags_get_type" c_g_mount_mount_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags MountMountFlags

    instance IsGFlag MountMountFlags

    -- Flags IOStreamSpliceFlags
    -- | GIOStreamSpliceFlags determine how streams should be spliced.
    --
    -- /Since: 2.28/
    data IOStreamSpliceFlags =
          IOStreamSpliceFlagsNone
        -- ^ Do not close either stream.
        | IOStreamSpliceFlagsCloseStream1
        -- ^ Close the first stream after
        --     the splice.
        | IOStreamSpliceFlagsCloseStream2
        -- ^ Close the second stream after
        --     the splice.
        | IOStreamSpliceFlagsWaitForBoth
        -- ^ Wait for both splice operations to finish
        --     before calling the callback.
        | AnotherIOStreamSpliceFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> IOStreamSpliceFlags -> ShowS
    [IOStreamSpliceFlags] -> ShowS
    IOStreamSpliceFlags -> String
    (Int -> IOStreamSpliceFlags -> ShowS)
    -> (IOStreamSpliceFlags -> String)
    -> ([IOStreamSpliceFlags] -> ShowS)
    -> Show IOStreamSpliceFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> IOStreamSpliceFlags -> ShowS
    showsPrec :: Int -> IOStreamSpliceFlags -> ShowS
    $cshow :: IOStreamSpliceFlags -> String
    show :: IOStreamSpliceFlags -> String
    $cshowList :: [IOStreamSpliceFlags] -> ShowS
    showList :: [IOStreamSpliceFlags] -> ShowS
    Show, IOStreamSpliceFlags -> IOStreamSpliceFlags -> Bool
    (IOStreamSpliceFlags -> IOStreamSpliceFlags -> Bool)
    -> (IOStreamSpliceFlags -> IOStreamSpliceFlags -> Bool)
    -> Eq IOStreamSpliceFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: IOStreamSpliceFlags -> IOStreamSpliceFlags -> Bool
    == :: IOStreamSpliceFlags -> IOStreamSpliceFlags -> Bool
    $c/= :: IOStreamSpliceFlags -> IOStreamSpliceFlags -> Bool
    /= :: IOStreamSpliceFlags -> IOStreamSpliceFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_io_stream_splice_flags_get_type" c_g_io_stream_splice_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags IOStreamSpliceFlags

    instance IsGFlag IOStreamSpliceFlags

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

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

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

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

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

    foreign import ccall "g_file_query_info_flags_get_type" c_g_file_query_info_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags FileQueryInfoFlags

    instance IsGFlag FileQueryInfoFlags

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

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

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

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

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

    foreign import ccall "g_file_monitor_flags_get_type" c_g_file_monitor_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags FileMonitorFlags

    instance IsGFlag FileMonitorFlags

    -- Flags FileMeasureFlags
    -- | Flags that can be used with 'GI.Gio.Interfaces.File.fileMeasureDiskUsage'.
    --
    -- /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@.
        --   Since GLib 2.78. and similarly to @du@ since GNU Coreutils 9.2, this will
        --   ignore the sizes of file types other than regular files and links, as the
        --   sizes of other file types are not specified in a standard way.
        | 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
    $cshowsPrec :: Int -> FileMeasureFlags -> ShowS
    showsPrec :: Int -> FileMeasureFlags -> ShowS
    $cshow :: FileMeasureFlags -> String
    show :: FileMeasureFlags -> String
    $cshowList :: [FileMeasureFlags] -> ShowS
    showList :: [FileMeasureFlags] -> ShowS
    Show, FileMeasureFlags -> FileMeasureFlags -> Bool
    (FileMeasureFlags -> FileMeasureFlags -> Bool)
    -> (FileMeasureFlags -> FileMeasureFlags -> Bool)
    -> Eq FileMeasureFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FileMeasureFlags -> FileMeasureFlags -> Bool
    == :: FileMeasureFlags -> FileMeasureFlags -> Bool
    $c/= :: FileMeasureFlags -> FileMeasureFlags -> Bool
    /= :: FileMeasureFlags -> FileMeasureFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_file_measure_flags_get_type" c_g_file_measure_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags FileMeasureFlags

    instance IsGFlag FileMeasureFlags

    -- Flags FileCreateFlags
    -- | Flags used when an operation may create a file.
    data FileCreateFlags =
          FileCreateFlagsNone
        -- ^ No flags set.
        | FileCreateFlagsPrivate
        -- ^ Create a file that can only be
        --    accessed by the current user.
        | FileCreateFlagsReplaceDestination
        -- ^ Replace the destination
        --    as if it didn\'t exist before. Don\'t try to keep any old
        --    permissions, replace instead of following links. This
        --    is generally useful if you\'re doing a \"copy over\"
        --    rather than a \"save new version of\" replace operation.
        --    You can think of it as \"unlink destination\" before
        --    writing to it, although the implementation may not
        --    be exactly like that. This flag can only be used with
        --    'GI.Gio.Interfaces.File.fileReplace' and its variants, including 'GI.Gio.Interfaces.File.fileReplaceContents'.
        --    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
    $cshowsPrec :: Int -> FileCreateFlags -> ShowS
    showsPrec :: Int -> FileCreateFlags -> ShowS
    $cshow :: FileCreateFlags -> String
    show :: FileCreateFlags -> String
    $cshowList :: [FileCreateFlags] -> ShowS
    showList :: [FileCreateFlags] -> ShowS
    Show, FileCreateFlags -> FileCreateFlags -> Bool
    (FileCreateFlags -> FileCreateFlags -> Bool)
    -> (FileCreateFlags -> FileCreateFlags -> Bool)
    -> Eq FileCreateFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FileCreateFlags -> FileCreateFlags -> Bool
    == :: FileCreateFlags -> FileCreateFlags -> Bool
    $c/= :: FileCreateFlags -> FileCreateFlags -> Bool
    /= :: FileCreateFlags -> FileCreateFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_file_create_flags_get_type" c_g_file_create_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags FileCreateFlags

    instance IsGFlag FileCreateFlags

    -- Flags FileCopyFlags
    -- | Flags used when copying or moving files.
    data FileCopyFlags =
          FileCopyFlagsNone
        -- ^ No flags set.
        | FileCopyFlagsOverwrite
        -- ^ Overwrite any existing files
        | FileCopyFlagsBackup
        -- ^ Make a backup of any existing files.
        | FileCopyFlagsNofollowSymlinks
        -- ^ Don\'t follow symlinks.
        | FileCopyFlagsAllMetadata
        -- ^ Copy all file metadata instead of just default set used for copy (see t'GI.Gio.Objects.FileInfo.FileInfo').
        | FileCopyFlagsNoFallbackForMove
        -- ^ Don\'t use copy and delete fallback if native move not supported.
        | FileCopyFlagsTargetDefaultPerms
        -- ^ Leaves target file with default perms, instead of setting the source file perms.
        | FileCopyFlagsTargetDefaultModifiedTime
        -- ^ Use default modification
        --     timestamps instead of copying them from the source file. Since 2.80
        | 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
    $cshowsPrec :: Int -> FileCopyFlags -> ShowS
    showsPrec :: Int -> FileCopyFlags -> ShowS
    $cshow :: FileCopyFlags -> String
    show :: FileCopyFlags -> String
    $cshowList :: [FileCopyFlags] -> ShowS
    showList :: [FileCopyFlags] -> ShowS
    Show, FileCopyFlags -> FileCopyFlags -> Bool
    (FileCopyFlags -> FileCopyFlags -> Bool)
    -> (FileCopyFlags -> FileCopyFlags -> Bool) -> Eq FileCopyFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FileCopyFlags -> FileCopyFlags -> Bool
    == :: FileCopyFlags -> FileCopyFlags -> Bool
    $c/= :: FileCopyFlags -> FileCopyFlags -> Bool
    /= :: FileCopyFlags -> FileCopyFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_file_copy_flags_get_type" c_g_file_copy_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags FileCopyFlags

    instance IsGFlag FileCopyFlags

    -- Flags FileAttributeInfoFlags
    -- | Flags specifying the behaviour of an attribute.
    data FileAttributeInfoFlags =
          FileAttributeInfoFlagsNone
        -- ^ no flags set.
        | FileAttributeInfoFlagsCopyWithFile
        -- ^ copy the attribute values when the file is copied.
        | FileAttributeInfoFlagsCopyWhenMoved
        -- ^ copy the attribute values when the file is moved.
        | AnotherFileAttributeInfoFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> FileAttributeInfoFlags -> ShowS
    [FileAttributeInfoFlags] -> ShowS
    FileAttributeInfoFlags -> String
    (Int -> FileAttributeInfoFlags -> ShowS)
    -> (FileAttributeInfoFlags -> String)
    -> ([FileAttributeInfoFlags] -> ShowS)
    -> Show FileAttributeInfoFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FileAttributeInfoFlags -> ShowS
    showsPrec :: Int -> FileAttributeInfoFlags -> ShowS
    $cshow :: FileAttributeInfoFlags -> String
    show :: FileAttributeInfoFlags -> String
    $cshowList :: [FileAttributeInfoFlags] -> ShowS
    showList :: [FileAttributeInfoFlags] -> ShowS
    Show, FileAttributeInfoFlags -> FileAttributeInfoFlags -> Bool
    (FileAttributeInfoFlags -> FileAttributeInfoFlags -> Bool)
    -> (FileAttributeInfoFlags -> FileAttributeInfoFlags -> Bool)
    -> Eq FileAttributeInfoFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FileAttributeInfoFlags -> FileAttributeInfoFlags -> Bool
    == :: FileAttributeInfoFlags -> FileAttributeInfoFlags -> Bool
    $c/= :: FileAttributeInfoFlags -> FileAttributeInfoFlags -> Bool
    /= :: FileAttributeInfoFlags -> FileAttributeInfoFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_file_attribute_info_flags_get_type" c_g_file_attribute_info_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags FileAttributeInfoFlags

    instance IsGFlag FileAttributeInfoFlags

    -- Flags DriveStartFlags
    -- | Flags used when starting a drive.
    --
    -- /Since: 2.22/
    data DriveStartFlags =
          DriveStartFlagsNone
        -- ^ No flags set.
        | AnotherDriveStartFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DriveStartFlags -> ShowS
    [DriveStartFlags] -> ShowS
    DriveStartFlags -> String
    (Int -> DriveStartFlags -> ShowS)
    -> (DriveStartFlags -> String)
    -> ([DriveStartFlags] -> ShowS)
    -> Show DriveStartFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DriveStartFlags -> ShowS
    showsPrec :: Int -> DriveStartFlags -> ShowS
    $cshow :: DriveStartFlags -> String
    show :: DriveStartFlags -> String
    $cshowList :: [DriveStartFlags] -> ShowS
    showList :: [DriveStartFlags] -> ShowS
    Show, DriveStartFlags -> DriveStartFlags -> Bool
    (DriveStartFlags -> DriveStartFlags -> Bool)
    -> (DriveStartFlags -> DriveStartFlags -> Bool)
    -> Eq DriveStartFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DriveStartFlags -> DriveStartFlags -> Bool
    == :: DriveStartFlags -> DriveStartFlags -> Bool
    $c/= :: DriveStartFlags -> DriveStartFlags -> Bool
    /= :: DriveStartFlags -> DriveStartFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_drive_start_flags_get_type" c_g_drive_start_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags DriveStartFlags

    instance IsGFlag DriveStartFlags

    -- Flags DBusSubtreeFlags
    -- | Flags passed to 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.
    --
    -- /Since: 2.26/
    data DBusSubtreeFlags =
          DBusSubtreeFlagsNone
        -- ^ No flags set.
        | DBusSubtreeFlagsDispatchToUnenumeratedNodes
        -- ^ Method calls to objects not in the enumerated range
        --                                                       will still be dispatched. This is useful if you want
        --                                                       to dynamically spawn objects in the subtree.
        | AnotherDBusSubtreeFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DBusSubtreeFlags -> ShowS
    [DBusSubtreeFlags] -> ShowS
    DBusSubtreeFlags -> String
    (Int -> DBusSubtreeFlags -> ShowS)
    -> (DBusSubtreeFlags -> String)
    -> ([DBusSubtreeFlags] -> ShowS)
    -> Show DBusSubtreeFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DBusSubtreeFlags -> ShowS
    showsPrec :: Int -> DBusSubtreeFlags -> ShowS
    $cshow :: DBusSubtreeFlags -> String
    show :: DBusSubtreeFlags -> String
    $cshowList :: [DBusSubtreeFlags] -> ShowS
    showList :: [DBusSubtreeFlags] -> ShowS
    Show, DBusSubtreeFlags -> DBusSubtreeFlags -> Bool
    (DBusSubtreeFlags -> DBusSubtreeFlags -> Bool)
    -> (DBusSubtreeFlags -> DBusSubtreeFlags -> Bool)
    -> Eq DBusSubtreeFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DBusSubtreeFlags -> DBusSubtreeFlags -> Bool
    == :: DBusSubtreeFlags -> DBusSubtreeFlags -> Bool
    $c/= :: DBusSubtreeFlags -> DBusSubtreeFlags -> Bool
    /= :: DBusSubtreeFlags -> DBusSubtreeFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_dbus_subtree_flags_get_type" c_g_dbus_subtree_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags DBusSubtreeFlags

    instance IsGFlag DBusSubtreeFlags

    -- Flags DBusSignalFlags
    -- | Flags used when subscribing to signals via 'GI.Gio.Objects.DBusConnection.dBusConnectionSignalSubscribe'.
    --
    -- /Since: 2.26/
    data DBusSignalFlags =
          DBusSignalFlagsNone
        -- ^ No flags set.
        | DBusSignalFlagsNoMatchRule
        -- ^ Don\'t actually send the AddMatch
        -- D-Bus call for this signal subscription.  This gives you more control
        -- over which match rules you add (but you must add them manually).
        | DBusSignalFlagsMatchArg0Namespace
        -- ^ Match first arguments that
        -- contain a bus or interface name with the given namespace.
        | DBusSignalFlagsMatchArg0Path
        -- ^ Match first arguments that
        -- contain an object path that is either equivalent to the given path,
        -- or one of the paths is a subpath of the other.
        | AnotherDBusSignalFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DBusSignalFlags -> ShowS
    [DBusSignalFlags] -> ShowS
    DBusSignalFlags -> String
    (Int -> DBusSignalFlags -> ShowS)
    -> (DBusSignalFlags -> String)
    -> ([DBusSignalFlags] -> ShowS)
    -> Show DBusSignalFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DBusSignalFlags -> ShowS
    showsPrec :: Int -> DBusSignalFlags -> ShowS
    $cshow :: DBusSignalFlags -> String
    show :: DBusSignalFlags -> String
    $cshowList :: [DBusSignalFlags] -> ShowS
    showList :: [DBusSignalFlags] -> ShowS
    Show, DBusSignalFlags -> DBusSignalFlags -> Bool
    (DBusSignalFlags -> DBusSignalFlags -> Bool)
    -> (DBusSignalFlags -> DBusSignalFlags -> Bool)
    -> Eq DBusSignalFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DBusSignalFlags -> DBusSignalFlags -> Bool
    == :: DBusSignalFlags -> DBusSignalFlags -> Bool
    $c/= :: DBusSignalFlags -> DBusSignalFlags -> Bool
    /= :: DBusSignalFlags -> DBusSignalFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_dbus_signal_flags_get_type" c_g_dbus_signal_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags DBusSignalFlags

    instance IsGFlag DBusSignalFlags

    -- Flags DBusServerFlags
    -- | Flags used when creating a t'GI.Gio.Objects.DBusServer.DBusServer'.
    --
    -- /Since: 2.26/
    data DBusServerFlags =
          DBusServerFlagsNone
        -- ^ No flags set.
        | DBusServerFlagsRunInThread
        -- ^ All [DBusServer::newConnection]("GI.Gio.Objects.DBusServer#g:signal:newConnection")
        -- signals will run in separated dedicated threads (see signal for
        -- details).
        | DBusServerFlagsAuthenticationAllowAnonymous
        -- ^ Allow the anonymous
        -- authentication method.
        | DBusServerFlagsAuthenticationRequireSameUser
        -- ^ Require the UID of the
        -- peer to be the same as the UID of the server when authenticating. (Since: 2.68)
        | 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
    $cshowsPrec :: Int -> DBusServerFlags -> ShowS
    showsPrec :: Int -> DBusServerFlags -> ShowS
    $cshow :: DBusServerFlags -> String
    show :: DBusServerFlags -> String
    $cshowList :: [DBusServerFlags] -> ShowS
    showList :: [DBusServerFlags] -> ShowS
    Show, DBusServerFlags -> DBusServerFlags -> Bool
    (DBusServerFlags -> DBusServerFlags -> Bool)
    -> (DBusServerFlags -> DBusServerFlags -> Bool)
    -> Eq DBusServerFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DBusServerFlags -> DBusServerFlags -> Bool
    == :: DBusServerFlags -> DBusServerFlags -> Bool
    $c/= :: DBusServerFlags -> DBusServerFlags -> Bool
    /= :: DBusServerFlags -> DBusServerFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_dbus_server_flags_get_type" c_g_dbus_server_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags DBusServerFlags

    instance IsGFlag DBusServerFlags

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

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

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

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

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

    foreign import ccall "g_dbus_send_message_flags_get_type" c_g_dbus_send_message_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags DBusSendMessageFlags

    instance IsGFlag DBusSendMessageFlags

    -- Flags DBusProxyFlags
    -- | Flags used when constructing an instance of a t'GI.Gio.Objects.DBusProxy.DBusProxy' derived class.
    --
    -- /Since: 2.26/
    data DBusProxyFlags =
          DBusProxyFlagsNone
        -- ^ No flags set.
        | DBusProxyFlagsDoNotLoadProperties
        -- ^ Don\'t load properties.
        | DBusProxyFlagsDoNotConnectSignals
        -- ^ Don\'t connect to signals on the remote object.
        | DBusProxyFlagsDoNotAutoStart
        -- ^ If the proxy is for a well-known name,
        -- do not ask the bus to launch an owner during proxy initialization or a method call.
        -- This flag is only meaningful in proxies for well-known names.
        | DBusProxyFlagsGetInvalidatedProperties
        -- ^ If set, the property value for any __invalidated property__ will be (asynchronously) retrieved upon receiving the <http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties `PropertiesChanged`> D-Bus signal and the property will not cause emission of the [DBusProxy::gPropertiesChanged]("GI.Gio.Objects.DBusProxy#g:signal:gPropertiesChanged") signal. When the value is received the [DBusProxy::gPropertiesChanged]("GI.Gio.Objects.DBusProxy#g:signal:gPropertiesChanged") signal is emitted for the property along with the retrieved value. Since 2.32.
        | DBusProxyFlagsDoNotAutoStartAtConstruction
        -- ^ If the proxy is for a well-known name,
        -- do not ask the bus to launch an owner during proxy initialization, but allow it to be
        -- autostarted by a method call. This flag is only meaningful in proxies for well-known names,
        -- and only if 'GI.Gio.Flags.DBusProxyFlagsDoNotAutoStart' is not also specified.
        | DBusProxyFlagsNoMatchRule
        -- ^ 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). (Since: 2.72)
        | 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
    $cshowsPrec :: Int -> DBusProxyFlags -> ShowS
    showsPrec :: Int -> DBusProxyFlags -> ShowS
    $cshow :: DBusProxyFlags -> String
    show :: DBusProxyFlags -> String
    $cshowList :: [DBusProxyFlags] -> ShowS
    showList :: [DBusProxyFlags] -> ShowS
    Show, DBusProxyFlags -> DBusProxyFlags -> Bool
    (DBusProxyFlags -> DBusProxyFlags -> Bool)
    -> (DBusProxyFlags -> DBusProxyFlags -> Bool) -> Eq DBusProxyFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DBusProxyFlags -> DBusProxyFlags -> Bool
    == :: DBusProxyFlags -> DBusProxyFlags -> Bool
    $c/= :: DBusProxyFlags -> DBusProxyFlags -> Bool
    /= :: DBusProxyFlags -> DBusProxyFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_dbus_proxy_flags_get_type" c_g_dbus_proxy_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags DBusProxyFlags

    instance IsGFlag DBusProxyFlags

    -- Flags DBusPropertyInfoFlags
    -- | Flags describing the access control of a D-Bus property.
    --
    -- /Since: 2.26/
    data DBusPropertyInfoFlags =
          DBusPropertyInfoFlagsNone
        -- ^ No flags set.
        | DBusPropertyInfoFlagsReadable
        -- ^ Property is readable.
        | DBusPropertyInfoFlagsWritable
        -- ^ Property is writable.
        | AnotherDBusPropertyInfoFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DBusPropertyInfoFlags -> ShowS
    [DBusPropertyInfoFlags] -> ShowS
    DBusPropertyInfoFlags -> String
    (Int -> DBusPropertyInfoFlags -> ShowS)
    -> (DBusPropertyInfoFlags -> String)
    -> ([DBusPropertyInfoFlags] -> ShowS)
    -> Show DBusPropertyInfoFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DBusPropertyInfoFlags -> ShowS
    showsPrec :: Int -> DBusPropertyInfoFlags -> ShowS
    $cshow :: DBusPropertyInfoFlags -> String
    show :: DBusPropertyInfoFlags -> String
    $cshowList :: [DBusPropertyInfoFlags] -> ShowS
    showList :: [DBusPropertyInfoFlags] -> ShowS
    Show, DBusPropertyInfoFlags -> DBusPropertyInfoFlags -> Bool
    (DBusPropertyInfoFlags -> DBusPropertyInfoFlags -> Bool)
    -> (DBusPropertyInfoFlags -> DBusPropertyInfoFlags -> Bool)
    -> Eq DBusPropertyInfoFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DBusPropertyInfoFlags -> DBusPropertyInfoFlags -> Bool
    == :: DBusPropertyInfoFlags -> DBusPropertyInfoFlags -> Bool
    $c/= :: DBusPropertyInfoFlags -> DBusPropertyInfoFlags -> Bool
    /= :: DBusPropertyInfoFlags -> DBusPropertyInfoFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_dbus_property_info_flags_get_type" c_g_dbus_property_info_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags DBusPropertyInfoFlags

    instance IsGFlag DBusPropertyInfoFlags

    -- Flags DBusObjectManagerClientFlags
    -- | Flags used when constructing a t'GI.Gio.Objects.DBusObjectManagerClient.DBusObjectManagerClient'.
    --
    -- /Since: 2.30/
    data DBusObjectManagerClientFlags =
          DBusObjectManagerClientFlagsNone
        -- ^ No flags set.
        | DBusObjectManagerClientFlagsDoNotAutoStart
        -- ^ If not set and the
        --   manager is for a well-known name, then request the bus to launch
        --   an owner for the name if no-one owns the name. This flag can only
        --   be used in managers for well-known names.
        | AnotherDBusObjectManagerClientFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DBusObjectManagerClientFlags -> ShowS
    [DBusObjectManagerClientFlags] -> ShowS
    DBusObjectManagerClientFlags -> String
    (Int -> DBusObjectManagerClientFlags -> ShowS)
    -> (DBusObjectManagerClientFlags -> String)
    -> ([DBusObjectManagerClientFlags] -> ShowS)
    -> Show DBusObjectManagerClientFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DBusObjectManagerClientFlags -> ShowS
    showsPrec :: Int -> DBusObjectManagerClientFlags -> ShowS
    $cshow :: DBusObjectManagerClientFlags -> String
    show :: DBusObjectManagerClientFlags -> String
    $cshowList :: [DBusObjectManagerClientFlags] -> ShowS
    showList :: [DBusObjectManagerClientFlags] -> ShowS
    Show, DBusObjectManagerClientFlags
    -> DBusObjectManagerClientFlags -> Bool
    (DBusObjectManagerClientFlags
     -> DBusObjectManagerClientFlags -> Bool)
    -> (DBusObjectManagerClientFlags
        -> DBusObjectManagerClientFlags -> Bool)
    -> Eq DBusObjectManagerClientFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DBusObjectManagerClientFlags
    -> DBusObjectManagerClientFlags -> Bool
    == :: DBusObjectManagerClientFlags
    -> DBusObjectManagerClientFlags -> Bool
    $c/= :: DBusObjectManagerClientFlags
    -> DBusObjectManagerClientFlags -> Bool
    /= :: DBusObjectManagerClientFlags
    -> DBusObjectManagerClientFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_dbus_object_manager_client_flags_get_type" c_g_dbus_object_manager_client_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags DBusObjectManagerClientFlags

    instance IsGFlag DBusObjectManagerClientFlags

    -- Flags DBusMessageFlags
    -- | Message flags used in t'GI.Gio.Objects.DBusMessage.DBusMessage'.
    --
    -- /Since: 2.26/
    data DBusMessageFlags =
          DBusMessageFlagsNone
        -- ^ No flags set.
        | DBusMessageFlagsNoReplyExpected
        -- ^ A reply is not expected.
        | DBusMessageFlagsNoAutoStart
        -- ^ The bus must not launch an
        -- owner for the destination name in response to this message.
        | DBusMessageFlagsAllowInteractiveAuthorization
        -- ^ If set on a method
        -- call, this flag means that the caller is prepared to wait for interactive
        -- authorization. Since 2.46.
        | AnotherDBusMessageFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DBusMessageFlags -> ShowS
    [DBusMessageFlags] -> ShowS
    DBusMessageFlags -> String
    (Int -> DBusMessageFlags -> ShowS)
    -> (DBusMessageFlags -> String)
    -> ([DBusMessageFlags] -> ShowS)
    -> Show DBusMessageFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DBusMessageFlags -> ShowS
    showsPrec :: Int -> DBusMessageFlags -> ShowS
    $cshow :: DBusMessageFlags -> String
    show :: DBusMessageFlags -> String
    $cshowList :: [DBusMessageFlags] -> ShowS
    showList :: [DBusMessageFlags] -> ShowS
    Show, DBusMessageFlags -> DBusMessageFlags -> Bool
    (DBusMessageFlags -> DBusMessageFlags -> Bool)
    -> (DBusMessageFlags -> DBusMessageFlags -> Bool)
    -> Eq DBusMessageFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DBusMessageFlags -> DBusMessageFlags -> Bool
    == :: DBusMessageFlags -> DBusMessageFlags -> Bool
    $c/= :: DBusMessageFlags -> DBusMessageFlags -> Bool
    /= :: DBusMessageFlags -> DBusMessageFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_dbus_message_flags_get_type" c_g_dbus_message_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags DBusMessageFlags

    instance IsGFlag DBusMessageFlags

    -- Flags DBusInterfaceSkeletonFlags
    -- | Flags describing the behavior of a t'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton' instance.
    --
    -- /Since: 2.30/
    data DBusInterfaceSkeletonFlags =
          DBusInterfaceSkeletonFlagsNone
        -- ^ No flags set.
        | DBusInterfaceSkeletonFlagsHandleMethodInvocationsInThread
        -- ^ Each method invocation is handled in
        --   a thread dedicated to the invocation. This means that the method implementation can use blocking IO
        --   without blocking any other part of the process. It also means that the method implementation must
        --   use locking to access data structures used by other threads.
        | AnotherDBusInterfaceSkeletonFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DBusInterfaceSkeletonFlags -> ShowS
    [DBusInterfaceSkeletonFlags] -> ShowS
    DBusInterfaceSkeletonFlags -> String
    (Int -> DBusInterfaceSkeletonFlags -> ShowS)
    -> (DBusInterfaceSkeletonFlags -> String)
    -> ([DBusInterfaceSkeletonFlags] -> ShowS)
    -> Show DBusInterfaceSkeletonFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DBusInterfaceSkeletonFlags -> ShowS
    showsPrec :: Int -> DBusInterfaceSkeletonFlags -> ShowS
    $cshow :: DBusInterfaceSkeletonFlags -> String
    show :: DBusInterfaceSkeletonFlags -> String
    $cshowList :: [DBusInterfaceSkeletonFlags] -> ShowS
    showList :: [DBusInterfaceSkeletonFlags] -> ShowS
    Show, DBusInterfaceSkeletonFlags -> DBusInterfaceSkeletonFlags -> Bool
    (DBusInterfaceSkeletonFlags -> DBusInterfaceSkeletonFlags -> Bool)
    -> (DBusInterfaceSkeletonFlags
        -> DBusInterfaceSkeletonFlags -> Bool)
    -> Eq DBusInterfaceSkeletonFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DBusInterfaceSkeletonFlags -> DBusInterfaceSkeletonFlags -> Bool
    == :: DBusInterfaceSkeletonFlags -> DBusInterfaceSkeletonFlags -> Bool
    $c/= :: DBusInterfaceSkeletonFlags -> DBusInterfaceSkeletonFlags -> Bool
    /= :: DBusInterfaceSkeletonFlags -> DBusInterfaceSkeletonFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_dbus_interface_skeleton_flags_get_type" c_g_dbus_interface_skeleton_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags DBusInterfaceSkeletonFlags

    instance IsGFlag DBusInterfaceSkeletonFlags

    -- Flags DBusConnectionFlags
    -- | Flags used when creating a new t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    --
    -- /Since: 2.26/
    data DBusConnectionFlags =
          DBusConnectionFlagsNone
        -- ^ No flags set.
        | DBusConnectionFlagsAuthenticationClient
        -- ^ Perform authentication against server.
        | DBusConnectionFlagsAuthenticationServer
        -- ^ Perform authentication against client.
        | DBusConnectionFlagsAuthenticationAllowAnonymous
        -- ^ When
        -- authenticating as a server, allow the anonymous authentication
        -- method.
        | DBusConnectionFlagsMessageBusConnection
        -- ^ Pass this flag if connecting to a peer that is a
        -- message bus. This means that the @/Hello()/@ method will be invoked as part of the connection setup.
        | DBusConnectionFlagsDelayMessageProcessing
        -- ^ If set, processing of D-Bus messages is
        -- delayed until 'GI.Gio.Objects.DBusConnection.dBusConnectionStartMessageProcessing' is called.
        | DBusConnectionFlagsAuthenticationRequireSameUser
        -- ^ When authenticating
        -- as a server, require the UID of the peer to be the same as the UID of the server. (Since: 2.68)
        | DBusConnectionFlagsCrossNamespace
        -- ^ When authenticating, try to use
        --  protocols that work across a Linux user namespace boundary, even if this
        --  reduces interoperability with older D-Bus implementations. This currently
        --  affects client-side @EXTERNAL@ authentication, for which this flag makes
        --  connections to a server in another user namespace succeed, but causes
        --  a deadlock when connecting to a GDBus server older than 2.73.3. Since: 2.74
        | 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
    $cshowsPrec :: Int -> DBusConnectionFlags -> ShowS
    showsPrec :: Int -> DBusConnectionFlags -> ShowS
    $cshow :: DBusConnectionFlags -> String
    show :: DBusConnectionFlags -> String
    $cshowList :: [DBusConnectionFlags] -> ShowS
    showList :: [DBusConnectionFlags] -> ShowS
    Show, DBusConnectionFlags -> DBusConnectionFlags -> Bool
    (DBusConnectionFlags -> DBusConnectionFlags -> Bool)
    -> (DBusConnectionFlags -> DBusConnectionFlags -> Bool)
    -> Eq DBusConnectionFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DBusConnectionFlags -> DBusConnectionFlags -> Bool
    == :: DBusConnectionFlags -> DBusConnectionFlags -> Bool
    $c/= :: DBusConnectionFlags -> DBusConnectionFlags -> Bool
    /= :: DBusConnectionFlags -> DBusConnectionFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_dbus_connection_flags_get_type" c_g_dbus_connection_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags DBusConnectionFlags

    instance IsGFlag DBusConnectionFlags

    -- Flags DBusCapabilityFlags
    -- | Capabilities negotiated with the remote peer.
    --
    -- /Since: 2.26/
    data DBusCapabilityFlags =
          DBusCapabilityFlagsNone
        -- ^ No flags set.
        | DBusCapabilityFlagsUnixFdPassing
        -- ^ The connection
        -- supports exchanging UNIX file descriptors with the remote peer.
        | AnotherDBusCapabilityFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DBusCapabilityFlags -> ShowS
    [DBusCapabilityFlags] -> ShowS
    DBusCapabilityFlags -> String
    (Int -> DBusCapabilityFlags -> ShowS)
    -> (DBusCapabilityFlags -> String)
    -> ([DBusCapabilityFlags] -> ShowS)
    -> Show DBusCapabilityFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DBusCapabilityFlags -> ShowS
    showsPrec :: Int -> DBusCapabilityFlags -> ShowS
    $cshow :: DBusCapabilityFlags -> String
    show :: DBusCapabilityFlags -> String
    $cshowList :: [DBusCapabilityFlags] -> ShowS
    showList :: [DBusCapabilityFlags] -> ShowS
    Show, DBusCapabilityFlags -> DBusCapabilityFlags -> Bool
    (DBusCapabilityFlags -> DBusCapabilityFlags -> Bool)
    -> (DBusCapabilityFlags -> DBusCapabilityFlags -> Bool)
    -> Eq DBusCapabilityFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DBusCapabilityFlags -> DBusCapabilityFlags -> Bool
    == :: DBusCapabilityFlags -> DBusCapabilityFlags -> Bool
    $c/= :: DBusCapabilityFlags -> DBusCapabilityFlags -> Bool
    /= :: DBusCapabilityFlags -> DBusCapabilityFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_dbus_capability_flags_get_type" c_g_dbus_capability_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags DBusCapabilityFlags

    instance IsGFlag DBusCapabilityFlags

    -- Flags DBusCallFlags
    -- | Flags used in 'GI.Gio.Objects.DBusConnection.dBusConnectionCall' and similar APIs.
    --
    -- /Since: 2.26/
    data DBusCallFlags =
          DBusCallFlagsNone
        -- ^ No flags set.
        | DBusCallFlagsNoAutoStart
        -- ^ The bus must not launch
        -- an owner for the destination name in response to this method
        -- invocation.
        | DBusCallFlagsAllowInteractiveAuthorization
        -- ^ the caller is prepared to
        -- wait for interactive authorization. Since 2.46.
        | AnotherDBusCallFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DBusCallFlags -> ShowS
    [DBusCallFlags] -> ShowS
    DBusCallFlags -> String
    (Int -> DBusCallFlags -> ShowS)
    -> (DBusCallFlags -> String)
    -> ([DBusCallFlags] -> ShowS)
    -> Show DBusCallFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DBusCallFlags -> ShowS
    showsPrec :: Int -> DBusCallFlags -> ShowS
    $cshow :: DBusCallFlags -> String
    show :: DBusCallFlags -> String
    $cshowList :: [DBusCallFlags] -> ShowS
    showList :: [DBusCallFlags] -> ShowS
    Show, DBusCallFlags -> DBusCallFlags -> Bool
    (DBusCallFlags -> DBusCallFlags -> Bool)
    -> (DBusCallFlags -> DBusCallFlags -> Bool) -> Eq DBusCallFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DBusCallFlags -> DBusCallFlags -> Bool
    == :: DBusCallFlags -> DBusCallFlags -> Bool
    $c/= :: DBusCallFlags -> DBusCallFlags -> Bool
    /= :: DBusCallFlags -> DBusCallFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_dbus_call_flags_get_type" c_g_dbus_call_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags DBusCallFlags

    instance IsGFlag DBusCallFlags

    -- Flags ConverterFlags
    -- | Flags used when calling a 'GI.Gio.Interfaces.Converter.converterConvert'.
    --
    -- /Since: 2.24/
    data ConverterFlags =
          ConverterFlagsNone
        -- ^ No flags.
        | ConverterFlagsInputAtEnd
        -- ^ At end of input data
        | ConverterFlagsFlush
        -- ^ Flush data
        | AnotherConverterFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ConverterFlags -> ShowS
    [ConverterFlags] -> ShowS
    ConverterFlags -> String
    (Int -> ConverterFlags -> ShowS)
    -> (ConverterFlags -> String)
    -> ([ConverterFlags] -> ShowS)
    -> Show ConverterFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ConverterFlags -> ShowS
    showsPrec :: Int -> ConverterFlags -> ShowS
    $cshow :: ConverterFlags -> String
    show :: ConverterFlags -> String
    $cshowList :: [ConverterFlags] -> ShowS
    showList :: [ConverterFlags] -> ShowS
    Show, ConverterFlags -> ConverterFlags -> Bool
    (ConverterFlags -> ConverterFlags -> Bool)
    -> (ConverterFlags -> ConverterFlags -> Bool) -> Eq ConverterFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ConverterFlags -> ConverterFlags -> Bool
    == :: ConverterFlags -> ConverterFlags -> Bool
    $c/= :: ConverterFlags -> ConverterFlags -> Bool
    /= :: ConverterFlags -> ConverterFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_converter_flags_get_type" c_g_converter_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags ConverterFlags

    instance IsGFlag ConverterFlags

    -- Flags BusNameWatcherFlags
    -- | Flags used in @/g_bus_watch_name()/@.
    --
    -- /Since: 2.26/
    data BusNameWatcherFlags =
          BusNameWatcherFlagsNone
        -- ^ No flags set.
        | BusNameWatcherFlagsAutoStart
        -- ^ If no-one owns the name when
        -- beginning to watch the name, ask the bus to launch an owner for the
        -- name.
        | AnotherBusNameWatcherFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> BusNameWatcherFlags -> ShowS
    [BusNameWatcherFlags] -> ShowS
    BusNameWatcherFlags -> String
    (Int -> BusNameWatcherFlags -> ShowS)
    -> (BusNameWatcherFlags -> String)
    -> ([BusNameWatcherFlags] -> ShowS)
    -> Show BusNameWatcherFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BusNameWatcherFlags -> ShowS
    showsPrec :: Int -> BusNameWatcherFlags -> ShowS
    $cshow :: BusNameWatcherFlags -> String
    show :: BusNameWatcherFlags -> String
    $cshowList :: [BusNameWatcherFlags] -> ShowS
    showList :: [BusNameWatcherFlags] -> ShowS
    Show, BusNameWatcherFlags -> BusNameWatcherFlags -> Bool
    (BusNameWatcherFlags -> BusNameWatcherFlags -> Bool)
    -> (BusNameWatcherFlags -> BusNameWatcherFlags -> Bool)
    -> Eq BusNameWatcherFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BusNameWatcherFlags -> BusNameWatcherFlags -> Bool
    == :: BusNameWatcherFlags -> BusNameWatcherFlags -> Bool
    $c/= :: BusNameWatcherFlags -> BusNameWatcherFlags -> Bool
    /= :: BusNameWatcherFlags -> BusNameWatcherFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_bus_name_watcher_flags_get_type" c_g_bus_name_watcher_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags BusNameWatcherFlags

    instance IsGFlag BusNameWatcherFlags

    -- Flags BusNameOwnerFlags
    -- | Flags used in @/g_bus_own_name()/@.
    --
    -- /Since: 2.26/
    data BusNameOwnerFlags =
          BusNameOwnerFlagsNone
        -- ^ No flags set.
        | BusNameOwnerFlagsAllowReplacement
        -- ^ Allow another message bus connection to claim the name.
        | BusNameOwnerFlagsReplace
        -- ^ If another message bus connection owns the name and have
        -- specified 'GI.Gio.Flags.BusNameOwnerFlagsAllowReplacement', 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
    $cshowsPrec :: Int -> BusNameOwnerFlags -> ShowS
    showsPrec :: Int -> BusNameOwnerFlags -> ShowS
    $cshow :: BusNameOwnerFlags -> String
    show :: BusNameOwnerFlags -> String
    $cshowList :: [BusNameOwnerFlags] -> ShowS
    showList :: [BusNameOwnerFlags] -> ShowS
    Show, BusNameOwnerFlags -> BusNameOwnerFlags -> Bool
    (BusNameOwnerFlags -> BusNameOwnerFlags -> Bool)
    -> (BusNameOwnerFlags -> BusNameOwnerFlags -> Bool)
    -> Eq BusNameOwnerFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BusNameOwnerFlags -> BusNameOwnerFlags -> Bool
    == :: BusNameOwnerFlags -> BusNameOwnerFlags -> Bool
    $c/= :: BusNameOwnerFlags -> BusNameOwnerFlags -> Bool
    /= :: BusNameOwnerFlags -> BusNameOwnerFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_bus_name_owner_flags_get_type" c_g_bus_name_owner_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags BusNameOwnerFlags

    instance IsGFlag BusNameOwnerFlags

    -- Flags AskPasswordFlags
    -- | t'GI.Gio.Flags.AskPasswordFlags' are used to request specific information from the
    -- user, or to notify the user of their choices in an authentication
    -- situation.
    data AskPasswordFlags =
          AskPasswordFlagsNeedPassword
        -- ^ operation requires a password.
        | AskPasswordFlagsNeedUsername
        -- ^ operation requires a username.
        | AskPasswordFlagsNeedDomain
        -- ^ operation requires a domain.
        | AskPasswordFlagsSavingSupported
        -- ^ operation supports saving settings.
        | AskPasswordFlagsAnonymousSupported
        -- ^ operation supports anonymous users.
        | AskPasswordFlagsTcrypt
        -- ^ operation takes TCRYPT parameters (Since: 2.58)
        | AnotherAskPasswordFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AskPasswordFlags -> ShowS
    [AskPasswordFlags] -> ShowS
    AskPasswordFlags -> String
    (Int -> AskPasswordFlags -> ShowS)
    -> (AskPasswordFlags -> String)
    -> ([AskPasswordFlags] -> ShowS)
    -> Show AskPasswordFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AskPasswordFlags -> ShowS
    showsPrec :: Int -> AskPasswordFlags -> ShowS
    $cshow :: AskPasswordFlags -> String
    show :: AskPasswordFlags -> String
    $cshowList :: [AskPasswordFlags] -> ShowS
    showList :: [AskPasswordFlags] -> ShowS
    Show, AskPasswordFlags -> AskPasswordFlags -> Bool
    (AskPasswordFlags -> AskPasswordFlags -> Bool)
    -> (AskPasswordFlags -> AskPasswordFlags -> Bool)
    -> Eq AskPasswordFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AskPasswordFlags -> AskPasswordFlags -> Bool
    == :: AskPasswordFlags -> AskPasswordFlags -> Bool
    $c/= :: AskPasswordFlags -> AskPasswordFlags -> Bool
    /= :: AskPasswordFlags -> AskPasswordFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_ask_password_flags_get_type" c_g_ask_password_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags AskPasswordFlags

    instance IsGFlag AskPasswordFlags

    -- Flags ApplicationFlags
    -- | Flags used to define the behaviour of a t'GI.Gio.Objects.Application.Application'.
    --
    -- /Since: 2.28/
    data ApplicationFlags =
          ApplicationFlagsFlagsNone
        -- ^ Default. Deprecated in 2.74, use
        --   'GI.Gio.Flags.ApplicationFlagsDefaultFlags' instead
        | ApplicationFlagsDefaultFlags
        -- ^ Default flags. Since: 2.74
        | 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 [Application::commandLine]("GI.Gio.Objects.Application#g:signal:commandLine") signal handler, via
        --     'GI.Gio.Objects.ApplicationCommandLine.applicationCommandLineGetenv'.
        | ApplicationFlagsNonUnique
        -- ^ Make no attempts to do any of the typical
        --     single-instance application negotiation, even if the application
        --     ID is given.  The application neither attempts to become the
        --     owner of the application ID nor does it check if an existing
        --     owner already exists.  Everything occurs in the local process.
        --     Since: 2.30.
        | ApplicationFlagsCanOverrideAppId
        -- ^ Allow users to override the
        --     application ID from the command line with @--gapplication-app-id@.
        --     Since: 2.48
        | ApplicationFlagsAllowReplacement
        -- ^ Allow another instance to take over
        --     the bus name. Since: 2.60
        | ApplicationFlagsReplace
        -- ^ Take over from another instance. This flag is
        --     usually set by passing @--gapplication-replace@ on the commandline.
        --     Since: 2.60
        | AnotherApplicationFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ApplicationFlags -> ShowS
    [ApplicationFlags] -> ShowS
    ApplicationFlags -> String
    (Int -> ApplicationFlags -> ShowS)
    -> (ApplicationFlags -> String)
    -> ([ApplicationFlags] -> ShowS)
    -> Show ApplicationFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ApplicationFlags -> ShowS
    showsPrec :: Int -> ApplicationFlags -> ShowS
    $cshow :: ApplicationFlags -> String
    show :: ApplicationFlags -> String
    $cshowList :: [ApplicationFlags] -> ShowS
    showList :: [ApplicationFlags] -> ShowS
    Show, ApplicationFlags -> ApplicationFlags -> Bool
    (ApplicationFlags -> ApplicationFlags -> Bool)
    -> (ApplicationFlags -> ApplicationFlags -> Bool)
    -> Eq ApplicationFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ApplicationFlags -> ApplicationFlags -> Bool
    == :: ApplicationFlags -> ApplicationFlags -> Bool
    $c/= :: ApplicationFlags -> ApplicationFlags -> Bool
    /= :: ApplicationFlags -> ApplicationFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_application_flags_get_type" c_g_application_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags ApplicationFlags

    instance IsGFlag ApplicationFlags

    -- Flags AppInfoCreateFlags
    -- | Flags used when creating a t'GI.Gio.Interfaces.AppInfo.AppInfo'.
    data AppInfoCreateFlags =
          AppInfoCreateFlagsNone
        -- ^ No flags.
        | AppInfoCreateFlagsNeedsTerminal
        -- ^ Application opens in a terminal window.
        | AppInfoCreateFlagsSupportsUris
        -- ^ Application supports URI arguments.
        | AppInfoCreateFlagsSupportsStartupNotification
        -- ^ Application supports startup notification. Since 2.26
        | AnotherAppInfoCreateFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AppInfoCreateFlags -> ShowS
    [AppInfoCreateFlags] -> ShowS
    AppInfoCreateFlags -> String
    (Int -> AppInfoCreateFlags -> ShowS)
    -> (AppInfoCreateFlags -> String)
    -> ([AppInfoCreateFlags] -> ShowS)
    -> Show AppInfoCreateFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AppInfoCreateFlags -> ShowS
    showsPrec :: Int -> AppInfoCreateFlags -> ShowS
    $cshow :: AppInfoCreateFlags -> String
    show :: AppInfoCreateFlags -> String
    $cshowList :: [AppInfoCreateFlags] -> ShowS
    showList :: [AppInfoCreateFlags] -> ShowS
    Show, AppInfoCreateFlags -> AppInfoCreateFlags -> Bool
    (AppInfoCreateFlags -> AppInfoCreateFlags -> Bool)
    -> (AppInfoCreateFlags -> AppInfoCreateFlags -> Bool)
    -> Eq AppInfoCreateFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AppInfoCreateFlags -> AppInfoCreateFlags -> Bool
    == :: AppInfoCreateFlags -> AppInfoCreateFlags -> Bool
    $c/= :: AppInfoCreateFlags -> AppInfoCreateFlags -> Bool
    /= :: AppInfoCreateFlags -> AppInfoCreateFlags -> Bool
    Eq)

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

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

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

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

    foreign import ccall "g_app_info_create_flags_get_type" c_g_app_info_create_flags_get_type ::
        IO GType

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

    instance B.Types.BoxedFlags AppInfoCreateFlags

    instance IsGFlag AppInfoCreateFlags