    -- | 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.Gtk.Flags
        (

     -- * Flags

    -- ** ApplicationInhibitFlags #flag:ApplicationInhibitFlags#

        ApplicationInhibitFlags(..)             ,

    -- ** BuilderClosureFlags #flag:BuilderClosureFlags#

        BuilderClosureFlags(..)                 ,

    -- ** CellRendererState #flag:CellRendererState#

        CellRendererState(..)                   ,

    -- ** DebugFlags #flag:DebugFlags#

        DebugFlags(..)                          ,

    -- ** DialogFlags #flag:DialogFlags#

        DialogFlags(..)                         ,

    -- ** EventControllerScrollFlags #flag:EventControllerScrollFlags#

        EventControllerScrollFlags(..)          ,

    -- ** FontChooserLevel #flag:FontChooserLevel#

        FontChooserLevel(..)                    ,

    -- ** IconLookupFlags #flag:IconLookupFlags#

        IconLookupFlags(..)                     ,

    -- ** InputHints #flag:InputHints#

        InputHints(..)                          ,

    -- ** ListScrollFlags #flag:ListScrollFlags#

        ListScrollFlags(..)                     ,

    -- ** PickFlags #flag:PickFlags#

        PickFlags(..)                           ,

    -- ** PopoverMenuFlags #flag:PopoverMenuFlags#

        PopoverMenuFlags(..)                    ,

    -- ** PrintCapabilities #flag:PrintCapabilities#

        PrintCapabilities(..)                   ,

    -- ** ShortcutActionFlags #flag:ShortcutActionFlags#

        ShortcutActionFlags(..)                 ,

    -- ** StateFlags #flag:StateFlags#

        StateFlags(..)                          ,

    -- ** StyleContextPrintFlags #flag:StyleContextPrintFlags#

        StyleContextPrintFlags(..)              ,

    -- ** SvgFeatures #flag:SvgFeatures#

        SvgFeatures(..)                         ,

    -- ** TextBufferNotifyFlags #flag:TextBufferNotifyFlags#

        TextBufferNotifyFlags(..)               ,

    -- ** TextSearchFlags #flag:TextSearchFlags#

        TextSearchFlags(..)                     ,

    -- ** TreeModelFlags #flag:TreeModelFlags#

        TreeModelFlags(..)                      ,

        ) 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
    import qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)

    #else

    #endif

    -- Flags TreeModelFlags
    {-# DEPRECATED TreeModelFlags ["(Since version 4.10)","There is no replacement"] #-}
    -- | These flags indicate various properties of a @GtkTreeModel@.
    --
    -- They are returned by 'GI.Gtk.Interfaces.TreeModel.treeModelGetFlags', and must be
    -- static for the lifetime of the object. A more complete description
    -- of 'GI.Gtk.Flags.TreeModelFlagsItersPersist' can be found in the overview of
    -- this section.
    data TreeModelFlags =
          TreeModelFlagsItersPersist
        -- ^ iterators survive all signals
        --   emitted by the tree
        | TreeModelFlagsListOnly
        -- ^ the model is a list only, and never
        --   has children
        | AnotherTreeModelFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TreeModelFlags -> ShowS
    [TreeModelFlags] -> ShowS
    TreeModelFlags -> String
    (Int -> TreeModelFlags -> ShowS)
    -> (TreeModelFlags -> String)
    -> ([TreeModelFlags] -> ShowS)
    -> Show TreeModelFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TreeModelFlags -> ShowS
    showsPrec :: Int -> TreeModelFlags -> ShowS
    $cshow :: TreeModelFlags -> String
    show :: TreeModelFlags -> String
    $cshowList :: [TreeModelFlags] -> ShowS
    showList :: [TreeModelFlags] -> ShowS
    Show, TreeModelFlags -> TreeModelFlags -> Bool
    (TreeModelFlags -> TreeModelFlags -> Bool)
    -> (TreeModelFlags -> TreeModelFlags -> Bool) -> Eq TreeModelFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TreeModelFlags -> TreeModelFlags -> Bool
    == :: TreeModelFlags -> TreeModelFlags -> Bool
    $c/= :: TreeModelFlags -> TreeModelFlags -> Bool
    /= :: TreeModelFlags -> TreeModelFlags -> Bool
    Eq)

    instance P.Enum TreeModelFlags where
        fromEnum :: TreeModelFlags -> Int
    fromEnum TreeModelFlags
    TreeModelFlagsItersPersist = Int
    1
        fromEnum TreeModelFlags
    TreeModelFlagsListOnly = Int
    2
        fromEnum (AnotherTreeModelFlags Int
    k) = Int
    k

        toEnum :: Int -> TreeModelFlags
    toEnum Int
    1 = TreeModelFlags
    TreeModelFlagsItersPersist
        toEnum Int
    2 = TreeModelFlags
    TreeModelFlagsListOnly
        toEnum Int
    k = Int -> TreeModelFlags
    AnotherTreeModelFlags Int
    k

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

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

    foreign import ccall "gtk_tree_model_flags_get_type" c_gtk_tree_model_flags_get_type ::
        IO GType

    instance B.Types.TypedObject TreeModelFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_tree_model_flags_get_type

    instance B.Types.BoxedFlags TreeModelFlags

    instance IsGFlag TreeModelFlags

    -- Flags TextSearchFlags
    -- | Flags affecting how a search is done.
    --
    -- If neither @GTK_TEXT_SEARCH_VISIBLE_ONLY@ nor @GTK_TEXT_SEARCH_TEXT_ONLY@
    -- are enabled, the match must be exact; the special 0xFFFC character will
    -- match embedded paintables or child widgets.
    data TextSearchFlags =
          TextSearchFlagsVisibleOnly
        -- ^ Search only visible data. A search match may
        -- have invisible text interspersed.
        | TextSearchFlagsTextOnly
        -- ^ Search only text. A match may have paintables or
        -- child widgets mixed inside the matched range.
        | TextSearchFlagsCaseInsensitive
        -- ^ The text will be matched regardless of
        -- what case it is in.
        | AnotherTextSearchFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TextSearchFlags -> ShowS
    [TextSearchFlags] -> ShowS
    TextSearchFlags -> String
    (Int -> TextSearchFlags -> ShowS)
    -> (TextSearchFlags -> String)
    -> ([TextSearchFlags] -> ShowS)
    -> Show TextSearchFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TextSearchFlags -> ShowS
    showsPrec :: Int -> TextSearchFlags -> ShowS
    $cshow :: TextSearchFlags -> String
    show :: TextSearchFlags -> String
    $cshowList :: [TextSearchFlags] -> ShowS
    showList :: [TextSearchFlags] -> ShowS
    Show, TextSearchFlags -> TextSearchFlags -> Bool
    (TextSearchFlags -> TextSearchFlags -> Bool)
    -> (TextSearchFlags -> TextSearchFlags -> Bool)
    -> Eq TextSearchFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TextSearchFlags -> TextSearchFlags -> Bool
    == :: TextSearchFlags -> TextSearchFlags -> Bool
    $c/= :: TextSearchFlags -> TextSearchFlags -> Bool
    /= :: TextSearchFlags -> TextSearchFlags -> Bool
    Eq)

    instance P.Enum TextSearchFlags where
        fromEnum :: TextSearchFlags -> Int
    fromEnum TextSearchFlags
    TextSearchFlagsVisibleOnly = Int
    1
        fromEnum TextSearchFlags
    TextSearchFlagsTextOnly = Int
    2
        fromEnum TextSearchFlags
    TextSearchFlagsCaseInsensitive = Int
    4
        fromEnum (AnotherTextSearchFlags Int
    k) = Int
    k

        toEnum :: Int -> TextSearchFlags
    toEnum Int
    1 = TextSearchFlags
    TextSearchFlagsVisibleOnly
        toEnum Int
    2 = TextSearchFlags
    TextSearchFlagsTextOnly
        toEnum Int
    4 = TextSearchFlags
    TextSearchFlagsCaseInsensitive
        toEnum Int
    k = Int -> TextSearchFlags
    AnotherTextSearchFlags Int
    k

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

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

    foreign import ccall "gtk_text_search_flags_get_type" c_gtk_text_search_flags_get_type ::
        IO GType

    instance B.Types.TypedObject TextSearchFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_text_search_flags_get_type

    instance B.Types.BoxedFlags TextSearchFlags

    instance IsGFlag TextSearchFlags

    -- Flags TextBufferNotifyFlags
    -- | Values for [callback/@gtk@/.TextBufferCommitNotify] to denote the
    -- point of the notification.
    --
    -- /Since: 4.16/
    data TextBufferNotifyFlags =
          TextBufferNotifyFlagsBeforeInsert
        -- ^ Be notified before text
        --   is inserted into the underlying buffer.
        | TextBufferNotifyFlagsAfterInsert
        -- ^ Be notified after text
        --   has been inserted into the underlying buffer.
        | TextBufferNotifyFlagsBeforeDelete
        -- ^ Be notified before text
        --   is deleted from the underlying buffer.
        | TextBufferNotifyFlagsAfterDelete
        -- ^ Be notified after text
        --   has been deleted from the underlying buffer.
        | AnotherTextBufferNotifyFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TextBufferNotifyFlags -> ShowS
    [TextBufferNotifyFlags] -> ShowS
    TextBufferNotifyFlags -> String
    (Int -> TextBufferNotifyFlags -> ShowS)
    -> (TextBufferNotifyFlags -> String)
    -> ([TextBufferNotifyFlags] -> ShowS)
    -> Show TextBufferNotifyFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TextBufferNotifyFlags -> ShowS
    showsPrec :: Int -> TextBufferNotifyFlags -> ShowS
    $cshow :: TextBufferNotifyFlags -> String
    show :: TextBufferNotifyFlags -> String
    $cshowList :: [TextBufferNotifyFlags] -> ShowS
    showList :: [TextBufferNotifyFlags] -> ShowS
    Show, TextBufferNotifyFlags -> TextBufferNotifyFlags -> Bool
    (TextBufferNotifyFlags -> TextBufferNotifyFlags -> Bool)
    -> (TextBufferNotifyFlags -> TextBufferNotifyFlags -> Bool)
    -> Eq TextBufferNotifyFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TextBufferNotifyFlags -> TextBufferNotifyFlags -> Bool
    == :: TextBufferNotifyFlags -> TextBufferNotifyFlags -> Bool
    $c/= :: TextBufferNotifyFlags -> TextBufferNotifyFlags -> Bool
    /= :: TextBufferNotifyFlags -> TextBufferNotifyFlags -> Bool
    Eq)

    instance P.Enum TextBufferNotifyFlags where
        fromEnum :: TextBufferNotifyFlags -> Int
    fromEnum TextBufferNotifyFlags
    TextBufferNotifyFlagsBeforeInsert = Int
    1
        fromEnum TextBufferNotifyFlags
    TextBufferNotifyFlagsAfterInsert = Int
    2
        fromEnum TextBufferNotifyFlags
    TextBufferNotifyFlagsBeforeDelete = Int
    4
        fromEnum TextBufferNotifyFlags
    TextBufferNotifyFlagsAfterDelete = Int
    8
        fromEnum (AnotherTextBufferNotifyFlags Int
    k) = Int
    k

        toEnum :: Int -> TextBufferNotifyFlags
    toEnum Int
    1 = TextBufferNotifyFlags
    TextBufferNotifyFlagsBeforeInsert
        toEnum Int
    2 = TextBufferNotifyFlags
    TextBufferNotifyFlagsAfterInsert
        toEnum Int
    4 = TextBufferNotifyFlags
    TextBufferNotifyFlagsBeforeDelete
        toEnum Int
    8 = TextBufferNotifyFlags
    TextBufferNotifyFlagsAfterDelete
        toEnum Int
    k = Int -> TextBufferNotifyFlags
    AnotherTextBufferNotifyFlags Int
    k

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

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

    foreign import ccall "gtk_text_buffer_notify_flags_get_type" c_gtk_text_buffer_notify_flags_get_type ::
        IO GType

    instance B.Types.TypedObject TextBufferNotifyFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_text_buffer_notify_flags_get_type

    instance B.Types.BoxedFlags TextBufferNotifyFlags

    instance IsGFlag TextBufferNotifyFlags

    -- Flags SvgFeatures
    -- | Features of the SVG renderer that can be enabled or disabled.
    --
    -- By default, all features except @GTK_SVG_TRADITIONAL_SYMBOLIC@
    -- are enabled.
    --
    -- New values may be added in the future.
    --
    -- /Since: 4.22/
    data SvgFeatures =
          SvgFeaturesAnimations
        -- ^ Whether to run animations. If disabled,
        --   state changes are applied without transitions
        | SvgFeaturesSystemResources
        -- ^ Whether to use system resources,
        --   such as fonts. If disabled, only embedded fonts are used
        | SvgFeaturesExternalResources
        -- ^ Whether to load external
        --   resources, such as images. If disabled, only embedded
        --   images are loaded
        | SvgFeaturesExtensions
        -- ^ Whether to allow gpa extensions, such
        --   as states and transitions
        | SvgFeaturesTraditionalSymbolic
        -- ^ This feature is meant for
        --   compatibility with old symbolic icons. If this is enabled,
        --   fill and stroke attributes are ignored. The used colors
        --   are derived from symbolic style classes if present, and
        --   the default fill color is the symbolic foreground color.
        | AnotherSvgFeatures Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SvgFeatures -> ShowS
    [SvgFeatures] -> ShowS
    SvgFeatures -> String
    (Int -> SvgFeatures -> ShowS)
    -> (SvgFeatures -> String)
    -> ([SvgFeatures] -> ShowS)
    -> Show SvgFeatures
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SvgFeatures -> ShowS
    showsPrec :: Int -> SvgFeatures -> ShowS
    $cshow :: SvgFeatures -> String
    show :: SvgFeatures -> String
    $cshowList :: [SvgFeatures] -> ShowS
    showList :: [SvgFeatures] -> ShowS
    Show, SvgFeatures -> SvgFeatures -> Bool
    (SvgFeatures -> SvgFeatures -> Bool)
    -> (SvgFeatures -> SvgFeatures -> Bool) -> Eq SvgFeatures
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SvgFeatures -> SvgFeatures -> Bool
    == :: SvgFeatures -> SvgFeatures -> Bool
    $c/= :: SvgFeatures -> SvgFeatures -> Bool
    /= :: SvgFeatures -> SvgFeatures -> Bool
    Eq)

    instance P.Enum SvgFeatures where
        fromEnum :: SvgFeatures -> Int
    fromEnum SvgFeatures
    SvgFeaturesAnimations = Int
    1
        fromEnum SvgFeatures
    SvgFeaturesSystemResources = Int
    2
        fromEnum SvgFeatures
    SvgFeaturesExternalResources = Int
    4
        fromEnum SvgFeatures
    SvgFeaturesExtensions = Int
    8
        fromEnum SvgFeatures
    SvgFeaturesTraditionalSymbolic = Int
    16
        fromEnum (AnotherSvgFeatures Int
    k) = Int
    k

        toEnum :: Int -> SvgFeatures
    toEnum Int
    1 = SvgFeatures
    SvgFeaturesAnimations
        toEnum Int
    2 = SvgFeatures
    SvgFeaturesSystemResources
        toEnum Int
    4 = SvgFeatures
    SvgFeaturesExternalResources
        toEnum Int
    8 = SvgFeatures
    SvgFeaturesExtensions
        toEnum Int
    16 = SvgFeatures
    SvgFeaturesTraditionalSymbolic
        toEnum Int
    k = Int -> SvgFeatures
    AnotherSvgFeatures Int
    k

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

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

    foreign import ccall "gtk_svg_features_get_type" c_gtk_svg_features_get_type ::
        IO GType

    instance B.Types.TypedObject SvgFeatures where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_svg_features_get_type

    instance B.Types.BoxedFlags SvgFeatures

    instance IsGFlag SvgFeatures

    -- Flags StyleContextPrintFlags
    -- | Flags that modify the behavior of 'GI.Gtk.Objects.StyleContext.styleContextToString'.
    --
    -- New values may be added to this enumeration.
    data StyleContextPrintFlags =
          StyleContextPrintFlagsNone
        -- ^ Default value.
        | StyleContextPrintFlagsRecurse
        -- ^ Print the entire tree of
        --   CSS nodes starting at the style context\'s node
        | StyleContextPrintFlagsShowStyle
        -- ^ Show the values of the
        --   CSS properties for each node
        | StyleContextPrintFlagsShowChange
        -- ^ Show information about
        --   what changes affect the styles
        | AnotherStyleContextPrintFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> StyleContextPrintFlags -> ShowS
    [StyleContextPrintFlags] -> ShowS
    StyleContextPrintFlags -> String
    (Int -> StyleContextPrintFlags -> ShowS)
    -> (StyleContextPrintFlags -> String)
    -> ([StyleContextPrintFlags] -> ShowS)
    -> Show StyleContextPrintFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> StyleContextPrintFlags -> ShowS
    showsPrec :: Int -> StyleContextPrintFlags -> ShowS
    $cshow :: StyleContextPrintFlags -> String
    show :: StyleContextPrintFlags -> String
    $cshowList :: [StyleContextPrintFlags] -> ShowS
    showList :: [StyleContextPrintFlags] -> ShowS
    Show, StyleContextPrintFlags -> StyleContextPrintFlags -> Bool
    (StyleContextPrintFlags -> StyleContextPrintFlags -> Bool)
    -> (StyleContextPrintFlags -> StyleContextPrintFlags -> Bool)
    -> Eq StyleContextPrintFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: StyleContextPrintFlags -> StyleContextPrintFlags -> Bool
    == :: StyleContextPrintFlags -> StyleContextPrintFlags -> Bool
    $c/= :: StyleContextPrintFlags -> StyleContextPrintFlags -> Bool
    /= :: StyleContextPrintFlags -> StyleContextPrintFlags -> Bool
    Eq)

    instance P.Enum StyleContextPrintFlags where
        fromEnum :: StyleContextPrintFlags -> Int
    fromEnum StyleContextPrintFlags
    StyleContextPrintFlagsNone = Int
    0
        fromEnum StyleContextPrintFlags
    StyleContextPrintFlagsRecurse = Int
    1
        fromEnum StyleContextPrintFlags
    StyleContextPrintFlagsShowStyle = Int
    2
        fromEnum StyleContextPrintFlags
    StyleContextPrintFlagsShowChange = Int
    4
        fromEnum (AnotherStyleContextPrintFlags Int
    k) = Int
    k

        toEnum :: Int -> StyleContextPrintFlags
    toEnum Int
    0 = StyleContextPrintFlags
    StyleContextPrintFlagsNone
        toEnum Int
    1 = StyleContextPrintFlags
    StyleContextPrintFlagsRecurse
        toEnum Int
    2 = StyleContextPrintFlags
    StyleContextPrintFlagsShowStyle
        toEnum Int
    4 = StyleContextPrintFlags
    StyleContextPrintFlagsShowChange
        toEnum Int
    k = Int -> StyleContextPrintFlags
    AnotherStyleContextPrintFlags Int
    k

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

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

    foreign import ccall "gtk_style_context_print_flags_get_type" c_gtk_style_context_print_flags_get_type ::
        IO GType

    instance B.Types.TypedObject StyleContextPrintFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_style_context_print_flags_get_type

    instance B.Types.BoxedFlags StyleContextPrintFlags

    instance IsGFlag StyleContextPrintFlags

    -- Flags StateFlags
    -- | Describes a widget state.
    --
    -- Widget states are used to match the widget against CSS pseudo-classes.
    -- Note that GTK extends the regular CSS classes and sometimes uses
    -- different names.
    data StateFlags =
          StateFlagsNormal
        -- ^ State during normal operation
        | StateFlagsActive
        -- ^ Widget is active
        | StateFlagsPrelight
        -- ^ Widget has a mouse pointer over it
        | StateFlagsSelected
        -- ^ Widget is selected
        | StateFlagsInsensitive
        -- ^ Widget is insensitive
        | StateFlagsInconsistent
        -- ^ Widget is inconsistent
        | StateFlagsFocused
        -- ^ Widget has the keyboard focus
        | StateFlagsBackdrop
        -- ^ Widget is in a background toplevel window
        | StateFlagsDirLtr
        -- ^ Widget is in left-to-right text direction
        | StateFlagsDirRtl
        -- ^ Widget is in right-to-left text direction
        | StateFlagsLink
        -- ^ Widget is a link
        | StateFlagsVisited
        -- ^ The location the widget points to has already been visited
        | StateFlagsChecked
        -- ^ Widget is checked
        | StateFlagsDropActive
        -- ^ Widget is highlighted as a drop target for DND
        | StateFlagsFocusVisible
        -- ^ Widget has the visible focus
        | StateFlagsFocusWithin
        -- ^ Widget contains the keyboard focus
        | AnotherStateFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> StateFlags -> ShowS
    [StateFlags] -> ShowS
    StateFlags -> String
    (Int -> StateFlags -> ShowS)
    -> (StateFlags -> String)
    -> ([StateFlags] -> ShowS)
    -> Show StateFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> StateFlags -> ShowS
    showsPrec :: Int -> StateFlags -> ShowS
    $cshow :: StateFlags -> String
    show :: StateFlags -> String
    $cshowList :: [StateFlags] -> ShowS
    showList :: [StateFlags] -> ShowS
    Show, StateFlags -> StateFlags -> Bool
    (StateFlags -> StateFlags -> Bool)
    -> (StateFlags -> StateFlags -> Bool) -> Eq StateFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: StateFlags -> StateFlags -> Bool
    == :: StateFlags -> StateFlags -> Bool
    $c/= :: StateFlags -> StateFlags -> Bool
    /= :: StateFlags -> StateFlags -> Bool
    Eq)

    instance P.Enum StateFlags where
        fromEnum :: StateFlags -> Int
    fromEnum StateFlags
    StateFlagsNormal = Int
    0
        fromEnum StateFlags
    StateFlagsActive = Int
    1
        fromEnum StateFlags
    StateFlagsPrelight = Int
    2
        fromEnum StateFlags
    StateFlagsSelected = Int
    4
        fromEnum StateFlags
    StateFlagsInsensitive = Int
    8
        fromEnum StateFlags
    StateFlagsInconsistent = Int
    16
        fromEnum StateFlags
    StateFlagsFocused = Int
    32
        fromEnum StateFlags
    StateFlagsBackdrop = Int
    64
        fromEnum StateFlags
    StateFlagsDirLtr = Int
    128
        fromEnum StateFlags
    StateFlagsDirRtl = Int
    256
        fromEnum StateFlags
    StateFlagsLink = Int
    512
        fromEnum StateFlags
    StateFlagsVisited = Int
    1024
        fromEnum StateFlags
    StateFlagsChecked = Int
    2048
        fromEnum StateFlags
    StateFlagsDropActive = Int
    4096
        fromEnum StateFlags
    StateFlagsFocusVisible = Int
    8192
        fromEnum StateFlags
    StateFlagsFocusWithin = Int
    16384
        fromEnum (AnotherStateFlags Int
    k) = Int
    k

        toEnum :: Int -> StateFlags
    toEnum Int
    0 = StateFlags
    StateFlagsNormal
        toEnum Int
    1 = StateFlags
    StateFlagsActive
        toEnum Int
    2 = StateFlags
    StateFlagsPrelight
        toEnum Int
    4 = StateFlags
    StateFlagsSelected
        toEnum Int
    8 = StateFlags
    StateFlagsInsensitive
        toEnum Int
    16 = StateFlags
    StateFlagsInconsistent
        toEnum Int
    32 = StateFlags
    StateFlagsFocused
        toEnum Int
    64 = StateFlags
    StateFlagsBackdrop
        toEnum Int
    128 = StateFlags
    StateFlagsDirLtr
        toEnum Int
    256 = StateFlags
    StateFlagsDirRtl
        toEnum Int
    512 = StateFlags
    StateFlagsLink
        toEnum Int
    1024 = StateFlags
    StateFlagsVisited
        toEnum Int
    2048 = StateFlags
    StateFlagsChecked
        toEnum Int
    4096 = StateFlags
    StateFlagsDropActive
        toEnum Int
    8192 = StateFlags
    StateFlagsFocusVisible
        toEnum Int
    16384 = StateFlags
    StateFlagsFocusWithin
        toEnum Int
    k = Int -> StateFlags
    AnotherStateFlags Int
    k

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

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

    foreign import ccall "gtk_state_flags_get_type" c_gtk_state_flags_get_type ::
        IO GType

    instance B.Types.TypedObject StateFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_state_flags_get_type

    instance B.Types.BoxedFlags StateFlags

    instance IsGFlag StateFlags

    -- Flags ShortcutActionFlags
    -- | Flags that can be passed to action activation.
    --
    -- More flags may be added in the future.
    data ShortcutActionFlags =
          ShortcutActionFlagsExclusive
        -- ^ The action is the only
        --   action that can be activated. If this flag is not set,
        --   a future activation may select a different action.
        | AnotherShortcutActionFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ShortcutActionFlags -> ShowS
    [ShortcutActionFlags] -> ShowS
    ShortcutActionFlags -> String
    (Int -> ShortcutActionFlags -> ShowS)
    -> (ShortcutActionFlags -> String)
    -> ([ShortcutActionFlags] -> ShowS)
    -> Show ShortcutActionFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ShortcutActionFlags -> ShowS
    showsPrec :: Int -> ShortcutActionFlags -> ShowS
    $cshow :: ShortcutActionFlags -> String
    show :: ShortcutActionFlags -> String
    $cshowList :: [ShortcutActionFlags] -> ShowS
    showList :: [ShortcutActionFlags] -> ShowS
    Show, ShortcutActionFlags -> ShortcutActionFlags -> Bool
    (ShortcutActionFlags -> ShortcutActionFlags -> Bool)
    -> (ShortcutActionFlags -> ShortcutActionFlags -> Bool)
    -> Eq ShortcutActionFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ShortcutActionFlags -> ShortcutActionFlags -> Bool
    == :: ShortcutActionFlags -> ShortcutActionFlags -> Bool
    $c/= :: ShortcutActionFlags -> ShortcutActionFlags -> Bool
    /= :: ShortcutActionFlags -> ShortcutActionFlags -> Bool
    Eq)

    instance P.Enum ShortcutActionFlags where
        fromEnum :: ShortcutActionFlags -> Int
    fromEnum ShortcutActionFlags
    ShortcutActionFlagsExclusive = Int
    1
        fromEnum (AnotherShortcutActionFlags Int
    k) = Int
    k

        toEnum :: Int -> ShortcutActionFlags
    toEnum Int
    1 = ShortcutActionFlags
    ShortcutActionFlagsExclusive
        toEnum Int
    k = Int -> ShortcutActionFlags
    AnotherShortcutActionFlags Int
    k

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

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

    foreign import ccall "gtk_shortcut_action_flags_get_type" c_gtk_shortcut_action_flags_get_type ::
        IO GType

    instance B.Types.TypedObject ShortcutActionFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_shortcut_action_flags_get_type

    instance B.Types.BoxedFlags ShortcutActionFlags

    instance IsGFlag ShortcutActionFlags

    -- Flags PrintCapabilities
    -- | Specifies which features the print dialog should offer.
    --
    -- If neither 'GI.Gtk.Flags.PrintCapabilitiesGeneratePdf' nor
    -- 'GI.Gtk.Flags.PrintCapabilitiesGeneratePs' is specified, GTK assumes that all
    -- formats are supported.
    data PrintCapabilities =
          PrintCapabilitiesPageSet
        -- ^ Print dialog will offer printing even\/odd pages.
        | PrintCapabilitiesCopies
        -- ^ Print dialog will allow to print multiple copies.
        | PrintCapabilitiesCollate
        -- ^ Print dialog will allow to collate multiple copies.
        | PrintCapabilitiesReverse
        -- ^ Print dialog will allow to print pages in reverse order.
        | PrintCapabilitiesScale
        -- ^ Print dialog will allow to scale the output.
        | PrintCapabilitiesGeneratePdf
        -- ^ The program will send the document to
        --   the printer in PDF format
        | PrintCapabilitiesGeneratePs
        -- ^ The program will send the document to
        --   the printer in Postscript format
        | PrintCapabilitiesPreview
        -- ^ Print dialog will offer a preview
        | PrintCapabilitiesNumberUp
        -- ^ Print dialog will offer printing multiple
        --   pages per sheet
        | PrintCapabilitiesNumberUpLayout
        -- ^ Print dialog will allow to rearrange
        --   pages when printing multiple pages per sheet
        | AnotherPrintCapabilities Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PrintCapabilities -> ShowS
    [PrintCapabilities] -> ShowS
    PrintCapabilities -> String
    (Int -> PrintCapabilities -> ShowS)
    -> (PrintCapabilities -> String)
    -> ([PrintCapabilities] -> ShowS)
    -> Show PrintCapabilities
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PrintCapabilities -> ShowS
    showsPrec :: Int -> PrintCapabilities -> ShowS
    $cshow :: PrintCapabilities -> String
    show :: PrintCapabilities -> String
    $cshowList :: [PrintCapabilities] -> ShowS
    showList :: [PrintCapabilities] -> ShowS
    Show, PrintCapabilities -> PrintCapabilities -> Bool
    (PrintCapabilities -> PrintCapabilities -> Bool)
    -> (PrintCapabilities -> PrintCapabilities -> Bool)
    -> Eq PrintCapabilities
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PrintCapabilities -> PrintCapabilities -> Bool
    == :: PrintCapabilities -> PrintCapabilities -> Bool
    $c/= :: PrintCapabilities -> PrintCapabilities -> Bool
    /= :: PrintCapabilities -> PrintCapabilities -> Bool
    Eq)

    instance P.Enum PrintCapabilities where
        fromEnum :: PrintCapabilities -> Int
    fromEnum PrintCapabilities
    PrintCapabilitiesPageSet = Int
    1
        fromEnum PrintCapabilities
    PrintCapabilitiesCopies = Int
    2
        fromEnum PrintCapabilities
    PrintCapabilitiesCollate = Int
    4
        fromEnum PrintCapabilities
    PrintCapabilitiesReverse = Int
    8
        fromEnum PrintCapabilities
    PrintCapabilitiesScale = Int
    16
        fromEnum PrintCapabilities
    PrintCapabilitiesGeneratePdf = Int
    32
        fromEnum PrintCapabilities
    PrintCapabilitiesGeneratePs = Int
    64
        fromEnum PrintCapabilities
    PrintCapabilitiesPreview = Int
    128
        fromEnum PrintCapabilities
    PrintCapabilitiesNumberUp = Int
    256
        fromEnum PrintCapabilities
    PrintCapabilitiesNumberUpLayout = Int
    512
        fromEnum (AnotherPrintCapabilities Int
    k) = Int
    k

        toEnum :: Int -> PrintCapabilities
    toEnum Int
    1 = PrintCapabilities
    PrintCapabilitiesPageSet
        toEnum Int
    2 = PrintCapabilities
    PrintCapabilitiesCopies
        toEnum Int
    4 = PrintCapabilities
    PrintCapabilitiesCollate
        toEnum Int
    8 = PrintCapabilities
    PrintCapabilitiesReverse
        toEnum Int
    16 = PrintCapabilities
    PrintCapabilitiesScale
        toEnum Int
    32 = PrintCapabilities
    PrintCapabilitiesGeneratePdf
        toEnum Int
    64 = PrintCapabilities
    PrintCapabilitiesGeneratePs
        toEnum Int
    128 = PrintCapabilities
    PrintCapabilitiesPreview
        toEnum Int
    256 = PrintCapabilities
    PrintCapabilitiesNumberUp
        toEnum Int
    512 = PrintCapabilities
    PrintCapabilitiesNumberUpLayout
        toEnum Int
    k = Int -> PrintCapabilities
    AnotherPrintCapabilities Int
    k

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

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

    foreign import ccall "gtk_print_capabilities_get_type" c_gtk_print_capabilities_get_type ::
        IO GType

    instance B.Types.TypedObject PrintCapabilities where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_print_capabilities_get_type

    instance B.Types.BoxedFlags PrintCapabilities

    instance IsGFlag PrintCapabilities

    -- Flags PopoverMenuFlags
    -- | Flags that affect how t'GI.Gtk.Objects.PopoverMenu.PopoverMenu' widgets built from
    -- a t'GI.Gio.Objects.MenuModel.MenuModel' are created and displayed.
    data PopoverMenuFlags =
          PopoverMenuFlagsSliding
        -- ^ Submenus are presented as sliding submenus that replace the main menu.
        --
        -- /Since: 4.14/
        | PopoverMenuFlagsNested
        -- ^ Submenus are presented as traditional, nested
        --   popovers.
        | AnotherPopoverMenuFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PopoverMenuFlags -> ShowS
    [PopoverMenuFlags] -> ShowS
    PopoverMenuFlags -> String
    (Int -> PopoverMenuFlags -> ShowS)
    -> (PopoverMenuFlags -> String)
    -> ([PopoverMenuFlags] -> ShowS)
    -> Show PopoverMenuFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PopoverMenuFlags -> ShowS
    showsPrec :: Int -> PopoverMenuFlags -> ShowS
    $cshow :: PopoverMenuFlags -> String
    show :: PopoverMenuFlags -> String
    $cshowList :: [PopoverMenuFlags] -> ShowS
    showList :: [PopoverMenuFlags] -> ShowS
    Show, PopoverMenuFlags -> PopoverMenuFlags -> Bool
    (PopoverMenuFlags -> PopoverMenuFlags -> Bool)
    -> (PopoverMenuFlags -> PopoverMenuFlags -> Bool)
    -> Eq PopoverMenuFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PopoverMenuFlags -> PopoverMenuFlags -> Bool
    == :: PopoverMenuFlags -> PopoverMenuFlags -> Bool
    $c/= :: PopoverMenuFlags -> PopoverMenuFlags -> Bool
    /= :: PopoverMenuFlags -> PopoverMenuFlags -> Bool
    Eq)

    instance P.Enum PopoverMenuFlags where
        fromEnum :: PopoverMenuFlags -> Int
    fromEnum PopoverMenuFlags
    PopoverMenuFlagsSliding = Int
    0
        fromEnum PopoverMenuFlags
    PopoverMenuFlagsNested = Int
    1
        fromEnum (AnotherPopoverMenuFlags Int
    k) = Int
    k

        toEnum :: Int -> PopoverMenuFlags
    toEnum Int
    0 = PopoverMenuFlags
    PopoverMenuFlagsSliding
        toEnum Int
    1 = PopoverMenuFlags
    PopoverMenuFlagsNested
        toEnum Int
    k = Int -> PopoverMenuFlags
    AnotherPopoverMenuFlags Int
    k

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

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

    foreign import ccall "gtk_popover_menu_flags_get_type" c_gtk_popover_menu_flags_get_type ::
        IO GType

    instance B.Types.TypedObject PopoverMenuFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_popover_menu_flags_get_type

    instance B.Types.BoxedFlags PopoverMenuFlags

    instance IsGFlag PopoverMenuFlags

    -- Flags PickFlags
    -- | Flags that influence the behavior of [method/@widget@/.pick].
    data PickFlags =
          PickFlagsDefault
        -- ^ The default behavior, include widgets that are receiving events
        | PickFlagsInsensitive
        -- ^ Include widgets that are insensitive
        | PickFlagsNonTargetable
        -- ^ Include widgets that are marked as non-targetable. See [property/@widget@/:can-target]
        | AnotherPickFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PickFlags -> ShowS
    [PickFlags] -> ShowS
    PickFlags -> String
    (Int -> PickFlags -> ShowS)
    -> (PickFlags -> String)
    -> ([PickFlags] -> ShowS)
    -> Show PickFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PickFlags -> ShowS
    showsPrec :: Int -> PickFlags -> ShowS
    $cshow :: PickFlags -> String
    show :: PickFlags -> String
    $cshowList :: [PickFlags] -> ShowS
    showList :: [PickFlags] -> ShowS
    Show, PickFlags -> PickFlags -> Bool
    (PickFlags -> PickFlags -> Bool)
    -> (PickFlags -> PickFlags -> Bool) -> Eq PickFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PickFlags -> PickFlags -> Bool
    == :: PickFlags -> PickFlags -> Bool
    $c/= :: PickFlags -> PickFlags -> Bool
    /= :: PickFlags -> PickFlags -> Bool
    Eq)

    instance P.Enum PickFlags where
        fromEnum :: PickFlags -> Int
    fromEnum PickFlags
    PickFlagsDefault = Int
    0
        fromEnum PickFlags
    PickFlagsInsensitive = Int
    1
        fromEnum PickFlags
    PickFlagsNonTargetable = Int
    2
        fromEnum (AnotherPickFlags Int
    k) = Int
    k

        toEnum :: Int -> PickFlags
    toEnum Int
    0 = PickFlags
    PickFlagsDefault
        toEnum Int
    1 = PickFlags
    PickFlagsInsensitive
        toEnum Int
    2 = PickFlags
    PickFlagsNonTargetable
        toEnum Int
    k = Int -> PickFlags
    AnotherPickFlags Int
    k

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

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

    foreign import ccall "gtk_pick_flags_get_type" c_gtk_pick_flags_get_type ::
        IO GType

    instance B.Types.TypedObject PickFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_pick_flags_get_type

    instance B.Types.BoxedFlags PickFlags

    instance IsGFlag PickFlags

    -- Flags ListScrollFlags
    -- | List of actions to perform when scrolling to items in
    -- a list widget.
    --
    -- /Since: 4.12/
    data ListScrollFlags =
          ListScrollFlagsNone
        -- ^ Don\'t do anything extra
        | ListScrollFlagsFocus
        -- ^ Focus the target item
        | ListScrollFlagsSelect
        -- ^ Select the target item and
        --   unselect all other items.
        | AnotherListScrollFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ListScrollFlags -> ShowS
    [ListScrollFlags] -> ShowS
    ListScrollFlags -> String
    (Int -> ListScrollFlags -> ShowS)
    -> (ListScrollFlags -> String)
    -> ([ListScrollFlags] -> ShowS)
    -> Show ListScrollFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ListScrollFlags -> ShowS
    showsPrec :: Int -> ListScrollFlags -> ShowS
    $cshow :: ListScrollFlags -> String
    show :: ListScrollFlags -> String
    $cshowList :: [ListScrollFlags] -> ShowS
    showList :: [ListScrollFlags] -> ShowS
    Show, ListScrollFlags -> ListScrollFlags -> Bool
    (ListScrollFlags -> ListScrollFlags -> Bool)
    -> (ListScrollFlags -> ListScrollFlags -> Bool)
    -> Eq ListScrollFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ListScrollFlags -> ListScrollFlags -> Bool
    == :: ListScrollFlags -> ListScrollFlags -> Bool
    $c/= :: ListScrollFlags -> ListScrollFlags -> Bool
    /= :: ListScrollFlags -> ListScrollFlags -> Bool
    Eq)

    instance P.Enum ListScrollFlags where
        fromEnum :: ListScrollFlags -> Int
    fromEnum ListScrollFlags
    ListScrollFlagsNone = Int
    0
        fromEnum ListScrollFlags
    ListScrollFlagsFocus = Int
    1
        fromEnum ListScrollFlags
    ListScrollFlagsSelect = Int
    2
        fromEnum (AnotherListScrollFlags Int
    k) = Int
    k

        toEnum :: Int -> ListScrollFlags
    toEnum Int
    0 = ListScrollFlags
    ListScrollFlagsNone
        toEnum Int
    1 = ListScrollFlags
    ListScrollFlagsFocus
        toEnum Int
    2 = ListScrollFlags
    ListScrollFlagsSelect
        toEnum Int
    k = Int -> ListScrollFlags
    AnotherListScrollFlags Int
    k

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

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

    foreign import ccall "gtk_list_scroll_flags_get_type" c_gtk_list_scroll_flags_get_type ::
        IO GType

    instance B.Types.TypedObject ListScrollFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_list_scroll_flags_get_type

    instance B.Types.BoxedFlags ListScrollFlags

    instance IsGFlag ListScrollFlags

    -- Flags InputHints
    -- | Describes hints that might be taken into account by input methods
    -- or applications.
    --
    -- Note that input methods may already tailor their behaviour according
    -- to the [enum/@inputPurpose@/] of the entry.
    --
    -- Some common sense is expected when using these flags - mixing
    -- 'GI.Gtk.Flags.InputHintsLowercase' with any of the uppercase hints makes no sense.
    --
    -- This enumeration may be extended in the future; input methods should
    -- ignore unknown values.
    data InputHints =
          InputHintsNone
        -- ^ No special behaviour suggested
        | InputHintsSpellcheck
        -- ^ Suggest checking for typos
        | InputHintsNoSpellcheck
        -- ^ Suggest not checking for typos
        | InputHintsWordCompletion
        -- ^ Suggest word completion
        | InputHintsLowercase
        -- ^ Suggest to convert all text to lowercase
        | InputHintsUppercaseChars
        -- ^ Suggest to capitalize all text
        | InputHintsUppercaseWords
        -- ^ Suggest to capitalize the first
        --   character of each word
        | InputHintsUppercaseSentences
        -- ^ Suggest to capitalize the
        --   first word of each sentence
        | InputHintsInhibitOsk
        -- ^ Suggest to not show an onscreen keyboard
        --   (e.g for a calculator that already has all the keys).
        | InputHintsVerticalWriting
        -- ^ The text is vertical
        | InputHintsEmoji
        -- ^ Suggest offering Emoji support
        | InputHintsNoEmoji
        -- ^ Suggest not offering Emoji support
        | InputHintsPrivate
        -- ^ Request that the input method should not
        --    update personalized data (like typing history)
        | AnotherInputHints Int
        -- ^ Catch-all for unknown values
        deriving (Int -> InputHints -> ShowS
    [InputHints] -> ShowS
    InputHints -> String
    (Int -> InputHints -> ShowS)
    -> (InputHints -> String)
    -> ([InputHints] -> ShowS)
    -> Show InputHints
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> InputHints -> ShowS
    showsPrec :: Int -> InputHints -> ShowS
    $cshow :: InputHints -> String
    show :: InputHints -> String
    $cshowList :: [InputHints] -> ShowS
    showList :: [InputHints] -> ShowS
    Show, InputHints -> InputHints -> Bool
    (InputHints -> InputHints -> Bool)
    -> (InputHints -> InputHints -> Bool) -> Eq InputHints
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: InputHints -> InputHints -> Bool
    == :: InputHints -> InputHints -> Bool
    $c/= :: InputHints -> InputHints -> Bool
    /= :: InputHints -> InputHints -> Bool
    Eq)

    instance P.Enum InputHints where
        fromEnum :: InputHints -> Int
    fromEnum InputHints
    InputHintsNone = Int
    0
        fromEnum InputHints
    InputHintsSpellcheck = Int
    1
        fromEnum InputHints
    InputHintsNoSpellcheck = Int
    2
        fromEnum InputHints
    InputHintsWordCompletion = Int
    4
        fromEnum InputHints
    InputHintsLowercase = Int
    8
        fromEnum InputHints
    InputHintsUppercaseChars = Int
    16
        fromEnum InputHints
    InputHintsUppercaseWords = Int
    32
        fromEnum InputHints
    InputHintsUppercaseSentences = Int
    64
        fromEnum InputHints
    InputHintsInhibitOsk = Int
    128
        fromEnum InputHints
    InputHintsVerticalWriting = Int
    256
        fromEnum InputHints
    InputHintsEmoji = Int
    512
        fromEnum InputHints
    InputHintsNoEmoji = Int
    1024
        fromEnum InputHints
    InputHintsPrivate = Int
    2048
        fromEnum (AnotherInputHints Int
    k) = Int
    k

        toEnum :: Int -> InputHints
    toEnum Int
    0 = InputHints
    InputHintsNone
        toEnum Int
    1 = InputHints
    InputHintsSpellcheck
        toEnum Int
    2 = InputHints
    InputHintsNoSpellcheck
        toEnum Int
    4 = InputHints
    InputHintsWordCompletion
        toEnum Int
    8 = InputHints
    InputHintsLowercase
        toEnum Int
    16 = InputHints
    InputHintsUppercaseChars
        toEnum Int
    32 = InputHints
    InputHintsUppercaseWords
        toEnum Int
    64 = InputHints
    InputHintsUppercaseSentences
        toEnum Int
    128 = InputHints
    InputHintsInhibitOsk
        toEnum Int
    256 = InputHints
    InputHintsVerticalWriting
        toEnum Int
    512 = InputHints
    InputHintsEmoji
        toEnum Int
    1024 = InputHints
    InputHintsNoEmoji
        toEnum Int
    2048 = InputHints
    InputHintsPrivate
        toEnum Int
    k = Int -> InputHints
    AnotherInputHints Int
    k

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

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

    foreign import ccall "gtk_input_hints_get_type" c_gtk_input_hints_get_type ::
        IO GType

    instance B.Types.TypedObject InputHints where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_input_hints_get_type

    instance B.Types.BoxedFlags InputHints

    instance IsGFlag InputHints

    -- Flags IconLookupFlags
    -- | Used to specify options for 'GI.Gtk.Objects.IconTheme.iconThemeLookupIcon'.
    data IconLookupFlags =
          IconLookupFlagsNone
        -- ^ Perform a regular lookup.
        --
        -- /Since: 4.18/
        | IconLookupFlagsForceRegular
        -- ^ Try to always load regular icons, even
        --   when symbolic icon names are given
        | IconLookupFlagsForceSymbolic
        -- ^ Try to always load symbolic icons, even
        --   when regular icon names are given
        | IconLookupFlagsPreload
        -- ^ Starts loading the texture in the background
        --   so it is ready when later needed.
        | AnotherIconLookupFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> IconLookupFlags -> ShowS
    [IconLookupFlags] -> ShowS
    IconLookupFlags -> String
    (Int -> IconLookupFlags -> ShowS)
    -> (IconLookupFlags -> String)
    -> ([IconLookupFlags] -> ShowS)
    -> Show IconLookupFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> IconLookupFlags -> ShowS
    showsPrec :: Int -> IconLookupFlags -> ShowS
    $cshow :: IconLookupFlags -> String
    show :: IconLookupFlags -> String
    $cshowList :: [IconLookupFlags] -> ShowS
    showList :: [IconLookupFlags] -> ShowS
    Show, IconLookupFlags -> IconLookupFlags -> Bool
    (IconLookupFlags -> IconLookupFlags -> Bool)
    -> (IconLookupFlags -> IconLookupFlags -> Bool)
    -> Eq IconLookupFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: IconLookupFlags -> IconLookupFlags -> Bool
    == :: IconLookupFlags -> IconLookupFlags -> Bool
    $c/= :: IconLookupFlags -> IconLookupFlags -> Bool
    /= :: IconLookupFlags -> IconLookupFlags -> Bool
    Eq)

    instance P.Enum IconLookupFlags where
        fromEnum :: IconLookupFlags -> Int
    fromEnum IconLookupFlags
    IconLookupFlagsNone = Int
    0
        fromEnum IconLookupFlags
    IconLookupFlagsForceRegular = Int
    1
        fromEnum IconLookupFlags
    IconLookupFlagsForceSymbolic = Int
    2
        fromEnum IconLookupFlags
    IconLookupFlagsPreload = Int
    4
        fromEnum (AnotherIconLookupFlags Int
    k) = Int
    k

        toEnum :: Int -> IconLookupFlags
    toEnum Int
    0 = IconLookupFlags
    IconLookupFlagsNone
        toEnum Int
    1 = IconLookupFlags
    IconLookupFlagsForceRegular
        toEnum Int
    2 = IconLookupFlags
    IconLookupFlagsForceSymbolic
        toEnum Int
    4 = IconLookupFlags
    IconLookupFlagsPreload
        toEnum Int
    k = Int -> IconLookupFlags
    AnotherIconLookupFlags Int
    k

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

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

    foreign import ccall "gtk_icon_lookup_flags_get_type" c_gtk_icon_lookup_flags_get_type ::
        IO GType

    instance B.Types.TypedObject IconLookupFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_icon_lookup_flags_get_type

    instance B.Types.BoxedFlags IconLookupFlags

    instance IsGFlag IconLookupFlags

    -- Flags FontChooserLevel
    {-# DEPRECATED FontChooserLevel ["(Since version 4.20)","There is no replacement."] #-}
    -- | Specifies the granularity of font selection
    -- that is desired in a @GtkFontChooser@.
    --
    -- This enumeration may be extended in the future; applications should
    -- ignore unknown values.
    data FontChooserLevel =
          FontChooserLevelFamily
        -- ^ Allow selecting a font family
        | FontChooserLevelStyle
        -- ^ Allow selecting a specific font face
        | FontChooserLevelSize
        -- ^ Allow selecting a specific font size
        | FontChooserLevelVariations
        -- ^ Allow changing OpenType font variation axes
        | FontChooserLevelFeatures
        -- ^ Allow selecting specific OpenType font features
        | AnotherFontChooserLevel Int
        -- ^ Catch-all for unknown values
        deriving (Int -> FontChooserLevel -> ShowS
    [FontChooserLevel] -> ShowS
    FontChooserLevel -> String
    (Int -> FontChooserLevel -> ShowS)
    -> (FontChooserLevel -> String)
    -> ([FontChooserLevel] -> ShowS)
    -> Show FontChooserLevel
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FontChooserLevel -> ShowS
    showsPrec :: Int -> FontChooserLevel -> ShowS
    $cshow :: FontChooserLevel -> String
    show :: FontChooserLevel -> String
    $cshowList :: [FontChooserLevel] -> ShowS
    showList :: [FontChooserLevel] -> ShowS
    Show, FontChooserLevel -> FontChooserLevel -> Bool
    (FontChooserLevel -> FontChooserLevel -> Bool)
    -> (FontChooserLevel -> FontChooserLevel -> Bool)
    -> Eq FontChooserLevel
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FontChooserLevel -> FontChooserLevel -> Bool
    == :: FontChooserLevel -> FontChooserLevel -> Bool
    $c/= :: FontChooserLevel -> FontChooserLevel -> Bool
    /= :: FontChooserLevel -> FontChooserLevel -> Bool
    Eq)

    instance P.Enum FontChooserLevel where
        fromEnum :: FontChooserLevel -> Int
    fromEnum FontChooserLevel
    FontChooserLevelFamily = Int
    0
        fromEnum FontChooserLevel
    FontChooserLevelStyle = Int
    1
        fromEnum FontChooserLevel
    FontChooserLevelSize = Int
    2
        fromEnum FontChooserLevel
    FontChooserLevelVariations = Int
    4
        fromEnum FontChooserLevel
    FontChooserLevelFeatures = Int
    8
        fromEnum (AnotherFontChooserLevel Int
    k) = Int
    k

        toEnum :: Int -> FontChooserLevel
    toEnum Int
    0 = FontChooserLevel
    FontChooserLevelFamily
        toEnum Int
    1 = FontChooserLevel
    FontChooserLevelStyle
        toEnum Int
    2 = FontChooserLevel
    FontChooserLevelSize
        toEnum Int
    4 = FontChooserLevel
    FontChooserLevelVariations
        toEnum Int
    8 = FontChooserLevel
    FontChooserLevelFeatures
        toEnum Int
    k = Int -> FontChooserLevel
    AnotherFontChooserLevel Int
    k

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

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

    foreign import ccall "gtk_font_chooser_level_get_type" c_gtk_font_chooser_level_get_type ::
        IO GType

    instance B.Types.TypedObject FontChooserLevel where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_font_chooser_level_get_type

    instance B.Types.BoxedFlags FontChooserLevel

    instance IsGFlag FontChooserLevel

    -- Flags EventControllerScrollFlags
    -- | Describes the behavior of a @GtkEventControllerScroll@.
    data EventControllerScrollFlags =
          EventControllerScrollFlagsNone
        -- ^ Don\'t emit scroll.
        | EventControllerScrollFlagsVertical
        -- ^ Emit scroll with vertical deltas.
        | EventControllerScrollFlagsHorizontal
        -- ^ Emit scroll with horizontal deltas.
        | EventControllerScrollFlagsDiscrete
        -- ^ Only emit deltas that are multiples of 1.
        | EventControllerScrollFlagsKinetic
        -- ^ Emit [decelerate](#g:signal:decelerate) after continuous scroll finishes.
        | EventControllerScrollFlagsPhysicalDirection
        -- ^ A t'GI.Gtk.Flags.EventControllerScrollFlags' value to prefer physical direction over
        -- logical direction (i.e. oblivious to natural scroll).
        --
        -- /Since: 4.20/
        | EventControllerScrollFlagsBothAxes
        -- ^ Emit scroll on both axes.
        | AnotherEventControllerScrollFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> EventControllerScrollFlags -> ShowS
    [EventControllerScrollFlags] -> ShowS
    EventControllerScrollFlags -> String
    (Int -> EventControllerScrollFlags -> ShowS)
    -> (EventControllerScrollFlags -> String)
    -> ([EventControllerScrollFlags] -> ShowS)
    -> Show EventControllerScrollFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EventControllerScrollFlags -> ShowS
    showsPrec :: Int -> EventControllerScrollFlags -> ShowS
    $cshow :: EventControllerScrollFlags -> String
    show :: EventControllerScrollFlags -> String
    $cshowList :: [EventControllerScrollFlags] -> ShowS
    showList :: [EventControllerScrollFlags] -> ShowS
    Show, EventControllerScrollFlags -> EventControllerScrollFlags -> Bool
    (EventControllerScrollFlags -> EventControllerScrollFlags -> Bool)
    -> (EventControllerScrollFlags
        -> EventControllerScrollFlags -> Bool)
    -> Eq EventControllerScrollFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EventControllerScrollFlags -> EventControllerScrollFlags -> Bool
    == :: EventControllerScrollFlags -> EventControllerScrollFlags -> Bool
    $c/= :: EventControllerScrollFlags -> EventControllerScrollFlags -> Bool
    /= :: EventControllerScrollFlags -> EventControllerScrollFlags -> Bool
    Eq)

    instance P.Enum EventControllerScrollFlags where
        fromEnum :: EventControllerScrollFlags -> Int
    fromEnum EventControllerScrollFlags
    EventControllerScrollFlagsNone = Int
    0
        fromEnum EventControllerScrollFlags
    EventControllerScrollFlagsVertical = Int
    1
        fromEnum EventControllerScrollFlags
    EventControllerScrollFlagsHorizontal = Int
    2
        fromEnum EventControllerScrollFlags
    EventControllerScrollFlagsDiscrete = Int
    4
        fromEnum EventControllerScrollFlags
    EventControllerScrollFlagsKinetic = Int
    8
        fromEnum EventControllerScrollFlags
    EventControllerScrollFlagsPhysicalDirection = Int
    16
        fromEnum EventControllerScrollFlags
    EventControllerScrollFlagsBothAxes = Int
    3
        fromEnum (AnotherEventControllerScrollFlags Int
    k) = Int
    k

        toEnum :: Int -> EventControllerScrollFlags
    toEnum Int
    0 = EventControllerScrollFlags
    EventControllerScrollFlagsNone
        toEnum Int
    1 = EventControllerScrollFlags
    EventControllerScrollFlagsVertical
        toEnum Int
    2 = EventControllerScrollFlags
    EventControllerScrollFlagsHorizontal
        toEnum Int
    4 = EventControllerScrollFlags
    EventControllerScrollFlagsDiscrete
        toEnum Int
    8 = EventControllerScrollFlags
    EventControllerScrollFlagsKinetic
        toEnum Int
    16 = EventControllerScrollFlags
    EventControllerScrollFlagsPhysicalDirection
        toEnum Int
    3 = EventControllerScrollFlags
    EventControllerScrollFlagsBothAxes
        toEnum Int
    k = Int -> EventControllerScrollFlags
    AnotherEventControllerScrollFlags Int
    k

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

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

    foreign import ccall "gtk_event_controller_scroll_flags_get_type" c_gtk_event_controller_scroll_flags_get_type ::
        IO GType

    instance B.Types.TypedObject EventControllerScrollFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_event_controller_scroll_flags_get_type

    instance B.Types.BoxedFlags EventControllerScrollFlags

    instance IsGFlag EventControllerScrollFlags

    -- Flags DialogFlags
    {-# DEPRECATED DialogFlags ["(Since version 4.20)","There is no replacement."] #-}
    -- | Flags used to influence dialog construction.
    data DialogFlags =
          DialogFlagsModal
        -- ^ Make the constructed dialog modal
        | DialogFlagsDestroyWithParent
        -- ^ Destroy the dialog when its parent is destroyed
        | DialogFlagsUseHeaderBar
        -- ^ Create dialog with actions in header
        --   bar instead of action area
        | AnotherDialogFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DialogFlags -> ShowS
    [DialogFlags] -> ShowS
    DialogFlags -> String
    (Int -> DialogFlags -> ShowS)
    -> (DialogFlags -> String)
    -> ([DialogFlags] -> ShowS)
    -> Show DialogFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DialogFlags -> ShowS
    showsPrec :: Int -> DialogFlags -> ShowS
    $cshow :: DialogFlags -> String
    show :: DialogFlags -> String
    $cshowList :: [DialogFlags] -> ShowS
    showList :: [DialogFlags] -> ShowS
    Show, DialogFlags -> DialogFlags -> Bool
    (DialogFlags -> DialogFlags -> Bool)
    -> (DialogFlags -> DialogFlags -> Bool) -> Eq DialogFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DialogFlags -> DialogFlags -> Bool
    == :: DialogFlags -> DialogFlags -> Bool
    $c/= :: DialogFlags -> DialogFlags -> Bool
    /= :: DialogFlags -> DialogFlags -> Bool
    Eq)

    instance P.Enum DialogFlags where
        fromEnum :: DialogFlags -> Int
    fromEnum DialogFlags
    DialogFlagsModal = Int
    1
        fromEnum DialogFlags
    DialogFlagsDestroyWithParent = Int
    2
        fromEnum DialogFlags
    DialogFlagsUseHeaderBar = Int
    4
        fromEnum (AnotherDialogFlags Int
    k) = Int
    k

        toEnum :: Int -> DialogFlags
    toEnum Int
    1 = DialogFlags
    DialogFlagsModal
        toEnum Int
    2 = DialogFlags
    DialogFlagsDestroyWithParent
        toEnum Int
    4 = DialogFlags
    DialogFlagsUseHeaderBar
        toEnum Int
    k = Int -> DialogFlags
    AnotherDialogFlags Int
    k

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

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

    foreign import ccall "gtk_dialog_flags_get_type" c_gtk_dialog_flags_get_type ::
        IO GType

    instance B.Types.TypedObject DialogFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_dialog_flags_get_type

    instance B.Types.BoxedFlags DialogFlags

    instance IsGFlag DialogFlags

    -- Flags DebugFlags
    -- | Flags to use with 'GI.Gtk.Functions.setDebugFlags'.
    --
    -- Settings these flags causes GTK to print out different
    -- types of debugging information. Some of these flags are
    -- only available when GTK has been configured with @-Ddebug=true@.
    data DebugFlags =
          DebugFlagsText
        -- ^ Information about GtkTextView
        | DebugFlagsTree
        -- ^ Information about GtkTreeView
        | DebugFlagsKeybindings
        -- ^ Information about keyboard shortcuts
        | DebugFlagsModules
        -- ^ Information about modules and extensions
        | DebugFlagsGeometry
        -- ^ Information about size allocation
        | DebugFlagsIcontheme
        -- ^ Information about icon themes
        | DebugFlagsPrinting
        -- ^ Information about printing
        | DebugFlagsBuilderTrace
        -- ^ Trace GtkBuilder operation
        | DebugFlagsSizeRequest
        -- ^ Information about size requests
        | DebugFlagsNoCssCache
        -- ^ Disable the style property cache
        | DebugFlagsInteractive
        -- ^ Open the GTK inspector
        | DebugFlagsTouchscreen
        -- ^ Show touch UI elements for pointer events.
        --
        -- /Since: 4.20/
        | DebugFlagsActions
        -- ^ Information about actions and menu models
        | DebugFlagsLayout
        -- ^ Information from layout managers
        | DebugFlagsSnapshot
        -- ^ Include debug render nodes in the generated snapshots
        | DebugFlagsConstraints
        -- ^ Information from the constraints solver
        | DebugFlagsBuilderObjects
        -- ^ Log unused GtkBuilder objects
        | DebugFlagsA11y
        -- ^ Information about accessibility state changes
        | DebugFlagsIconfallback
        -- ^ Information about icon fallback.
        --
        -- /Since: 4.2/
        | DebugFlagsInvertTextDir
        -- ^ Inverts the default text-direction.
        --
        -- /Since: 4.8/
        | DebugFlagsCss
        -- ^ Information about deprecated CSS features.
        --
        -- /Since: 4.16/
        | DebugFlagsBuilder
        -- ^ Information about deprecated GtkBuilder features.
        --
        -- /Since: 4.18/
        | DebugFlagsSession
        -- ^ Information about session saving.
        --
        -- /Since: 4.22/
        | AnotherDebugFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DebugFlags -> ShowS
    [DebugFlags] -> ShowS
    DebugFlags -> String
    (Int -> DebugFlags -> ShowS)
    -> (DebugFlags -> String)
    -> ([DebugFlags] -> ShowS)
    -> Show DebugFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DebugFlags -> ShowS
    showsPrec :: Int -> DebugFlags -> ShowS
    $cshow :: DebugFlags -> String
    show :: DebugFlags -> String
    $cshowList :: [DebugFlags] -> ShowS
    showList :: [DebugFlags] -> ShowS
    Show, DebugFlags -> DebugFlags -> Bool
    (DebugFlags -> DebugFlags -> Bool)
    -> (DebugFlags -> DebugFlags -> Bool) -> Eq DebugFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DebugFlags -> DebugFlags -> Bool
    == :: DebugFlags -> DebugFlags -> Bool
    $c/= :: DebugFlags -> DebugFlags -> Bool
    /= :: DebugFlags -> DebugFlags -> Bool
    Eq)

    instance P.Enum DebugFlags where
        fromEnum :: DebugFlags -> Int
    fromEnum DebugFlags
    DebugFlagsText = Int
    1
        fromEnum DebugFlags
    DebugFlagsTree = Int
    2
        fromEnum DebugFlags
    DebugFlagsKeybindings = Int
    4
        fromEnum DebugFlags
    DebugFlagsModules = Int
    8
        fromEnum DebugFlags
    DebugFlagsGeometry = Int
    16
        fromEnum DebugFlags
    DebugFlagsIcontheme = Int
    32
        fromEnum DebugFlags
    DebugFlagsPrinting = Int
    64
        fromEnum DebugFlags
    DebugFlagsBuilderTrace = Int
    128
        fromEnum DebugFlags
    DebugFlagsSizeRequest = Int
    256
        fromEnum DebugFlags
    DebugFlagsNoCssCache = Int
    512
        fromEnum DebugFlags
    DebugFlagsInteractive = Int
    1024
        fromEnum DebugFlags
    DebugFlagsTouchscreen = Int
    2048
        fromEnum DebugFlags
    DebugFlagsActions = Int
    4096
        fromEnum DebugFlags
    DebugFlagsLayout = Int
    8192
        fromEnum DebugFlags
    DebugFlagsSnapshot = Int
    16384
        fromEnum DebugFlags
    DebugFlagsConstraints = Int
    32768
        fromEnum DebugFlags
    DebugFlagsBuilderObjects = Int
    65536
        fromEnum DebugFlags
    DebugFlagsA11y = Int
    131072
        fromEnum DebugFlags
    DebugFlagsIconfallback = Int
    262144
        fromEnum DebugFlags
    DebugFlagsInvertTextDir = Int
    524288
        fromEnum DebugFlags
    DebugFlagsCss = Int
    1048576
        fromEnum DebugFlags
    DebugFlagsBuilder = Int
    2097152
        fromEnum DebugFlags
    DebugFlagsSession = Int
    4194304
        fromEnum (AnotherDebugFlags Int
    k) = Int
    k

        toEnum :: Int -> DebugFlags
    toEnum Int
    1 = DebugFlags
    DebugFlagsText
        toEnum Int
    2 = DebugFlags
    DebugFlagsTree
        toEnum Int
    4 = DebugFlags
    DebugFlagsKeybindings
        toEnum Int
    8 = DebugFlags
    DebugFlagsModules
        toEnum Int
    16 = DebugFlags
    DebugFlagsGeometry
        toEnum Int
    32 = DebugFlags
    DebugFlagsIcontheme
        toEnum Int
    64 = DebugFlags
    DebugFlagsPrinting
        toEnum Int
    128 = DebugFlags
    DebugFlagsBuilderTrace
        toEnum Int
    256 = DebugFlags
    DebugFlagsSizeRequest
        toEnum Int
    512 = DebugFlags
    DebugFlagsNoCssCache
        toEnum Int
    1024 = DebugFlags
    DebugFlagsInteractive
        toEnum Int
    2048 = DebugFlags
    DebugFlagsTouchscreen
        toEnum Int
    4096 = DebugFlags
    DebugFlagsActions
        toEnum Int
    8192 = DebugFlags
    DebugFlagsLayout
        toEnum Int
    16384 = DebugFlags
    DebugFlagsSnapshot
        toEnum Int
    32768 = DebugFlags
    DebugFlagsConstraints
        toEnum Int
    65536 = DebugFlags
    DebugFlagsBuilderObjects
        toEnum Int
    131072 = DebugFlags
    DebugFlagsA11y
        toEnum Int
    262144 = DebugFlags
    DebugFlagsIconfallback
        toEnum Int
    524288 = DebugFlags
    DebugFlagsInvertTextDir
        toEnum Int
    1048576 = DebugFlags
    DebugFlagsCss
        toEnum Int
    2097152 = DebugFlags
    DebugFlagsBuilder
        toEnum Int
    4194304 = DebugFlags
    DebugFlagsSession
        toEnum Int
    k = Int -> DebugFlags
    AnotherDebugFlags Int
    k

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

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

    foreign import ccall "gtk_debug_flags_get_type" c_gtk_debug_flags_get_type ::
        IO GType

    instance B.Types.TypedObject DebugFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_debug_flags_get_type

    instance B.Types.BoxedFlags DebugFlags

    instance IsGFlag DebugFlags

    -- Flags CellRendererState
    {-# DEPRECATED CellRendererState ["(Since version 4.20)","There is no replacement."] #-}
    -- | Tells how a cell is to be rendered.
    data CellRendererState =
          CellRendererStateSelected
        -- ^ The cell is currently selected, and
        --  probably has a selection colored background to render to.
        | CellRendererStatePrelit
        -- ^ The mouse is hovering over the cell.
        | CellRendererStateInsensitive
        -- ^ The cell is drawn in an insensitive manner
        | CellRendererStateSorted
        -- ^ The cell is in a sorted row
        | CellRendererStateFocused
        -- ^ The cell is in the focus row.
        | CellRendererStateExpandable
        -- ^ The cell is in a row that can be expanded
        | CellRendererStateExpanded
        -- ^ The cell is in a row that is expanded
        | AnotherCellRendererState Int
        -- ^ Catch-all for unknown values
        deriving (Int -> CellRendererState -> ShowS
    [CellRendererState] -> ShowS
    CellRendererState -> String
    (Int -> CellRendererState -> ShowS)
    -> (CellRendererState -> String)
    -> ([CellRendererState] -> ShowS)
    -> Show CellRendererState
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CellRendererState -> ShowS
    showsPrec :: Int -> CellRendererState -> ShowS
    $cshow :: CellRendererState -> String
    show :: CellRendererState -> String
    $cshowList :: [CellRendererState] -> ShowS
    showList :: [CellRendererState] -> ShowS
    Show, CellRendererState -> CellRendererState -> Bool
    (CellRendererState -> CellRendererState -> Bool)
    -> (CellRendererState -> CellRendererState -> Bool)
    -> Eq CellRendererState
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CellRendererState -> CellRendererState -> Bool
    == :: CellRendererState -> CellRendererState -> Bool
    $c/= :: CellRendererState -> CellRendererState -> Bool
    /= :: CellRendererState -> CellRendererState -> Bool
    Eq)

    instance P.Enum CellRendererState where
        fromEnum :: CellRendererState -> Int
    fromEnum CellRendererState
    CellRendererStateSelected = Int
    1
        fromEnum CellRendererState
    CellRendererStatePrelit = Int
    2
        fromEnum CellRendererState
    CellRendererStateInsensitive = Int
    4
        fromEnum CellRendererState
    CellRendererStateSorted = Int
    8
        fromEnum CellRendererState
    CellRendererStateFocused = Int
    16
        fromEnum CellRendererState
    CellRendererStateExpandable = Int
    32
        fromEnum CellRendererState
    CellRendererStateExpanded = Int
    64
        fromEnum (AnotherCellRendererState Int
    k) = Int
    k

        toEnum :: Int -> CellRendererState
    toEnum Int
    1 = CellRendererState
    CellRendererStateSelected
        toEnum Int
    2 = CellRendererState
    CellRendererStatePrelit
        toEnum Int
    4 = CellRendererState
    CellRendererStateInsensitive
        toEnum Int
    8 = CellRendererState
    CellRendererStateSorted
        toEnum Int
    16 = CellRendererState
    CellRendererStateFocused
        toEnum Int
    32 = CellRendererState
    CellRendererStateExpandable
        toEnum Int
    64 = CellRendererState
    CellRendererStateExpanded
        toEnum Int
    k = Int -> CellRendererState
    AnotherCellRendererState Int
    k

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

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

    foreign import ccall "gtk_cell_renderer_state_get_type" c_gtk_cell_renderer_state_get_type ::
        IO GType

    instance B.Types.TypedObject CellRendererState where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_cell_renderer_state_get_type

    instance B.Types.BoxedFlags CellRendererState

    instance IsGFlag CellRendererState

    -- Flags BuilderClosureFlags
    -- | The list of flags that can be passed to 'GI.Gtk.Objects.Builder.builderCreateClosure'.
    --
    -- New values may be added in the future for new features, so external
    -- implementations of t'GI.Gtk.Interfaces.BuilderScope.BuilderScope' should test the flags
    -- for unknown values and raise a 'GI.Gtk.Enums.BuilderErrorInvalidAttribute' error
    -- when they encounter one.
    data BuilderClosureFlags =
          BuilderClosureFlagsSwapped
        -- ^ The closure should be created swapped. See
        --   @/g_cclosure_new_swap()/@ for details.
        | AnotherBuilderClosureFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> BuilderClosureFlags -> ShowS
    [BuilderClosureFlags] -> ShowS
    BuilderClosureFlags -> String
    (Int -> BuilderClosureFlags -> ShowS)
    -> (BuilderClosureFlags -> String)
    -> ([BuilderClosureFlags] -> ShowS)
    -> Show BuilderClosureFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BuilderClosureFlags -> ShowS
    showsPrec :: Int -> BuilderClosureFlags -> ShowS
    $cshow :: BuilderClosureFlags -> String
    show :: BuilderClosureFlags -> String
    $cshowList :: [BuilderClosureFlags] -> ShowS
    showList :: [BuilderClosureFlags] -> ShowS
    Show, BuilderClosureFlags -> BuilderClosureFlags -> Bool
    (BuilderClosureFlags -> BuilderClosureFlags -> Bool)
    -> (BuilderClosureFlags -> BuilderClosureFlags -> Bool)
    -> Eq BuilderClosureFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BuilderClosureFlags -> BuilderClosureFlags -> Bool
    == :: BuilderClosureFlags -> BuilderClosureFlags -> Bool
    $c/= :: BuilderClosureFlags -> BuilderClosureFlags -> Bool
    /= :: BuilderClosureFlags -> BuilderClosureFlags -> Bool
    Eq)

    instance P.Enum BuilderClosureFlags where
        fromEnum :: BuilderClosureFlags -> Int
    fromEnum BuilderClosureFlags
    BuilderClosureFlagsSwapped = Int
    1
        fromEnum (AnotherBuilderClosureFlags Int
    k) = Int
    k

        toEnum :: Int -> BuilderClosureFlags
    toEnum Int
    1 = BuilderClosureFlags
    BuilderClosureFlagsSwapped
        toEnum Int
    k = Int -> BuilderClosureFlags
    AnotherBuilderClosureFlags Int
    k

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

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

    foreign import ccall "gtk_builder_closure_flags_get_type" c_gtk_builder_closure_flags_get_type ::
        IO GType

    instance B.Types.TypedObject BuilderClosureFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_builder_closure_flags_get_type

    instance B.Types.BoxedFlags BuilderClosureFlags

    instance IsGFlag BuilderClosureFlags

    -- Flags ApplicationInhibitFlags
    -- | Types of user actions that may be blocked by @GtkApplication@.
    --
    -- See 'GI.Gtk.Objects.Application.applicationInhibit'.
    data ApplicationInhibitFlags =
          ApplicationInhibitFlagsLogout
        -- ^ Inhibit ending the user session
        --   by logging out or by shutting down the computer
        | ApplicationInhibitFlagsSwitch
        -- ^ Inhibit user switching
        | ApplicationInhibitFlagsSuspend
        -- ^ Inhibit suspending the
        --   session or computer
        | ApplicationInhibitFlagsIdle
        -- ^ Inhibit the session being
        --   marked as idle (and possibly locked)
        | AnotherApplicationInhibitFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ApplicationInhibitFlags -> ShowS
    [ApplicationInhibitFlags] -> ShowS
    ApplicationInhibitFlags -> String
    (Int -> ApplicationInhibitFlags -> ShowS)
    -> (ApplicationInhibitFlags -> String)
    -> ([ApplicationInhibitFlags] -> ShowS)
    -> Show ApplicationInhibitFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ApplicationInhibitFlags -> ShowS
    showsPrec :: Int -> ApplicationInhibitFlags -> ShowS
    $cshow :: ApplicationInhibitFlags -> String
    show :: ApplicationInhibitFlags -> String
    $cshowList :: [ApplicationInhibitFlags] -> ShowS
    showList :: [ApplicationInhibitFlags] -> ShowS
    Show, ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool
    (ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool)
    -> (ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool)
    -> Eq ApplicationInhibitFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool
    == :: ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool
    $c/= :: ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool
    /= :: ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool
    Eq)

    instance P.Enum ApplicationInhibitFlags where
        fromEnum :: ApplicationInhibitFlags -> Int
    fromEnum ApplicationInhibitFlags
    ApplicationInhibitFlagsLogout = Int
    1
        fromEnum ApplicationInhibitFlags
    ApplicationInhibitFlagsSwitch = Int
    2
        fromEnum ApplicationInhibitFlags
    ApplicationInhibitFlagsSuspend = Int
    4
        fromEnum ApplicationInhibitFlags
    ApplicationInhibitFlagsIdle = Int
    8
        fromEnum (AnotherApplicationInhibitFlags Int
    k) = Int
    k

        toEnum :: Int -> ApplicationInhibitFlags
    toEnum Int
    1 = ApplicationInhibitFlags
    ApplicationInhibitFlagsLogout
        toEnum Int
    2 = ApplicationInhibitFlags
    ApplicationInhibitFlagsSwitch
        toEnum Int
    4 = ApplicationInhibitFlags
    ApplicationInhibitFlagsSuspend
        toEnum Int
    8 = ApplicationInhibitFlags
    ApplicationInhibitFlagsIdle
        toEnum Int
    k = Int -> ApplicationInhibitFlags
    AnotherApplicationInhibitFlags Int
    k

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

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

    foreign import ccall "gtk_application_inhibit_flags_get_type" c_gtk_application_inhibit_flags_get_type ::
        IO GType

    instance B.Types.TypedObject ApplicationInhibitFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_application_inhibit_flags_get_type

    instance B.Types.BoxedFlags ApplicationInhibitFlags

    instance IsGFlag ApplicationInhibitFlags