    -- | 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

    -- ** AccelFlags #flag:AccelFlags#

        AccelFlags(..)                          ,

    -- ** ApplicationInhibitFlags #flag:ApplicationInhibitFlags#

        ApplicationInhibitFlags(..)             ,

    -- ** AttachOptions #flag:AttachOptions#

        AttachOptions(..)                       ,

    -- ** CalendarDisplayOptions #flag:CalendarDisplayOptions#

        CalendarDisplayOptions(..)              ,

    -- ** CellRendererState #flag:CellRendererState#

        CellRendererState(..)                   ,

    -- ** DebugFlag #flag:DebugFlag#

        DebugFlag(..)                           ,

    -- ** DestDefaults #flag:DestDefaults#

        DestDefaults(..)                        ,

    -- ** DialogFlags #flag:DialogFlags#

        DialogFlags(..)                         ,

    -- ** EventControllerScrollFlags #flag:EventControllerScrollFlags#

        EventControllerScrollFlags(..)          ,

    -- ** FileFilterFlags #flag:FileFilterFlags#

        FileFilterFlags(..)                     ,

    -- ** FontChooserLevel #flag:FontChooserLevel#

        FontChooserLevel(..)                    ,

    -- ** IconLookupFlags #flag:IconLookupFlags#

        IconLookupFlags(..)                     ,

    -- ** InputHints #flag:InputHints#

        InputHints(..)                          ,

    -- ** JunctionSides #flag:JunctionSides#

        JunctionSides(..)                       ,

    -- ** PlacesOpenFlags #flag:PlacesOpenFlags#

        PlacesOpenFlags(..)                     ,

    -- ** RcFlags #flag:RcFlags#

        RcFlags(..)                             ,

    -- ** RecentFilterFlags #flag:RecentFilterFlags#

        RecentFilterFlags(..)                   ,

    -- ** RegionFlags #flag:RegionFlags#

        RegionFlags(..)                         ,

    -- ** StateFlags #flag:StateFlags#

        StateFlags(..)                          ,

    -- ** StyleContextPrintFlags #flag:StyleContextPrintFlags#

        StyleContextPrintFlags(..)              ,

    -- ** TargetFlags #flag:TargetFlags#

        TargetFlags(..)                         ,

    -- ** TextSearchFlags #flag:TextSearchFlags#

        TextSearchFlags(..)                     ,

    -- ** ToolPaletteDragTargets #flag:ToolPaletteDragTargets#

        ToolPaletteDragTargets(..)              ,

    -- ** TreeModelFlags #flag:TreeModelFlags#

        TreeModelFlags(..)                      ,

    -- ** UIManagerItemType #flag:UIManagerItemType#

        UIManagerItemType(..)                   ,

        ) 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 UIManagerItemType
    {-# DEPRECATED UIManagerItemType ["(Since version 3.10)"] #-}
    -- | These enumeration values are used by 'GI.Gtk.Objects.UIManager.uIManagerAddUi' to determine
    -- what UI element to create.
    data UIManagerItemType =
          UIManagerItemTypeAuto
        -- ^ Pick the type of the UI element according to context.
        | UIManagerItemTypeMenubar
        -- ^ Create a menubar.
        | UIManagerItemTypeMenu
        -- ^ Create a menu.
        | UIManagerItemTypeToolbar
        -- ^ Create a toolbar.
        | UIManagerItemTypePlaceholder
        -- ^ Insert a placeholder.
        | UIManagerItemTypePopup
        -- ^ Create a popup menu.
        | UIManagerItemTypeMenuitem
        -- ^ Create a menuitem.
        | UIManagerItemTypeToolitem
        -- ^ Create a toolitem.
        | UIManagerItemTypeSeparator
        -- ^ Create a separator.
        | UIManagerItemTypeAccelerator
        -- ^ Install an accelerator.
        | UIManagerItemTypePopupWithAccels
        -- ^ Same as 'GI.Gtk.Flags.UIManagerItemTypePopup', but the
        --   actions’ accelerators are shown.
        | AnotherUIManagerItemType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> UIManagerItemType -> ShowS
    [UIManagerItemType] -> ShowS
    UIManagerItemType -> String
    (Int -> UIManagerItemType -> ShowS)
    -> (UIManagerItemType -> String)
    -> ([UIManagerItemType] -> ShowS)
    -> Show UIManagerItemType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> UIManagerItemType -> ShowS
    showsPrec :: Int -> UIManagerItemType -> ShowS
    $cshow :: UIManagerItemType -> String
    show :: UIManagerItemType -> String
    $cshowList :: [UIManagerItemType] -> ShowS
    showList :: [UIManagerItemType] -> ShowS
    Show, UIManagerItemType -> UIManagerItemType -> Bool
    (UIManagerItemType -> UIManagerItemType -> Bool)
    -> (UIManagerItemType -> UIManagerItemType -> Bool)
    -> Eq UIManagerItemType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: UIManagerItemType -> UIManagerItemType -> Bool
    == :: UIManagerItemType -> UIManagerItemType -> Bool
    $c/= :: UIManagerItemType -> UIManagerItemType -> Bool
    /= :: UIManagerItemType -> UIManagerItemType -> Bool
    Eq)

    instance P.Enum UIManagerItemType where
        fromEnum :: UIManagerItemType -> Int
    fromEnum UIManagerItemType
    UIManagerItemTypeAuto = Int
    0
        fromEnum UIManagerItemType
    UIManagerItemTypeMenubar = Int
    1
        fromEnum UIManagerItemType
    UIManagerItemTypeMenu = Int
    2
        fromEnum UIManagerItemType
    UIManagerItemTypeToolbar = Int
    4
        fromEnum UIManagerItemType
    UIManagerItemTypePlaceholder = Int
    8
        fromEnum UIManagerItemType
    UIManagerItemTypePopup = Int
    16
        fromEnum UIManagerItemType
    UIManagerItemTypeMenuitem = Int
    32
        fromEnum UIManagerItemType
    UIManagerItemTypeToolitem = Int
    64
        fromEnum UIManagerItemType
    UIManagerItemTypeSeparator = Int
    128
        fromEnum UIManagerItemType
    UIManagerItemTypeAccelerator = Int
    256
        fromEnum UIManagerItemType
    UIManagerItemTypePopupWithAccels = Int
    512
        fromEnum (AnotherUIManagerItemType Int
    k) = Int
    k

        toEnum :: Int -> UIManagerItemType
    toEnum Int
    0 = UIManagerItemType
    UIManagerItemTypeAuto
        toEnum Int
    1 = UIManagerItemType
    UIManagerItemTypeMenubar
        toEnum Int
    2 = UIManagerItemType
    UIManagerItemTypeMenu
        toEnum Int
    4 = UIManagerItemType
    UIManagerItemTypeToolbar
        toEnum Int
    8 = UIManagerItemType
    UIManagerItemTypePlaceholder
        toEnum Int
    16 = UIManagerItemType
    UIManagerItemTypePopup
        toEnum Int
    32 = UIManagerItemType
    UIManagerItemTypeMenuitem
        toEnum Int
    64 = UIManagerItemType
    UIManagerItemTypeToolitem
        toEnum Int
    128 = UIManagerItemType
    UIManagerItemTypeSeparator
        toEnum Int
    256 = UIManagerItemType
    UIManagerItemTypeAccelerator
        toEnum Int
    512 = UIManagerItemType
    UIManagerItemTypePopupWithAccels
        toEnum Int
    k = Int -> UIManagerItemType
    AnotherUIManagerItemType Int
    k

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

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

    foreign import ccall "gtk_ui_manager_item_type_get_type" c_gtk_ui_manager_item_type_get_type ::
        IO GType

    instance B.Types.TypedObject UIManagerItemType where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_ui_manager_item_type_get_type

    instance B.Types.BoxedFlags UIManagerItemType

    instance IsGFlag UIManagerItemType

    -- Flags TreeModelFlags
    -- | These flags indicate various properties of a t'GI.Gtk.Interfaces.TreeModel.TreeModel'.
    --
    -- They are returned by 'GI.Gtk.Interfaces.TreeModel.treeModelGetFlags', and must be
    -- static for the lifetime of the object. A more complete description
    -- of @/GTK_TREE_MODEL_ITERS_PERSIST/@ 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 ToolPaletteDragTargets
    -- | Flags used to specify the supported drag targets.
    data ToolPaletteDragTargets =
          ToolPaletteDragTargetsItems
        -- ^ Support drag of items.
        | ToolPaletteDragTargetsGroups
        -- ^ Support drag of groups.
        | AnotherToolPaletteDragTargets Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ToolPaletteDragTargets -> ShowS
    [ToolPaletteDragTargets] -> ShowS
    ToolPaletteDragTargets -> String
    (Int -> ToolPaletteDragTargets -> ShowS)
    -> (ToolPaletteDragTargets -> String)
    -> ([ToolPaletteDragTargets] -> ShowS)
    -> Show ToolPaletteDragTargets
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ToolPaletteDragTargets -> ShowS
    showsPrec :: Int -> ToolPaletteDragTargets -> ShowS
    $cshow :: ToolPaletteDragTargets -> String
    show :: ToolPaletteDragTargets -> String
    $cshowList :: [ToolPaletteDragTargets] -> ShowS
    showList :: [ToolPaletteDragTargets] -> ShowS
    Show, ToolPaletteDragTargets -> ToolPaletteDragTargets -> Bool
    (ToolPaletteDragTargets -> ToolPaletteDragTargets -> Bool)
    -> (ToolPaletteDragTargets -> ToolPaletteDragTargets -> Bool)
    -> Eq ToolPaletteDragTargets
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ToolPaletteDragTargets -> ToolPaletteDragTargets -> Bool
    == :: ToolPaletteDragTargets -> ToolPaletteDragTargets -> Bool
    $c/= :: ToolPaletteDragTargets -> ToolPaletteDragTargets -> Bool
    /= :: ToolPaletteDragTargets -> ToolPaletteDragTargets -> Bool
    Eq)

    instance P.Enum ToolPaletteDragTargets where
        fromEnum :: ToolPaletteDragTargets -> Int
    fromEnum ToolPaletteDragTargets
    ToolPaletteDragTargetsItems = Int
    1
        fromEnum ToolPaletteDragTargets
    ToolPaletteDragTargetsGroups = Int
    2
        fromEnum (AnotherToolPaletteDragTargets Int
    k) = Int
    k

        toEnum :: Int -> ToolPaletteDragTargets
    toEnum Int
    1 = ToolPaletteDragTargets
    ToolPaletteDragTargetsItems
        toEnum Int
    2 = ToolPaletteDragTargets
    ToolPaletteDragTargetsGroups
        toEnum Int
    k = Int -> ToolPaletteDragTargets
    AnotherToolPaletteDragTargets Int
    k

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

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

    foreign import ccall "gtk_tool_palette_drag_targets_get_type" c_gtk_tool_palette_drag_targets_get_type ::
        IO GType

    instance B.Types.TypedObject ToolPaletteDragTargets where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_tool_palette_drag_targets_get_type

    instance B.Types.BoxedFlags ToolPaletteDragTargets

    instance IsGFlag ToolPaletteDragTargets

    -- 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 pixbufs 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 pixbufs 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 TargetFlags
    -- | The t'GI.Gtk.Flags.TargetFlags' enumeration is used to specify
    -- constraints on a t'GI.Gtk.Structs.TargetEntry.TargetEntry'.
    data TargetFlags =
          TargetFlagsSameApp
        -- ^ If this is set, the target will only be selected
        --   for drags within a single application.
        | TargetFlagsSameWidget
        -- ^ If this is set, the target will only be selected
        --   for drags within a single widget.
        | TargetFlagsOtherApp
        -- ^ If this is set, the target will not be selected
        --   for drags within a single application.
        | TargetFlagsOtherWidget
        -- ^ If this is set, the target will not be selected
        --   for drags withing a single widget.
        | AnotherTargetFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TargetFlags -> ShowS
    [TargetFlags] -> ShowS
    TargetFlags -> String
    (Int -> TargetFlags -> ShowS)
    -> (TargetFlags -> String)
    -> ([TargetFlags] -> ShowS)
    -> Show TargetFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TargetFlags -> ShowS
    showsPrec :: Int -> TargetFlags -> ShowS
    $cshow :: TargetFlags -> String
    show :: TargetFlags -> String
    $cshowList :: [TargetFlags] -> ShowS
    showList :: [TargetFlags] -> ShowS
    Show, TargetFlags -> TargetFlags -> Bool
    (TargetFlags -> TargetFlags -> Bool)
    -> (TargetFlags -> TargetFlags -> Bool) -> Eq TargetFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TargetFlags -> TargetFlags -> Bool
    == :: TargetFlags -> TargetFlags -> Bool
    $c/= :: TargetFlags -> TargetFlags -> Bool
    /= :: TargetFlags -> TargetFlags -> Bool
    Eq)

    instance P.Enum TargetFlags where
        fromEnum :: TargetFlags -> Int
    fromEnum TargetFlags
    TargetFlagsSameApp = Int
    1
        fromEnum TargetFlags
    TargetFlagsSameWidget = Int
    2
        fromEnum TargetFlags
    TargetFlagsOtherApp = Int
    4
        fromEnum TargetFlags
    TargetFlagsOtherWidget = Int
    8
        fromEnum (AnotherTargetFlags Int
    k) = Int
    k

        toEnum :: Int -> TargetFlags
    toEnum Int
    1 = TargetFlags
    TargetFlagsSameApp
        toEnum Int
    2 = TargetFlags
    TargetFlagsSameWidget
        toEnum Int
    4 = TargetFlags
    TargetFlagsOtherApp
        toEnum Int
    8 = TargetFlags
    TargetFlagsOtherWidget
        toEnum Int
    k = Int -> TargetFlags
    AnotherTargetFlags Int
    k

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

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

    foreign import ccall "gtk_target_flags_get_type" c_gtk_target_flags_get_type ::
        IO GType

    instance B.Types.TypedObject TargetFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_target_flags_get_type

    instance B.Types.BoxedFlags TargetFlags

    instance IsGFlag TargetFlags

    -- Flags StyleContextPrintFlags
    -- | Flags that modify the behavior of 'GI.Gtk.Objects.StyleContext.styleContextToString'.
    -- New values may be added to this enumeration.
    data StyleContextPrintFlags =
          StyleContextPrintFlagsNone
        -- ^ /No description available in the introspection data./
        | 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
        | 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 (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
    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. Since 3.8
        | StateFlagsDirRtl
        -- ^ Widget is in right-to-left text direction. Since 3.8
        | StateFlagsLink
        -- ^ Widget is a link. Since 3.12
        | StateFlagsVisited
        -- ^ The location the widget points to has already been visited. Since 3.12
        | StateFlagsChecked
        -- ^ Widget is checked. Since 3.14
        | StateFlagsDropActive
        -- ^ Widget is highlighted as a drop target for DND. Since 3.20
        | 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 (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
    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 RegionFlags
    -- | Describes a region within a widget.
    data RegionFlags =
          RegionFlagsEven
        -- ^ Region has an even number within a set.
        | RegionFlagsOdd
        -- ^ Region has an odd number within a set.
        | RegionFlagsFirst
        -- ^ Region is the first one within a set.
        | RegionFlagsLast
        -- ^ Region is the last one within a set.
        | RegionFlagsOnly
        -- ^ Region is the only one within a set.
        | RegionFlagsSorted
        -- ^ Region is part of a sorted area.
        | AnotherRegionFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> RegionFlags -> ShowS
    [RegionFlags] -> ShowS
    RegionFlags -> String
    (Int -> RegionFlags -> ShowS)
    -> (RegionFlags -> String)
    -> ([RegionFlags] -> ShowS)
    -> Show RegionFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RegionFlags -> ShowS
    showsPrec :: Int -> RegionFlags -> ShowS
    $cshow :: RegionFlags -> String
    show :: RegionFlags -> String
    $cshowList :: [RegionFlags] -> ShowS
    showList :: [RegionFlags] -> ShowS
    Show, RegionFlags -> RegionFlags -> Bool
    (RegionFlags -> RegionFlags -> Bool)
    -> (RegionFlags -> RegionFlags -> Bool) -> Eq RegionFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RegionFlags -> RegionFlags -> Bool
    == :: RegionFlags -> RegionFlags -> Bool
    $c/= :: RegionFlags -> RegionFlags -> Bool
    /= :: RegionFlags -> RegionFlags -> Bool
    Eq)

    instance P.Enum RegionFlags where
        fromEnum :: RegionFlags -> Int
    fromEnum RegionFlags
    RegionFlagsEven = Int
    1
        fromEnum RegionFlags
    RegionFlagsOdd = Int
    2
        fromEnum RegionFlags
    RegionFlagsFirst = Int
    4
        fromEnum RegionFlags
    RegionFlagsLast = Int
    8
        fromEnum RegionFlags
    RegionFlagsOnly = Int
    16
        fromEnum RegionFlags
    RegionFlagsSorted = Int
    32
        fromEnum (AnotherRegionFlags Int
    k) = Int
    k

        toEnum :: Int -> RegionFlags
    toEnum Int
    1 = RegionFlags
    RegionFlagsEven
        toEnum Int
    2 = RegionFlags
    RegionFlagsOdd
        toEnum Int
    4 = RegionFlags
    RegionFlagsFirst
        toEnum Int
    8 = RegionFlags
    RegionFlagsLast
        toEnum Int
    16 = RegionFlags
    RegionFlagsOnly
        toEnum Int
    32 = RegionFlags
    RegionFlagsSorted
        toEnum Int
    k = Int -> RegionFlags
    AnotherRegionFlags Int
    k

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

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

    foreign import ccall "gtk_region_flags_get_type" c_gtk_region_flags_get_type ::
        IO GType

    instance B.Types.TypedObject RegionFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_region_flags_get_type

    instance B.Types.BoxedFlags RegionFlags

    instance IsGFlag RegionFlags

    -- Flags RecentFilterFlags
    -- | These flags indicate what parts of a t'GI.Gtk.Structs.RecentFilterInfo.RecentFilterInfo' struct
    -- are filled or need to be filled.
    data RecentFilterFlags =
          RecentFilterFlagsUri
        -- ^ the URI of the file being tested
        | RecentFilterFlagsDisplayName
        -- ^ the string that will be used to
        --  display the file in the recent chooser
        | RecentFilterFlagsMimeType
        -- ^ the mime type of the file
        | RecentFilterFlagsApplication
        -- ^ the list of applications that have
        --  registered the file
        | RecentFilterFlagsGroup
        -- ^ the groups to which the file belongs to
        | RecentFilterFlagsAge
        -- ^ the number of days elapsed since the file
        --  has been registered
        | AnotherRecentFilterFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> RecentFilterFlags -> ShowS
    [RecentFilterFlags] -> ShowS
    RecentFilterFlags -> String
    (Int -> RecentFilterFlags -> ShowS)
    -> (RecentFilterFlags -> String)
    -> ([RecentFilterFlags] -> ShowS)
    -> Show RecentFilterFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RecentFilterFlags -> ShowS
    showsPrec :: Int -> RecentFilterFlags -> ShowS
    $cshow :: RecentFilterFlags -> String
    show :: RecentFilterFlags -> String
    $cshowList :: [RecentFilterFlags] -> ShowS
    showList :: [RecentFilterFlags] -> ShowS
    Show, RecentFilterFlags -> RecentFilterFlags -> Bool
    (RecentFilterFlags -> RecentFilterFlags -> Bool)
    -> (RecentFilterFlags -> RecentFilterFlags -> Bool)
    -> Eq RecentFilterFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RecentFilterFlags -> RecentFilterFlags -> Bool
    == :: RecentFilterFlags -> RecentFilterFlags -> Bool
    $c/= :: RecentFilterFlags -> RecentFilterFlags -> Bool
    /= :: RecentFilterFlags -> RecentFilterFlags -> Bool
    Eq)

    instance P.Enum RecentFilterFlags where
        fromEnum :: RecentFilterFlags -> Int
    fromEnum RecentFilterFlags
    RecentFilterFlagsUri = Int
    1
        fromEnum RecentFilterFlags
    RecentFilterFlagsDisplayName = Int
    2
        fromEnum RecentFilterFlags
    RecentFilterFlagsMimeType = Int
    4
        fromEnum RecentFilterFlags
    RecentFilterFlagsApplication = Int
    8
        fromEnum RecentFilterFlags
    RecentFilterFlagsGroup = Int
    16
        fromEnum RecentFilterFlags
    RecentFilterFlagsAge = Int
    32
        fromEnum (AnotherRecentFilterFlags Int
    k) = Int
    k

        toEnum :: Int -> RecentFilterFlags
    toEnum Int
    1 = RecentFilterFlags
    RecentFilterFlagsUri
        toEnum Int
    2 = RecentFilterFlags
    RecentFilterFlagsDisplayName
        toEnum Int
    4 = RecentFilterFlags
    RecentFilterFlagsMimeType
        toEnum Int
    8 = RecentFilterFlags
    RecentFilterFlagsApplication
        toEnum Int
    16 = RecentFilterFlags
    RecentFilterFlagsGroup
        toEnum Int
    32 = RecentFilterFlags
    RecentFilterFlagsAge
        toEnum Int
    k = Int -> RecentFilterFlags
    AnotherRecentFilterFlags Int
    k

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

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

    foreign import ccall "gtk_recent_filter_flags_get_type" c_gtk_recent_filter_flags_get_type ::
        IO GType

    instance B.Types.TypedObject RecentFilterFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_recent_filter_flags_get_type

    instance B.Types.BoxedFlags RecentFilterFlags

    instance IsGFlag RecentFilterFlags

    -- Flags RcFlags
    -- | Deprecated
    data RcFlags =
          RcFlagsFg
        -- ^ Deprecated
        | RcFlagsBg
        -- ^ Deprecated
        | RcFlagsText
        -- ^ Deprecated
        | RcFlagsBase
        -- ^ Deprecated
        | AnotherRcFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> RcFlags -> ShowS
    [RcFlags] -> ShowS
    RcFlags -> String
    (Int -> RcFlags -> ShowS)
    -> (RcFlags -> String) -> ([RcFlags] -> ShowS) -> Show RcFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RcFlags -> ShowS
    showsPrec :: Int -> RcFlags -> ShowS
    $cshow :: RcFlags -> String
    show :: RcFlags -> String
    $cshowList :: [RcFlags] -> ShowS
    showList :: [RcFlags] -> ShowS
    Show, RcFlags -> RcFlags -> Bool
    (RcFlags -> RcFlags -> Bool)
    -> (RcFlags -> RcFlags -> Bool) -> Eq RcFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RcFlags -> RcFlags -> Bool
    == :: RcFlags -> RcFlags -> Bool
    $c/= :: RcFlags -> RcFlags -> Bool
    /= :: RcFlags -> RcFlags -> Bool
    Eq)

    instance P.Enum RcFlags where
        fromEnum :: RcFlags -> Int
    fromEnum RcFlags
    RcFlagsFg = Int
    1
        fromEnum RcFlags
    RcFlagsBg = Int
    2
        fromEnum RcFlags
    RcFlagsText = Int
    4
        fromEnum RcFlags
    RcFlagsBase = Int
    8
        fromEnum (AnotherRcFlags Int
    k) = Int
    k

        toEnum :: Int -> RcFlags
    toEnum Int
    1 = RcFlags
    RcFlagsFg
        toEnum Int
    2 = RcFlags
    RcFlagsBg
        toEnum Int
    4 = RcFlags
    RcFlagsText
        toEnum Int
    8 = RcFlags
    RcFlagsBase
        toEnum Int
    k = Int -> RcFlags
    AnotherRcFlags Int
    k

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

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

    foreign import ccall "gtk_rc_flags_get_type" c_gtk_rc_flags_get_type ::
        IO GType

    instance B.Types.TypedObject RcFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_rc_flags_get_type

    instance B.Types.BoxedFlags RcFlags

    instance IsGFlag RcFlags

    -- Flags PlacesOpenFlags
    -- | These flags serve two purposes.  First, the application can call 'GI.Gtk.Objects.PlacesSidebar.placesSidebarSetOpenFlags'
    -- using these flags as a bitmask.  This tells the sidebar that the application is able to open
    -- folders selected from the sidebar in various ways, for example, in new tabs or in new windows in
    -- addition to the normal mode.
    --
    -- Second, when one of these values gets passed back to the application in the
    -- [PlacesSidebar::openLocation]("GI.Gtk.Objects.PlacesSidebar#g:signal:openLocation") signal, it means that the application should
    -- open the selected location in the normal way, in a new tab, or in a new
    -- window.  The sidebar takes care of determining the desired way to open the location,
    -- based on the modifier keys that the user is pressing at the time the selection is made.
    --
    -- If the application never calls 'GI.Gtk.Objects.PlacesSidebar.placesSidebarSetOpenFlags', then the sidebar will only
    -- use @/GTK_PLACES_OPEN_NORMAL/@ in the [PlacesSidebar::openLocation]("GI.Gtk.Objects.PlacesSidebar#g:signal:openLocation") signal.  This is the
    -- default mode of operation.
    data PlacesOpenFlags =
          PlacesOpenFlagsNormal
        -- ^ This is the default mode that t'GI.Gtk.Objects.PlacesSidebar.PlacesSidebar' uses if no other flags
        --  are specified.  It indicates that the calling application should open the selected location
        --  in the normal way, for example, in the folder view beside the sidebar.
        | PlacesOpenFlagsNewTab
        -- ^ When passed to 'GI.Gtk.Objects.PlacesSidebar.placesSidebarSetOpenFlags', this indicates
        --  that the application can open folders selected from the sidebar in new tabs.  This value
        --  will be passed to the [PlacesSidebar::openLocation]("GI.Gtk.Objects.PlacesSidebar#g:signal:openLocation") signal when the user selects
        --  that a location be opened in a new tab instead of in the standard fashion.
        | PlacesOpenFlagsNewWindow
        -- ^ Similar to /@gTKPLACESOPENNEWTAB@/, but indicates that the application
        --  can open folders in new windows.
        | AnotherPlacesOpenFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PlacesOpenFlags -> ShowS
    [PlacesOpenFlags] -> ShowS
    PlacesOpenFlags -> String
    (Int -> PlacesOpenFlags -> ShowS)
    -> (PlacesOpenFlags -> String)
    -> ([PlacesOpenFlags] -> ShowS)
    -> Show PlacesOpenFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PlacesOpenFlags -> ShowS
    showsPrec :: Int -> PlacesOpenFlags -> ShowS
    $cshow :: PlacesOpenFlags -> String
    show :: PlacesOpenFlags -> String
    $cshowList :: [PlacesOpenFlags] -> ShowS
    showList :: [PlacesOpenFlags] -> ShowS
    Show, PlacesOpenFlags -> PlacesOpenFlags -> Bool
    (PlacesOpenFlags -> PlacesOpenFlags -> Bool)
    -> (PlacesOpenFlags -> PlacesOpenFlags -> Bool)
    -> Eq PlacesOpenFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PlacesOpenFlags -> PlacesOpenFlags -> Bool
    == :: PlacesOpenFlags -> PlacesOpenFlags -> Bool
    $c/= :: PlacesOpenFlags -> PlacesOpenFlags -> Bool
    /= :: PlacesOpenFlags -> PlacesOpenFlags -> Bool
    Eq)

    instance P.Enum PlacesOpenFlags where
        fromEnum :: PlacesOpenFlags -> Int
    fromEnum PlacesOpenFlags
    PlacesOpenFlagsNormal = Int
    1
        fromEnum PlacesOpenFlags
    PlacesOpenFlagsNewTab = Int
    2
        fromEnum PlacesOpenFlags
    PlacesOpenFlagsNewWindow = Int
    4
        fromEnum (AnotherPlacesOpenFlags Int
    k) = Int
    k

        toEnum :: Int -> PlacesOpenFlags
    toEnum Int
    1 = PlacesOpenFlags
    PlacesOpenFlagsNormal
        toEnum Int
    2 = PlacesOpenFlags
    PlacesOpenFlagsNewTab
        toEnum Int
    4 = PlacesOpenFlags
    PlacesOpenFlagsNewWindow
        toEnum Int
    k = Int -> PlacesOpenFlags
    AnotherPlacesOpenFlags Int
    k

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

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

    foreign import ccall "gtk_places_open_flags_get_type" c_gtk_places_open_flags_get_type ::
        IO GType

    instance B.Types.TypedObject PlacesOpenFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_places_open_flags_get_type

    instance B.Types.BoxedFlags PlacesOpenFlags

    instance IsGFlag PlacesOpenFlags

    -- Flags JunctionSides
    -- | Describes how a rendered element connects to adjacent elements.
    data JunctionSides =
          JunctionSidesNone
        -- ^ No junctions.
        | JunctionSidesCornerTopleft
        -- ^ Element connects on the top-left corner.
        | JunctionSidesCornerTopright
        -- ^ Element connects on the top-right corner.
        | JunctionSidesCornerBottomleft
        -- ^ Element connects on the bottom-left corner.
        | JunctionSidesCornerBottomright
        -- ^ Element connects on the bottom-right corner.
        | JunctionSidesTop
        -- ^ Element connects on the top side.
        | JunctionSidesBottom
        -- ^ Element connects on the bottom side.
        | JunctionSidesLeft
        -- ^ Element connects on the left side.
        | JunctionSidesRight
        -- ^ Element connects on the right side.
        | AnotherJunctionSides Int
        -- ^ Catch-all for unknown values
        deriving (Int -> JunctionSides -> ShowS
    [JunctionSides] -> ShowS
    JunctionSides -> String
    (Int -> JunctionSides -> ShowS)
    -> (JunctionSides -> String)
    -> ([JunctionSides] -> ShowS)
    -> Show JunctionSides
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> JunctionSides -> ShowS
    showsPrec :: Int -> JunctionSides -> ShowS
    $cshow :: JunctionSides -> String
    show :: JunctionSides -> String
    $cshowList :: [JunctionSides] -> ShowS
    showList :: [JunctionSides] -> ShowS
    Show, JunctionSides -> JunctionSides -> Bool
    (JunctionSides -> JunctionSides -> Bool)
    -> (JunctionSides -> JunctionSides -> Bool) -> Eq JunctionSides
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: JunctionSides -> JunctionSides -> Bool
    == :: JunctionSides -> JunctionSides -> Bool
    $c/= :: JunctionSides -> JunctionSides -> Bool
    /= :: JunctionSides -> JunctionSides -> Bool
    Eq)

    instance P.Enum JunctionSides where
        fromEnum :: JunctionSides -> Int
    fromEnum JunctionSides
    JunctionSidesNone = Int
    0
        fromEnum JunctionSides
    JunctionSidesCornerTopleft = Int
    1
        fromEnum JunctionSides
    JunctionSidesCornerTopright = Int
    2
        fromEnum JunctionSides
    JunctionSidesCornerBottomleft = Int
    4
        fromEnum JunctionSides
    JunctionSidesCornerBottomright = Int
    8
        fromEnum JunctionSides
    JunctionSidesTop = Int
    3
        fromEnum JunctionSides
    JunctionSidesBottom = Int
    12
        fromEnum JunctionSides
    JunctionSidesLeft = Int
    5
        fromEnum JunctionSides
    JunctionSidesRight = Int
    10
        fromEnum (AnotherJunctionSides Int
    k) = Int
    k

        toEnum :: Int -> JunctionSides
    toEnum Int
    0 = JunctionSides
    JunctionSidesNone
        toEnum Int
    1 = JunctionSides
    JunctionSidesCornerTopleft
        toEnum Int
    2 = JunctionSides
    JunctionSidesCornerTopright
        toEnum Int
    4 = JunctionSides
    JunctionSidesCornerBottomleft
        toEnum Int
    8 = JunctionSides
    JunctionSidesCornerBottomright
        toEnum Int
    3 = JunctionSides
    JunctionSidesTop
        toEnum Int
    12 = JunctionSides
    JunctionSidesBottom
        toEnum Int
    5 = JunctionSides
    JunctionSidesLeft
        toEnum Int
    10 = JunctionSides
    JunctionSidesRight
        toEnum Int
    k = Int -> JunctionSides
    AnotherJunctionSides Int
    k

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

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

    foreign import ccall "gtk_junction_sides_get_type" c_gtk_junction_sides_get_type ::
        IO GType

    instance B.Types.TypedObject JunctionSides where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_junction_sides_get_type

    instance B.Types.BoxedFlags JunctionSides

    instance IsGFlag JunctionSides

    -- 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 t'GI.Gtk.Enums.InputPurpose' of the entry.
    --
    -- Some common sense is expected when using these flags - mixing
    -- /@gTKINPUTHINTLOWERCASE@/ with any of the uppercase hints makes no sense.
    --
    -- This enumeration may be extended in the future; input methods should
    -- ignore unknown values.
    --
    -- /Since: 3.6/
    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. Since 3.18
        | InputHintsEmoji
        -- ^ Suggest offering Emoji support. Since 3.22.20
        | InputHintsNoEmoji
        -- ^ Suggest not offering Emoji support. Since 3.22.20
        | 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 (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
    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 =
          IconLookupFlagsNoSvg
        -- ^ Never get SVG icons, even if gdk-pixbuf
        --   supports them. Cannot be used together with 'GI.Gtk.Flags.IconLookupFlagsForceSvg'.
        | IconLookupFlagsForceSvg
        -- ^ Get SVG icons, even if gdk-pixbuf
        --   doesn’t support them.
        --   Cannot be used together with 'GI.Gtk.Flags.IconLookupFlagsNoSvg'.
        | IconLookupFlagsUseBuiltin
        -- ^ When passed to
        --   'GI.Gtk.Objects.IconTheme.iconThemeLookupIcon' includes builtin icons
        --   as well as files. For a builtin icon, 'GI.Gtk.Objects.IconInfo.iconInfoGetFilename'
        --   is 'P.Nothing' and you need to call 'GI.Gtk.Objects.IconInfo.iconInfoGetBuiltinPixbuf'.
        | IconLookupFlagsGenericFallback
        -- ^ Try to shorten icon name at \'-\'
        --   characters before looking at inherited themes. This flag is only
        --   supported in functions that take a single icon name. For more general
        --   fallback, see 'GI.Gtk.Objects.IconTheme.iconThemeChooseIcon'. Since 2.12.
        | IconLookupFlagsForceSize
        -- ^ Always get the icon scaled to the
        --   requested size. Since 2.14.
        | IconLookupFlagsForceRegular
        -- ^ Try to always load regular icons, even
        --   when symbolic icon names are given. Since 3.14.
        | IconLookupFlagsForceSymbolic
        -- ^ Try to always load symbolic icons, even
        --   when regular icon names are given. Since 3.14.
        | IconLookupFlagsDirLtr
        -- ^ Try to load a variant of the icon for left-to-right
        --   text direction. Since 3.14.
        | IconLookupFlagsDirRtl
        -- ^ Try to load a variant of the icon for right-to-left
        --   text direction. Since 3.14.
        | 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
    IconLookupFlagsNoSvg = Int
    1
        fromEnum IconLookupFlags
    IconLookupFlagsForceSvg = Int
    2
        fromEnum IconLookupFlags
    IconLookupFlagsUseBuiltin = Int
    4
        fromEnum IconLookupFlags
    IconLookupFlagsGenericFallback = Int
    8
        fromEnum IconLookupFlags
    IconLookupFlagsForceSize = Int
    16
        fromEnum IconLookupFlags
    IconLookupFlagsForceRegular = Int
    32
        fromEnum IconLookupFlags
    IconLookupFlagsForceSymbolic = Int
    64
        fromEnum IconLookupFlags
    IconLookupFlagsDirLtr = Int
    128
        fromEnum IconLookupFlags
    IconLookupFlagsDirRtl = Int
    256
        fromEnum (AnotherIconLookupFlags Int
    k) = Int
    k

        toEnum :: Int -> IconLookupFlags
    toEnum Int
    1 = IconLookupFlags
    IconLookupFlagsNoSvg
        toEnum Int
    2 = IconLookupFlags
    IconLookupFlagsForceSvg
        toEnum Int
    4 = IconLookupFlags
    IconLookupFlagsUseBuiltin
        toEnum Int
    8 = IconLookupFlags
    IconLookupFlagsGenericFallback
        toEnum Int
    16 = IconLookupFlags
    IconLookupFlagsForceSize
        toEnum Int
    32 = IconLookupFlags
    IconLookupFlagsForceRegular
        toEnum Int
    64 = IconLookupFlags
    IconLookupFlagsForceSymbolic
        toEnum Int
    128 = IconLookupFlags
    IconLookupFlagsDirLtr
        toEnum Int
    256 = IconLookupFlags
    IconLookupFlagsDirRtl
        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
    -- | This enumeration specifies the granularity of font selection
    -- that is desired in a font chooser.
    --
    -- 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
        -- ^ /No description available in the introspection data./
        | 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 FileFilterFlags
    -- | These flags indicate what parts of a t'GI.Gtk.Structs.FileFilterInfo.FileFilterInfo' struct
    -- are filled or need to be filled.
    data FileFilterFlags =
          FileFilterFlagsFilename
        -- ^ the filename of the file being tested
        | FileFilterFlagsUri
        -- ^ the URI for the file being tested
        | FileFilterFlagsDisplayName
        -- ^ the string that will be used to
        --   display the file in the file chooser
        | FileFilterFlagsMimeType
        -- ^ the mime type of the file
        | AnotherFileFilterFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> FileFilterFlags -> ShowS
    [FileFilterFlags] -> ShowS
    FileFilterFlags -> String
    (Int -> FileFilterFlags -> ShowS)
    -> (FileFilterFlags -> String)
    -> ([FileFilterFlags] -> ShowS)
    -> Show FileFilterFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FileFilterFlags -> ShowS
    showsPrec :: Int -> FileFilterFlags -> ShowS
    $cshow :: FileFilterFlags -> String
    show :: FileFilterFlags -> String
    $cshowList :: [FileFilterFlags] -> ShowS
    showList :: [FileFilterFlags] -> ShowS
    Show, FileFilterFlags -> FileFilterFlags -> Bool
    (FileFilterFlags -> FileFilterFlags -> Bool)
    -> (FileFilterFlags -> FileFilterFlags -> Bool)
    -> Eq FileFilterFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FileFilterFlags -> FileFilterFlags -> Bool
    == :: FileFilterFlags -> FileFilterFlags -> Bool
    $c/= :: FileFilterFlags -> FileFilterFlags -> Bool
    /= :: FileFilterFlags -> FileFilterFlags -> Bool
    Eq)

    instance P.Enum FileFilterFlags where
        fromEnum :: FileFilterFlags -> Int
    fromEnum FileFilterFlags
    FileFilterFlagsFilename = Int
    1
        fromEnum FileFilterFlags
    FileFilterFlagsUri = Int
    2
        fromEnum FileFilterFlags
    FileFilterFlagsDisplayName = Int
    4
        fromEnum FileFilterFlags
    FileFilterFlagsMimeType = Int
    8
        fromEnum (AnotherFileFilterFlags Int
    k) = Int
    k

        toEnum :: Int -> FileFilterFlags
    toEnum Int
    1 = FileFilterFlags
    FileFilterFlagsFilename
        toEnum Int
    2 = FileFilterFlags
    FileFilterFlagsUri
        toEnum Int
    4 = FileFilterFlags
    FileFilterFlagsDisplayName
        toEnum Int
    8 = FileFilterFlags
    FileFilterFlagsMimeType
        toEnum Int
    k = Int -> FileFilterFlags
    AnotherFileFilterFlags Int
    k

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

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

    foreign import ccall "gtk_file_filter_flags_get_type" c_gtk_file_filter_flags_get_type ::
        IO GType

    instance B.Types.TypedObject FileFilterFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_file_filter_flags_get_type

    instance B.Types.BoxedFlags FileFilterFlags

    instance IsGFlag FileFilterFlags

    -- Flags EventControllerScrollFlags
    -- | Describes the behavior of a t'GI.Gtk.Objects.EventControllerScroll.EventControllerScroll'.
    --
    -- /Since: 3.24/
    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 [EventControllerScroll::decelerate]("GI.Gtk.Objects.EventControllerScroll#g:signal:decelerate")
        --   after continuous scroll finishes.
        | 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
    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
    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
    -- | Flags used to influence dialog construction.
    data DialogFlags =
          DialogFlagsModal
        -- ^ Make the constructed dialog modal,
        --     see 'GI.Gtk.Objects.Window.windowSetModal'
        | DialogFlagsDestroyWithParent
        -- ^ Destroy the dialog when its
        --     parent is destroyed, see 'GI.Gtk.Objects.Window.windowSetDestroyWithParent'
        | DialogFlagsUseHeaderBar
        -- ^ Create dialog with actions in header
        --     bar instead of action area. Since 3.12.
        | 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 DestDefaults
    -- | The t'GI.Gtk.Flags.DestDefaults' enumeration specifies the various
    -- types of action that will be taken on behalf
    -- of the user for a drag destination site.
    data DestDefaults =
          DestDefaultsMotion
        -- ^ If set for a widget, GTK+, during a drag over this
        --   widget will check if the drag matches this widget’s list of possible targets
        --   and actions.
        --   GTK+ will then call 'GI.Gdk.Functions.dragStatus' as appropriate.
        | DestDefaultsHighlight
        -- ^ If set for a widget, GTK+ will draw a highlight on
        --   this widget as long as a drag is over this widget and the widget drag format
        --   and action are acceptable.
        | DestDefaultsDrop
        -- ^ If set for a widget, when a drop occurs, GTK+ will
        --   will check if the drag matches this widget’s list of possible targets and
        --   actions. If so, GTK+ will call 'GI.Gtk.Objects.Widget.widgetDragGetData' on behalf of the widget.
        --   Whether or not the drop is successful, GTK+ will call 'GI.Gtk.Functions.dragFinish'. If
        --   the action was a move, then if the drag was successful, then 'P.True' will be
        --   passed for the /@delete@/ parameter to 'GI.Gtk.Functions.dragFinish'.
        | DestDefaultsAll
        -- ^ If set, specifies that all default actions should
        --   be taken.
        | AnotherDestDefaults Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DestDefaults -> ShowS
    [DestDefaults] -> ShowS
    DestDefaults -> String
    (Int -> DestDefaults -> ShowS)
    -> (DestDefaults -> String)
    -> ([DestDefaults] -> ShowS)
    -> Show DestDefaults
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DestDefaults -> ShowS
    showsPrec :: Int -> DestDefaults -> ShowS
    $cshow :: DestDefaults -> String
    show :: DestDefaults -> String
    $cshowList :: [DestDefaults] -> ShowS
    showList :: [DestDefaults] -> ShowS
    Show, DestDefaults -> DestDefaults -> Bool
    (DestDefaults -> DestDefaults -> Bool)
    -> (DestDefaults -> DestDefaults -> Bool) -> Eq DestDefaults
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DestDefaults -> DestDefaults -> Bool
    == :: DestDefaults -> DestDefaults -> Bool
    $c/= :: DestDefaults -> DestDefaults -> Bool
    /= :: DestDefaults -> DestDefaults -> Bool
    Eq)

    instance P.Enum DestDefaults where
        fromEnum :: DestDefaults -> Int
    fromEnum DestDefaults
    DestDefaultsMotion = Int
    1
        fromEnum DestDefaults
    DestDefaultsHighlight = Int
    2
        fromEnum DestDefaults
    DestDefaultsDrop = Int
    4
        fromEnum DestDefaults
    DestDefaultsAll = Int
    7
        fromEnum (AnotherDestDefaults Int
    k) = Int
    k

        toEnum :: Int -> DestDefaults
    toEnum Int
    1 = DestDefaults
    DestDefaultsMotion
        toEnum Int
    2 = DestDefaults
    DestDefaultsHighlight
        toEnum Int
    4 = DestDefaults
    DestDefaultsDrop
        toEnum Int
    7 = DestDefaults
    DestDefaultsAll
        toEnum Int
    k = Int -> DestDefaults
    AnotherDestDefaults Int
    k

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

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

    foreign import ccall "gtk_dest_defaults_get_type" c_gtk_dest_defaults_get_type ::
        IO GType

    instance B.Types.TypedObject DestDefaults where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_dest_defaults_get_type

    instance B.Types.BoxedFlags DestDefaults

    instance IsGFlag DestDefaults

    -- Flags DebugFlag
    -- | /No description available in the introspection data./
    data DebugFlag =
          DebugFlagMisc
        -- ^ /No description available in the introspection data./
        | DebugFlagPlugsocket
        -- ^ /No description available in the introspection data./
        | DebugFlagText
        -- ^ /No description available in the introspection data./
        | DebugFlagTree
        -- ^ /No description available in the introspection data./
        | DebugFlagUpdates
        -- ^ /No description available in the introspection data./
        | DebugFlagKeybindings
        -- ^ /No description available in the introspection data./
        | DebugFlagMultihead
        -- ^ /No description available in the introspection data./
        | DebugFlagModules
        -- ^ /No description available in the introspection data./
        | DebugFlagGeometry
        -- ^ /No description available in the introspection data./
        | DebugFlagIcontheme
        -- ^ /No description available in the introspection data./
        | DebugFlagPrinting
        -- ^ /No description available in the introspection data./
        | DebugFlagBuilder
        -- ^ /No description available in the introspection data./
        | DebugFlagSizeRequest
        -- ^ /No description available in the introspection data./
        | DebugFlagNoCssCache
        -- ^ /No description available in the introspection data./
        | DebugFlagBaselines
        -- ^ /No description available in the introspection data./
        | DebugFlagPixelCache
        -- ^ /No description available in the introspection data./
        | DebugFlagNoPixelCache
        -- ^ /No description available in the introspection data./
        | DebugFlagInteractive
        -- ^ /No description available in the introspection data./
        | DebugFlagTouchscreen
        -- ^ /No description available in the introspection data./
        | DebugFlagActions
        -- ^ /No description available in the introspection data./
        | DebugFlagResize
        -- ^ /No description available in the introspection data./
        | DebugFlagLayout
        -- ^ /No description available in the introspection data./
        | AnotherDebugFlag Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DebugFlag -> ShowS
    [DebugFlag] -> ShowS
    DebugFlag -> String
    (Int -> DebugFlag -> ShowS)
    -> (DebugFlag -> String)
    -> ([DebugFlag] -> ShowS)
    -> Show DebugFlag
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DebugFlag -> ShowS
    showsPrec :: Int -> DebugFlag -> ShowS
    $cshow :: DebugFlag -> String
    show :: DebugFlag -> String
    $cshowList :: [DebugFlag] -> ShowS
    showList :: [DebugFlag] -> ShowS
    Show, DebugFlag -> DebugFlag -> Bool
    (DebugFlag -> DebugFlag -> Bool)
    -> (DebugFlag -> DebugFlag -> Bool) -> Eq DebugFlag
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DebugFlag -> DebugFlag -> Bool
    == :: DebugFlag -> DebugFlag -> Bool
    $c/= :: DebugFlag -> DebugFlag -> Bool
    /= :: DebugFlag -> DebugFlag -> Bool
    Eq)

    instance P.Enum DebugFlag where
        fromEnum :: DebugFlag -> Int
    fromEnum DebugFlag
    DebugFlagMisc = Int
    1
        fromEnum DebugFlag
    DebugFlagPlugsocket = Int
    2
        fromEnum DebugFlag
    DebugFlagText = Int
    4
        fromEnum DebugFlag
    DebugFlagTree = Int
    8
        fromEnum DebugFlag
    DebugFlagUpdates = Int
    16
        fromEnum DebugFlag
    DebugFlagKeybindings = Int
    32
        fromEnum DebugFlag
    DebugFlagMultihead = Int
    64
        fromEnum DebugFlag
    DebugFlagModules = Int
    128
        fromEnum DebugFlag
    DebugFlagGeometry = Int
    256
        fromEnum DebugFlag
    DebugFlagIcontheme = Int
    512
        fromEnum DebugFlag
    DebugFlagPrinting = Int
    1024
        fromEnum DebugFlag
    DebugFlagBuilder = Int
    2048
        fromEnum DebugFlag
    DebugFlagSizeRequest = Int
    4096
        fromEnum DebugFlag
    DebugFlagNoCssCache = Int
    8192
        fromEnum DebugFlag
    DebugFlagBaselines = Int
    16384
        fromEnum DebugFlag
    DebugFlagPixelCache = Int
    32768
        fromEnum DebugFlag
    DebugFlagNoPixelCache = Int
    65536
        fromEnum DebugFlag
    DebugFlagInteractive = Int
    131072
        fromEnum DebugFlag
    DebugFlagTouchscreen = Int
    262144
        fromEnum DebugFlag
    DebugFlagActions = Int
    524288
        fromEnum DebugFlag
    DebugFlagResize = Int
    1048576
        fromEnum DebugFlag
    DebugFlagLayout = Int
    2097152
        fromEnum (AnotherDebugFlag Int
    k) = Int
    k

        toEnum :: Int -> DebugFlag
    toEnum Int
    1 = DebugFlag
    DebugFlagMisc
        toEnum Int
    2 = DebugFlag
    DebugFlagPlugsocket
        toEnum Int
    4 = DebugFlag
    DebugFlagText
        toEnum Int
    8 = DebugFlag
    DebugFlagTree
        toEnum Int
    16 = DebugFlag
    DebugFlagUpdates
        toEnum Int
    32 = DebugFlag
    DebugFlagKeybindings
        toEnum Int
    64 = DebugFlag
    DebugFlagMultihead
        toEnum Int
    128 = DebugFlag
    DebugFlagModules
        toEnum Int
    256 = DebugFlag
    DebugFlagGeometry
        toEnum Int
    512 = DebugFlag
    DebugFlagIcontheme
        toEnum Int
    1024 = DebugFlag
    DebugFlagPrinting
        toEnum Int
    2048 = DebugFlag
    DebugFlagBuilder
        toEnum Int
    4096 = DebugFlag
    DebugFlagSizeRequest
        toEnum Int
    8192 = DebugFlag
    DebugFlagNoCssCache
        toEnum Int
    16384 = DebugFlag
    DebugFlagBaselines
        toEnum Int
    32768 = DebugFlag
    DebugFlagPixelCache
        toEnum Int
    65536 = DebugFlag
    DebugFlagNoPixelCache
        toEnum Int
    131072 = DebugFlag
    DebugFlagInteractive
        toEnum Int
    262144 = DebugFlag
    DebugFlagTouchscreen
        toEnum Int
    524288 = DebugFlag
    DebugFlagActions
        toEnum Int
    1048576 = DebugFlag
    DebugFlagResize
        toEnum Int
    2097152 = DebugFlag
    DebugFlagLayout
        toEnum Int
    k = Int -> DebugFlag
    AnotherDebugFlag Int
    k

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

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

    foreign import ccall "gtk_debug_flag_get_type" c_gtk_debug_flag_get_type ::
        IO GType

    instance B.Types.TypedObject DebugFlag where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_debug_flag_get_type

    instance B.Types.BoxedFlags DebugFlag

    instance IsGFlag DebugFlag

    -- Flags CellRendererState
    -- | 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. Since 3.4
        | CellRendererStateExpanded
        -- ^ The cell is in a row that is expanded. Since 3.4
        | 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 CalendarDisplayOptions
    -- | These options can be used to influence the display and behaviour of a t'GI.Gtk.Objects.Calendar.Calendar'.
    data CalendarDisplayOptions =
          CalendarDisplayOptionsShowHeading
        -- ^ Specifies that the month and year should be displayed.
        | CalendarDisplayOptionsShowDayNames
        -- ^ Specifies that three letter day descriptions should be present.
        | CalendarDisplayOptionsNoMonthChange
        -- ^ Prevents the user from switching months with the calendar.
        | CalendarDisplayOptionsShowWeekNumbers
        -- ^ Displays each week numbers of the current year, down the
        -- left side of the calendar.
        | CalendarDisplayOptionsShowDetails
        -- ^ Just show an indicator, not the full details
        -- text when details are provided. See 'GI.Gtk.Objects.Calendar.calendarSetDetailFunc'.
        | AnotherCalendarDisplayOptions Int
        -- ^ Catch-all for unknown values
        deriving (Int -> CalendarDisplayOptions -> ShowS
    [CalendarDisplayOptions] -> ShowS
    CalendarDisplayOptions -> String
    (Int -> CalendarDisplayOptions -> ShowS)
    -> (CalendarDisplayOptions -> String)
    -> ([CalendarDisplayOptions] -> ShowS)
    -> Show CalendarDisplayOptions
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CalendarDisplayOptions -> ShowS
    showsPrec :: Int -> CalendarDisplayOptions -> ShowS
    $cshow :: CalendarDisplayOptions -> String
    show :: CalendarDisplayOptions -> String
    $cshowList :: [CalendarDisplayOptions] -> ShowS
    showList :: [CalendarDisplayOptions] -> ShowS
    Show, CalendarDisplayOptions -> CalendarDisplayOptions -> Bool
    (CalendarDisplayOptions -> CalendarDisplayOptions -> Bool)
    -> (CalendarDisplayOptions -> CalendarDisplayOptions -> Bool)
    -> Eq CalendarDisplayOptions
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CalendarDisplayOptions -> CalendarDisplayOptions -> Bool
    == :: CalendarDisplayOptions -> CalendarDisplayOptions -> Bool
    $c/= :: CalendarDisplayOptions -> CalendarDisplayOptions -> Bool
    /= :: CalendarDisplayOptions -> CalendarDisplayOptions -> Bool
    Eq)

    instance P.Enum CalendarDisplayOptions where
        fromEnum :: CalendarDisplayOptions -> Int
    fromEnum CalendarDisplayOptions
    CalendarDisplayOptionsShowHeading = Int
    1
        fromEnum CalendarDisplayOptions
    CalendarDisplayOptionsShowDayNames = Int
    2
        fromEnum CalendarDisplayOptions
    CalendarDisplayOptionsNoMonthChange = Int
    4
        fromEnum CalendarDisplayOptions
    CalendarDisplayOptionsShowWeekNumbers = Int
    8
        fromEnum CalendarDisplayOptions
    CalendarDisplayOptionsShowDetails = Int
    32
        fromEnum (AnotherCalendarDisplayOptions Int
    k) = Int
    k

        toEnum :: Int -> CalendarDisplayOptions
    toEnum Int
    1 = CalendarDisplayOptions
    CalendarDisplayOptionsShowHeading
        toEnum Int
    2 = CalendarDisplayOptions
    CalendarDisplayOptionsShowDayNames
        toEnum Int
    4 = CalendarDisplayOptions
    CalendarDisplayOptionsNoMonthChange
        toEnum Int
    8 = CalendarDisplayOptions
    CalendarDisplayOptionsShowWeekNumbers
        toEnum Int
    32 = CalendarDisplayOptions
    CalendarDisplayOptionsShowDetails
        toEnum Int
    k = Int -> CalendarDisplayOptions
    AnotherCalendarDisplayOptions Int
    k

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

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

    foreign import ccall "gtk_calendar_display_options_get_type" c_gtk_calendar_display_options_get_type ::
        IO GType

    instance B.Types.TypedObject CalendarDisplayOptions where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_calendar_display_options_get_type

    instance B.Types.BoxedFlags CalendarDisplayOptions

    instance IsGFlag CalendarDisplayOptions

    -- Flags AttachOptions
    -- | Denotes the expansion properties that a widget will have when it (or its
    -- parent) is resized.
    data AttachOptions =
          AttachOptionsExpand
        -- ^ the widget should expand to take up any extra space in its
        -- container that has been allocated.
        | AttachOptionsShrink
        -- ^ the widget should shrink as and when possible.
        | AttachOptionsFill
        -- ^ the widget should fill the space allocated to it.
        | AnotherAttachOptions Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AttachOptions -> ShowS
    [AttachOptions] -> ShowS
    AttachOptions -> String
    (Int -> AttachOptions -> ShowS)
    -> (AttachOptions -> String)
    -> ([AttachOptions] -> ShowS)
    -> Show AttachOptions
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AttachOptions -> ShowS
    showsPrec :: Int -> AttachOptions -> ShowS
    $cshow :: AttachOptions -> String
    show :: AttachOptions -> String
    $cshowList :: [AttachOptions] -> ShowS
    showList :: [AttachOptions] -> ShowS
    Show, AttachOptions -> AttachOptions -> Bool
    (AttachOptions -> AttachOptions -> Bool)
    -> (AttachOptions -> AttachOptions -> Bool) -> Eq AttachOptions
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AttachOptions -> AttachOptions -> Bool
    == :: AttachOptions -> AttachOptions -> Bool
    $c/= :: AttachOptions -> AttachOptions -> Bool
    /= :: AttachOptions -> AttachOptions -> Bool
    Eq)

    instance P.Enum AttachOptions where
        fromEnum :: AttachOptions -> Int
    fromEnum AttachOptions
    AttachOptionsExpand = Int
    1
        fromEnum AttachOptions
    AttachOptionsShrink = Int
    2
        fromEnum AttachOptions
    AttachOptionsFill = Int
    4
        fromEnum (AnotherAttachOptions Int
    k) = Int
    k

        toEnum :: Int -> AttachOptions
    toEnum Int
    1 = AttachOptions
    AttachOptionsExpand
        toEnum Int
    2 = AttachOptions
    AttachOptionsShrink
        toEnum Int
    4 = AttachOptions
    AttachOptionsFill
        toEnum Int
    k = Int -> AttachOptions
    AnotherAttachOptions Int
    k

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

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

    foreign import ccall "gtk_attach_options_get_type" c_gtk_attach_options_get_type ::
        IO GType

    instance B.Types.TypedObject AttachOptions where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_attach_options_get_type

    instance B.Types.BoxedFlags AttachOptions

    instance IsGFlag AttachOptions

    -- Flags ApplicationInhibitFlags
    -- | Types of user actions that may be blocked by 'GI.Gtk.Objects.Application.applicationInhibit'.
    --
    -- /Since: 3.4/
    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

    -- Flags AccelFlags
    -- | Accelerator flags used with 'GI.Gtk.Objects.AccelGroup.accelGroupConnect'.
    data AccelFlags =
          AccelFlagsVisible
        -- ^ Accelerator is visible
        | AccelFlagsLocked
        -- ^ Accelerator not removable
        | AccelFlagsMask
        -- ^ Mask
        | AnotherAccelFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AccelFlags -> ShowS
    [AccelFlags] -> ShowS
    AccelFlags -> String
    (Int -> AccelFlags -> ShowS)
    -> (AccelFlags -> String)
    -> ([AccelFlags] -> ShowS)
    -> Show AccelFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AccelFlags -> ShowS
    showsPrec :: Int -> AccelFlags -> ShowS
    $cshow :: AccelFlags -> String
    show :: AccelFlags -> String
    $cshowList :: [AccelFlags] -> ShowS
    showList :: [AccelFlags] -> ShowS
    Show, AccelFlags -> AccelFlags -> Bool
    (AccelFlags -> AccelFlags -> Bool)
    -> (AccelFlags -> AccelFlags -> Bool) -> Eq AccelFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AccelFlags -> AccelFlags -> Bool
    == :: AccelFlags -> AccelFlags -> Bool
    $c/= :: AccelFlags -> AccelFlags -> Bool
    /= :: AccelFlags -> AccelFlags -> Bool
    Eq)

    instance P.Enum AccelFlags where
        fromEnum :: AccelFlags -> Int
    fromEnum AccelFlags
    AccelFlagsVisible = Int
    1
        fromEnum AccelFlags
    AccelFlagsLocked = Int
    2
        fromEnum AccelFlags
    AccelFlagsMask = Int
    7
        fromEnum (AnotherAccelFlags Int
    k) = Int
    k

        toEnum :: Int -> AccelFlags
    toEnum Int
    1 = AccelFlags
    AccelFlagsVisible
        toEnum Int
    2 = AccelFlags
    AccelFlagsLocked
        toEnum Int
    7 = AccelFlags
    AccelFlagsMask
        toEnum Int
    k = Int -> AccelFlags
    AnotherAccelFlags Int
    k

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

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

    foreign import ccall "gtk_accel_flags_get_type" c_gtk_accel_flags_get_type ::
        IO GType

    instance B.Types.TypedObject AccelFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_accel_flags_get_type

    instance B.Types.BoxedFlags AccelFlags

    instance IsGFlag AccelFlags