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

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Flags
        (

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

        AppInfoCreateFlags(..)                  ,

    -- ** ApplicationFlags #flag:ApplicationFlags#

        ApplicationFlags(..)                    ,

    -- ** AskPasswordFlags #flag:AskPasswordFlags#

        AskPasswordFlags(..)                    ,

    -- ** BusNameOwnerFlags #flag:BusNameOwnerFlags#

        BusNameOwnerFlags(..)                   ,

    -- ** BusNameWatcherFlags #flag:BusNameWatcherFlags#

        BusNameWatcherFlags(..)                 ,

    -- ** ConverterFlags #flag:ConverterFlags#

        ConverterFlags(..)                      ,

    -- ** DBusCallFlags #flag:DBusCallFlags#

        DBusCallFlags(..)                       ,

    -- ** DBusCapabilityFlags #flag:DBusCapabilityFlags#

        DBusCapabilityFlags(..)                 ,

    -- ** DBusConnectionFlags #flag:DBusConnectionFlags#

        DBusConnectionFlags(..)                 ,

    -- ** DBusInterfaceSkeletonFlags #flag:DBusInterfaceSkeletonFlags#

        DBusInterfaceSkeletonFlags(..)          ,

    -- ** DBusMessageFlags #flag:DBusMessageFlags#

        DBusMessageFlags(..)                    ,

    -- ** DBusObjectManagerClientFlags #flag:DBusObjectManagerClientFlags#

        DBusObjectManagerClientFlags(..)        ,

    -- ** DBusPropertyInfoFlags #flag:DBusPropertyInfoFlags#

        DBusPropertyInfoFlags(..)               ,

    -- ** DBusProxyFlags #flag:DBusProxyFlags#

        DBusProxyFlags(..)                      ,

    -- ** DBusSendMessageFlags #flag:DBusSendMessageFlags#

        DBusSendMessageFlags(..)                ,

    -- ** DBusServerFlags #flag:DBusServerFlags#

        DBusServerFlags(..)                     ,

    -- ** DBusSignalFlags #flag:DBusSignalFlags#

        DBusSignalFlags(..)                     ,

    -- ** DBusSubtreeFlags #flag:DBusSubtreeFlags#

        DBusSubtreeFlags(..)                    ,

    -- ** DriveStartFlags #flag:DriveStartFlags#

        DriveStartFlags(..)                     ,

    -- ** FileAttributeInfoFlags #flag:FileAttributeInfoFlags#

        FileAttributeInfoFlags(..)              ,

    -- ** FileCopyFlags #flag:FileCopyFlags#

        FileCopyFlags(..)                       ,

    -- ** FileCreateFlags #flag:FileCreateFlags#

        FileCreateFlags(..)                     ,

    -- ** FileMeasureFlags #flag:FileMeasureFlags#

        FileMeasureFlags(..)                    ,

    -- ** FileMonitorFlags #flag:FileMonitorFlags#

        FileMonitorFlags(..)                    ,

    -- ** FileQueryInfoFlags #flag:FileQueryInfoFlags#

        FileQueryInfoFlags(..)                  ,

    -- ** IOStreamSpliceFlags #flag:IOStreamSpliceFlags#

        IOStreamSpliceFlags(..)                 ,

    -- ** MountMountFlags #flag:MountMountFlags#

        MountMountFlags(..)                     ,

    -- ** MountUnmountFlags #flag:MountUnmountFlags#

        MountUnmountFlags(..)                   ,

    -- ** OutputStreamSpliceFlags #flag:OutputStreamSpliceFlags#

        OutputStreamSpliceFlags(..)             ,

    -- ** ResolverNameLookupFlags #flag:ResolverNameLookupFlags#

        ResolverNameLookupFlags(..)             ,

    -- ** ResourceFlags #flag:ResourceFlags#

        ResourceFlags(..)                       ,

    -- ** ResourceLookupFlags #flag:ResourceLookupFlags#

        ResourceLookupFlags(..)                 ,

    -- ** SettingsBindFlags #flag:SettingsBindFlags#

        SettingsBindFlags(..)                   ,

    -- ** SocketMsgFlags #flag:SocketMsgFlags#

        SocketMsgFlags(..)                      ,

    -- ** SubprocessFlags #flag:SubprocessFlags#

        SubprocessFlags(..)                     ,

    -- ** TestDBusFlags #flag:TestDBusFlags#

        TestDBusFlags(..)                       ,

    -- ** TlsCertificateFlags #flag:TlsCertificateFlags#

        TlsCertificateFlags(..)                 ,

    -- ** TlsDatabaseVerifyFlags #flag:TlsDatabaseVerifyFlags#

        TlsDatabaseVerifyFlags(..)              ,

    -- ** TlsPasswordFlags #flag:TlsPasswordFlags#

        TlsPasswordFlags(..)                    ,

        ) where

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

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

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

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

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

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

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

    foreign import ccall "g_tls_password_flags_get_type" c_g_tls_password_flags_get_type ::
        IO GType

    instance BoxedFlags TlsPasswordFlags where
        boxedFlagsType _ = c_g_tls_password_flags_get_type

    instance IsGFlag TlsPasswordFlags

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

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

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

        toEnum 0 = TlsDatabaseVerifyFlagsNone
        toEnum k = AnotherTlsDatabaseVerifyFlags k

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

    foreign import ccall "g_tls_database_verify_flags_get_type" c_g_tls_database_verify_flags_get_type ::
        IO GType

    instance BoxedFlags TlsDatabaseVerifyFlags where
        boxedFlagsType _ = c_g_tls_database_verify_flags_get_type

    instance IsGFlag TlsDatabaseVerifyFlags

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

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

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

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

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

    foreign import ccall "g_tls_certificate_flags_get_type" c_g_tls_certificate_flags_get_type ::
        IO GType

    instance BoxedFlags TlsCertificateFlags where
        boxedFlagsType _ = c_g_tls_certificate_flags_get_type

    instance IsGFlag TlsCertificateFlags

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

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

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

        toEnum 0 = TestDBusFlagsNone
        toEnum k = AnotherTestDBusFlags k

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

    foreign import ccall "g_test_dbus_flags_get_type" c_g_test_dbus_flags_get_type ::
        IO GType

    instance BoxedFlags TestDBusFlags where
        boxedFlagsType _ = c_g_test_dbus_flags_get_type

    instance IsGFlag TestDBusFlags

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

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

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

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

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

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

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

    foreign import ccall "g_subprocess_flags_get_type" c_g_subprocess_flags_get_type ::
        IO GType

    instance BoxedFlags SubprocessFlags where
        boxedFlagsType _ = c_g_subprocess_flags_get_type

    instance IsGFlag SubprocessFlags

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

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

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

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

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

    foreign import ccall "g_socket_msg_flags_get_type" c_g_socket_msg_flags_get_type ::
        IO GType

    instance BoxedFlags SocketMsgFlags where
        boxedFlagsType _ = c_g_socket_msg_flags_get_type

    instance IsGFlag SocketMsgFlags

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

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

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

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

    foreign import ccall "g_settings_bind_flags_get_type" c_g_settings_bind_flags_get_type ::
        IO GType

    instance BoxedFlags SettingsBindFlags where
        boxedFlagsType _ = c_g_settings_bind_flags_get_type

    instance IsGFlag SettingsBindFlags

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

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

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

        toEnum 0 = ResourceLookupFlagsNone
        toEnum k = AnotherResourceLookupFlags k

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

    foreign import ccall "g_resource_lookup_flags_get_type" c_g_resource_lookup_flags_get_type ::
        IO GType

    instance BoxedFlags ResourceLookupFlags where
        boxedFlagsType _ = c_g_resource_lookup_flags_get_type

    instance IsGFlag ResourceLookupFlags

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

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

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

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

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

    foreign import ccall "g_resource_flags_get_type" c_g_resource_flags_get_type ::
        IO GType

    instance BoxedFlags ResourceFlags where
        boxedFlagsType _ = c_g_resource_flags_get_type

    instance IsGFlag ResourceFlags

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

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

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

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

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

    foreign import ccall "g_resolver_name_lookup_flags_get_type" c_g_resolver_name_lookup_flags_get_type ::
        IO GType

    instance BoxedFlags ResolverNameLookupFlags where
        boxedFlagsType _ = c_g_resolver_name_lookup_flags_get_type

    instance IsGFlag ResolverNameLookupFlags

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

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

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

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

    foreign import ccall "g_output_stream_splice_flags_get_type" c_g_output_stream_splice_flags_get_type ::
        IO GType

    instance BoxedFlags OutputStreamSpliceFlags where
        boxedFlagsType _ = c_g_output_stream_splice_flags_get_type

    instance IsGFlag OutputStreamSpliceFlags

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

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

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

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

    foreign import ccall "g_mount_unmount_flags_get_type" c_g_mount_unmount_flags_get_type ::
        IO GType

    instance BoxedFlags MountUnmountFlags where
        boxedFlagsType _ = c_g_mount_unmount_flags_get_type

    instance IsGFlag MountUnmountFlags

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

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

        toEnum 0 = MountMountFlagsNone
        toEnum k = AnotherMountMountFlags k

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

    foreign import ccall "g_mount_mount_flags_get_type" c_g_mount_mount_flags_get_type ::
        IO GType

    instance BoxedFlags MountMountFlags where
        boxedFlagsType _ = c_g_mount_mount_flags_get_type

    instance IsGFlag MountMountFlags

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

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

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

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

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

    foreign import ccall "g_io_stream_splice_flags_get_type" c_g_io_stream_splice_flags_get_type ::
        IO GType

    instance BoxedFlags IOStreamSpliceFlags where
        boxedFlagsType _ = c_g_io_stream_splice_flags_get_type

    instance IsGFlag IOStreamSpliceFlags

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

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

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

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

    foreign import ccall "g_file_query_info_flags_get_type" c_g_file_query_info_flags_get_type ::
        IO GType

    instance BoxedFlags FileQueryInfoFlags where
        boxedFlagsType _ = c_g_file_query_info_flags_get_type

    instance IsGFlag FileQueryInfoFlags

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

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

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

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

    foreign import ccall "g_file_monitor_flags_get_type" c_g_file_monitor_flags_get_type ::
        IO GType

    instance BoxedFlags FileMonitorFlags where
        boxedFlagsType _ = c_g_file_monitor_flags_get_type

    instance IsGFlag FileMonitorFlags

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

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

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

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

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

    foreign import ccall "g_file_measure_flags_get_type" c_g_file_measure_flags_get_type ::
        IO GType

    instance BoxedFlags FileMeasureFlags where
        boxedFlagsType _ = c_g_file_measure_flags_get_type

    instance IsGFlag FileMeasureFlags

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

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

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

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

    foreign import ccall "g_file_create_flags_get_type" c_g_file_create_flags_get_type ::
        IO GType

    instance BoxedFlags FileCreateFlags where
        boxedFlagsType _ = c_g_file_create_flags_get_type

    instance IsGFlag FileCreateFlags

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

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

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

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

    foreign import ccall "g_file_copy_flags_get_type" c_g_file_copy_flags_get_type ::
        IO GType

    instance BoxedFlags FileCopyFlags where
        boxedFlagsType _ = c_g_file_copy_flags_get_type

    instance IsGFlag FileCopyFlags

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

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

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

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

    foreign import ccall "g_file_attribute_info_flags_get_type" c_g_file_attribute_info_flags_get_type ::
        IO GType

    instance BoxedFlags FileAttributeInfoFlags where
        boxedFlagsType _ = c_g_file_attribute_info_flags_get_type

    instance IsGFlag FileAttributeInfoFlags

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

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

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

        toEnum 0 = DriveStartFlagsNone
        toEnum k = AnotherDriveStartFlags k

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

    foreign import ccall "g_drive_start_flags_get_type" c_g_drive_start_flags_get_type ::
        IO GType

    instance BoxedFlags DriveStartFlags where
        boxedFlagsType _ = c_g_drive_start_flags_get_type

    instance IsGFlag DriveStartFlags

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

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

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

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

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

    foreign import ccall "g_dbus_subtree_flags_get_type" c_g_dbus_subtree_flags_get_type ::
        IO GType

    instance BoxedFlags DBusSubtreeFlags where
        boxedFlagsType _ = c_g_dbus_subtree_flags_get_type

    instance IsGFlag DBusSubtreeFlags

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

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

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

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

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

    foreign import ccall "g_dbus_signal_flags_get_type" c_g_dbus_signal_flags_get_type ::
        IO GType

    instance BoxedFlags DBusSignalFlags where
        boxedFlagsType _ = c_g_dbus_signal_flags_get_type

    instance IsGFlag DBusSignalFlags

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

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

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

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

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

    foreign import ccall "g_dbus_server_flags_get_type" c_g_dbus_server_flags_get_type ::
        IO GType

    instance BoxedFlags DBusServerFlags where
        boxedFlagsType _ = c_g_dbus_server_flags_get_type

    instance IsGFlag DBusServerFlags

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

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

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

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

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

    foreign import ccall "g_dbus_send_message_flags_get_type" c_g_dbus_send_message_flags_get_type ::
        IO GType

    instance BoxedFlags DBusSendMessageFlags where
        boxedFlagsType _ = c_g_dbus_send_message_flags_get_type

    instance IsGFlag DBusSendMessageFlags

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

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

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

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

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

    foreign import ccall "g_dbus_proxy_flags_get_type" c_g_dbus_proxy_flags_get_type ::
        IO GType

    instance BoxedFlags DBusProxyFlags where
        boxedFlagsType _ = c_g_dbus_proxy_flags_get_type

    instance IsGFlag DBusProxyFlags

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

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

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

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

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

    foreign import ccall "g_dbus_property_info_flags_get_type" c_g_dbus_property_info_flags_get_type ::
        IO GType

    instance BoxedFlags DBusPropertyInfoFlags where
        boxedFlagsType _ = c_g_dbus_property_info_flags_get_type

    instance IsGFlag DBusPropertyInfoFlags

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

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

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

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

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

    foreign import ccall "g_dbus_object_manager_client_flags_get_type" c_g_dbus_object_manager_client_flags_get_type ::
        IO GType

    instance BoxedFlags DBusObjectManagerClientFlags where
        boxedFlagsType _ = c_g_dbus_object_manager_client_flags_get_type

    instance IsGFlag DBusObjectManagerClientFlags

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

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

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

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

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

    foreign import ccall "g_dbus_message_flags_get_type" c_g_dbus_message_flags_get_type ::
        IO GType

    instance BoxedFlags DBusMessageFlags where
        boxedFlagsType _ = c_g_dbus_message_flags_get_type

    instance IsGFlag DBusMessageFlags

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

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

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

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

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

    foreign import ccall "g_dbus_interface_skeleton_flags_get_type" c_g_dbus_interface_skeleton_flags_get_type ::
        IO GType

    instance BoxedFlags DBusInterfaceSkeletonFlags where
        boxedFlagsType _ = c_g_dbus_interface_skeleton_flags_get_type

    instance IsGFlag DBusInterfaceSkeletonFlags

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

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

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

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

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

    foreign import ccall "g_dbus_connection_flags_get_type" c_g_dbus_connection_flags_get_type ::
        IO GType

    instance BoxedFlags DBusConnectionFlags where
        boxedFlagsType _ = c_g_dbus_connection_flags_get_type

    instance IsGFlag DBusConnectionFlags

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

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

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

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

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

    foreign import ccall "g_dbus_capability_flags_get_type" c_g_dbus_capability_flags_get_type ::
        IO GType

    instance BoxedFlags DBusCapabilityFlags where
        boxedFlagsType _ = c_g_dbus_capability_flags_get_type

    instance IsGFlag DBusCapabilityFlags

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

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

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

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

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

    foreign import ccall "g_dbus_call_flags_get_type" c_g_dbus_call_flags_get_type ::
        IO GType

    instance BoxedFlags DBusCallFlags where
        boxedFlagsType _ = c_g_dbus_call_flags_get_type

    instance IsGFlag DBusCallFlags

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

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

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

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

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

    foreign import ccall "g_converter_flags_get_type" c_g_converter_flags_get_type ::
        IO GType

    instance BoxedFlags ConverterFlags where
        boxedFlagsType _ = c_g_converter_flags_get_type

    instance IsGFlag ConverterFlags

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

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

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

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

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

    foreign import ccall "g_bus_name_watcher_flags_get_type" c_g_bus_name_watcher_flags_get_type ::
        IO GType

    instance BoxedFlags BusNameWatcherFlags where
        boxedFlagsType _ = c_g_bus_name_watcher_flags_get_type

    instance IsGFlag BusNameWatcherFlags

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

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

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

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

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

    foreign import ccall "g_bus_name_owner_flags_get_type" c_g_bus_name_owner_flags_get_type ::
        IO GType

    instance BoxedFlags BusNameOwnerFlags where
        boxedFlagsType _ = c_g_bus_name_owner_flags_get_type

    instance IsGFlag BusNameOwnerFlags

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

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

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

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

    foreign import ccall "g_ask_password_flags_get_type" c_g_ask_password_flags_get_type ::
        IO GType

    instance BoxedFlags AskPasswordFlags where
        boxedFlagsType _ = c_g_ask_password_flags_get_type

    instance IsGFlag AskPasswordFlags

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

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

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

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

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

    foreign import ccall "g_application_flags_get_type" c_g_application_flags_get_type ::
        IO GType

    instance BoxedFlags ApplicationFlags where
        boxedFlagsType _ = c_g_application_flags_get_type

    instance IsGFlag ApplicationFlags

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

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

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

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

    foreign import ccall "g_app_info_create_flags_get_type" c_g_app_info_create_flags_get_type ::
        IO GType

    instance BoxedFlags AppInfoCreateFlags where
        boxedFlagsType _ = c_g_app_info_create_flags_get_type

    instance IsGFlag AppInfoCreateFlags